 |
 
Prezentowane materiały są przeznaczone dla uczniów
szkół ponadgimnazjalnych. |
©2011 mgr
Jerzy Wałaszek
|
|
Prezentowane materiały są przeznaczone dla uczniów
szkół ponadgimnazjalnych. |
©2011 mgr
Jerzy Wałaszek
|
; ===================================================================== ; Listing Asemblerowy Systemu Operacyjnego w pamięci ROM komputera ZX81 ; ===================================================================== ; ---------------------------------------- ; Data ostatniej aktualizacji: 13-LIS-2011 ; ---------------------------------------- ; Ten plik można poddać asemblacji bezpośrednio w TASM'e, który jest darmowo dostępny w sieci Internet. Można dokonywać w nim ; zmian w celu uzyskania nowych funkcji, np. w symulatorze ZX81, lecz miejsca na takie modyfikacje jest bardzo mało. To właśnie ; brak miejsca w 8KB pamięci ROM wymusił na programistach oszczędności, które niejednokrotnie zwalniają i tak już wolnego ZX-81. ; Dokumentacja nie jest kompletna i w miarę możliwości, a przede wszystkim czasu, będzie stopniowo rozbudowywana. Zawarte tutaj ; procedury są doskonałym przykładem technik programowania mikroprocesora Z80 i mogą być bardzo cennym źródłem wiedzy o tym układzie. ; Ze swej strony zmodyfikowałem plik dostępny w wersji angielskiej w Internecie, tak aby zastąpić etykiety adresowe etykietami ; słownymi. W tym celu został napisany prosty program w C++, który przeglądnął plik źródłowy, zapamiętał wszystkie etykiety, ; a następnie odpowiednio przekonwertował go na postać HTML, dodając hiperłącza, które umożliwiają szybkie poruszanie się po ; całym listingu. Zamieniłem również odwołania adresowe do zmiennych systemowych na ich nazwy mnemotechniczne. Sądzę, iż dzięki ; tym zabiegom kod stał się bardziej czytelny. Adresy etykiet są zawsze wypisane w komentarzu bezpośrednio nad nazwą etykiety ; w kodzie szesnastkowym i dziesiętnym. ;************************************* ;** Definicje zmiennych systemowych ** ;************************************* ERR_NR .EQU $4000 ; $4000 : 16384 FLAGS .EQU $4001 ; $4001 : 16385 ERR_SP .EQU $4002 ; $4002 : 16386 RAMTOP .EQU $4004 ; $4004 : 16388 MODE .EQU $4006 ; $4006 : 16390 PPC .EQU $4007 ; $4007 : 16391 VERSN .EQU $4009 ; $4009 : 16393 E_PPC .EQU $400A ; $400A : 16394 D_FILE .EQU $400C ; $400C : 16396 DF_CC .EQU $400E ; $400E : 16398 VARS .EQU $4010 ; $4010 : 16400 DEST .EQU $4012 ; $4012 : 16402 E_LINE .EQU $4014 ; $4014 : 16404 CH_ADD .EQU $4016 ; $4016 : 16406 X_PTR .EQU $4018 ; $4018 : 16408 STKBOT .EQU $401A ; $401A : 16410 STKEND .EQU $401C ; $401C : 16412 BREG .EQU $401E ; $401E : 16414 MEM .EQU $401F ; $401F : 16415 UNUSED1 .EQU $4020 ; $4020 : 16416 UNUSED2 .EQU $4021 ; $4021 : 16417 DF_SZ .EQU $4022 ; $4022 : 16418 S_TOP .EQU $4023 ; $4023 : 16419 LAST_K .EQU $4025 ; $4025 : 16421 DBOUNC .EQU $4027 ; $4027 : 16423 MARGIN .EQU $4028 ; $4028 : 16424 NXTLIN .EQU $4029 ; $4029 : 16425 OLDPPC .EQU $402B ; $402B : 16427 FLAGX .EQU $402D ; $402D : 16429 STRLEN .EQU $402E ; $402E : 16430 T_ADDR .EQU $4030 ; $4030 : 16432 SEED .EQU $4032 ; $4032 : 16434 FRAMES .EQU $4034 ; $4034 : 16436 COORDS .EQU $4036 ; $4036 : 16438 PR_CC .EQU $4038 ; $4038 : 16440 S_POSN .EQU $4039 ; $4039 : 16441 CDFLAG .EQU $403B ; $403B : 16443 PRBUFF .EQU $403C ; $403C : 16444 MEMBOT .EQU $405D ; $405D : 16477 ;********************************************** ;** Część 1. PROCEDURY RESTARTU ORAZ TABLICE ** ;********************************************** ; -------------------------------- ; PUNKT WEJŚCIA DLA STARTU SYSTEMU ; -------------------------------- ; Wszystkie mikroprocesory Z80 rozpoczynają wykonywanie programu asemblerowego od adresu 0. Przy starcie systemu ustawiony jest ; Tryb Przerwań 0, komputery ZX korzystają z Trybu Przerwań 1. Przerwania są wyłączone. ; $0000 : 0 START: OUT ($FD),A ; wyłącz generator przerwań niemaskowanych, jeśli ten ROM pracuje na sprzęcie ZX81. ; Jeśli sprzętem jest wcześniejszy ZX80, to operacja nie wywołuje żadnego efektu. LD BC,$7FFF ; Ustaw BC na szczyt możliwej pamięci RAM. ZX81 może wykonywać kod maszynowy tylko ; poniżej adresu $8000, ponieważ wyższe adresy są wykorzystywane do sprzętowo-programowej ; obsługi obrazu telewizyjnego. Jeśli komputer ma więcej pamięci, to można ją wykorzystywać ; do przechowywania danych - jednakże bufor wyświetlania musi być poniżej $8000. JP RAM_CHECK ; ----------------------- ; PUNKT WEJŚCIA DLA BŁĘDU ; ----------------------- ; Punkt wejścia natychmiastowej obsługi błędu. Komputery ZX wykonują ten sam kod maszynowy zarówno w trakcie interpretacji programu ; w języku BASIC, jak i podczas sprawdzania składni. Jeśli błąd powstał w trakcie pracy programu, tworzony jest krótki komunikat. ; Jeśli błąd powstał przy wprowadzania wiersza programu w języku BASIC lub przy wprowadzaniu danych itd., to znacznik błędu wskazuje ; dokładne położenie błędu. ; $0008 : 8 ERROR_1: LD HL,(CH_ADD) ; pobierz adres znaku z CH_ADD LD (X_PTR),HL ; i ustaw wskaźnik błędu X_PTR. JR ERROR_2 ; przeskocz do przodu, aby kontynuować w ERROR-2. ; ------------------------------------------------- ; PUNKT WEJŚCIA DLA DRUKOWANIA ZNAKU W AKUMULATORZE ; ------------------------------------------------- ; Drukowany jest znak w akumulatorze przy użyciu zapasowego zestawu rejestrów, zatem nie ma potrzeby zachowywania głównych rejestrów ; mikroprocesora. ; $0010 : 16 PRINT_A: AND A ; test zera, czyli spacji JP NZ,PRINT_CH ; jeśli jest to znak różny od spacji, to drukujemy go w PRINT_CH. JP PRINT_SP ; a spację drukujemy w PRINT_SP. .BYTE $FF ; nieużywane ; ---------------------------------- ; PUNKT WEJŚCIA DLA POBIERANIA ZNAKU ; ---------------------------------- ; Pobrany zostaje znak adresowany zmienną systemową CH_ADD i jeśli jest on różny od spacji, to zostaje zwrócony. W przeciwnym razie ; zmienna CH_ADD jest zwiększana i pobrany zostanie kolejny znak aż do natrafienia na znak różny od spacji ; $0018 : 24 GET_CHAR: LD HL,(CH_ADD) ; pobieramy adres znaku do pary rejestrów HL LD A,(HL) ; pobieramy do A znak o adresie z CH_ADD ; $001C : 28 TEST_SP: AND A ; sprawdzamy, czy jest spacją RET NZ ; jeśli nie, to wracamy ze znakiem w A NOP ; inaczej przechodzimy do następnej procedury - dwie instrukcje NOP wykonane NOP ; zostają w 8 taktach ; ------------------------------------------ ; PUNKT WEJŚCIA DLA POBRANIA KOLEJNEGO ZNAKU ; ------------------------------------------ ; Adres znaku CH_ADD zostaje zwiększony o 1 i pobierany jest kolejny znak, który będzie zwrócony, jeśli nie jest spacją lub kursorem. ; W przeciwnym razie proces jest powtarzany. ; $0020 : 32 NEXT_CHAR: CALL CH_ADD_1 ; zwiększ CH_ADD i pobierz kolejny znak JR TEST_SP ; ponownie dokonaj testu na spację .BYTE $FF, $FF, $FF ; nieużywane ; -------------------------------------------------- ; PUNKT WEJŚCIA DLA KALKULATORA ZMIENNOPRZECINKOWEGO ; -------------------------------------------------- ; Następuje skok do rekurencyjnej procedury kalkulatora zmiennoprzecinkowego, który jest sterowany wewnętrznym językiem podobnym do ; FORTH'a i opartym na stosie. Za wywołaniem RST 28H następuje ciąg kodów bajtowych, które są poleceniami w języku kalkulatora. ; Kalkulator jest wykorzystywany do wyliczania wartości wszystkich funkcji arytmetycznych języka ZX81 BASIC. ; W pięciu pozostałych bajtach umieszczono procedurę obsługi rozkazu kalkulatora END_CALC, który kończy wykonywanie poleceń kalkulatora. ; $0028 : 40 FP_CALC: JP CALCULATE ; skocz bezpośrednio do procedury obsługi kalkulatora ; $002B : 43 END_CALC: POP AF ; usuń ze stosu adres powrotu do kalkulatora EXX ; przełącz się na zapasowy zestaw rejestrów EX (SP),HL ; jako adres powrotu wykorzystaj wskaźnik programu kalkulatora w HL'. Przy zakończeniu rekurencji poprzedni ; wskaźnik jest umieszczany w HL' EXX ; przełącz na podstawowy zestaw rejestrów RET ; powróć z obliczeń w kalkulatorze do programu ; --------------------------------- ; PUNKT WEJŚCIA TWORZENIA BC SPACJI ; --------------------------------- ; Wejście to wykorzystywane jest osiem razy do tworzenia w obszarze roboczym odpowiedniej liczby spacji, których liczba przekazywana ; jest w parze rejestrów BC. ; $0030 : 48 BC_SPACES: PUSH BC ; umieść liczbę spacji na stosie LD HL,(E_LINE) ; pobierz do HL adres obszaru wiersza edycji ze zmiennej systemowej E_LINE PUSH HL ; zachowaj ten adres na stosie JP RESERVE ; kontynuuj w procedurze RESERVE. ; -------------------------- ; PUNKT WEJŚCIA DLA PRZERWAŃ ; -------------------------- ; Procedura obsługi przerwania w trybie 1 zajmuje się całkowicie tworzeniem obrazu telewizyjnego. Na ZX81 przerwania maskowane są ; włączone tylko w czasie wykonywania procedury obsługującej je. Ta procedura obsługi przerwań automatycznie wyłącza przerwania ; na samym początku i ostatnie przerwanie w kolejce kończy się zanim obsługa przerwań ponownie zostanie włączona. W pamięci ROM ZX81 ; nie znajdziesz instrukcji DI wyłączającej obsługę przerwań maskowanych. Przerwanie maskowane jest wyzwalane, gdy bit 6 rejestru ; odświeżania mikroprocesora Z80 zmienia się ; z jedynki na 0. Dzieje się tak dlatego, iż linia adresowa A6 jest połączona z ; wejściem INT. W trakcie cyklu odświeżania na liniach adresowych A0-A8 umieszczana jest zawartość rejestru R. Z kolei mikroprocesor Z80 ; testuje linię INT przy ostatnim cyklu wykonania instrukcji, gdy trwa jeszcze cykl odświeżania. ; Z80 zawsze będzie wykonywał instrukcję HALT (NEWLINE), gdy zdarzy się przerwanie. Instrukcja HALT w kółko wykonuje instrukcje NOP, ; lecz przy każdej z nich zawartość rejestru R jest zwiększana, podobnie jak przy każdej prostej instrukcji (młodsze 7 bitów jest ; zwiększane dwukrotnie dla instrukcji z przedrostkiem). Proces ten jest kontrolowany przez układ ULA - Sinclair Computer Logic Chip - ; wyprodukowany w firmie: ; Ferranti - ULA = Uncommitted Logic Array. ; Gdy wystąpi przerwanie w trybie 1 rejestr licznika rozkazów PC, który adresuje instrukcję za rozkazem NEWLINE/HALT w górnej połówce ; pamięci powyżej 32K, zostanie umieszczony na stosie maszynowym. Potrzebne są 193 przerwania do utworzenia końca 56-tej linii górnego ; marginesu oraz ; 192 linii środkowego obrazu TV, a chociaż każde przerwanie przerywa obsługę poprzedniego, nie wystąpi problem ; z rozrostem stosu maszynowego, ponieważ za każdym razem adresy powrotne są z niego usuwane. ; Licznik linii skanujących w rejestrze C zlicza w dół od 8 do 1 w czasie tworzenia każdego wiersza tekstu. Dla ostatniej linii ; marginesu górnego licznik w C jest ustawiany na 1. ; Czas wykonania kodu ma podstawowe znaczenie, ponieważ prawy margines, powrót strumienia elektronów oraz lewy margines zajmuje ; dokładnie 58 taktów zegara i przez tyle taktów wykonuje się ta procedura. ; $0038 : 56 INTERRUPT: DEC C ; (4) zmniejsz licznik linii skanujących w rejestrze C. JP NZ,SCAN_LINE ; (10/10) jeśli C różne od 0, skocz naprzód do SCAN_LINE POP HL ; (10) ustaw adres początku następnego wiersza w buforze wyświetlania DEC B ; (4) zmniejsz licznik wierszy RET Z ; (11/5) gdy obrazek jest skończony, powróć do L028B z wyłączonymi przerwaniami. SET 3,C ; (8) załaduj licznik linii skanujących wartością 8. ; Uwaga: LD C,$8 ma 7 taktów zegara, co jest zbyt mało ; $0041 : 65 WAIT_INT: LD R,A ; (9) załaduj R początkową wartością $DD, która będzie zwiększana przy każdej instrukcji EI ; (4) włącz obsługę przerwań. [ R ma teraz wartość $DE ]. JP (HL) ; (4) skocz do echa bufora wyświetlania w górnej połówce pamięci i wykonaj kody znaków $00 - $3F ; jako instrukcje NOP. Układ wideo w ZX81 potrafi odczytać te znaki i przy pomocy rejestru I umie ; zamienić matryce znaków z ROM na wiersze bajtów. Na końcu każdego wiersza zostanie napotkany ; kod NEWLINE/HALT zanim rejestr R zliczy do $FF. Jednakże to przejście z $FF na $80 wyzwala ; następne przerwanie. [R ma teraz wartość $DF] ; $0045 : 69 SCAN_LINE: POP DE ; (10) usuń adres za NEWLINE, ponieważ ten sam wiersz tekstu musi być "wykonany" 8 razy RET Z ; (5) opóźnienie - instrukcja nigdy nie powoduje powrotu, ponieważ warunek jest zawsze fałszywy JR WAIT_INT ; (12) z powrotem do WAIT_INT ; Uwaga. W komputerze z pamięcią mniejszą niż 4K RAM bufor wyświetlania będzie zwinięty, a powyższy mechanizm obsługuje zarówno pełny ; jak i zwinięty bufor. Przy pełnym buforze 32 znaki w wierszu jest traktowane jako instrukcje NOP, a rejestr odświeżania R zwiększy ; zawartość z $E0 (pierwszy znak) do $FF (ostatni znak) i przy następnej instrukcji HALT wystąpi przerwanie (R zmieni stan na $80). ; Przy zwiniętym buforze wyświetlania wykonywanie kodów zatrzyma się na instrukcji HALT, która cyklicznie rozpocznie wykonywanie NOP. ; Rejestr R będzie zwiększany, aż do osiągnięcia $FF, a następnie $80, co wyzwoli przerwanie. Działa to bezbłędnie dla wszystkich wierszy ; ekranu, które zawierają od 0 do 32 znaków zakończonych kodem NEWLINE/HALT. Jedna linia obrazu zajmuje zawsze 128 cykli zegara. ; ------------------------------ ; PROCEDURA ZWIĘKSZANIA CH_ADD ; ------------------------------ ; Procedura zwiększa zmienną systemową CH_ADD i kończy działanie, jeśli pod nowym adresem (CH_ADD) nie znajduje się znak kursora. ; W przeciwnym razie pobiera znak za kursorem. ZX81 umieszcza na pozycji kursora prawdziwy znak kursora - w przeciwieństwie do poprzedników ; i następców ZX81, gdzie stosowano jedynie wskaźnik. ; Na wyjściu mamy: ; A - pobrany znak ; HL - adres znaku ; $0049 : 73 CH_ADD_1: LD HL,(CH_ADD) ; pobierz zawartość zmiennej systemowej CH_ADD ; $004C : 76 TEMP_PTR1: INC HL ; zaadresuj następną pozycję ; $004D : 77 TEMP_PTR2: LD (CH_ADD),HL ; uaktualnij zmienną systemową CH_ADD LD A,(HL) ; pobierz znak z nowej pozycji CP $7F ; sprawdź, czy jest to znak kursora RET NZ ; jeśli nie, powróć z procedury JR TEMP_PTR1 ; cofnij się do TEMP_PTR1, aby pobrać następny znak ; --------------------- ; KONTYNUACJA 'ERROR_2' ; --------------------- ; Jest to kontynuacja punktu wejścia dla błędów ERROR_1. Jeśli błąd wystąpił w czasie wykonywania programu, to na stosie będzie odłożony ; adres numeru błędu, który należy wyświetlić, chyba że błąd wystąpił w trakcie wprowadzania danych. Jeśli błąd powstał w czasie ; sprawdzania składni, to na stosie będzie adres procedury edycji, a pozycja błędu pojawi się po ponownym wydruku zawartości spodu ekranu. ; $0056 : 86 ERROR_2: POP HL ; pobierz ze stosu adres powrotu, który wskazuje na bajt z kodem błędu, umieszczony tuż za rozkazem RST 08H. LD L,(HL) ; pobierz kod błędu do L. HL nie jest już potrzebne ; $0058 : 88 ERROR_3: LD (IY+$00),L ; umieść kod błędu w zmiennej systemowej ERR_NR LD SP,(ERR_SP) ; ustaw stos ze zmiennej ERR_SP CALL SLOW_FAST ; wybierz tryb SLOW. JP SET_MIN ; wyjdź do adresu na stosie poprzez procedurę SET_MIN. .BYTE $FF ; nieużywane ; ------------------------------------------ ; PROCEDURA OBSŁUGI PRZERWAŃ NIE MASKOWANYCH ; ------------------------------------------ ; Techniczna sztuczka Jima Westwooda z wykorzystaniem przerwań niemaskowanych rozwiązała problem migania obrazu nękający użytkowników ; modelu ZX80, a dla komputera ZX81 podarowała tryb SLOW z jednoczesnymi obliczeniami oraz wyświetlaniem obrazu. Zwróć uwagę, iż dla tej ; funkcji oraz współdziałania w tworzeniu obrazu zarezerwowana została para rejestrów AF'. Przy zliczaniu linii obrazu telewizyjnego NMI ; nie wykorzystuje głównych rejestrów. Obwód elektroniczny dla generatora NMI jest zawarty wewnątrz układu ULA. Zliczanie w kierunku zera ; zajmuje jej 32 takty zegarowe. ; $0066 : 102 NMI: EX AF,AF' ; (4) przełącz się na kopię akumulatora dla procedury NMI INC A ; (4) zwiększ zawartość licznika linii o 1 JP M,NMI_RET ; (10/10) jeśli wynik ujemny w kodzie U2, to skocz do NMI_RET, ponieważ będzie to część testu ; sprawdzającego, czy generacja NMI pracuje lub wartość pośrednia dla licznika pustych linii, ; zliczającego w przód na wartościach zanegowanych. JR Z,NMI_CONT ; (12) naprzód do NMI_CONT, gdy licznik przekręcił się na 0 ; Uwaga. Synchronizowanie NMI, gdy A zwiększane jest z zera na jeden zajmuje 7 taktów zegara dając w sumie 32 + 7 = 39 taktów na obieg ; procedury. ; $006D : 109 NMI_RET: EX AF,AF' ; (4) przełącz z licznika linii lub wyniku testu $80 na zwykły A RET ; (10) powróć na chwilę do aplikacji użytkownika. ; To odgałęzienie jest wykonywane, gdy narysowana została 55 (lub 31) linia marginesu. ; $006F : 111 NMI_CONT: EX AF,AF' ; (4) przywróć główny akumulator. PUSH AF ; (11) zapisz główne rejestru na stosie. PUSH BC ; (11) PUSH DE ; (11) PUSH HL ; (11) ; następna procedura ustawiająca jest faktycznie potrzebna tylko po wygenerowaniu górnego zbioru pustych linii marginesu LD HL,(D_FILE) ; (16) pobierz adres startu bufora obrazu ze zmiennej D_FILE wskazujący instrukcję ; NEWLINE/HALT umieszczoną na początku. SET 7,H ; (8) przelicz adres na echo bufora w górnej połówce pamięci ponad 32K HALT ; (1) HALT synchronizuje z NMI. Używa się go ze specjalnym obwodem połączonym ; z liniami HALT i WAIT mikroprocesora Z80 w celu wstrzymania na 1 takt zegara. ; ---------------------------------------------------------------------------- ; Przerwanie NMI zostało wygenerowane - zaczynamy zliczanie. Strumień elektronów jest przy prawej krawędzi ekranu telewizyjnego. ; Najpierw obsługa NMI, podobna do instrukcji CALL = 17 taktów zegara. ; Teraz czas zużyty przez NMI na ścieżkę zero-jeden = 39 taktów. ; Powyższa instrukcja HALT = 1 takt. ; Dwie instrukcje poniżej = 19 taktów. ; Kod pod adresem 281H do instrukcji CALL włącznie = 43 takty. ; Wywołana procedura pod adresem 2B5H = 24 takty. ; -------------------------------------- --- ; W sumie wszystkie instrukcje Z80 = 143 takty. ; Tymczasem po stronie telewizora: ; Powrót poziomy strumienia elektronów = 15 taktów. ; Lewy margines o szerokości 8 znaków = 32 takty ; Tworzenie 75% linii skanowania z pierwszego NEWLINE = 96 takty ; --------------------------------------- --- ; 143 takty ; Ponieważ do czasu napotkania pierwszej instrukcji JP (HL), która wykona echo bufora wyświetlania, należy dodatkowo wyświetlić 8 ; pozycji znakowych lewego marginesu, to rejestr odświeżania musi zawierać $F8. Idąc zatem wstecz i uwzględniając fakt, iż każda ; instrukcja zwiększa rejestr R o 1, dochodzimy do wniosku, iż rejestr R należy załadować wartością $F5. OUT ($FD),A ; (11) zatrzymaj generator NMI. JP (IX) ; (8) naprzód do 281H (po górnym marginesie) lub do 28FH ; ********************** ; ** TABLICE KLAWISZY ** ; ********************** ; ------------------------------ ; KODY ZNAKÓW BEZ KLAWISZA SHIFT ; ------------------------------ ; $007E : 126 K_UNSHIFT:.BYTE $3F ; Z .BYTE $3D ; X .BYTE $28 ; C .BYTE $3B ; V .BYTE $26 ; A .BYTE $38 ; S .BYTE $29 ; D .BYTE $2B ; F .BYTE $2C ; G .BYTE $36 ; Q .BYTE $3C ; W .BYTE $2A ; E .BYTE $37 ; R .BYTE $39 ; T .BYTE $1D ; 1 .BYTE $1E ; 2 .BYTE $1F ; 3 .BYTE $20 ; 4 .BYTE $21 ; 5 .BYTE $1C ; 0 .BYTE $25 ; 9 .BYTE $24 ; 8 .BYTE $23 ; 7 .BYTE $22 ; 6 .BYTE $35 ; P .BYTE $34 ; O .BYTE $2E ; I .BYTE $3A ; U .BYTE $3E ; Y .BYTE $76 ; NEWLINE .BYTE $31 ; L .BYTE $30 ; K .BYTE $2F ; J .BYTE $2D ; H .BYTE $00 ; SPACE .BYTE $1B ; . .BYTE $32 ; M .BYTE $33 ; N .BYTE $27 ; B ; ----------------------------- ; KODY ZNAKÓW Z KLAWISZEM SHIFT ; ----------------------------- ; $00A5 : 165 K_SHIFT: .BYTE $0E ; : .BYTE $19 ; ; .BYTE $0F ; ? .BYTE $18 ; / .BYTE $E3 ; STOP .BYTE $E1 ; LPRINT .BYTE $E4 ; SLOW .BYTE $E5 ; FAST .BYTE $E2 ; LLIST .BYTE $C0 ; "" .BYTE $D9 ; OR .BYTE $E0 ; STEP .BYTE $DB ; <= .BYTE $DD ; <> .BYTE $75 ; EDIT .BYTE $DA ; AND .BYTE $DE ; THEN .BYTE $DF ; TO .BYTE $72 ; kursor w lewo .BYTE $77 ; RUBOUT .BYTE $74 ; GRAPHICS .BYTE $73 ; kursor w prawo .BYTE $70 ; kursor w górę .BYTE $71 ; kursor w dół .BYTE $0B ; " .BYTE $11 ; ) .BYTE $10 ; ( .BYTE $0D ; $ .BYTE $DC ; >= .BYTE $79 ; FUNCTION .BYTE $14 ; = .BYTE $15 ; + .BYTE $16 ; - .BYTE $D8 ; ** .BYTE $0C ; L .BYTE $1A ; , .BYTE $12 ; > .BYTE $13 ; < .BYTE $17 ; * ; -------------------- ; KODY ZNAKOWE FUNKCJI ; -------------------- ; $00CC : 204 K_FUNCT: .BYTE $CD ; LN .BYTE $CE ; EXP .BYTE $C1 ; AT .BYTE $78 ; KL .BYTE $CA ; ASN .BYTE $CB ; ACS .BYTE $CC ; ATN .BYTE $D1 ; SGN .BYTE $D2 ; ABS .BYTE $C7 ; SIN .BYTE $C8 ; COS .BYTE $C9 ; TAN .BYTE $CF ; INT .BYTE $40 ; RND .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $C2 ; TAB .BYTE $D3 ; PEEK .BYTE $C4 ; CODE .BYTE $D6 ; CHR$ .BYTE $D5 ; STR$ .BYTE $78 ; KL .BYTE $D4 ; USR .BYTE $C6 ; LEN .BYTE $C5 ; VAL .BYTE $D0 ; SQR .BYTE $78 ; KL .BYTE $78 ; KL .BYTE $42 ; PI .BYTE $D7 ; NOT .BYTE $41 ; INKEY$ ; -------------------------- ; KODY ZNAKÓW 'GRAFICZNYCH' ; -------------------------- ; $00F3 : 243 K_GRAPH: .BYTE $08 ; grafika .BYTE $0A ; grafika .BYTE $09 ; grafika .BYTE $8A ; grafika .BYTE $89 ; grafika .BYTE $81 ; grafika .BYTE $82 ; grafika .BYTE $07 ; grafika .BYTE $84 ; grafika .BYTE $06 ; grafika .BYTE $01 ; grafika .BYTE $02 ; grafika .BYTE $87 ; grafika .BYTE $04 ; grafika .BYTE $05 ; grafika .BYTE $77 ; RUBOUT .BYTE $78 ; KL .BYTE $85 ; grafika .BYTE $03 ; grafika .BYTE $83 ; grafika .BYTE $8B ; grafika .BYTE $91 ; negatyw ) .BYTE $90 ; negatyw ( .BYTE $8D ; negatyw $ .BYTE $86 ; grafika .BYTE $78 ; KL .BYTE $92 ; negatyw > .BYTE $95 ; negatyw + .BYTE $96 ; negatyw - .BYTE $88 ; grafika ; -------------- ; TABELE 'NAZW' ; -------------- ; $0111 : 273 TOKENST: .BYTE $0F+$80 ; '?'+$80 .BYTE $0B,$0B+$80 ; "" .BYTE $26,$39+$80 ; AT .BYTE $39,$26,$27+$80 ; TAB .BYTE $0F+$80 ; '?'+$80 .BYTE $28,$34,$29,$2A+$80 ; CODE .BYTE $3B,$26,$31+$80 ; VAL .BYTE $31,$2A,$33+$80 ; LEN .BYTE $38,$2E,$33+$80 ; SIN .BYTE $28,$34,$38+$80 ; COS .BYTE $39,$26,$33+$80 ; TAN .BYTE $26,$38,$33+$80 ; ASN .BYTE $26,$28,$38+$80 ; ACS .BYTE $26,$39,$33+$80 ; ATN .BYTE $31,$33+$80 ; LN .BYTE $2A,$3D,$35+$80 ; EXP .BYTE $2E,$33,$39+$80 ; INT .BYTE $38,$36,$37+$80 ; SQR .BYTE $38,$2C,$33+$80 ; SGN .BYTE $26,$27,$38+$80 ; ABS .BYTE $35,$2A,$2A,$30+$80 ; PEEK .BYTE $3A,$38,$37+$80 ; USR .BYTE $38,$39,$37,$0D+$80 ; STR$ .BYTE $28,$2D,$37,$0D+$80 ; CHR$ .BYTE $33,$34,$39+$80 ; NOT .BYTE $17,$17+$80 ; ** .BYTE $34,$37+$80 ; OR .BYTE $26,$33,$29+$80 ; AND .BYTE $13,$14+$80 ; <= .BYTE $12,$14+$80 ; >= .BYTE $13,$12+$80 ; <> .BYTE $39,$2D,$2A,$33+$80 ; THEN .BYTE $39,$34+$80 ; TO .BYTE $38,$39,$2A,$35+$80 ; STEP .BYTE $31,$35,$37,$2E,$33,$39+$80 ; LPRINT .BYTE $31,$31,$2E,$38,$39+$80 ; LLIST .BYTE $38,$39,$34,$35+$80 ; STOP .BYTE $38,$31,$34,$3C+$80 ; SLOW .BYTE $2B,$26,$38,$39+$80 ; FAST .BYTE $33,$2A,$3C+$80 ; NEW .BYTE $38,$28,$37,$34,$31,$31+$80 ; SCROLL .BYTE $28,$34,$33,$39+$80 ; CONT .BYTE $29,$2E,$32+$80 ; DIM .BYTE $37,$2A,$32+$80 ; REM .BYTE $2B,$34,$37+$80 ; FOR .BYTE $2C,$34,$39,$34+$80 ; GOTO .BYTE $2C,$34,$38,$3A,$27+$80 ; GOSUB .BYTE $2E,$33,$35,$3A,$39+$80 ; INPUT .BYTE $31,$34,$26,$29+$80 ; LOAD .BYTE $31,$2E,$38,$39+$80 ; LIST .BYTE $31,$2A,$39+$80 ; LET .BYTE $35,$26,$3A,$38,$2A+$80 ; PAUSE .BYTE $33,$2A,$3D,$39+$80 ; NEXT .BYTE $35,$34,$30,$2A+$80 ; POKE .BYTE $35,$37,$2E,$33,$39+$80 ; PRINT .BYTE $35,$31,$34,$39+$80 ; PLOT .BYTE $37,$3A,$33+$80 ; RUN .BYTE $38,$26,$3B,$2A+$80 ; SAVE .BYTE $37,$26,$33,$29+$80 ; RAND .BYTE $2E,$2B+$80 ; IF .BYTE $28,$31,$38+$80 ; CLS .BYTE $3A,$33,$35,$31,$34,$39+$80 ; UNPLOT .BYTE $28,$31,$2A,$26,$37+$80 ; CLEAR .BYTE $37,$2A,$39,$3A,$37,$33+$80 ; RETURN .BYTE $28,$34,$35,$3E+$80 ; COPY .BYTE $37,$33,$29+$80 ; RND .BYTE $2E,$33,$30,$2A,$3E,$0D+$80 ; INKEY$ .BYTE $35,$2E+$80 ; PI ; ----------------------------------------- ; PROCEDURA 'UAKTUALNIANIA ODCZYTU-ZAPISU' ; ----------------------------------------- ; ; HL jest zwiększane aż do momentu, gdy zrówna się z wartością przechowywaną w E_LINE ; $01FC : 508 LOAD_SAVE: INC HL ; zwiększ HL o 1 EX DE,HL ; przenieś HL do DE, chwilowo LD HL,(E_LINE) ; pobierz adres wiersza edycyjnego do HL SCF ; ustaw znacznik przeniesienia SBC HL,DE ; porównaj HL z E_LINE, wynik w HL nas nie interesuje EX DE,HL ; przywróć HL zwiększone o 1 z DE RET NC ; wróć, jeśli należy załadować/zapisać więcej bajtów HL < E_LINE POP HL ; inaczej usuń ze stosu adres powrotu ; ------------------------- ; PROCEDURY 'WYŚWIETLANIA' ; ------------------------ ; ; Sprawdzenie, w jakim trybie pracuje aktualnie komputer: FAST czy SLOW. ; Testowany jest znacznik SLOW - bit nr 6 zmiennej systemowej CDFLAG. Procedura kończy się powrotem, jeśli program pracuje ; w trybie FAST lub gdy obraz dla trybu SLOW jest niedostępny. ; $0207 : 519 SLOW_FAST: LD HL,CDFLAG ; Pobierz do HL adres zmiennej CDFLAG. LD A,(HL) ; Załaduj jej zawartość do akumulatora. RLA ; przesuń bit nr 6 na pozycję nr 7. XOR (HL) ; bit 7 <- bit 6 xor bit 7 RLA ; umieść bit nr 7 w znaczniku przeniesienia. RET NC ; jeśli bity były takie same, to powróć. ; Teraz sprawdzamy, czy rzeczywiście mamy do czynienia z ZX81 lub, czy jest to ZX80 z nowym ROM'em. Standardowy ZX80 nie ; posiadał generatora NMI. LD A,$7F ; Załaduj do akumulatora %011111111 EX AF,AF' ; zachowaj to w AF' LD B,$11 ; licznik, po którym powinno pojawić się przerwanie NMI, jeśli mamy do czynienia z ZX81. OUT ($FE),A ; uruchom generator NMI. ; Uwaga: jeśli to jest ZX81, to procedura obsługi NMI powinna zwiększyć AF' ; $0216 : 534 LOOP_11: DJNZ LOOP_11 ; pętla, w którą wskoczy NMI = 16*13 cykli + 8 = 216 cykli. OUT ($FD),A ; wyłącz generator NMI. EX AF,AF' ; odtwórz wartość AF'. RLA ; testuj bit 7 poprzedniego AF' JR NC,NO_SLOW ; skocz naprzód do NO_SLOW, jeśli bit 7 jest wciąż 0 ; Jeśli AF' zostało zwiększone, to generator NMI działa i tryb SLOW może być ustawiony. SET 7,(HL) ; oznacza tryb SLOW - liczenie i wyświetlanie. PUSH AF ; * zapisz główne rejestry PUSH BC ; ** PUSH DE ; *** PUSH HL ; **** JR DISPLAY_1 ; przejdź naprzód do DISPLAY_1. ; $0226 : 550 NO_SLOW: RES 6,(HL) ; skasuj bit 6 zmiennej CDFLAG. RET ; -------------------------- ; GŁÓWNA PĘTLA WYŚWIETLANIA ; -------------------------- ; Ta procedura jest wykonywana jeden raz dla każdej wyświetlanej ramki. Najpierw pobierany jest i zmniejszany o 1 licznik ramek. ; Gdy licznik osiągnie zero, następuje powrót. ; $0229 : 553 DISPLAY_1: LD HL,(FRAMES) ; pobierz 2-bajtową zmienną systemową FRAMES. DEC HL ; zmniejsz licznik ramek. ; $022D : 557 DISPLAY_P: LD A,$7F ; przygotuj maskę AND H ; wybierz bity 6-0 z H. OR L ; połącz je z bitami L. LD A,H ; przeładuj A wszystkimi bitami z H dla testu PAUSE. Poprzednie dwa rozkazy ustawiły znacznik Z. ; Uwaga: oba skoki muszą zająć dokładnie ten sam czas. JR NZ,ANOTHER ; (12/7) naprzód do ANOTHER, jeśli bity 14-0 są niezerowe RLA ; (4) testuj bit 15 zmiennej FRAMES. JR OVER_NC ; (12) naprzód do OVER_NC z wynikiem ; $0237 : 567 ANOTHER: LD B,(HL) ; (7) Uwaga: wprowadza jedynie opóźnienie. SCF ; (4) ustaw znacznik przeniesienia. ; Uwaga: skok do tego miejsca zajmuje albo (12)(7)(4) cykli, albo (7)(4)(12) cykli. ; $0239 : 569 OVER_NC: LD H,A ; (4) ustaw H na zero LD (FRAMES),HL ; (16) uaktualnij zmienną systemową FRAMES RET NC ; (11/5) wróć, jeśli FRAMES jest używane przez PAUSE ; $023E : 574 DISPLAY_2: CALL KEYBOARD ; procedura KEYBOARD wstawia rząd klawisza do H i kolumnę do L. Odczyt portów również ; rozpoczyna impuls synchronizacji ramki TV. LD BC,(LAST_K) ; pobierz wartość ostatniego klawisza z LAST_K LD (LAST_K),HL ; uaktualnij LAST_K nową wartością. LD A,B ; do A wpisz poprzednią kolumnę - będzie $FF, jeśli nie naciśnięto żadnego klawisza ADD A,$02 ; dodanie 2 ustawi przeniesienie, jeśli nie było klawisza. SBC HL,BC ; odejmij z przeniesieniem te dwie wartości klawiszowe. ; Jeśli w obu był ten sam klawisz, to HL otrzyma wartość 0. LD A,(DBOUNC) ; pobierz zmienną systemową DEBOUNCE OR H ; i utwórz sumę logiczną z obu bajtami różnicy OR L ; ustawiając znacznik zera dla nadchodzącego skoku. LD E,B ; przenieś wartość kolumny do E LD B,$0B ; a do B wstaw jedenaście LD HL,CDFLAG ; W HL ustaw adres zmiennej systemowej CDFLAG RES 0,(HL) ; wyzeruj bit 0 zmiennej CDFLAG JR NZ,NO_KEY ; przeskocz naprzód, jeśli DEBOUNCE/różnicę >0 do NO-KEY BIT 7,(HL) ; sprawdź bit liczenia i wyświetlania w CDFLAG SET 0,(HL) ; ustaw na 1 bit 0 zmiennej CDFLAG. RET Z ; wróć, jeśli bit 7 oznaczał tryb fast. DEC B ; (4) zmniejsz licznik. NOP ; (4) opóźnienie - 4 cykle zegara SCF ; (4) ustaw znacznik przeniesienia ; $0264 : 612 NO_KEY: LD HL,DBOUNC ; pobierz adres zmiennej DEBOUNCE CCF ; zaneguj znacznik przeniesienia RL B ; obróć w lewo rejestr B pobierając bit przeniesienia C<-76543210<-C ; $026A : 618 LOOP_B: DJNZ LOOP_B ; pętla dopóki B>0 do LOOP-B LD B,(HL) ; pobierz wartość DEBOUNCE do B LD A,E ; przenieś wartość kolumny do A CP $FE SBC A,A LD B,$1F OR (HL) AND B RRA LD (HL),A ; uaktualnij DEBOUNCE OUT ($FF),A ; zakończ impuls synchronizacji ramki TV. LD HL,(D_FILE) ; (12) ustaw w HL adres bufora wyświetlania z D_FILE SET 7,H ; (8) ustaw bit 15, aby adresować echo bufora w górnej połówce RAM. CALL DISPLAY_3 ; (17) procedura DISPLAY-3 wyświetla górny zbiór pustych linii ; ------------------- ; PROCEDURA 'VIDEO-1' ; ------------------- ; $0281 : 641 R_IX_1: LD A,R ; (9) nieszkodliwe opóźnienie lub coś bardzo sprytnego? LD BC,$1901 ; (10) 25 wierszy, 1 linia skanująca w pierwszym. LD A,$F5 ; (7) Ta wartość zostanie załadowana do R i zapewni, iż cykl rozpocznie się we właściwej ; części ekranu po pozycji znaku nr 32 CALL DISPLAY_5 ; (17) procedura DISPLAY-5 kończy bieżącą pustą linię a następnie tworzy obraz zawartości ; bufora wyświetlania wykorzystując przerwania INT. Ostatnie przerwanie powraca do następnego adresu. ; $028B : 651 L028B DEC HL ; ustaw HL na ostatnie NEWLINE/HALT. CALL DISPLAY_3 ; procedura DISPLAY-3 wyświetla dolny zbiór pustych linii ; $028F : 655 R_IX_2: JP DISPLAY_1 ; wróć do DISPLAY-1 ; -------------------------------------- ; PROCEDURA 'WYŚWIETLANIA PUSTYCH LINII' ; -------------------------------------- ; Ten podprogram wywoływany jest dwukrotnie (zobacz powyżej) do utworzenia najpierw pustych linii u góry obrazu telewizyjnego, ; a następnie pustych linii na spodzie obrazu. ; $0292 : 658 DISPLAY_3: POP IX ; pobierz adres powrotny do rejestru IX. będzie to albo L0281, albo L028F - zobacz wyżej. LD C,(IY+$28) ; załaduj C wartością stałej systemowej MARGIN. BIT 7,(IY+$3B) ; sprawdź w CDFLAG, czy działa tryb wyświetlania i liczenia. JR Z,DISPLAY_4 ; w trybie FAST naprzód do DISPLAY-4 LD A,C ; przenieś MARGIN do A - 31d lub 55d. NEG ; zaneguj INC A EX AF,AF' ; umieść zanegowaną liczbę pustych linii w A' OUT ($FE),A ; włącz generator NMI. POP HL ; **** POP DE ; *** POP BC ; ** POP AF ; * Odtwórz główne rejestry RET ; powróć - koniec przerwania. Powrót nastąpi do programu użytkownika - BASIC lub kod maszynowy, ; który będzie przerywany przy każdym NMI. ; ---------------------- ; PROCEDURA 'TRYBU FAST' ; ---------------------- ; $02A9 : 681 DISPLAY_4: LD A,$FC ; (7) załaduj A z wartością opóźnienia dla R LD B,$01 ; (7) tylko jeden wiersz. CALL DISPLAY_5 ; (17) procedura DISPLAY-5 DEC HL ; (6) wskaż z powrotem na HALT. EX (SP),HL ; (19) Niegroźne opóźnienie, jeśli stosowane w parze. EX (SP),HL ; (19) Niegroźne opóźnienie. JP (IX) ; (8) do L0281 lub L028F ; --------------------- ; PROCEDURA 'DISPLAY-5' ; --------------------- ; Ta procedura jest wywoływana z trybów SLOW i FAST do utworzenia środka obrazu TV. W trybie SLOW rejestr R jest zwiększany przy ; każdej instrukcji do wartości $F7 przy zakończeniu procedury. W trybie FAST wartość końcowa będzie równa $FF, a przerwanie pojawi ; się, gdy tylko Licznik Rozkazów osiągnie instrukcję HALT. (24 cykle zegara) ; $02B5 : 693 DISPLAY_5: LD R,A ; (9) Załaduj R z A. R = wolno: $F5 szybko: $FC LD A,$DD ; (7) załaduj przyszłą wartość R. $F6 $FD EI ; (4) Włącz przerwania $F7 $FE JP (HL) ; (4) skocz do echa obrazu. $F8 $FF ; ------------------------------------- ; PROCEDURA 'PRZESZUKIWANIA KLAWIATURY' ; ------------------------------------- ; Klawiatura jest czytana w czasie okresu synchronizacji pionowej, gdy nie jest wyświetlany obraz. Odczyt portu z wyzerowanym najmłodszym ; bitem adresu, np. $FE rozpoczyna impuls synchronizacji pionowej. ; $02BB : 699 KEYBOARD: LD HL,$FFFF ; (16) przygotuj bufor na przyjęcie klawisza LD BC,$FEFE ; (20) ustaw BC na port $FEFE. Rejestr B ze swoim wyzerowanym jednym bitem pełni rolę licznika do 8. IN A,(C) ; (11) odczytaj port - na magistrali adresowej są umieszczane wszystkie 16 bitów. Start impulsu VSYNC. OR $01 ; (7) ustaw prawy bit, aby ignorować klawisz SHIFT. ; $02C5 : 709 EACH_LINE: OR $E0 ; [7] OR %11100000 LD D,A ; [4] przenieś do D. CPL ; [4] zaneguj - teraz znaczą tylko bity 4-0. CP $01 ; [7] ustawia przeniesienie, jeśli A zawiera zero. SBC A,A ; [4] $FF, jeśli $00, inaczej zero. OR B ; [7] $FF lub port FE, FD, FB.... AND L ; [4] O ile nie naciśnięto kilku klawiszy, L wciąż będzie $FF. Jeśli naciśnięto więcej niż jeden klawisz, ; to A ma teraz nieważną wartość. LD L,A ; [4] przenieś do L. ; teraz rozważ identyfikator kolumny. LD A,H ; [4] będzie równe $FF, jeśli nie było poprzednich klawiszy. AND D ; [4] 111xxxxx LD H,A ; [4] przenieś A do H ; ponieważ tylko jeden klawisz może być naciśnięty, H będzie zawierało, jeśli ważne, jedną z wartości 11111110, 11111101, 11111011, ; 11110111, 11101111 od zewnętrznej kolumny, powiedzmy Q, do wewnętrznej kolumny, powiedzmy T. RLC B ; [8] obróć licznik 8 / adres portu. ustawia przeniesienie, jeśli więcej do zrobienia. IN A,(C) ; [10] odczytaj kolejną połówkę wiersza. Tym razem wszystkie pięć bitów. JR C,EACH_LINE ; [12](7) kontynuuj w pętli, aż będzie zrobione ; Za drugim razem ostatnim odczytywanym wierszem jest SHIFT,Z,X,C,V. RRA ; (4) sprawdź klawisz SHIFT - przeniesienie zostanie wyzerowane jeśli ten klawisz jest wciśnięty. RL H ; (8) obróć w lewo H biorąc przeniesienie, co daje wartości kolumnowe - ; $FD, $FB, $F7, $EF, $DF. ; lub $FC, $FA, $F6, $EE, $DE z SHIFT. ; Teraz H identyfikuje kolumnę, a L identyfikuje wiersz w matrycy klawiatury. ; Teraz jest dobry moment na sprawdzenie, czy jest to komputer brytyjski lub amerykański. Wersja amerykańska posiada dodatkową diodę, ; która zeruje bit 6 odczytany z portu. RLA ; (4) skompensuj test na klawisz SHIFT. RLA ; (4) wyprowadź obrotem bit 7. RLA ; (4) testuj bit 6. SBC A,A ; (4) $FF lub $00 {USA} AND $18 ; (7) $18 lub $00 ADD A,$1F ; (7) $37 lub $1F ; wynikiem jest albo 31 (USA), albo 55 (WB) pustych linii ponad i poniżej obrazu TV. LD (MARGIN),A ; (13) uaktualnij zmienną systemową MARGIN RET ; (10) powróć ; --------------------------------- ; PROCEDURA 'USTAWIANIA TRYBU FAST' ; --------------------------------- ; $02E7 : 743 SET_FAST: BIT 7,(IY+$3B) ; zmienna systemowa CDFLAG RET Z HALT ; Czekaj na przerwanie OUT ($FD),A RES 7,(IY+$3B) ; zmienna systemowa CDFLAG RET ; ---------- ; 'RAPORT-F' ; ---------- ; $02F4 : 756 REPORT_F: RST 08H ; ERROR-1 .BYTE $0E ; Raport błędu: Brak nazwy programu. ; ------------------------ ; PROCEDURA 'ROZKAZU SAVE' ; ------------------------ ; $02F6 : 758 SAVE: CALL NAME JR C,REPORT_F ; jeśli pusta nazwa, wróć do REPORT-F powyżej. EX DE,HL LD DE,$12CB ; pięć sekund czasu ; $02FF : 767 HEADER: CALL BREAK_1 JR NC,BREAK_2 ; do BREAK-2 ; $0304 : 772 DELAY_1: DJNZ DELAY_1 ; pętla opóźniająca DEC DE LD A,D OR E JR NZ,HEADER ; wstecz do HEADER dla opóźnienia ; $030B : 779 OUT_NAME: CALL OUT_BYTE BIT 7,(HL) ; test na zanegowany bit. INC HL ; adres następnego znaku nazwy. JR Z,OUT_NAME ; jęli brak zanegowanego bitu, wróć do OUT-NAME ; teraz zacznij zapisywać zmienne systemowe. LD HL,VERSN ; ustaw start obszaru na VERSN, zachowując przy okazji RAMTOP i inne. ; $0316 : 790 OUT_PROG: CALL OUT_BYTE CALL LOAD_SAVE JR OUT_PROG ; pętla do OUT-PROG ; -------------------- ; PROCEDURA 'OUT-BYTE' ; -------------------- ; Ta procedura zapisuje bajt danych bit po bicie na domowy magnetofon. ; $031E : 798 OUT_BYTE: LD E,(HL) ; pobierz bajt do zapisu. SCF ; ustaw znacznik przeniesienia - jako marker. ; $0320 : 800 EACH_BIT: RL E ; C < 76543210 < C RET Z ; wróć, gdy przejdzie bit markera SBC A,A ; $FF jeśli bit ustawiony lub $00 bez przeniesienia AND $05 ; $05 $00 ADD A,$04 ; $09 $04 LD C,A ; przenieś licznik czasu do C. bit ustawiony ma dłuższy impuls niż bit wyzerowany. ; $0329 : 809 PULSES: OUT ($FF),A ; impuls do magnetofonu. LD B,$23 ; ustaw stałą czasową ; $032D : 813 DELAY_2: DJNZ DELAY_2 ; samozapętlenie do DELAY-2 CALL BREAK_1 ; procedura BREAK-1 testuje klawisz BREAK. ; $0332 : 818 BREAK_2: JR NC,REPORT_D ; jeśli przerwa, to naprzód do REPORT-D LD B,$1E ; ustaw wartość opóźnienia. ; $0336 : 822 DELAY_3: DJNZ DELAY_3 ; samozapętlenie do DELAY-3 DEC C ; zmniejsz licznik JR NZ,PULSES ; wróć w pętli do PULSES ; $033B : 827 DELAY_4: AND A ; wyzeruj przeniesienie dla następnego testu bitu. DJNZ DELAY_4 ; samozapętlenie do DELAY-4 (B jest zero - 256) JR EACH_BIT ; wróć w pętli do EACH-BIT ; ------------------------ ; PROCEDURA 'ROZKAZU LOAD' ; ------------------------ ; $0340 : 832 LOAD: CALL NAME ; DE wskazuje początek nazwy w RAM. RL D ; pobierz przeniesienie RRC D ; teraz przeniesienie w bicie 7. ; $0347 : 839 NEXT_PROG: CALL IN_BYTE JR NEXT_PROG ; pętla do NEXT-PROG ; ------------------- ; PROCEDURA 'IN-BYTE' ; ------------------- ; $034C : 844 IN_BYTE: LD C,$01 ; przygotuj licznik do ośmiu 00000001. ; $034E : 846 NEXT_BIT: LD B,$00 ; ustaw licznik na 256 ; $0350 : 848 BREAK_3: LD A,$7F ; odczytaj wiersz klawiatury IN A,($FE) ; z klawiszem SPACE. OUT ($FF),A ; wyślij sygnał na ekran. RRA ; sprawdź naciśnięcie SPACE. JR NC,BREAK_4 ; jeśli tak, skocz naprzód do BREAK-4 RLA ; odwróć powyższy obrót bitów RLA ; sprawdź bit taśmy. JR C,GET_BIT ; jeśli ustawiony, idź naprzód do GET-BIT DJNZ BREAK_3 ; wróć w pętli do BREAK-3 POP AF ; usuń adres powrotu. CP D ; $0361 : 865 RESTART: JP NC,INITIAL ; jeśli D jest zero, skocz naprzód do INITIAL, aby zresetować system jeśli sygnał z taśmy ; przekroczył dozwolony czas, np. przy zatrzymaniu magnetofonu. Nie wystarczy zwykły raport błędów, ; ponieważ część zmiennych systemowych została nadpisana. LD H,D ; w przeciwnym razie przenieś start nazwy LD L,E ; do rejestru HL ; $0366 : 870 IN_NAME: CALL IN_BYTE ; procedura IN-BYTE jest pewnego rodzaju rekursją dla części nazwy. Odebrany bajt jest w C. BIT 7,D ; czy nazwa jest pustym łańcuchem? LD A,C ; przenieś bit do A. JR NZ,MATCHING ; przy pustym łańcuchu naprzód do MATCHING CP (HL) ; inaczej porównaj z łańcuchem w pamięci. JR NZ,NEXT_PROG ; wróć przy niezgodności do NEXT-PROG (na pozór koniec procedury, lecz adres powrotny został usunięty). ; $0371 : 881 MATCHING: INC HL ; adresuj następny znak nazwy RLA ; test na zanegowany bit. JR NC,IN_NAME ; jeśli go brak, wróć do IN-NAME ; nazwa w całości zgadza się. Przejdź do odczytu danych, ale najpierw zwiększ starszy bajt E_LINE, która jest jedną ze zmiennych ; systemowych do załadowania. Ponieważ młodszy bajt jest odczytywany przed starszym, możliwe jest, że w fazie pośredniej błędna wartość ; mogłaby spowodować zbyt wczesne zakończenie ładowania - zobacz na test w LOAD/SAVE. INC (IY+$15) ; zwiększ starszy bajt zmiennej systemowej E_LINE. LD HL,VERSN ; rozpocznij ładowanie od zmiennej systemowej VERSN. ; $037B : 891 IN_PROG: LD D,B ; ustaw D na zero jako znacznik. CALL IN_BYTE ; procedura IN-BYTE ładuje bajt LD (HL),C ; wstaw zebrany bajt do pamięci. CALL LOAD_SAVE JR IN_PROG ; wróć w pętli do IN-PROG ; to odgałęzienie zbiera pełny bajt przed zwykłym opuszczeniem procedury IN-BYTE. ; $0385 : 901 GET_BIT: PUSH DE ; zachowaj LD E,$94 ; wartość licznika czasu. ; $0388 : 904 TRAILER: LD B,$1A ; licznik na dwadzieścia sześć. ; $038A : 906 COUNTER: DEC E ; zmniejsz stan licznika. IN A,($FE) ; wczytaj bit z magnetofonu RLA BIT 7,E LD A,E JR C,TRAILER ; z ustawionym przeniesieniem wróć do TRAILER DJNZ COUNTER ; inaczej do COUNTER POP DE JR NZ,BIT_DONE ; do BIT-DONE CP $56 JR NC,NEXT_BIT ; do NEXT-BIT ; $039C : 924 BIT_DONE: CCF ; zaneguj znacznik przeniesienia RL C JR NC,NEXT_BIT ; do NEXT-BIT RET ; powróć z pełnym bajtem. ; jeśli w trakcie odczytu danych było przerwanie, wykonaj reset. Jeśli przerwanie w czasie oczekiwania na program z taśmy, ; to przerwa dozwolona. ; $03A2 : 930 BREAK_4: LD A,D ; przenieś znacznik do A. AND A ; test na zero. JR Z,RESTART ; jeśli tak, wróć do RESTART ; $03A6 : 934 REPORT_D: RST 08H ; ERROR-1 .BYTE $0C ; Raport błędu: PRZERWANIE - CONT powtarza ; -------------------------- ; PROCEDURA 'NAZWY PROGRAMU' ; -------------------------- ; Nazwa jest sprawdzana na raport C. Wybrany zostaje tryb FAST oraz ostatnia litera nazwy jest ustawiana w negatywie. ; $03A8 : 936 NAME: CALL SCANNING LD A,(FLAGS) ADD A,A JP M,REPORT_C POP HL RET NC PUSH HL CALL SET_FAST CALL STK_FETCH LD H,D LD L,E DEC C RET M ADD HL,BC SET 7,(HL) ; ustaw bit 7 ostatniego znaku nazwy - znak w negatywie oznacza koniec łańcucha nazwy RET ; ----------------------- ; PROCEDURA ROZKAZU 'NEW' ; ----------------------- ; $03C3 : 963 NEW: CALL SET_FAST LD BC,(RAMTOP) ; pobierz zawartość zmiennej systemowej RAMTOP DEC BC ; ustaw na ostatni bajt systemowy ; --------------------------- ; PROCEDURA 'SPRAWDZANIA RAM' ; --------------------------- ; $03CB : 971 RAM_CHECK: LD H,B LD L,C ; przenieś BC do HL LD A,$3F ; $03CF : 975 RAM_FILL: LD (HL),$02 ; wypełnij pamięć liczbą $02 DEC HL CP H ; sprawdź, czy cała pamięć już wypełniona JR NZ,RAM_FILL ; jeśli nie, wypełniaj dalej ; $03D5 : 981 RAM_READ: AND A ; wyzeruj przeniesienie SBC HL,BC ADD HL,BC INC HL JR NC,SET_TOP DEC (HL) JR Z,SET_TOP DEC (HL) JR Z,RAM_READ ; $03E2 : 994 SET_TOP: LD (RAMTOP),HL ; ustaw zmienną systemową RAMTOP na pierwszy bajt ponad obszarem systemowym BASICU. ; ------------------------- ; PROCEDURA 'INICJALIZACJI' ; ------------------------- ; $03E5 : 997 INITIAL: LD HL,(RAMTOP) ; pobierz zmienną systemową RAMTOP. DEC HL ; ustaw adres ostatniego bajtu systemowego. LD (HL),$3E ; ustaw znacznik kończ $3E - zbyt duży dla starszego bajtu numeru wiersza. DEC HL ; ustaw adres nieważnego, młodszego bajtu. LD SP,HL ; i ustaw wskaźnik stosu na ten adres DEC HL ; ustaw adres pierwszego bajtu na stosie procesora, DEC HL ; który zostanie zapełniony przez następne CALL/PUSH. LD (ERR_SP),HL ; ustaw wskaźnik stosu błędów ERR_SP na początek obecnie pustego stosu procesora. ; Teraz ustaw rejestr I, aby układy generacji obrazu wiedziały, gdzie odnaleźć zastaw znaków. Ten ROM wykorzystuje zestaw znaków ; tylko do drukowania na ZX Printer. Obraz TV tworzony jest przez zewnętrzne obwody wideo. Ta pamięć ROM 8KB może być używana jako ; rozszerzenie w ZX80 zamiast jego oryginalnej pamięci 4KB ROM, zatem obwody wideo mogą być na ZX80. LD A,$1E ; dla tego ROM adres wynosi $1E00. LD I,A ; ustaw rejestr I poprzez rejestr A. IM 1 ; wybierz tryb 1 dla przerwań Z80. LD IY,ERR_NR ; ustaw IY na początek RAM, aby można było indeksować zmienne systemowe. LD (IY+$3B),$40 ; ustaw CDFLAG na 0100 0000. Bit 6 wskazuje wymagany tryb obliczeń i generacji obrazu. LD HL,$407D ; pierwsza komórka za Zmiennymi Systemowymi - 16509 dziesiętnie. LD (D_FILE),HL ; ustaw na tę wartość zmienną systemową D_FILE. LD B,$19 ; ustaw minimalny ekran na 24 znaki NEWLINE, które nastąpią po początkowym NEWLINE. ; $0408 : 1032 LINE: LD (HL),$76 ; wstaw NEWLINE (instrukcja HALT) INC HL ; zaadresuj następną pozycję. DJNZ LINE ; wróć w pętli do LINE dla wszystkich 25 znaków NEWLINE LD (VARS),HL ; ustaw zmienną systemową VARS na następny adres CALL CLEAR ; procedura CLEAR ustawia znacznik końca $80 oraz wskaźniki dynamicznej pamięci E_LINE, STKBOT i STKEND. ; $0413 : 1043 N_L_ONLY: CALL CURSOR_IN ; procedura CURSOR-IN wstawia kursor i znacznik końca w wierszu edycji, ustawiając również rozmiar ; dolnych dwóch wierszy ekranu. CALL SLOW_FAST ; procedura SLOW/FAST wybiera tryb obliczeń i wyświetlania ; ---------------------- ; SEKCJA 'WYDRUK BASICU' ; ---------------------- ; 'Górna' część obrazu jest tworzona przez wywołanie najpierw procedury polecenia CLS, a następnie program w języku BASIC jest wyświetlany ; od S-TOP. Użycie klawisza "kursor w dół" również powoduje przebudowę "górnej" części obrazu. ; $0419 : 1049 UPPER: CALL CLS LD HL,(E_PPC) ; młodszy bajt zmiennej systemowej E_PPC LD DE,(S_TOP) ; młodszy bajt zmiennej systemowej S_TOP AND A SBC HL,DE EX DE,HL JR NC,ADDR_TOP ADD HL,DE LD (S_TOP),HL ; młodszy bajt zmiennej systemowej S_TOP ; $042D : 1069 ADDR_TOP: CALL LINE_ADDR JR Z,LIST_TOP EX DE,HL ; $0433 : 1075 LIST_TOP: CALL LIST_PROG DEC (IY+$1E) ; zmienna systemowa BERG JR NZ,LOWER LD HL,(E_PPC) ; młodszy bajt zmiennej systemowej E_PPC CALL LINE_ADDR LD HL,(CH_ADD) ; młodszy bajt zmiennej systemowej CH_ADD SCF ; ustaw znacznik przeniesienia SBC HL,DE LD HL,S_TOP ; młodszy bajt zmiennej systemowej S_TOP JR NC,INC_LINE EX DE,HL LD A,(HL) INC HL LDI LD (DE),A JR UPPER ; punkt wejścia dla 'kursor w dół' ; $0454 : 1108 DOWN_KEY: LD HL,E_PPC ; młodszy bajt zmiennej systemowej E_PPC ; $0457 : 1111 INC_LINE: LD E,(HL) INC HL LD D,(HL) PUSH HL EX DE,HL INC HL CALL LINE_ADDR CALL LINE_NO POP HL ; $0464 : 1124 KEY_INPUT: BIT 5,(IY+$2D) ; zmienna systemowa FLAGX JR NZ,LOWER ; skocz naprzód do LOWER LD (HL),D DEC HL LD (HL),E JR UPPER ; ----------------------------- ; SEKCJA 'KOPII WIERSZA EDYCJI' ; ----------------------------- ; Procedura ta ustawia wiersz edycji jedynie z kursorem, gdy ; 1) Brakuje pamięci do edycji wiersza BASIC. ; 2) Podczas wprowadzania naciśnieto klawisz EDIT. ; Punktem wejścia jest LOWER ; $046F : 1135 EDIT_INP: CALL CURSOR_IN ; procedura CURSOR-IN ustawia wiersz edycji jedynie z kursorem. ; $0472 : 1138 LOWER: LD HL,(E_LINE) ; pobierz start wiersza edycji z E_LINE. ; $0475 : 1141 EACH_CHAR: LD A,(HL) ; pobierz znak z wiersza edycji. CP $7E ; porównaj go ze znacznikiem liczby. JR NZ,END_LINE ; jeśli różny, skocz naprzód do END-LINE LD BC,$0006 ; inaczej sześć niewidocznych bajtów do usunięcia. CALL RECLAIM_2 JR EACH_CHAR ; wróć do EACH-CHAR ; $0482 : 1154 END_LINE: CP $76 INC HL JR NZ,EACH_CHAR ; $0487 : 1159 EDIT_LINE: CALL CURSOR ; procedura CURSOR ustawia kursor K lub L. ; $048A : 1162 EDIT_ROOM: CALL LINE_ENDS LD HL,(E_LINE) ; pobierz zmienną systemową E_LINE LD (IY+$00),$FF ; zmienna systemowa ERR_NR CALL COPY_LINE BIT 7,(IY+$00) ; zmienna systemowa ERR_NR JR NZ,DISPLAY_6 LD A,(DF_SZ) ; zmienna systemowa DF_SZ CP $18 JR NC,DISPLAY_6 INC A LD (DF_SZ),A LD B,A LD C,$01 CALL LOC_ADDR LD D,H LD E,L LD A,(HL) ; $04B1 : 1201 FREE_LINE: DEC HL CP (HL) JR NZ,FREE_LINE INC HL EX DE,HL LD A,($4005) ; starszy bajt zmiennej systemowej RAMTOP CP $4D CALL C,RECLAIM_1 JR EDIT_ROOM ; ------------------------------- ; SEKCJA 'OCZEKIWANIA NA KLAWISZ' ; ------------------------------- ; $04C1 : 1217 DISPLAY_6: LD HL,$0000 ; zeruj HL LD (X_PTR),HL ; wyzeruj zmienną systemową X_PTR LD HL,CDFLAG ; pobierz CDFLAG do HL BIT 7,(HL) ; sprawdź bit 7 CALL Z,DISPLAY_1 ; jeśli jest wyzerowany, wywołaj procedurę DISPLAY-1 ; $04CF : 1231 SLOW_DISP: BIT 0,(HL) ; sprawdź bit 0 JR Z,SLOW_DISP ; jeśli wyzerowany, skocz do SLOW-DISP LD BC,(LAST_K) ; pobierz do BC zmienną systemową LAST_K CALL DEBOUNCE ; czekaj na wygaśnięcie drgań klawiatury CALL DECODE ; dekoduj klawisz JR NC,LOWER ; wróć do LOWER ; ------------------------------- ; SEKCJA 'DEKODOWANIA KLAWIATURY' ; ------------------------------- ; Zdekodowany kod klawisza jest w E a HL wskazuje na pozycję w tablicy klawiszy. D zawiera zero. ; $04DF : 1247 K_DECODE: LD A,(MODE) ; pobierz zawartość zmiennej systemowej MODE DEC A ; testuj razem trzy wartości JP M,FETCH_2 ; naprzód przy zerze do FETCH-2 JR NZ,FETCH_1 ; naprzód przy 2 do FETCH-1 ; Pierwotną wartością było 1, a teraz jest zero. LD (MODE),A ; uaktualnij zmienną systemową MODE DEC E ; zmniejsz E do zakresu $00 - $7F LD A,E ; przenieś je do A SUB $27 ; odejmij 39, ustawiając przeniesienie, jeśli w zakresie 00 - 38 JR C,FUNC_BASE ; w takim razie idź do przodu do FUNC-BASE LD E,A ; inaczej ustaw w E zmniejszoną wartość ; $04F2 : 1266 FUNC_BASE: LD HL,K_FUNCT ; adres tablicy K-FUNCT dla klawiszy funkcyjnych. JR TABLE_ADD ; skocz naprzód do TABLE-ADD ; $04F7 : 1271 FETCH_1: LD A,(HL) CP $76 JR Z,K_L_KEY CP $40 SET 7,A JR C,ENTER LD HL,$00C7 ; $0505 : 1285 TABLE_ADD: ADD HL,DE JR FETCH_3 ; $0508 : 1288 FETCH_2: LD A,(HL) BIT 2,(IY+$01) ; zmienna systemowa FLAGS - tryb K lub L ? JR NZ,TEST_CURS ADD A,$C0 CP $E6 JR NC,TEST_CURS ; $0515 : 1301 FETCH_3: LD A,(HL) ; $0516 : 1302 TEST_CURS: CP $F0 JP PE,KEY_SORT ; $051B : 1307 ENTER: LD E,A CALL CURSOR LD A,E CALL ADD_CHAR ; $0523 : 1315 BACK_NEXT: JP LOWER ; --------------------------- ; PROCEDURA 'DODAWANIA ZNAKU' ; --------------------------- ; $0526 : 1318 ADD_CHAR: CALL ONE_SPACE LD (DE),A RET ; ---------------------------- ; PROCEDURA 'KLAWISZY KURSORA' ; ---------------------------- ; $052B : 1323 K_L_KEY: LD A,$78 ; $052D : 1325 KEY_SORT: LD E,A LD HL,$0482 ; adres bazowy ED-KEYS ADD HL,DE ADD HL,DE LD C,(HL) INC HL LD B,(HL) PUSH BC ; $0537 : 1335 CURSOR: LD HL,(E_LINE) ; zmienna systemowa E_LINE BIT 5,(IY+$2D) ; zmienna systemowa FLAGX JR NZ,L_MODE ; $0540 : 1344 K_MODE: RES 2,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj użycie trybu K ; $0544 : 1348 TEST_CHAR: LD A,(HL) CP $7F RET Z INC HL CALL NUMBER JR Z,TEST_CHAR CP $26 JR C,TEST_CHAR CP $DE JR Z,K_MODE ; $0556 : 1366 L_MODE: SET 2,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj użycie trybu L JR TEST_CHAR ; -------------------------- ; PROCEDURA 'WYCZYŚĆ-JEDEN' ; -------------------------- ; $055C : 1372 CLEAR_ONE: LD BC,$0001 JP RECLAIM_2 ; ----------------------------- ; TABLICA 'KLAWISZY EDYCYJNYCH' ; ----------------------------- ; $0562 : 1378 ED_KEYS: .WORD UP_KEY ; Adres: $059F .WORD DOWN_KEY ; Adres: $0454 .WORD LEFT_KEY ; Adres: $0576 .WORD RIGHT_KEY ; Adres: $057F .WORD FUNCTION ; Adres: $05AF .WORD EDIT_KEY ; Adres: $05C4 .WORD N_L_KEY ; Adres: $060C .WORD RUBOUT ; Adres: $058B .WORD FUNCTION ; Adres: $05AF .WORD FUNCTION ; Adres: $05AF ; ------------------------- ; PROCEDURA 'KURSOR W LEWO' ; ------------------------- ; $0576 : 1398 LEFT_KEY: CALL LEFT_EDGE LD A,(HL) LD (HL),$7F INC HL JR GET_CODE ; -------------------------- ; PROCEDURA 'KURSOR W PRAWO' ; -------------------------- ; $057F : 1407 RIGHT_KEY: INC HL LD A,(HL) CP $76 JR Z,ENDED_2 LD (HL),$7F DEC HL ; $0588 : 1416 GET_CODE: LD (HL),A ; $0589 : 1417 ENDED_1: JR BACK_NEXT ; ----------------------- ; PROCEDURA 'WYMAZYWANIA' ; ----------------------- ; $058B : 1419 RUBOUT: CALL LEFT_EDGE CALL CLEAR_ONE JR ENDED_1 ; ------------------------ ; PROCEDURA 'LEWA KRAWĘDŹ' ; ------------------------ ; $0593 : 1427 LEFT_EDGE: DEC HL LD DE,(E_LINE) LD A,(DE) CP $7F RET NZ POP DE ; $059D : 1437 ENDED_2: JR ENDED_1 ; ------------------------- ; PROCEDURA 'KURSOR W GÓRĘ' ; ------------------------- ; $059F : 1439 UP_KEY: LD HL,(E_PPC) CALL LINE_ADDR EX DE,HL CALL LINE_NO LD HL,$400B ; ustaw HL na starszy bajt zmiennej systemowej E_PPC JP KEY_INPUT ; skocz wstecz do KEY-INPUT ; ----------------------------- ; PROCEDURA 'KLAWISZ FUNKCYJNY' ; ----------------------------- ; $05AF : 1455 FUNCTION: LD A,E AND $07 LD (MODE),A JR ENDED_2 ; -------------------------------- ; PROCEDURA 'ZBIERZ NUMER WIERSZA' ; -------------------------------- ; $05B7 : 1463 ZERO_DE: EX DE,HL LD DE,DISPLAY_6 + 1 ; $04C2 - miejsce adresujące dwa zera ; $05BB : 1467 LINE_NO: LD A,(HL) AND $C0 JR NZ,ZERO_DE LD D,(HL) INC HL LD E,(HL) RET ; ------------------------ ; PROCEDURA 'KLAWISZ EDIT' ; ------------------------ ; $05C4 : 1476 EDIT_KEY: CALL LINE_ENDS ; procedura LINE-ENDS czyści spód ekranu. LD HL,EDIT_INP PUSH HL ; ** umieszczane na stosie jako adres pętli w przypadku błędu. BIT 5,(IY+$2D) ; testuj FLAGX RET NZ ; w trybie wprowadzania skocz pośrednio do do $046F, EDIT-INP (zacznij jeszcze raz). LD HL,(E_LINE) ; pobierz E_LINE LD (DF_CC),HL ; i użyj do uaktualnienia kursora ekranowego DF_CC ; teraz RST $10 wydrukuje numery wierszy do wiersza edycji zamiast na ekran. Najpierw jednak należy się upewnić, że żaden znak newline ; nie pojawi się poza ekranem podczas drukowania numerów wierszy do tego wiersza edycyjnego. LD HL,$1821 ; przygotuj wiersz 0, kolumnę 0 LD (S_POSN),HL ; uaktualnij S_POSN tymi podstawionymi wartościami. LD HL,(E_PPC) ; pobierz bieżący wiersz z E_PPC, może to być nieistniejący wiersz, tj. ostatnio usunięty. CALL LINE_ADDR ; procedura LINE-ADDR pobiera adres wiersza lub, gdy go brak, adres następnego wiersza. CALL LINE_NO ; procedura LINE-NO pobiera numer wiersza, jeśli taki jest, do DE, pozostawiając HL wskazujące ; na drugi młodszy bajt. LD A,D ; sprawdź, czy numer wiersza wynosi zero. OR E RET Z ; wróć, jeśli brak numeru wiersza - brak programu do edycji. DEC HL ; wskazuj starszy bajt. CALL OUT_NO ; procedura OUT-NO zapisuje numer do wiersza edycji. INC HL ; wskazuj na bajty długości. LD C,(HL) ; młodszy baj do C. INC HL LD B,(HL) ; starszy bajt do B. INC HL ; wskazuj pierwszy znak w wierszu. LD DE,(DF_CC) ; pobierz kursor pliku wyświetlania DF_CC LD A,$7F ; przygotuj znak kursora. LD (DE),A ; i wstaw go do wiersza edycji. INC DE ; zwiększ adres przeznaczenia. PUSH HL ; * zapisz początek BASIC. LD HL,$001D ; 29 bajtów nadmiarowych. ADD HL,DE ; dodaj adres kursora. ADD HL,BC ; dodaj długość wiersza. SBC HL,SP ; odejmij wskaźnik stosu. POP HL ; * odtwórz wskaźnik początku BASIC. RET NC ; jeśli brak miejsca, wróć do L046F EDIT-INP. Klawisz EDIT nie będzie działał. LDIR ; inaczej skopiuj bajty z programu do wiersza edycji. Uwaga, ukryte wartości zmiennoprzecinkowe ; również są kopiowane do wiersza edycji EX DE,HL ; przenieś wskaźnik wolnego miejsca do HL POP DE ; ** usuń adres EDIT-INP ze stosu. CALL SET_STK_B ; procedura SET-STK-B ustawia STKEND z HL. JR ENDED_2 ; wstecz do ENDED-2 i po kolejnych 3 skokach do $0472, LOWER. ; Uwaga. Procedura LOWER usuwa ukryte wartości zmiennoprzecinkowe z wiersza edycji. ; --------------------------- ; PROCEDURA 'KLAWISZ NEWLINE' ; --------------------------- ; $060C : 1548 N_L_KEY: CALL LINE_ENDS LD HL,LOWER ; przygotuj adres: LOWER BIT 5,(IY+$2D) ; zmienna systemowa FLAGX JR NZ,NOW_SCAN LD HL,(E_LINE) LD A,(HL) CP $FF JR Z,STK_UPPER CALL CLEAR_PRB CALL CLS ; $0626 : 1574 STK_UPPER: LD HL,UPPER ; $0629 : 1577 NOW_SCAN: PUSH HL ; zapisz na stosie adres procedury (LOWER lub UPPER). CALL LINE_SCAN POP HL CALL CURSOR CALL CLEAR_ONE CALL E_LINE_NO JR NZ,N_L_INP LD A,B OR C JP NZ,N_L_LINE DEC BC DEC BC LD (PPC),BC LD (IY+$22),$02 ; zmienna systemowa DF_SZ LD DE,(D_FILE) JR TEST_NULL ; $064E : 1614 N_L_INP: CP $76 JR Z,N_L_NULL ; to N/L-NULL LD BC,(T_ADDR) CALL LOC_ADDR LD DE,(NXTLIN) LD (IY+$22),$02 ; zmienna systemowa DF_SZ ; $0661 : 1633 TEST_NULL: RST 18H ; POBIERZ-ZNAK CP $76 ; $0664 : 1636 N_L_NULL: JP Z,N_L_ONLY LD (IY+$01),$80 ; zmienna systemowa FLAGS EX DE,HL ; $066C : 1644 NEXT_LINE: LD (NXTLIN),HL EX DE,HL CALL TEMP_PTR2 CALL LINE_RUN RES 1,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj, że drukarka nie jest używana LD A,$C0 LD (IY+$19),A ; młodszy bajt zmiennej systemowej X_PTR CALL X_TEMP RES 5,(IY+$2D) ; zmienna systemowa FLAGX BIT 7,(IY+$00) ; zmienna systemowa ERR_NR JR Z,STOP_LINE LD HL,(NXTLIN) AND (HL) JR NZ,STOP_LINE LD D,(HL) INC HL LD E,(HL) LD (PPC),DE INC HL LD E,(HL) INC HL LD D,(HL) INC HL EX DE,HL ADD HL,DE CALL BREAK_1 JR C,NEXT_LINE LD HL,ERR_NR BIT 7,(HL) JR Z,STOP_LINE LD (HL),$0C ; $06AE : 1710 STOP_LINE: BIT 7,(IY+$38) ; zmienna systemowa PR_CC CALL Z,COPY_BUFF LD BC,$0121 CALL LOC_ADDR LD A,(ERR_NR) LD BC,(PPC) INC A JR Z,REPORT CP $09 JR NZ,CONTINUE INC BC ; $06CA : 1738 CONTINUE: LD (OLDPPC),BC JR NZ,REPORT DEC BC ; $06D1 : 1745 REPORT: CALL OUT_CODE LD A,$18 RST 10H ; PISZ-AKUMULATOR CALL OUT_NUM CALL CURSOR_IN JP DISPLAY_6 ; $06E0 : 1760 N_L_LINE: LD (E_PPC),BC LD HL,(CH_ADD) EX DE,HL LD HL,N_L_ONLY ; adresuj: N/L-ONLY PUSH HL LD HL,(STKBOT) SBC HL,DE PUSH HL PUSH BC CALL SET_FAST CALL CLS POP HL CALL LINE_ADDR JR NZ,COPY_OVER CALL NEXT_ONE CALL RECLAIM_2 ; $0705 : 1797 COPY_OVER: POP BC LD A,C DEC A OR B RET Z PUSH BC INC BC INC BC INC BC INC BC DEC HL CALL MAKE_ROOM CALL SLOW_FAST POP BC PUSH BC INC DE LD HL,(STKBOT) DEC HL LDDR ; kopiuj bajty LD HL,(E_PPC) EX DE,HL POP BC LD (HL),B DEC HL LD (HL),C DEC HL LD (HL),E DEC HL LD (HL),D RET ; ---------------------------------- ; PROCEDURY POLECEŃ 'LIST' I 'LLIST' ; ---------------------------------- ; $072C : 1836 LLIST: SET 1,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj uzywanie drukarki ; $0730 : 1840 LIST: CALL FIND_INT LD A,B ; pobierz starszy bajt numeru wiersza dostarczonego przez użytkownika. AND $3F ; i ogranicz go do zakresu 1-16383. LD H,A LD L,C LD (E_PPC),HL ; wynik umieść w zmiennej systemowej E_PPC CALL LINE_ADDR ; $073E : 1854 LIST_PROG: LD E,$00 ; $0740 : 1856 UNTIL_END: CALL OUT_LINE ; procedura OUT-LINE tworzy listing jednego wiersza w BASIC wracając wcześniej, gdy ekran staje się ; pełny lub napotka koniec programu. JR UNTIL_END ; pętla do UNTIL-END ; --------------------------------- ; PROCEDURA 'WYDRUKU WIERSZA BASIC' ; --------------------------------- ; $0745 : 1861 OUT_LINE: LD BC,(E_PPC) CALL CP_LINES LD D,$92 JR Z,TEST_END LD DE,$0000 RL E ; $0755 : 1877 TEST_END: LD (IY+$1E),E ; zmienna systemowa BERG LD A,(HL) CP $40 POP BC RET NC PUSH BC CALL OUT_NO INC HL LD A,D RST 10H ; PISZ-AKUMULATOR INC HL INC HL ; $0766 : 1894 COPY_LINE: LD (CH_ADD),HL SET 0,(IY+$01) ; zmienna systemowa FLAGS - usuń wiodącą spację ; $076D : 1901 MORE_LINE: LD BC,(X_PTR) LD HL,(CH_ADD) AND A SBC HL,BC JR NZ,TEST_NUM LD A,$B8 RST 10H ; PISZ-AKUMULATOR ; $077C : 1916 TEST_NUM: LD HL,(CH_ADD) LD A,(HL) INC HL CALL NUMBER LD (CH_ADD),HL JR Z,MORE_LINE CP $7F JR Z,OUT_CURS CP $76 JR Z,OUT_CH BIT 6,A JR Z,NOT_TOKEN CALL TOKENS JR MORE_LINE ; wróć w pętli do MORE-LINE ; $079A : 1946 NOT_TOKEN: RST 10H ; PISZ-AKUMULATOR JR MORE_LINE ; wróć w pętli do MORE-LINE ; $079D : 1949 OUT_CURS: LD A,(MODE) ; pobierz zawartość zmiennej systemowej MODE LD B,$AB ; przygotuj negatywowe F dla kursora funkcyjnego. AND A ; test na zero JR NZ,FLAGS_2 ; jeśli nie, skocz naprzód do FLAGS-2 LD A,(FLAGS) ; pobierz zmienną systemową FLAGS. LD B,$B0 ; przygotuj negatywowe K dla kursora. ; $07AA : 1962 FLAGS_2: RRA ; 00000?00 -> 000000?0 RRA ; 000000?0 -> 0000000? AND $01 ; 0000000? 0000000x ADD A,B ; [F] -> [G] lub [K] -> [L] CALL PRINT_SP ; procedura PRINT-SP drukuje znak JR MORE_LINE ; wróć do MORE-LINE ; ------------------ ; PROCEDURA 'LICZBA' ; ------------------ ; Ta procedura sprawdza, czy znak w rejestrze jest równy znacznikowi liczby. Jeśli tak, to wartość w parze rejestrów HL jest zwiększana o 5, ; aby albo przeskoczyć liczbę zmiennoprzecinkową, albo zarezerwować pięć bajtów na taką liczbę. ; $07B4 : 1972 NUMBER: CP $7E ; znacznik liczby? RET NZ ; wróć, jeśli nie INC HL ; przesuń HL o pięć bajtów INC HL INC HL INC HL INC HL RET ; ----------------------------------- ; PROCEDURA 'DEKODOWANIA KLAWIATURY' ; ----------------------------------- ; Różne 'wartości klawiszy' przechowywane w parze rejestrów BC są 'dekodowane' na normalne kody znakowe komputera ZX81 poprzez wyszukiwanie ich ; w tablicy klawiszy spod adresu $007E ($007D+1) - KUNSHIFT. Kod znaku jest określony przez (HL). ; $07BD : 1981 DECODE: LD D,$00 SRA B SBC A,A OR $26 LD L,$05 SUB L ; $07C7 : 1991 KEY_LINE: ADD A,L SCF RR C JR C,KEY_LINE INC C RET NZ LD C,B DEC L LD L,$01 JR NZ,KEY_LINE LD HL,$007D LD E,A ADD HL,DE SCF RET ; ----------------------- ; PROCEDURA 'DRUKOWANIA' ; ----------------------- ; Dwie procedurki WRITE-CH i WRITE stanowią istotne części procedury drukującej. Jednakże zanim znak będzie mógł zostać wydrukowany, należy pobrać ; S-POSN, sprawdzić i w razie konieczności poszerzyć ekran. Stosowane są różne punkty wejścia do tej procedury, które związane są z zamianą ; kodów binarnych na kody znakowe komputera ZX81. ; $07DC : 2012 LEAD_SP: LD A,E AND A RET M JR PRINT_CH ; $07E1 : 2017 OUT_DIGIT: XOR A ; $07E2 : 2018 DIGIT_INC: ADD HL,BC INC A JR C,DIGIT_INC SBC HL,BC DEC A JR Z,LEAD_SP ; $07EB : 2027 OUT_CODE: LD E,$1C ADD A,E ; $07EE : 2030 OUT_CH: AND A JR Z,PRINT_SP ; $07F1 : 2033 PRINT_CH: RES 0,(IY+$01) ; uaktualnij zmienną FLAGS - sygnalizuj zezwolenia na wiodącą spację ; $07F5 : 2037 PRINT_SP: EXX PUSH HL BIT 1,(IY+$01) ; testuj zmienną FLAGS - czy drukarka w użyciu ? JR NZ,LPRINT_A ; jeśli tak, drukuj do drukarki CALL ENTER_CH JR PRINT_EXX ; $0802 : 2050 LPRINT_A: CALL LPRINT_CH ; $0805 : 2053 PRINT_EXX: POP HL EXX RET ; $0808 : 2056 ENTER_CH: LD D,A LD BC,(S_POSN) LD A,C CP $21 JR Z,TEST_LOW ; $0812 : 2066 TEST_N_L: LD A,$76 CP D JR Z,WRITE_N_L LD HL,(DF_CC) CP (HL) LD A,D JR NZ,WRITE_CH DEC C JR NZ,EXPAND_1 INC HL LD (DF_CC),HL LD C,$21 DEC B LD (S_POSN),BC ; $082C : 2092 TEST_LOW: LD A,B CP (IY+$22) ; zmienna systemowa DF_SZ JR Z,REPORT_5 AND A JR NZ,TEST_N_L ; $0835 : 2101 REPORT_5: LD L,$04 ; 'brak miejsca na ekranie' JP ERROR_3 ; $083A : 2106 EXPAND_1: CALL ONE_SPACE EX DE,HL ; $083E : 2110 WRITE_CH: LD (HL),A INC HL LD (DF_CC),HL DEC (IY+$39) ; zmienna systemowa S_POSN_x RET ; $0847 : 2119 WRITE_N_L: LD C,$21 DEC B SET 0,(IY+$01) ; zmienna systemowa FLAGS - unieważnij wiodącą spację JP LOC_ADDR ; ---------------------- ; PROCEDURA 'LPRINT-CH' ; ---------------------- ; Ten podprogram wysyła znak do drukarki ZX-Printer, umieszczając kod znaku w buforze drukarki. ; Uwaga. PR-CC zawiera młodszy bajt adresu bufora. Starszy bajt ma zawsze wartość stałą. ; $0851 : 2129 LPRINT_CH: CP $76 ; porównaj z NEWLINE. JR Z,COPY_BUFF ; jeśli równe, skocz naprzód do COPY-BUFF LD C,A ; kopię znaku umieść w C. LD A,(PR_CC) ; pobierz adres bufora z PR_CC AND $7F ; zignoruj bit 7, aby utworzyć prawdziwy adres. CP $5C ; Porównaj z 33 kolumną LD L,A ; utwórz młodszy bajt adresu bufora LD H,$40 ; starszy bajt ma wartość stałą. CALL Z,COPY_BUFF ; wywołaj procedurę COPY-BUFF, aby wysłać pełny bufor do drukarki, jeśli pierwsze 32 bajty są użyte. ; (to zresetuje HL na początek) LD (HL),C ; umieść znak w buforze. INC L ; zwiększ pozycję - nie będzie przekroczenia granicy 256. LD (IY+$38),L ; uaktualnij zmienną systemową PR_CC automatycznie resetując bit 7, aby pokazać, że bufor nie jest pusty. RET ; -------------------------- ; PROCEDURA POLECENIA 'COPY' ; -------------------------- ; Cały ekran znakowy jest kopiowany do drukarki ZX-Printer. Drukowane są wszystkie 24 wiersze tekstu/grafiki. ; $0869 : 2153 COPY: LD D,$16 ; przygotuj się do kopiowania 24 wierszy tekstu. LD HL,(D_FILE) ; ustaw HL na poczatek pliku wideo ze zmiennej D_FILE. INC HL JR COPY_D ; naprzód do COPY_D ; Pojedynczy bufor znakowy jest kopiowany do drukarki ZX-Printer. ; $0871 : 2161 COPY_BUFF: LD D,$01 ; przygotuj się do kopiowania pojedynczego wiersza tekstu. LD HL,PRBUFF ; ustaw HL na start bufora drukarki PRBUFF. ; obie ścieżki zbiegają się tutaj. ; $0876 : 2166 COPY_D: CALL SET_FAST PUSH BC ; przechowaj BC, może być wiszący znak w C z LPRINT-CH ; $087A : 2170 COPY_LOOP: PUSH HL ; zachowaj wskaźnik pierwszego znaku. (*) XOR A ; wyzeruj akumulator. LD E,A ; ustaw licznik wierszy pikseli na zero, zakres 0-7. ; ta wewnętrzna pętla zajmuje się każdą poziomą linią pikseli. ; $087D : 2173 COPY_TIME: OUT ($FB),A ; wyzerowany bit 2 włącza silnik drukarki z nieaktywnym pisakiem - wyzerowany bit 7. POP HL ; pobierz wskaźnik pierwszego znaku (*) dla pętli wewnętrznej. ; $0880 : 2176 COPY_BRK: CALL BREAK_1 ; sprawdź, czy użytkownik przerwał operację JR C,COPY_CONT ; jeśli nie było naciśniętego klawisza, idź naprzód do COPY-CONT ; inaczej rejestr A będzie zawierał 11111111 0 RRA ; 0111 1111 OUT ($FB),A ; zatrzymaj silnik drukarki, wyłącz pisak. ; $0888 : 2184 REPORT_D2: RST 08H ; ERROR-1 .BYTE $0C ; Raport błędu: PRZERWANIE - CONT powtarza ; $088A : 2186 COPY_CONT: IN A,($FB) ; czytaj port drukarki. ADD A,A ; testuj bity 6 i 7 JP M,COPY_END ; jeśli brak drukarki, skocz naprzód do COPY-END JR NC,COPY_BRK ; wróć do COPY-BRK, jeśli pisak nie jest na pozycji PUSH HL ; zachowaj wskaźnik pierwszego znaku (*) PUSH DE ; zachowaj wiersz znaków i wiersz pikseli. LD A,D ; do A licznik linii ? CP $02 ; przy ostatniej linii ustawia przeniesienie. SBC A,A ; teraz $FF przy ostatniej linii lub zero w innym przypadku. ; teraz sprytnie przygotuj maskę kontrolną dla drukarki, ustawiając bit 2(później przesunięty do 1) rejestru D, aby zwolnić drukarkę ; dla ostatnich dwóch linii pikseli( E = 6 i 7) AND E ; AND z numerem linii 0-7 RLCA ; przesuń w lewo. AND E ; AND jeszcze raz. LD D,A ; zapisz maskę sterującą w D. ; $089C : 2204 COPY_NEXT: LD C,(HL) ; załaduj znak z ekranu lub z bufora. LD A,C ; zapisz kopię w C dla późniejszego testu na negatyw. INC HL ; uaktualnij wskaźnik dla następnego obiegu. CP $76 ; czy znakiem jest NEWLINE ? JR Z,COPY_N_L ; naprzód do COPY-N/L, jeśli tak PUSH HL ; * inaczej zachowaj wskaźnik znaku. SLA A ; (?) pomnóż przez 2 ADD A,A ; pomnóż przez 4 ADD A,A ; pomnóż przez 8 LD H,$0F ; załaduj do H połówkę adresu matryc znakowych. RL H ; teraz $1E lub $1F (z przeniesieniem) ADD A,E ; dodaj numer linii 0-7 LD L,A ; teraz HL adresuje bajt źródłowy w matrycy RL C ; testuj znak, ustawiając przeniesienie, jeśli jest negatywem. SBC A,A ; akumulator teraz ma zawartość $00 dla normalnych znaków lub $FF dla negatywów. XOR (HL) ; połącz ze wzorem bitowym z końca ROM. LD C,A ; przenieś bajt do C. LD B,$08 ; licznik 8 bitów do wyprowadzenia. ; $08B5 : 2229 COPY_BITS: LD A,D ; pobierz maskę sterowania szybkością z D. RLC C ; umieść bit do wyprowadzenia w przeniesieniu. RRA ; umieść go w bicie 7, bit prędkości w bicie 1 LD H,A ; zapisz przygotowaną maskę w rejestrze H. ; $08BA : 2234 COPY_WAIT: IN A,($FB) ; czytaj port drukarki RRA ; czekaj na sygnał wyrównania z enkodera. JR NC,COPY_WAIT ; jeśli brak, czekaj w pętli LD A,H ; bajt kontrolny do A. OUT ($FB),A ; i wyprowadź go do portu drukarki. DJNZ COPY_BITS ; w pętli wyprowadź wszystkie 8 bitów POP HL ; odzyskaj wskaźnik znaku. JR COPY_NEXT ; skocz wstecz do COPY-NEXT, aby skopiować przyległy znak ; Napotkany został znak NEWLINE, który albo występuje za wierszem tekstu, albo jest pierwszym znakiem ekranu lub wiersza drukarki. ; $08C7 : 2247 COPY_N_L: IN A,($FB) ; czytaj port drukarki. RRA ; czekaj na sygnał z enkodera. JR NC,COPY_N_L ; jeśli go brak, czekaj w pętli LD A,D ; przenieś maskę prędkości do A. RRCA ; przesuń bit prędkości na pozycję 1. Bit 7 jest ustawiony na 0 - sterowanie pisakiem. OUT ($FB),A ; ustaw prędkość drukarki. POP DE ; odtwórz wiersz znaku oraz wiersz pikseli. INC E ; zwiększ wiersz pikseli 0-7. BIT 3,E ; sprawdź, czy osiągnięto wartość 8. JR Z,COPY_TIME ; jeśli nie, wróć do COPY-TIME ; skończono 8 linii pikseli, wiersz tekstu. POP BC ; pozbądź się niepotrzebnego już znacznika pierwszego znaku DEC D ; zmniejsz licznik wiersza tekstu. JR NZ,COPY_LOOP ; jeśli nie zero, cofnij się do COPY-LOOP LD A,$04 ; zatrzymaj silnik drukarki, który już pracuje wolno. OUT ($FB),A ; zapisz do portu drukarki. ; $08DE : 2270 COPY_END: CALL SLOW_FAST POP BC ; odzyskaj zachowaną parę rejestrów BC. ; ---------------------------------------- ; PROCEDURA 'CZYSZCZENIA BUFORA DRUKARKI' ; ---------------------------------------- ; Ten podprogram ustawia 32 bajty bufora drukarki na zero (spacje), a 33-cim znakiem staje się NEWLINE. Wykonywane to jest po przesłaniu ; zawartości bufora do drukarki, lecz dodatkowo również po wydrukowaniu na niej 24 wierszy ekranowych. ; Uwaga. To jest błąd logiczny, ponieważ ostatnia operacja wcale nie wymaga bufora. Logicznie ujmując, powinno być możliwe takie użycie: ; 10 LPRINT "HELLO "; ; 20 COPY ; 30 LPRINT ; "WORLD" ; i oczekiwanie, że cała wiadomość pojawi się na drukarce. Co zadziwiające, ten błąd logiczny nigdy nie został wykryty, a chociaż można się ; kłócić, czy powyższy program daje błąd, to powtórzenie tego błędu na Spectrum już jest bez żadnych wątpliwości błędem oprogramowania. ; Ponieważ bufor drukarki ma stały adres na końcu obszaru zmiennych systemowych, a pozycja druku jest w zakresie od $3C do $5C, to bit 7 ; zmiennej systemowej jest ustawiany na 1, aby zasygnalizować pusty bufor i automatycznie zresetować się, gdy zmienna ta jest uaktualniana ; jakąkolwiek pozycją druku - sprytnie. ; $08E2 : 2274 CLEAR_PRB: LD HL,$405C ; adres ustawiony na koniec PRBUFF LD (HL),$76 ; umieść NEWLINE na ostatniej pozycji. LD B,$20 ; przygotuj się do wyzerowania 32 poprzedzających znaków. ; $08E9 : 2281 PRB_BYTES: DEC HL ; zmniejsz adres - mogłoby być DEC L. LD (HL),$00 ; umieść bajt zero. DJNZ PRB_BYTES ; pętla do PRB-BYTES dla wszystkich 32 bajtów LD A,L ; pobierz pozycję wydruku znaku. SET 7,A ; zasygnalizuj, że bufor jest pusty. LD (PR_CC),A ; uaktualnij jednobajtową zmienną PR_CC RET ; -------------------- ; PROCEDURA 'PISZ NA' ; -------------------- ; Procedura sprawdza poprawność parametrów dostarczonych poleceniu PRINT AT. Jeśli parametry są złe, sygnalizowany jest błąd B, inaczej otrzymywane są ; poprawne wartości S-POSN i DF-CC poprzez użycie procedury LOC_ADDR. ; $08F5 : 2293 PRINT_AT: LD A,$17 ; sprawdź, czy współrzędna wierszowa jest w zakresie SUB B ; od 0 do 23 JR C,WRONG_VAL ; jeśli nie, skocz do WRONG-VAL ; $08FA : 2298 TEST_VAL: CP (IY+$22) ; porównaj wynik z liczbą wierszy w dolnej części ekranu JP C,REPORT_5 ; jeśli pozycja na nie wkracza, zgłoś błąd skacząc do REPORT-5 INC A LD B,A LD A,$1F ; teraz sprawdź tak samo współrzędną kolumnową SUB C ; powinna być w zakresie od 0 do 31 ; $0905 : 2309 WRONG_VAL: JP C,REPORT_B ; jeśli nie jest, skocz do REPORT-B ADD A,$02 LD C,A ; $090B : 2315 SET_FIELD: BIT 1,(IY+$01) ; zmienna systemowa FLAGS - drukarka w użyciu JR Z,LOC_ADDR LD A,$5D SUB C LD (PR_CC),A RET ; ------------------------------------- ; PROCEDURA 'ADRESU POZYCJI NA EKRANIE' ; ------------------------------------- ; Ta ważna procedura ustawia wartość DF-CC dla zadanej pozycji na ekranie. Jeśli obraz jest zwinięty i z tego powodu nie zawiera tej pozycji, ; to pożądana linia zostaje rozwinięta. ; $0918 : 2328 LOC_ADDR: LD (S_POSN),BC LD HL,(VARS) LD D,C LD A,$22 SUB C LD C,A LD A,$76 INC B ; $0927 : 2343 LOOK_BACK: DEC HL CP (HL) JR NZ,LOOK_BACK DJNZ LOOK_BACK INC HL CPIR DEC HL LD (DF_CC),HL SCF RET PO DEC D RET Z PUSH BC CALL MAKE_ROOM POP BC LD B,C LD H,D LD L,E ; $0940 : 2368 EXPAND_2: LD (HL),$00 DEC HL DJNZ EXPAND_2 EX DE,HL INC HL LD (DF_CC),HL RET ; --------------------------------------------- ; PROCEDURA 'ROZWIJANIA NAZW POLECEŃ I FUNKCJI' ; --------------------------------------------- ; Kody znaków odnoszące się do nazw poleceń i funkcji są rozwijane za pomocą tej procedury. Adres każde 'rozwiniętej nazwy' w tablicy nazw jest ; znajdowany przy pomocy procedury TOKEN_ADD. Wiodąca spacja zostaje wydrukowana, jeśli określa ją bit 0 zmiennej FLAGS, następnie zostają ; wydrukowane litery nazwy i na końcu jest dodawana spacja, jeśli jest potrzebna. ; $094B : 2379 TOKENS: PUSH AF ; zachowaj kod znaku CALL TOKEN_ADD ; procedura TOKEN_ADD wyszukuje adres nazwy w tablicy nazw wg kodu znaku. Adres w BC. JR NC,ALL_CHARS ; jeśli wiodąca spacja nie występuje, przejdź do drukowania liter nazwy BIT 0,(IY+$01) ; zmienna systemowa FLAGS - jeśli ustawione, wiodąca spacja JR NZ,ALL_CHARS XOR A ; zeruj akumulator otrzymując kod znaku spacji RST 10H ; PISZ-AKUMULATOR - wypisz spację wiodącą ; $0959 : 2393 ALL_CHARS: LD A,(BC) ; pobierz znak nazwy do akumulatora AND $3F ; jeśli jest to ostatni znak nazwy, to pozbądź się bitu negatywu RST 10H ; PISZ-AKUMULATOR - wypisz znak LD A,(BC) ; ponownie pobierz znak INC BC ; przesuń wskaźnik na następną literę nazwy w tablicy ADD A,A ; testuj bit negatywowy, jeśli ustawiony, to był to ostatni znak nazwy JR NC,ALL_CHARS ; jeśli bit nie ustawiony, kontynuuj wyświetlanie liter nazwy POP BC BIT 7,B RET Z CP $1A JR Z,TRAIL_SP CP $38 RET C ; $096D : 2413 TRAIL_SP: XOR A SET 0,(IY+$01) ; zmienna systemowa FLAGS - Usuń wiodącą wiodącą spację JP PRINT_SP ; $0975 : 2421 TOKEN_ADD: PUSH HL LD HL,TOKENST ; Adres TOKENÓW BIT 7,A ; sprawdź kod TOKENA JR Z,TEST_HIGH AND $3F ; $097F : 2431 TEST_HIGH: CP $43 JR NC,FOUND LD B,A INC B ; $0985 : 2437 WORDS: BIT 7,(HL) INC HL JR Z,WORDS DJNZ WORDS BIT 6,A JR NZ,COMP_FLAG CP $18 ; $0992 : 2450 COMP_FLAG: CCF ; $0993 : 2451 FOUND: LD B,H LD C,L POP HL RET NC LD A,(BC) ADD A,$E4 RET ; -------------------------- ; PROCEDURA 'JEDNO MIEJSCE' ; -------------------------- ; Procedura ta jest wywoływana zawsze, gdy jest potrzebne jedno miejsce w obszarze programu lub w obrębie ekranu. ; $099B : 2459 ONE_SPACE: LD BC,$0001 ; liczba bajtów do zarezerwowania ; ------------------------- ; PROCEDURA 'ZRÓB MIEJSCE' ; ------------------------- ; Procedura ta tworzy BC miejsc od pozycji (HL) ; $099E : 2462 MAKE_ROOM: PUSH HL ; zachowaj HL CALL TEST_ROOM ; sprawdź, czy jest tyle wolnej pamięci POP HL ; odzyskaj HL CALL POINTERS LD HL,(STKEND) ; pobierz adres końca używanej pamięci EX DE,HL ; adres ten będzie źródłem LDDR ; przesuń bajty w górę robiąc miejsce RET ; ---------------------- ; PROCEDURA 'WSKAŹNIKI' ; ---------------------- ; Jeśli jakieś wskaźniki muszą być zmieniane, zostaje wywołana ta procedura z wielkością zmiany w BC, a HL określającym wskaźniki do zmiany. Wszystkie ; wskaźniki wskazujące poniżej HL nie zostaną zmienione. ; $09AD : 2477 POINTERS: PUSH AF PUSH HL LD HL,D_FILE LD A,$09 ; $09B4 : 2484 NEXT_PTR: LD E,(HL) INC HL LD D,(HL) EX (SP),HL AND A SBC HL,DE ADD HL,DE EX (SP),HL JR NC,PTR_DONE PUSH DE EX DE,HL ADD HL,BC EX DE,HL LD (HL),D DEC HL LD (HL),E INC HL POP DE ; $09C8 : 2504 PTR_DONE: INC HL DEC A JR NZ,NEXT_PTR EX DE,HL POP DE POP AF AND A SBC HL,DE LD B,H LD C,L INC BC ADD HL,DE EX DE,HL RET ; ------------------------- ; PROCEDURA 'ADRES WIERSZA' ; ------------------------- ; Dla danego numeru wiersza w HL procedura wyznacza jego adres w obszarze programu lub adres następnego wiersza, jeśli wskazany wiersz ; nie występuje w programie. ; $09D8 : 2520 LINE_ADDR: PUSH HL ; zachowaj numer wiersza LD HL,$407D ; umieść w HL początek obszaru programu w języku BASIC LD D,H ; skopiuj HL do DE LD E,L ; $09DE : 2526 NEXT_TEST: POP BC ; odtwórz numer wiersza w BC CALL CP_LINES ; porównaj numer w BC z numerem w programie, wskazywanym przez HL RET NC ; jeśli BC <= HL, zakończ - HL wskazuje wiersz PUSH BC ; zachowaj na stosie numer wiersza CALL NEXT_ONE ; przesuń się na początek następnego wiersza EX DE,HL JR NEXT_TEST ; kontynuuj szukanie ; ----------------------------------- ; PROCEDURA 'PORÓWNAJ NUMERY WIERSZY' ; ----------------------------------- ; Numer wiersza w (HL) jest porównywany z numerem w BC. Numery wierszy są przechowywane w porządku odwrotnym do normalnego przechowywania ; liczb 16 bitowych w Z80 - MSB LSB. Dzięki temu procedura porównania nieco się upraszcza. ; $09EA : 2538 CP_LINES: LD A,(HL) ; porównaj starsze bajty (HL) z BC CP B RET NZ ; jeśli różne, wróć INC HL ; przejdź do młodszych bajtów LD A,(HL) ; porównaj je DEC HL ; przywróć HL CP C RET ; --------------------------------------- ; PROCEDURA 'NASTĘPNY WIERSZ LUB ZMIENNA' ; --------------------------------------- ; Ta procedura bardzo sprytnie znajduje początek kolejnego wiersza języka BASIC lub początek następnej zmiennej w obszarze zmiennych. ; Numery wierszy są rozpoznawane przez wartość starszego bajtu mniejszą od $40, a różne typy zmiennych przez bity 6 i 7 w ich nazwach. ; $09F2 : 2546 NEXT_ONE: PUSH HL LD A,(HL) CP $40 JR C,LINES BIT 5,A JR Z,NEXT_O_4 ADD A,A JP M,NEXT_FIVE CCF ; $0A01 : 2561 NEXT_FIVE: LD BC,$0005 JR NC,NEXT_LETT LD C,$11 ; $0A08 : 2568 NEXT_LETT: RLA INC HL LD A,(HL) JR NC,NEXT_LETT JR NEXT_ADD ; $0A0F : 2575 LINES: INC HL ; $0A10 : 2576 NEXT_O_4: INC HL LD C,(HL) INC HL LD B,(HL) INC HL ; $0A15 : 2581 NEXT_ADD: ADD HL,BC POP DE ; ------------------- ; PROCEDURA 'RÓŻNICA' ; ------------------- ; Ta procedura znajduje różnicę wartości w parach rejestrów HL i DL. Wynik jest zwracany w parze rejestrów BC ; $0A17 : 2583 DIFFER: AND A ; zeruj przeniesienie SBC HL,DE ; HL = HL - DE LD B,H ; różnica do BC LD C,L ADD HL,DE ; przywróć poprzednią wartość HL EX DE,HL RET ; ------------------------- ; PROCEDURA 'DOLNE WIERSZE' ; ------------------------- ; Procedura czyści dolne wiersze ekranu. ; $0A1F : 2591 LINE_ENDS: LD B,(IY+$22) ; zmienna systemowa DF_SZ PUSH BC CALL B_LINES POP BC DEC B JR B_LINES ; ----------------------- ; PROCEDURA ROZKAZU 'CLS' ; ----------------------- ; Procedura czyści zawartość ekranu ; $0A2A : 2602 CLS: LD B,$18 ; do B załaduj liczbę wierszy na ekranie $18 = 24 ; Znajdowany jest adres części ekranu do wyczyszczenia oraz wykonany zostaje test, czy system zawiera mniej, czy więcej 3 1/4 KB pamięci RAM. ; $0A2C : 2604 B_LINES: RES 1,(IY+$01) ; zmienna systemowa FLAGS - Sygnalizuj brak drukarki LD C,$21 PUSH BC CALL LOC_ADDR POP BC LD A,($4005) ; starszy bajt zmiennej systemowej RAMTOP CP $4D ; sprawdź, czy ekran jest zwinięty JR C,COLLAPSED ; jeśli tak, skocz naprzód do COLLAPSED ; W przypadku rozwiniętego pliku obrazu odpowiednia liczba spacji zostaje wydrukowana, aby wyczyścić założoną liczbę wierszy SET 7,(IY+$3A) ; zmienna systemowa S_POSN_y ; $0A42 : 2626 CLEAR_LOC: XOR A ; przygotuj spację CALL PRINT_SP ; wydrukuj spację LD HL,(S_POSN) LD A,L OR H AND $7E JR NZ,CLEAR_LOC JP LOC_ADDR ; Jeśli plik obrazu jest zwinięty, zostaje użyta instrukcja LDIR do skopiowania znaku nowego wiersza - N/L tyle razy, ile przechowuje rejestr C ; (poprzednio B). Następnie zostaje pobrana zmienna VARS i zwrócona nadmiarowa pamięć w obszarze obrazu. ; $0A52 : 2642 COLLAPSED: LD D,H LD E,L DEC HL LD C,B LD B,$00 LDIR LD HL,(VARS) ; ------------------------ ; PROCEDURA 'ODZYSKIWANIA' ; ------------------------ ; Najpierw zmieniane są wskaźniki, a następnie określony obszar pamięci RAM zostaje odzyskany przez użycie instrukcji LDIR do nadpisania ; niechcianej części pamięci RAM. ; $0A5D : 2653 RECLAIM_1: CALL DIFFER ; $0A60 : 2656 RECLAIM_2: PUSH BC LD A,B CPL LD B,A LD A,C CPL LD C,A INC BC CALL POINTERS EX DE,HL POP HL ADD HL,DE PUSH DE LDIR POP HL RET ; --------------------------------- ; PROCEDURA 'NUMERU WIERSZA EDYCJI' ; --------------------------------- ; Ta procedura jest wykorzystywana do określenia, czy bieżący wiersz edycji rozpoczyna się poprawnym numerem od 1 do 9999. Wskaźnik CH_ADD ; jest tymczasowo używany do wskazywania wzdłuż wiersza edycji. Powrót następuje, jeśli jest wykonywany rozkaz INPUT. Do pobrania numeru wiersza ; jest najpierw wywoływana procedura INT_TO_FP, a następnie procedura FP_TO_BC do stworzenia wartości całkowitej w BC. Wartość ta jest dalej ; sprawdzana na zakres 1-9999. Procedura wychodzi poprzez procedurę SET_MEM, która zeruje STKEND. ; $0A73 : 2675 E_LINE_NO: LD HL,(E_LINE) CALL TEMP_PTR2 RST 18H ; POBIERZ-ZNAK BIT 5,(IY+$2D) ; zmienna systemowa FLAGX RET NZ LD HL,MEMBOT LD (STKEND),HL CALL INT_TO_FP ; przekształć numer wiersza w liczbę zmiennoprzecinkową na stosie kalkulatora CALL FP_TO_BC ; pobierz liczbę zmiennoprzecinkową ze stosu kalkulatora i umieść ją w BC jako liczbę całkowitą JR C,NO_NUMBER ; jeśli nie jest to poprawna liczba, skocz do raportu błędu LD HL,$D8F0 ; wartość '-10000' ADD HL,BC ; sprawdź, czy numer mieści się w zakresie 1-9999 ; $0A91 : 2705 NO_NUMBER: JP C,REPORT_C ; jeśli zły numer, zgłoś błąd C CP A JP SET_MIN ; ------------------------------------------------- ; PROCEDURY WYŚWIETLANIA 'RAPORTU I NUMERU WIERSZA' ; ------------------------------------------------- ; Punkt wejścia OUT_NUM jest używany do wyświetlania numerów wierszy z raportem błędu ; $0A98 : 2712 OUT_NUM: PUSH DE PUSH HL XOR A BIT 7,B JR NZ,UNITS LD H,B LD L,C LD E,$FF JR THOUSAND ; Punkt wejścia OUT_NO jest używany do wyświetlania numerów wierszy na początku wierszy języka BASIC. ; $0AA5 : 2725 OUT_NO: PUSH DE LD D,(HL) INC HL LD E,(HL) PUSH HL EX DE,HL LD E,$00 ; ustaw E na wiodącą spację ; $0AAD : 2733 THOUSAND: LD BC,$FC18 CALL OUT_DIGIT LD BC,$FF9C CALL OUT_DIGIT LD C,$F6 CALL OUT_DIGIT LD A,L ; $0ABF : 2751 UNITS: CALL OUT_CODE POP HL POP DE RET ; -------------------------- ; PROCEDURA 'USUŃ ZE STOSU' ; -------------------------- ; Ten podprogram jest używany do wcześniejszego powrotu z procedury, gdy sprawdzana jest składnia. W ZX-81 te same procedury, które wykonują ; polecenia, również sprawdzają składnie w wierszu edycyjnym. Pozwala to dokładnie umieścić znacznik błędu w miejscu, gdzie naruszona jest składnia. ; Sekwencja CALL SYNTAX-Z ; RET Z może być zastąpiona przez wywołanie tego podprogramu, chociaż nie zastąpił on wszystkich wystąpień powyższych ; dwóch instrukcji. ; $0AC5 : 2757 UNSTACK_Z: CALL SYNTAX_Z ; procedura SYNTAX-Z zwraca ustawiony znacznik zera, gdy sprawdza składnię. POP HL ; pobierz adres powrotny. RET Z ; jeśli jest sprawdzana składnia, wróć do poprzedniej procedury wywołującej JP (HL) ; inaczej skocz do wywołującej procedury, jak zrobiłby to rozkaz RET. ; ---------------------------- ; PROCEDURA POLECENIA 'LPRINT' ; ---------------------------- ; Bit 1 zmiennej FLAGS jest zawsze ustawiony na 1 przy drukowaniu na drukarce. ; $0ACB : 2763 LPRINT: SET 1,(IY+$01) ; zmienna systemowa FLAGS - informuj o używaniu drukarki ; --------------------------- ; PROCEDURA POLECENIA 'PRINT' ; --------------------------- ; Test, czy jest sam rozkaz PRINT ; $0ACF : 2767 PRINT: LD A,(HL) ; pobierz znak do drukowania CP $76 ; NEWLINE? JP Z,PRINT_END ; jeśli tak, skocz na koniec procedury ; Tworzona jest teraz pętla, która zajmie się kolejnymi elementami wiersza polecenia PRINT. Najpierw sprawdzane jest, czy kolejny znak ; to przecinek lub średnik - oba posiadają specyficzną funkcję w instrukcji PRINT. ; $0AD5 : 2773 PRINT_1: SUB $1A ADC A,$00 JR Z,SPACING ; Teraz sprawdzane jest, czy następnym znakiem jest znak AT. CP $A7 JR NZ,NOT_AT ; jeśli nie, przeskocz naprzód do NOT_AT RST 20H ; pobierz następny znak CALL CLASS_6 ; oblicz następne wyrażenie - numer wiersza CP $1A ; sprawdź, czy separatorem jest przecinek JP NZ,REPORT_C ; jeśli nie, zgłoś błąd C RST 20H ; pobieramy kolejny znak CALL CLASS_6 ; oblicz następne wyrażenie - numer kolumny CALL SYNTAX_ON ; wykonaj test, czy wiersz jest wykonywany lub czy jest sprawdzana składnia. Jeśli jest tylko sprawdzana ; składnia, zostanie wykonany skok pośredni do PRINT_ON ; Numer kolumny i wiersza znajduje się na stosie kalkulatora, jednakże muszą one zostać zamienione miejscami. RST 28H ; KALKULATOR .BYTE $01 ; zamień .BYTE $34 ; koniec-obliczeń CALL STK_TO_BC ; pobierz do pary rejestrów BC dwie wartości ze stosu kalkulatora CALL PRINT_AT ; ustaw pozycję wydruku JR PRINT_ON ; kontynuuj drukowanie ; $0AFA : 2810 NOT_AT: CP $A8 ; sprawdź, czy drukowany znak to TAB JR NZ,NOT_TAB ; jeśli nie, przeskocz wprzód do NOT_TAB RST 20H ; pobierz kolejny znak CALL CLASS_6 ; oblicz wartość wyrażenia CALL SYNTAX_ON ; sprawdź, czy jest sprawdzana składnia. Jeśli tak, skocz do PRINT_ON CALL STK_TO_A ; pobierz ze stosu kalkulatora wartość tabulatora do akumulatora JP NZ,REPORT_B ; w przypadku błędu, wyjdź przez RAPORT_B AND $1F ; inaczej sprawdź poprawność argumentu TAB LD C,A BIT 1,(IY+$01) ; zmienna systemowa FLAGS - drukarka w użyciu? JR Z,TAB_TEST SUB (IY+$38) ; zmienna systemowa PR_CC SET 7,A ADD A,$3C CALL NC,COPY_BUFF ; $0B1E : 2846 TAB_TEST: ADD A,(IY+$39) ; zmienna systemowa S_POSN_x CP $21 LD A,($403A) ; zmienna systemowa S_POSN_y SBC A,$01 CALL TEST_VAL ; znajdź nowe wartości dla DF_CC i S_POSN SET 0,(IY+$01) ; zmienna systemowa FLAGS - zlikwiduj wiodącą spację JR PRINT_ON ; kontynuuj wydruk ; $0B31 : 2865 NOT_TAB: CALL SCANNING ; oblicz wartość wyrażenia, wynik umieść na stosie kalkulatora CALL PRINT_STK ; wyświetl ostatnią wartość ze stosu kalkulatora ; Procedura teraz sprawdza, czy w wierszu polecenia PRINT występuje kolejne wyrażenie ; $0B37 : 2871 PRINT_ON: RST 18H ; POBIERZ-ZNAK SUB $1A ADC A,$00 JR Z,SPACING CALL CHECK_END JP PRINT_END ; Tutaj rozdzielane są dwa znaki sterujące wydrukiem - przecinek i średnik ; $0B44 : 2884 SPACING: CALL NC,FIELD RST 20H ; NASTĘPNY-ZNAK CP $76 RET Z JP PRINT_1 ; Ten podprogram powoduje skok do PRINT_ON w czasie sprawdzania składni ; $0B4E : 2894 SYNTAX_ON: CALL SYNTAX_Z ; czy jest sprawdzana składnia? RET NZ ; jeśli nie, wróć POP HL ; usuń ze stosu adres powrotu JR PRINT_ON ; kontynuuj przeglądanie wiersza wydruku ; Procedura drukuje zawartość szczytu stosu ; $0B55 : 2901 PRINT_STK: CALL UNSTACK_Z ; jeśli jest sprawdzana składnia, nastąpi wyjście z procedury BIT 6,(IY+$01) ; zmienna systemowa FLAGS - wynik liczbowy czy znakowy? CALL Z,STK_FETCH ; - pobierz ze stosu parametry łańcucha. Łańcuchy i liczby obsługuj osobno JR Z,PR_STR_4 ; jeśli się udało, skocz do obsługi łańcuchów JP PRINT_FP ; inaczej obsłuż wydruk liczby. ; Długość łańcucha jest umieszczona w parze rejestrów BC, a adres początku łańcucha znajduje się w parze rejestrów DE. ; $0B64 : 2916 PR_STR_1: LD A,$0B ; znak cudzysłowu ; $0B66 : 2918 PR_STR_2: RST 10H ; PISZ-AKUMULATOR ; $0B67 : 2919 PR_STR_3: LD DE,(X_PTR) ; pobierz wskaźnik łańcucha ze zmiennej systemowej X_PTR ; $0B6B : 2923 PR_STR_4: LD A,B ; sprawdź, czy koniec łańcucha OR C DEC BC ; zmniejsz długość łańcucha RET Z ; powróć, jeśli wydrukowano wszystkie znaki w łańcuchu LD A,(DE) ; pobierz znak z łańcucha INC DE ; zwiększ wskaźnik łańcucha LD (X_PTR),DE ; zachowaj go w zmiennej systemowej X_PTR BIT 6,A ; sprawdź, czy znak jednoliterowy JR Z,PR_STR_2 ; jeśli tak, drukuj go CP $C0 ; podwójny cudzysłów - drukuj jako zwykły cudzysłów JR Z,PR_STR_1 PUSH BC ; zachowaj długość łańcucha CALL TOKENS ; wydrukuj znak wieloliterowy POP BC ; odtwórz długość łańcucha JR PR_STR_3 ; kontynuuj drukowanie łańcucha ; $0B84 : 2948 PRINT_END: CALL UNSTACK_Z ; jeśli sprawdzana jest składnia, nastąpi wyjście z procedury LD A,$76 ; inaczej drukuj znak końca wiersza RST 10H ; PISZ-AKUMULATOR RET ; Tutaj znajdowana jest właściwa wartość zmiennej systemowej S_POSN oraz w razie potrzeby również PR_CC. ; $0B8B : 2955 FIELD: CALL UNSTACK_Z ; wróć przy sprawdzaniu składni SET 0,(IY+$01) ; zmienna systemowa FLAGS - usuń wiodącą spację XOR A ; kod spacji RST 10H ; wyświetl spację LD BC,(S_POSN) LD A,C BIT 1,(IY+$01) ; zmienna systemowa FLAGS - drukarka w użyciu? JR Z,CENTRE LD A,$5D SUB (IY+$38) ; zmienna systemowa PR_CC ; $0BA4 : 2980 CENTRE: LD C,$11 CP C JR NC,RIGHT LD C,$01 ; $0BAB : 2987 RIGHT: CALL SET_FIELD RET ; --------------------------------- ; PROCEDURY POLECEŃ 'PLOT I UNPLOT' ; --------------------------------- ; $0BAF : 2991 PLOT_UNP: CALL STK_TO_BC LD (COORDS),BC LD A,$2B SUB B JP C,REPORT_B LD B,A LD A,$01 SRA B JR NC,COLUMNS LD A,$04 ; $0BC5 : 3013 COLUMNS: SRA C JR NC,FIND_ADDR RLCA ; $0BCA : 3018 FIND_ADDR: PUSH AF CALL PRINT_AT LD A,(HL) RLCA CP $10 JR NC,TABLE_PTR RRCA JR NC,SQ_SAVED XOR $8F ; $0BD9 : 3033 SQ_SAVED: LD B,A ; $0BDA : 3034 TABLE_PTR: LD DE,P_UNPLOT LD A,(T_ADDR) SUB E JP M,PLOT POP AF CPL AND B JR UNPLOT ; $0BE9 : 3049 PLOT: POP AF OR B ; $0BEB : 3051 UNPLOT: CP $08 JR C,PLOT_END XOR $8F ; $0BF1 : 3057 PLOT_END: EXX RST 10H ; PISZ-AKUMULATOR EXX RET ; ----------------------- ; PROCEDURA 'STACK-TO-BC' ; ----------------------- ; Procedura pobiera dwie liczby zmiennoprzecinkowe ze stosu kalkulatora, zamienia je na liczby całkowite o zakresie 0-255 i umieszcza ; w parze rejestrów BC ; $0BF5 : 3061 STK_TO_BC: CALL STK_TO_A LD B,A PUSH BC CALL STK_TO_A LD E,C POP BC LD D,C LD C,A RET ; ---------------------- ; PROCEDURA 'STACK-TO-A' ; ---------------------- ; Procedura pobiera liczbę zmiennoprzecinkową ze stosu kalkulatora, zamienia ją na liczbę całkowitą o zakresie 0-255 i umieszcza w rejestrze A ; $0C02 : 3074 STK_TO_A: CALL FP_TO_A JP C,REPORT_B LD C,$01 RET Z LD C,$FF RET ; ------------------------------ ; PROCEDURA 'PRZEWIJANIA EKRANU' ; ------------------------------ ; $0C0E : 3086 SCROLL: LD B,(IY+$22) ; zmienna systemowa DF_SZ LD C,$21 CALL LOC_ADDR CALL ONE_SPACE LD A,(HL) LD (DE),A INC (IY+$3A) ; zmienna systemowa S_POSN_y LD HL,(D_FILE) INC HL LD D,H LD E,L CPIR JP RECLAIM_1 ; ----------------- ; TABLICE 'SKŁADNI' ; ----------------- ; i) TAblica przesunięć ; $0C29 : 3113 OFFSET_T:.BYTE P_LPRINT - $ ; 8B przesunięcie pod adres P-LPRINT .BYTE P_LLIST - $ ; 8D przesunięcie pod adres P-LLIST .BYTE P_STOP - $ ; 2D przesunięcie pod adres P-STOP .BYTE P_SLOW - $ ; 7F przesunięcie pod adres P-SLOW .BYTE P_FAST - $ ; 81 przesunięcie pod adres P-FAST .BYTE P_NEW - $ ; 49 przesunięcie pod adres P-NEW .BYTE P_SCROLL - $ ; 75 przesunięcie pod adres P-SCROLL .BYTE P_CONT - $ ; 5F przesunięcie pod adres P-CONT .BYTE P_DIM - $ ; 40 przesunięcie pod adres P-DIM .BYTE P_REM - $ ; 42 przesunięcie pod adres P-REM .BYTE P_FOR - $ ; 2B przesunięcie pod adres P-FOR .BYTE P_GOTO - $ ; 17 przesunięcie pod adres P-GOTO .BYTE P_GOSUB - $ ; 1F przesunięcie pod adres P-GOSUB .BYTE P_INPUT - $ ; 37 przesunięcie pod adres P-INPUT .BYTE P_LOAD - $ ; 52 przesunięcie pod adres P-LOAD .BYTE P_LIST - $ ; 45 przesunięcie pod adres P-LIST .BYTE P_LET - $ ; 0F przesunięcie pod adres P-LET .BYTE P_PAUSE - $ ; 6D przesunięcie pod adres P-PAUSE .BYTE P_NEXT - $ ; 2B przesunięcie pod adres P-NEXT .BYTE P_POKE - $ ; 44 przesunięcie pod adres P-POKE .BYTE P_PRINT - $ ; 2D przesunięcie pod adres P-PRINT .BYTE P_PLOT - $ ; 5A przesunięcie pod adres P-PLOT .BYTE P_RUN - $ ; 3B przesunięcie pod adres P-RUN .BYTE P_SAVE - $ ; 4C przesunięcie pod adres P-SAVE .BYTE P_RAND - $ ; 45 przesunięcie pod adres P-RAND .BYTE P_IF - $ ; 0D przesunięcie pod adres P-IF .BYTE P_CLS - $ ; 52 przesunięcie pod adres P-CLS .BYTE P_UNPLOT - $ ; 5A przesunięcie pod adres P-UNPLOT .BYTE P_CLEAR - $ ; 4D przesunięcie pod adres P-CLEAR .BYTE P_RETURN - $ ; 15 przesunięcie pod adres P-RETURN .BYTE P_COPY - $ ; 6A przesunięcie pod adres P-COPY ; ii) Tablica parametrów ; $0C48 : 3144 P_LET: .BYTE $01 ; Klasa-01 - wymagana zmienna .BYTE $14 ; Separator: '=' .BYTE $02 ; Klasa-02 - musi wystąpić wyrażenie liczbowe lub łańcuchowe ; $0C4B : 3147 P_GOTO: .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD GOTO ; Adres: $0E81; Adres: GOTO ; $0C4F : 3151 P_IF: .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $DE ; Separator: 'THEN' .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD IF ; Adres: $0DAB; Adres: IF ; $0C54 : 3156 P_GOSUB: .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD GOSUB ; Adres: $0EB5; Adres: GOSUB ; $0C58 : 3160 P_STOP: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD STOP ; Adres: $0CDC; Adres: STOP ; $0C5B : 3163 P_RETURN:.BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD RETURN ; Adres: $0ED8; Adres: RETURN ; $0C5E : 3166 P_FOR: .BYTE $04 ; Klasa-04 - musi wystąpić zmienna jednoliterowa .BYTE $14 ; Separator: '=' .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $DF ; Separator: 'TO' .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD FOR ; Adres: $0DB9; Adres: FOR ; $0C66 : 3174 P_NEXT: .BYTE $04 ; Klasa-04 - musi wystąpić zmienna jednoliterowa .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD NEXT ; Adres: $0E2E; Adres: NEXT ; $0C6A : 3178 P_PRINT: .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD PRINT ; Adres: $0ACF; Adres: PRINT ; $0C6D : 3181 P_INPUT: .BYTE $01 ; Klasa-01 - wymagana zmienna .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD INPUT ; Adres: $0EE9; Adres: INPUT ; $0C71 : 3185 P_DIM: .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD DIM ; Adres: $1409; Adres: DIM ; $0C74 : 3188 P_REM: .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD REM ; Adres: $0D6A; Adres: REM ; $0C77 : 3191 P_NEW: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD NEW ; Adres: $03C3; Adres: NEW ; $0C7A : 3194 P_RUN: .BYTE $03 ; Klasa-03 - może wystąpić wyrażenie liczbowe, inaczej wartość zero .WORD RUN ; Adres: $0EAF; Adres: RUN ; $0C7D : 3197 P_LIST: .BYTE $03 ; Klasa-03 - może wystąpić wyrażenie liczbowe, inaczej wartość zero .WORD LIST ; Adres: $0730; Adres: LIST ; $0C80 : 3200 P_POKE: .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $1A ; Separator: ',' .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD POKE ; Adres: $0E92; Adres: POKE ; $0C86 : 3206 P_RAND: .BYTE $03 ; Klasa-03 - może wystąpić wyrażenie liczbowe, inaczej wartość zero .WORD RAND ; Adres: $0E6C; Adres: RAND ; $0C89 : 3209 P_LOAD: .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD LOAD ; Adres: $0340; Adres: LOAD ; $0C8C : 3212 P_SAVE: .BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD SAVE ; Adres: $02F6; Adres: SAVE ; $0C8F : 3215 P_CONT: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD CONT ; Adres: $0E7C; Adres: CONT ; $0C92 : 3218 P_CLEAR: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD CLEAR ; Adres: $149A; Adres: CLEAR ; $0C95 : 3221 P_CLS: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD CLS ; Adres: $0A2A; Adres: CLS ; $0C98 : 3224 P_PLOT: .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $1A ; Separator: ',' .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD PLOT_UNP ; Adres: $0BAF; Adres: PLOT/UNP ; $0C9E : 3230 P_UNPLOT:.BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $1A ; Separator: ',' .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD PLOT_UNP ; Adres: $0BAF; Adres: PLOT/UNP ; $0CA4 : 3236 P_SCROLL:.BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD SCROLL ; Adres: $0C0E; Adres: SCROLL ; $0CA7 : 3239 P_PAUSE: .BYTE $06 ; Klasa-06 - musi wystąpić wyrażenie liczbowe .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD PAUSE ; Adres: $0F32; Adres: PAUSE ; $0CAB : 3243 P_SLOW: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD SLOW ; Adres: $0F2B; Adres: SLOW ; $0CAE : 3246 P_FAST: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD FAST ; Adres: $0F23; Adres: FAST ; $0CB1 : 3249 P_COPY: .BYTE $00 ; Klasa-00 - brak dalszych parametrów .WORD COPY ; Adres: $0869; Adres: COPY ; $0CB4 : 3252 P_LPRINT:.BYTE $05 ; Klasa-05 - zmienna składnia w całości sprawdzana przez procedurę .WORD LPRINT ; Adres: $0ACB; Adres: LPRINT ; $0CB7 : 3255 P_LLIST: .BYTE $03 ; Klasa-03 - może wystąpić wyrażenie liczbowe, inaczej wartość zero .WORD LLIST ; Adres: $072C; Adres: LLIST ; ------------------------------ ; PROCEDURA 'SKANOWANIE WIERSZA' ; ------------------------------ ; $0CBA : 3258 LINE_SCAN: LD (IY+$01),$01 ; zmienna systemowa FLAGS CALL E_LINE_NO ; $0CC1 : 3265 LINE_RUN: CALL SET_MIN LD HL,ERR_NR LD (HL),$FF LD HL,FLAGX BIT 5,(HL) JR Z,LINE_NULL CP $E3 ; 'STOP' ? LD A,(HL) JP NZ,INPUT_REP CALL SYNTAX_Z RET Z RST 08H ; ERROR-1 .BYTE $0C ; Raport Błędu: PRZERWANIE - CONT powtarza ; -------------------------- ; PROCEDURA POLECENIA 'STOP' ; -------------------------- ; $0CDC : 3292 STOP: RST 08H ; ERROR-1 .BYTE $08 ; Raport Błędu: polecenie STOP ; przetwarzanie wiersza jest kontynuowane sprawdzeniem, czy następują jedynie spacje z kończącym je znakiem NEWLINE. Rozkaz IF również zagląda tutaj, ; jeśli wyrażenie testowe ma wartość true, aby wykonać polecenie za THEN, lecz polecenia tego wcale nie musi być, zatem ; 10 IF 1=1 THEN ; przechodzi test składniowy na wszystkich komputerach ZX. ; $0CDE : 3294 LINE_NULL: RST 18H ; POBIERZ-ZNAK LD B,$00 ; przygotuj wcześniej indeks CP $76 ; porównaj z NEWLINE. RET Z ; wróć, jeśli jest równe. LD C,A ; przenieś znak do C. RST 20H ; NASTĘPNY-ZNAK - przesuwa na kolejną pozycję. LD A,C ; znak do A SUB $E1 ; odejmij kod 'LPRINT' - najmniejszy kod rozkazu. JR C,REPORT_C2 ; jeśli mniejszy, skocz do REPORT-C2 LD C,A ; zmniejszony kod do C LD HL,OFFSET_T ; ustaw w HL adres tablicy przesunięć. ADD HL,BC ; indeksuj w tablicy. LD C,(HL) ; pobierz przesunięcie ADD HL,BC ; indeksuj w tablicy parametrów. JR GET_PARAM ; $0CF4 : 3316 SCAN_LOOP: LD HL,(T_ADDR) ; -> Punkt wejścia do pętli skanującej ; $0CF7 : 3319 GET_PARAM: LD A,(HL) INC HL LD (T_ADDR),HL LD BC,SCAN_LOOP ; Adres: SCAN-LOOP PUSH BC ; jest umieszczany na stosie maszynowym. LD C,A CP $0B JR NC,SEPARATOR LD HL,CLASS_TBL ; adres tablicy klas. LD B,$00 ADD HL,BC LD C,(HL) ADD HL,BC PUSH HL RST 18H ; POBIERZ-ZNAK RET ; pośredni skok do procedury klas a poprzez późniejszy RET do SCAN-LOOP ; --------------------- ; PROCEDURA 'SEPARATOR' ; --------------------- ; $0D10 : 3344 SEPARATOR: RST 18H ; POBIERZ-ZNAK CP C JR NZ,REPORT_C2 ; REPORT-C2 - Nonsens w języku BASIC RST 20H ; NASTĘPNY-ZNAK RET ; ---------------------- ; TABLICA 'KLAS POLECEŃ' ; ---------------------- ; ; $0D16 : 3350 CLASS_TBL:.BYTE CLASS_0 - $ ; 17 przesunięcie pod adres CLASS-0 .BYTE CLASS_1 - $ ; 25 przesunięcie pod adres CLASS-1 .BYTE CLASS_2 - $ ; 53 przesunięcie pod adres CLASS-2 .BYTE CLASS_3 - $ ; 0F przesunięcie pod adres CLASS-3 .BYTE CLASS_4 - $ ; 6B przesunięcie pod adres CLASS-4 .BYTE CLASS_5 - $ ; 13 przesunięcie pod adres CLASS-5 .BYTE CLASS_6 - $ ; 76 przesunięcie pod adres CLASS-6 ; -------------------------- ; PROCEDURA 'SPRAWDŹ KONIEC' ; -------------------------- ; Sprawdź koniec polecenia i czy nie ma nadmiarowych znaków za poprawnie sparsowanym poleceniem. Ponieważ w wierszu dozwolone jest tylko jedno ; polecenie, to jedynym dozwolonym znakiem za rozkazem może być NEWLINE. ; $0D1D : 3357 CHECK_END: CALL SYNTAX_Z RET NZ ; w czasie wykonania wróć. POP BC ; inaczej usuń adres powrotny. ; $0D22 : 3362 CHECK_2: LD A,(HL) ; pobierz znak. CP $76 ; sprawdź, czy NEWLINE. RET Z ; wróć, jeśli tak. ; $0D26 : 3366 REPORT_C2: JR REPORT_C ; REPORT-C2 - Nonsens w języku BASIC ; ------------------------- ; KLASY ROZKAZÓW 03, 00, 05 ; ------------------------- ; $0D28 : 3368 CLASS_3: CP $76 CALL NO_TO_STK ; $0D2D : 3373 CLASS_0: CP A ; $0D2E : 3374 CLASS_5: POP BC CALL Z,CHECK_END EX DE,HL LD HL,(T_ADDR) LD C,(HL) INC HL LD B,(HL) EX DE,HL ; $0D3A : 3386 CLASS_END: PUSH BC RET ; ----------------------------- ; KLASY ROZKAZÓW 01, 02, 04, 06 ; ----------------------------- ; $0D3C : 3388 CLASS_1: CALL LOOK_VARS ; $0D3F : 3391 CLASS_4_2: LD (IY+$2D),$00 ; zmienna systemowa FLAGX JR NC,SET_STK SET 1,(IY+$2D) ; zmienna systemowa FLAGX JR NZ,SET_STRLN ; $0D4B : 3403 REPORT_2: RST 08H ; ERROR-1 .BYTE $01 ; Raport Błędu: Zmienna nie znaleziona ; $0D4D : 3405 SET_STK: CALL Z,STK_VAR BIT 6,(IY+$01) ; zmienna systemowa FLAGS - wynik liczbowy czy znakowy? JR NZ,SET_STRLN XOR A CALL SYNTAX_Z CALL NZ,STK_FETCH LD HL,FLAGX OR (HL) LD (HL),A EX DE,HL ; $0D63 : 3427 SET_STRLN: LD (STRLEN),BC LD (DEST),HL ; PROCEDURA POLECENIA 'REM' ; $0D6A : 3434 REM: RET ; $0D6B : 3435 CLASS_2: POP BC LD A,(FLAGS) ; $0D6F : 3439 INPUT_REP: PUSH AF CALL SCANNING POP AF LD BC,LET LD D,(IY+$01) ; zmienna systemowa FLAGS XOR D AND $40 JR NZ,REPORT_C BIT 7,D JR NZ,CLASS_END JR CHECK_2 ; $0D85 : 3461 CLASS_4: CALL LOOK_VARS PUSH AF LD A,C OR $9F INC A JR NZ,REPORT_C POP AF JR CLASS_4_2 ; $0D92 : 3474 CLASS_6: CALL SCANNING BIT 6,(IY+$01) ; zmienna systemowa FLAGS - wynik liczbowy czy znakowy? RET NZ ; $0D9A : 3482 REPORT_C: RST 08H ; ERROR-1 .BYTE $0B ; Raport błędu - Nonsens w języku BASIC ; -------------------------- ; PROCEDURA 'LICZBA NA STOS' ; -------------------------- ; $0D9C : 3484 NO_TO_STK: JR NZ,CLASS_6 ; wróć do CLASS-6 z niezerową liczbą. CALL SYNTAX_Z RET Z ; wróć, jeśli sprawdza się składnię. ; w czasie wykonania umieszczane jest na stosie kalkulatora zero, jako wartość standardowa. RST 28H ; KALKULATOR .BYTE $A0 ; na-stos-zero .BYTE $34 ; koniec-obliczeń RET ; ---------------------- ; PROCEDURA 'SKŁADNIA-Z' ; ---------------------- ; Ta procedura wraca z ustawionym znacznikiem Z, jeśli sprawdzana jest składnia. Wywołanie tej procedury zajmuje 3 bajty w porównaniu z 4, ; gdyby test był wykonywany na miejscu. Oczywiście cierpi na tym szybkość działania ZX-81. ; $0DA6 : 3494 SYNTAX_Z: BIT 7,(IY+$01) ; testuj FLAGS - jedynie sprawdzana składnia? RET ; ------------------------ ; PROCEDURA POLECENIA 'IF' ; ------------------------ ; W czasie wykonania procedury klas wyliczyły wartość warunku i wynik, prawda lub fałsz, znajduje się na stosie kalkulatora. ; $0DAB : 3499 IF: CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni JR Z,IF_END ; naprzód do IF-END w przypadku sprawdzania składni ; inaczej usuń wartość logiczną ze stosu kalkulatora. RST 28H ; KALKULATOR .BYTE $02 ; usuń .BYTE $34 ; koniec-obliczeń ; rejestr DE wskazóje wykładnik wartości zmiennoprzecinkowej. LD A,(DE) ; pobierz wykładnik AND A ; sprawdź, czy zero - FALSE. RET Z ; wróć, jeśli tak. ; $0DB6 : 3510 IF_END: JP LINE_NULL ; skocz wstecz do LINE-NULL ; ------------------------- ; PROCEDURA POLECENIA 'FOR' ; ------------------------- ; $0DB9 : 3513 FOR: CP $E0 ; czy bieżący znak jest poleceniem 'STEP' ? JR NZ,F_USE_ONE ; jeśli nie, to naprzód do F-USE-ONE RST 20H ; NASTĘPNY-ZNAK CALL CLASS_6 ; procedura CLASS-6 umieszcza liczbę na stosie CALL CHECK_END JR F_REORDER ; $0DC6 : 3526 F_USE_ONE: CALL CHECK_END RST 28H ; KALKULATOR .BYTE $A1 ; jeden-na-stos .BYTE $34 ; koniec-obliczeń ; $0DCC : 3532 F_REORDER: RST 28H ; KALKULATOR v, l, s. .BYTE $C0 ; stos-do-pamięci-0 v, l, s. .BYTE $02 ; usuń v, l. .BYTE $01 ; zamień l, v. .BYTE $E0 ; na-stos-paimięć-0 l, v, s. .BYTE $01 ; zamień l, s, v. .BYTE $34 ; koniec-obliczeń l, s, v. CALL LET LD (MEM),HL ; ustaw MEM na adresowaną zmienną. DEC HL ; wskaż na znak. LD A,(HL) SET 7,(HL) LD BC,$0006 ADD HL,BC RLCA JR C,F_LMT_STP SLA C CALL MAKE_ROOM INC HL ; $0DEA : 3562 F_LMT_STP: PUSH HL RST 28H ; KALKULATOR .BYTE $02 ; usuń .BYTE $02 ; usuń .BYTE $34 ; koniec-obliczeń POP HL EX DE,HL LD C,$0A ; ma być przesunięte dziesięć bajtów. LDIR ; kopiuj bajty LD HL,(PPC) ; ustaw HL na zmienną systemową PPC - bieżący wiersz. EX DE,HL ; przenieś do DE, wskaźnik zmiennej do HL. INC DE ; początek pętli będzie na następnym wierszu LD (HL),E INC HL LD (HL),D CALL NEXT_LOOP ; procedura NEXT-LOOP zajmuje się wstępnym obiegiem. RET NC ; jeśli możliwe, wróć. ; inaczej program wykonuje się od punktu za pierwszym pasującym rozkazem NEXT. BIT 7,(IY+$08) ; sprawdź starszy bajt PPC RET NZ ; wróć, jeśli powyżej 32767 ??? LD B,(IY+$2E) ; pobierz nazwę zmiennej ze STRLEN RES 6,B ; zrób ją prawdziwą literą. LD HL,(NXTLIN) ; ustaw HL z NXTLIN ; teraz wejdź do pętli szukającej pasującego NEXT. ; $0E0E : 3598 NXTLIN_NO: LD A,(HL) ; pobierz starszy bajt numeru wiersza. AND $C0 ; wymaskuj dolne bity $3F JR NZ,FOR_END ; skocz na koniec do FOR-END PUSH BC ; zachowaj literę CALL NEXT_ONE ; procedura NEXT-ONE znajdzie następny wiersz. POP BC ; odzyskaj literę INC HL ; przejdź nad numerem wiersza INC HL ; aż do długości INC HL ; wiersza CALL TEMP_PTR1 ; procedura TEMP-PTR1 ustawia CH_ADD RST 18H ; POBIERZ-ZNAK CP $F3 ; porównaj z 'NEXT'. EX DE,HL ; następny wiersz do HL. JR NZ,NXTLIN_NO ; jeśli brak zgodności, wstecz do NXTLIN-NO EX DE,HL ; odtwórz wskaźnik RST 20H ; NASTĘPNY-ZNAK idzie naprzód i pobiera literę do A. EX DE,HL ; zachowaj wskaźnik CP B ; porównaj z nazwą zmiennej. JR NZ,NXTLIN_NO ; jeśli nie pasuje, wróć do NXTLIN-NO ; $0E2A : 3626 FOR_END: LD (NXTLIN),HL ; uaktualnij zmienną systemową NXTLIN RET ; -------------------------- ; PROCEDURA POLECENIA 'NEXT' ; -------------------------- ; $0E2E : 3630 NEXT: BIT 1,(IY+$2D) ; zmienna systemowa FLAGX JP NZ,REPORT_2 LD HL,(DEST) BIT 7,(HL) JR Z,REPORT_1 INC HL LD (MEM),HL RST 28H ; KALKULATOR .BYTE $E0 ; na-stos-paimięć-0 .BYTE $E2 ; na-stos-paimięć-2 .BYTE $0F ; dodaj .BYTE $C0 ; stos-do-pamięci-0 .BYTE $02 ; usuń .BYTE $34 ; koniec-obliczeń CALL NEXT_LOOP RET C LD HL,(MEM) LD DE,$000F ADD HL,DE LD E,(HL) INC HL LD D,(HL) EX DE,HL JR GOTO_2 ; $0E58 : 3672 REPORT_1: RST 08H ; ERROR-1 .BYTE $00 ; Raport Błędu: NEXT bez FOR ; ---------------------- ; PROCEDURA 'PĘTLA NEXT' ; ---------------------- ; $0E5A : 3674 NEXT_LOOP: RST 28H ; KALKULATOR .BYTE $E1 ; na-stos-paimięć-1 .BYTE $E0 ; na-stos-paimięć-0 .BYTE $E2 ; na-stos-paimięć-2 .BYTE $32 ; mniej-niż-0 .BYTE $00 ; skocz-przy-prawdzie .BYTE $02 ; do $0E62, LMT-V-VAL .BYTE $01 ; zamień ; $0E62 : 3682 LMT_V_VAL: .BYTE $03 ; odejmij .BYTE $33 ; większe-niż-0 .BYTE $00 ; skocz-przy-prawdzie .BYTE $04 ; do $0E69, IMPOSS .BYTE $34 ; koniec-obliczeń AND A ; zeruj znacznik przeniesienia RET ; $0E69 : 3689 IMPOSS: .BYTE $34 ; koniec-obliczeń SCF RET ; -------------------------- ; PROCEDURA POLECENIA 'RAND' ; -------------------------- ; Z ZX-81 rozkaz nazywa się RAND, w ZX-Spectrum jest to Randomize. W obu tych przypadkach procedura obsługi jest identyczna - ustawia zmienną ; systemową SEED dostarczoną wartością lub wartością opartą na czasie, jeśli nie dostarczono żadnej liczby lub liczba ta jest równa zero. ; $0E6C : 3692 RAND: CALL FIND_INT LD A,B ; sprawdź, czy wartość jest równa zero OR C JR NZ,SET_SEED ; naprzód do SET-SEED, jeśli różne od zera LD BC,(FRAMES) ; inaczej pobierz zmienną systemową FRAMES ; $0E77 : 3703 SET_SEED: LD (SEED),BC ; uaktualnij zmienną systemową SEED RET ; -------------------------- ; PROCEDURA POLECENIA 'CONT' ; -------------------------- ; Kolejny skrócony rozkaz. Miejsca w ROM musiało bardzo brakować. Kontynuuje od wiersza, który był ustawiony w momencie naciśnięcia klawisza BREAK. ; Po STOP jest to następny wiersz, inaczej program by się od razu zatrzymał. ; $0E7C : 3708 CONT: LD HL,(OLDPPC) ; ustaw HL ze zmiennej systemowej OLDPPC JR GOTO_2 ; -------------------------- ; PROCEDURA POLECENIA 'GOTO' ; -------------------------- ; Nazwa również ucierpiała z powodu braku miejsca w ROM i nie ma w niej spacji pomiędzy GO i TO, jak w ZX-Spectrum. To samo dotyczy również ; polecenia GOSUB. ; $0E81 : 3713 GOTO: CALL FIND_INT LD H,B LD L,C ; $0E86 : 3718 GOTO_2: LD A,H CP $F0 JR NC,REPORT_B CALL LINE_ADDR LD (NXTLIN),HL RET ; -------------------------- ; PROCEDURA POLECENIA 'POKE' ; -------------------------- ; $0E92 : 3730 POKE: CALL FP_TO_A JR C,REPORT_B ; naprzód z nadmiarem do REPORT-B JR Z,POKE_SAVE ; jeśli dodatnie, naprzód do POKE-SAVE NEG ; zmień znak na przeciwny ; $0E9B : 3739 POKE_SAVE: PUSH AF ; zachowaj wartość CALL FIND_INT ; procedura FIND-INT pobiera adres do BC wywołując procedurę błędu przy nadmiarze lub wartości ujemnej POP AF ; odzyskaj wartość ; Uwaga, następne dwie instrukcje są pozostałością po ZX80 i nie powinno ich tytaj być, ale są. BIT 7,(IY+$00) ; sprawdź ERR_NR - czy wciąż $FF ? RET Z ; jeśli nie, wróć z błędem. LD (BC),A ; wpisz wartość pod wskazany adres. RET ; ----------------------------------- ; PROCEDURA 'ZNAJDŹ LICZBĘ CAŁKOWITĄ' ; ----------------------------------- ; $0EA7 : 3751 FIND_INT: CALL FP_TO_BC JR C,REPORT_B ; naprzód z nadmiarem do REPORT-B RET Z ; wróć, jeśli dodatnie (0-65535). ; $0EAD : 3757 REPORT_B: RST 08H ; ERROR-1 .BYTE $0A ; Raport Błędu: Liczba całkowita poza zakresem ; ------------------------- ; PROCEDURA POLECENIA 'RUN' ; ------------------------- ; $0EAF : 3759 RUN: CALL GOTO JP CLEAR ; --------------------------- ; PROCEDURA POLECENIA 'GOSUB' ; --------------------------- ; $0EB5 : 3765 GOSUB: LD HL,(PPC) INC HL EX (SP),HL PUSH HL LD (ERR_SP),SP ; ustaw wskaźnik stosu błędu - ERR_SP CALL GOTO LD BC,$0006 ; --------------------------- ; PROCEDURA 'SPRAWDŹ MIEJSCE' ; --------------------------- ; ; $0EC5 : 3781 TEST_ROOM: LD HL,(STKEND) ADD HL,BC JR C,REPORT_4 EX DE,HL LD HL,$0024 ADD HL,DE SBC HL,SP RET C ; $0ED3 : 3795 REPORT_4: LD L,$03 JP ERROR_3 ; ---------------------------- ; PROCEDURA POLECENIA 'RETURN' ; ---------------------------- ; $0ED8 : 3800 RETURN: POP HL EX (SP),HL LD A,H CP $3E JR Z,REPORT_7 LD (ERR_SP),SP JR GOTO_2 ; wstecz do GOTO-2 ; $0EE5 : 3813 REPORT_7: EX (SP),HL PUSH HL RST 08H ; ERROR-1 .BYTE $06 ; Raport Błędu: RETURN bez GOSUB ; --------------------------- ; PROCEDURA POLECENIA 'INPUT' ; --------------------------- ; $0EE9 : 3817 INPUT: BIT 7,(IY+$08) ; starszy bajt zmiennej systemowej PPC_hi JR NZ,REPORT_8 CALL X_TEMP LD HL,FLAGX SET 5,(HL) RES 6,(HL) LD A,(FLAGS) AND $40 LD BC,$0002 JR NZ,PROMPT LD C,$04 ; $0F05 : 3845 PROMPT: OR (HL) LD (HL),A RST 30H ; BC-MIEJSC LD (HL),$76 LD A,C RRCA RRCA JR C,ENTER_CUR LD A,$0B LD (DE),A DEC HL LD (HL),A ; $0F14 : 3860 ENTER_CUR: DEC HL LD (HL),$7F LD HL,(S_POSN) LD (T_ADDR),HL POP HL JP LOWER ; $0F21 : 3873 REPORT_8: RST 08H ; ERROR-1 .BYTE $07 ; Raport Błędu: Koniec pliku ; --------------------------- ; PROCEDURA POLECENIA 'PAUSE' ; --------------------------- ; $0F23 : 3875 FAST: CALL SET_FAST RES 6,(IY+$3B) ; zmienna systemowa CDFLAG RET ; -------------------------- ; PROCEDURA POLECENIA 'SLOW' ; -------------------------- ; ; $0F2B : 3883 SLOW: SET 6,(IY+$3B) ; zmienna systemowa CDFLAG JP SLOW_FAST ; --------------------------- ; PROCEDURA POLECENIA 'PAUSE' ; --------------------------- ; $0F32 : 3890 PAUSE: CALL FIND_INT CALL SET_FAST LD H,B LD L,C CALL DISPLAY_P LD (IY+$35),$FF ; starszy bajt zmiennej systemowej FRAMES CALL SLOW_FAST JR DEBOUNCE ; ------------------- ; PROCEDURA 'PRZERWA' ; ------------------- ; ; $0F46 : 3910 BREAK_1: LD A,$7F ; czytaj port $7FFE - klawisze B,N,M,.,SPACJA. IN A,($FE) RRA ; jeśli naciśnięto spację, będzie ustawione przeniesienie ; -------------------- ; PROCEDURA 'DEBOUNCE' ; -------------------- ; ; $0F4B : 3915 DEBOUNCE: RES 0,(IY+$3B) ; uaktualnij zmienną systemową CDFLAG LD A,$FF LD (DBOUNC),A RET ; ---------------------- ; PROCEDURA 'SKANOWANIA' ; ---------------------- ; To ta procedura rekurencyjna daje ZX81 jego moc. O ile w systemie jest wystarczająca ilość pamięci, może on obliczać wartości wyrażeń ; o nieograniczonej złożoności. ; Uwaga. Ponieważ nie ma jednoargumentowego plusa, więc PRINT +1 daje błąd składniowy. Na spektrum to działa, lecz również działa PRINT + "STRING". ; $0F55 : 3925 SCANNING: RST 18H ; POBIERZ-ZNAK LD B,$00 ; wyzeruj rejestr B PUSH BC ; umieść zero na stosie jako priorytetowy znacznik końca ; $0F59 : 3929 S_LOOP_1: CP $40 ; sprawdź ze znakiem 'RND' JR NZ,S_TEST_PI ; jeśli się nie zgadza, naprzód do S-TEST-PI ; ------------- ; FUNKCJA 'RND' ; ------------- CALL SYNTAX_Z ; wyjdź, jeśli jest sprawdzana składnia JR Z,S_JPI_END ; przy sprawdzaniu składni skocz naprzód do S-JPI-END LD BC,(SEED) ; pobierz zmienną systemową SEED CALL STACK_BC ; i umieść ją na stosie kalkulatora RST 28H ; KALKULATOR seed. .BYTE $A1 ; jeden-na-stos seed,1. .BYTE $0F ; dodaj seed+1. .BYTE $30 ; dane-na-stos seed+1,75. .BYTE $37 ; Wykładnik: $87, Bajty: 1 .BYTE $16 ;(+00,+00,+00) .BYTE $04 ; mnóż (seed+1)*75. .BYTE $30 ; dane-na-stos (seed+1)*75,65537. .BYTE $80 ; Bajty: 3 .BYTE $41 ; Wykładnik $91 .BYTE $00,$00,$80 ;(+00) .BYTE $2E ; n-modulo-m reszta,iloraz. .BYTE $02 ; usuń reszta z dzielenia (seed+1)*75/65537. .BYTE $A1 ; jeden-na-stos reszta,1. .BYTE $03 ; odejmij reszta-1. .BYTE $2D ; duplikuj reszta-1,reszta-1. .BYTE $34 ; koniec-obliczeń CALL FP_TO_BC LD (SEED),BC ; uaktualnij zmienną systemową SEED LD A,(HL) ; HL adresuje wykładnik ostatniej wartości AND A ; testuj zero JR Z,S_JPI_END ; jeśli zero, skocz naprzód do S-JPI-END SUB $10 ; inaczej zmniejsz wykładnik o 16 LD (HL),A ; co daje podzielenie ostatniej wartości o 65536 ; $0F8A : 3978 S_JPI_END: JR S_PI_END ; $0F8C : 3980 S_TEST_PI: CP $42 ; znak 'PI' JR NZ,S_TST_INK ; jeśli nie, naprzód do S-TST-INK ; --------------- ; OBLICZANIE 'PI' ; --------------- CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni JR Z,S_PI_END ; jeśli sprawdzanie składni, naprzód do S-PI-END RST 28H ; KALKULATOR .BYTE $A3 ; na-stos-pi/2 .BYTE $34 ; koniec-obliczeń INC (HL) ; zwiększ wykładnik, co na stosie da PI. ; $0F99 : 3993 S_PI_END: RST 20H ; NASTĘPNY-ZNAK - przesuwa do przodu wskaźnik znaków JP S_NUMERIC ; skocz naprzód so S-NUMERIC, aby przed kontynuacją ustawić znacznik ; informujący o wyniku liczbowym. ; $0F9D : 3997 S_TST_INK: CP $41 ; porównaj ze znakiem 'INKEY$' JR NZ,S_ALPHANUM ; jeśli się nie zgadza, naprzód do S-ALPHANUM ; ------------------- ; OBLICZANIE 'INKEY$' ; ------------------- CALL KEYBOARD LD B,H LD C,L LD D,C INC D CALL NZ,DECODE LD A,D ADC A,D LD B,D LD C,A EX DE,HL JR S_STRING ; $0FB2 : 4018 S_ALPHANUM: CALL ALPHANUM JR C,S_LTR_DGT ; naprzód, gdy alfanumeryczne do S-LTR-DGT CP $1B ; czy znak to '.' ? JP Z,S_DECIMAL ; jeśli tak, skocz naprzód do S-DECIMAL LD BC,$09D8 ; przygotuj operację 'odejmowania' o priorytecie 09 CP $16 ; czy znak to '-' ? JR Z,S_PUSH_PO ; jeśli tak, to naprzód do S-PUSH-PO CP $10 ; czy znak to '(' ? JR NZ,S_QUOTE ; jeśli tak, naprzód do S-QUOTE CALL CH_ADD_1 ; procedura CH-ADD+1 przesuwa do przodu wskaźnik znaków. CALL SCANNING ; rekursywnie wywołaj procedurę SCANNING, aby obliczyć wartość podwyrażenia CP $11 ; czy znak to ')' ? JR NZ,S_RPT_C ; jeśli nie, skocz naprzód do S-RPT-C CALL CH_ADD_1 ; procedura CH-ADD+1 przesuwa wskaźnik znaków JR S_J_CONT_3 ; skok względny do S-JP-CONT3, a później do S-CONT3 ; rozważ łańcuch w cudzysłowach, np. PRINT "HURA!" ; Uwaga, cudzysłowy nie są dozwolone wewnątrz łańcucha. ; $0FD6 : 4054 S_QUOTE: CP $0B ; czy znakiem jest cudzysłów (") ? JR NZ,S_FUNCTION ; jeśli nie, naprzód do S-FUNCTION CALL CH_ADD_1 ; procedura CH-ADD+1 przesuwa wskaźnik znaków PUSH HL ; * zachowaj początek łańcucha. JR S_QUOTE_S ; $0FE0 : 4064 S_Q_AGAIN: CALL CH_ADD_1 ; procedura CH-ADD+1 przesuwa wskaźnik znaków ; $0FE3 : 4067 S_QUOTE_S: CP $0B ; czy znakiem jest '"' ? JR NZ,S_Q_NL ; jeśli nie, naprzód do S-Q-NL POP DE ; * odzyskaj poczatek łańcucha AND A ; przygotuj się do odejmowania SBC HL,DE ; od bieżącej pozycji odejmij start LD B,H ; przenieś tą długość LD C,L ; do pary rejestrów BC ; $0FED : 4077 S_STRING: LD HL,FLAGS ; zaadresuj zmienną systemową FLAGS RES 6,(HL) ; sygnalizuj wynik łańcuchowy BIT 7,(HL) ; sprawdź, czy testowana jest składnia CALL NZ,STK_STO ; w czasie wykonania procedura STK-STO-$ umieszcza na stosie deskryptor łańcucha - start DE, długość BC. RST 20H ; NASTĘPNY-ZNAK - przesuń wskaźnik. ; $0FF8 : 4088 S_J_CONT_3: JP S_CONT_3 ; Należy rozważyć łańcuch bez zamykającego cudzysłowu. ; $0FFB : 4091 S_Q_NL: CP $76 ; porównaj z NEWLINE JR NZ,S_Q_AGAIN ; jeśli różne, wróć z powrotem do S-Q-AGAIN ; $0FFF : 4095 S_RPT_C: JP REPORT_C ; $1002 : 4098 S_FUNCTION: SUB $C4 ; odejmij 'CODE' zmniejszając kod znaku ; od CODE do '<>', zakres $00 - $XX JR C,S_RPT_C ; jeśli mniej, wróć do S-RPT-C ; sprawdź NOT, ostatnią funkcję w zestawie znaków. LD BC,$04EC ; przygotuj priorytet $04, operacja 'not' CP $13 ; porównaj z 'NOT' ( - CODE) JR Z,S_PUSH_PO ; jeśli się zgadza, skocz naprzód do S-PUSH-PO JR NC,S_RPT_C ; jeśli jest cokolwiek więcej, wstecz do S-RPT-C ; inaczej mamy do czynienia z funkcją od 'CODE' do 'CHR$' LD B,$10 ; priorytet 16 wiąże wszystkie funkcje z argumentami, usuwając potrzebę stosowania nawiasów. ADD A,$D9 ; dodaj $D9, aby uzyskać zakres od $D9 do $EB bit 6 jest ustawiony, aby pokazywać argument liczbowy. ; bit 7 jest ustawiony, aby pokazywać wynik liczbowy. ; teraz wyreguluj te standardowe znaczniki argumentów/wyników. LD C,A ; zachowaj kod w C CP $DC ; rozdziel 'CODE', 'VAL', 'LEN' JR NC,S_NO_TO ; jeśli argument jest łańcuchem, przejdź naprzód do S-NO-TO-$ RES 6,C ; sygnalizuj łańcuchowy argument. ; $101A : 4122 S_NO_TO: CP $EA ; wyizoluj górę zakresu: 'STR$' i 'CHR$' JR C,S_PUSH_PO ; z innymi przejdź naprzód do S-PUSH-PO RES 7,C ; sygnalizuj wynik łańcuchowy. ; $1020 : 4128 S_PUSH_PO: PUSH BC ; umieść na stosie priorytet/operację RST 20H ; NASTĘPNY-ZNAK JP S_LOOP_1 ; skocz wstecz do S-LOOP-1 ; $1025 : 4133 S_LTR_DGT: CP $26 ; porównaj z 'A'. JR C,S_DECIMAL ; jeśli poniżej, skocz naprzód do S-DECIMAL CALL LOOK_VARS ; poszukaj zmiennej JP C,REPORT_2 ; jeśli nie znaleziono, wstecz do REPORT-2 przy sprawdzaniu składni, zmienna jest zawsze 'znaleziona'. CALL Z,STK_VAR ; procedura STK-VAR umieszcza na stosie parametry łańcuchowe lub zwraca położenie komórki, jeśli parametry są liczbowe LD A,(FLAGS) ; pobierz FLAGS CP $C0 ; porównaj z wynikiem/argumentem liczbowym JR C,S_CONT_2 ; jeśli nie jest liczbowy, idź do S-CONT-2 INC HL ; zaadresuj liczbową zawartość zmiennej LD DE,(STKEND) ; ustaw przeznaczenie na STKEND CALL MOVE_FP ; procedura MOVE-FP umieszcza na stosie pięć bajtów EX DE,HL ; przenieś nową wolną pozycję z DE do HL. LD (STKEND),HL ; uaktualnij zmienną systemową STKEND JR S_CONT_2 ; Procedura skanowania liczby dziesiętnej jest wywoływana, gdy w wyrażeniu zostanie napotkana cyfra lub znak kropki. Gdy sprawdzana jest składnia, ; to "ukryta" liczba zmiennoprzecinkowa jest umieszczana w wierszu BASIC za zapisem liczby. W czasie wykonywania programu cyfry są pomijane, ; a pobrana zostaje liczba zmiennoprzecinkowa. ; $1047 : 4167 S_DECIMAL: CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni JR NZ,S_STK_DEC ; w czasie wykonania naprzód do S-STK-DEC CALL DEC_TO_FP RST 18H ; POBIERZ-ZNAK przesuwa HL poza cyfry LD BC,$0006 ; potrzebne jest sześć komórek. CALL MAKE_ROOM ; zrób na nie miejsce INC HL ; ustaw HL na pierwszą komórkę LD (HL),$7E ; wstaw znacznik liczby o kodzie 126 INC HL ; przejdź dalej EX DE,HL ; przenieś adres docelowy do DE. LD HL,(STKEND) ; ustaw HL na STKEND, które wskazuje na pierwszą komórkę za "ostatnią wartością" LD C,$05 ; do przesunięcia pięć bajtów AND A ; wyzeruj znacznik przeniesienia SBC HL,BC ; odejmij 5, wskazując na "ostatnią wartość" LD (STKEND),HL ; uaktualnij STKEND, co skutkuje usunięciem liczby LDIR ; przekopiuj wartość tych pięciu bajtów EX DE,HL ; wskaźnik BASIC do HL, który może wskazywać biały znak za liczbą DEC HL ; teraz wskazuje ostatni z pięciu bajtów. CALL TEMP_PTR1 ; procedura TEMP-PTR1 przesuwa wskaźnik na kolejny znak pomijając wszystkie znaki białe JR S_NUMERIC ; naprzód do S-NUMERIC, sygnalizując wynik liczbowy ; w czasie wykonania programu skok trafia w to miejsce, gdy zostanie napotkana cyfra lub kropka. ; $106F : 4207 S_STK_DEC: RST 20H ; NASTĘPNY-ZNAK CP $7E ; porównaj ze znacznikiem liczby JR NZ,S_STK_DEC ; cofnij się w pętli do S-STK-DEC aż znak zostanie odnaleziony pomijając wszystkie cyfry INC HL ; wskaż pierwszy z pięciu ukrytych bajtów. LD DE,(STKEND) ; ustaw przeznaczenie ze zmiennej systemowej STKEND CALL MOVE_FP ; procedura MOVE-FP umieszcza liczbę na stosie. LD (STKEND),DE ; uaktualnij zmienne systemowe STKEND LD (CH_ADD),HL ; oraz CH_ADD. ; $1083 : 4227 S_NUMERIC: SET 6,(IY+$01) ; uaktualnij FLAGS - sygnalizuj wynik liczbowy ; $1087 : 4231 S_CONT_2: RST 18H ; POBIERZ-ZNAK ; $1088 : 4232 S_CONT_3: CP $10 ; porównaj z nawiasem otwierającym '(' JR NZ,S_OPERTR ; jeśli nie, skocz naprzód do S-OPERTR BIT 6,(IY+$01) ; testuj FLAGS - wynik liczbowy czy łańcuchowy? JR NZ,S_LOOP ; jeśli liczbowy, naprzód do S-LOOP ; inaczej mamy do czynienia z łańcuchem znaków CALL SLICING RST 20H ; NASTĘPNY-ZNAK JR S_CONT_3 ; wróć do S-CONT-3 ; Znak jest teraz przetwarzany, aby utworzył odpowiednik w tablicy literałów kalkulatora. Jest to dosyć zawiłe, dlatego w ZX-Spectrum wprowadzono ; w tym miejscu prostą tablicę translacji. ; $1098 : 4248 S_OPERTR: LD BC,$00C3 ; standardowo przygotuj operator 'odejmowania'. Również ustaw B na zero do późniejszego indeksowania. CP $12 ; czy znakiem jest '>' ? JR C,S_LOOP ; jeśli mniej, skocz naprzód do S-LOOP, ponieważ osiągnięty został koniec sensownych wyrażeń SUB $16 ; czy znakiem jest '-' ? JR NC,SUBMLTDIV ; z - * / AND '**' '<>' skocz naprzód do SUBMLTDIV ADD A,$0D ; pozostałe zwiększ o trzynaście $09 ">' do $0C '+' JR GET_PRIO ; skocz naprzód do GET-PRIO ; $10A7 : 4263 SUBMLTDIV: CP $03 ; wyizoluj $00 '-', $01 '*', $02 '/' JR C,GET_PRIO ; naprzód do GET-PRIO, jeśli tak ; inaczej być może pierwotne do $D8 '**' do $DD '<>' już zmniejszone o $16 SUB $C2 ; dając zakres od $00 do $05 JR C,S_LOOP ; naprzód do S-LOOP, jeśli mniej CP $06 ; testuj górną granicę na nonsens, również JR NC,S_LOOP ; naprzód do S-LOOP, jeśli tak ADD A,$03 ; zwiększ o 3, aby otrzymać połączone operatory ; $00 '-' ; $01 '*' ; $02 '/' ; $03 '**' ; $04 'OR' ; $05 'AND' ; $06 '<=' ; $07 ">=' ; $08 '<>' ; $09 ">' ; $0A '<' ; $0B '=' ; $0C '+' ; $10B5 : 4277 GET_PRIO: ADD A,C ; dodaj do standardowej operacji 'sub' ($C3) LD C,A ; i bajt operatora umieść w C. LD HL,TBL_PRI-$C3 ; teoretyczna podstawa tablicy priorytetów. ADD HL,BC ; dodaj C ( B jest równe zero) LD B,(HL) ; pobierz priorytet do B ; $10BC : 4284 S_LOOP: POP DE ; odtwórz poprzednią zawartość LD A,D ; załaduj A priorytetem. CP B ; czy jest wyższy priorytet JR C,S_TIGHTER ; jeśli tak, skocz naprzód do S-TIGHTER AND A ; czy oba priorytety zero? JP Z,GET_CHAR ; jeśli zero, wyjdź poprzez GET-CHAR PUSH BC ; zapisz na stosie bieżące wartości PUSH DE ; zapisz na stosie ostatnie wartości CALL SYNTAX_Z ; czy sprawdzana składnia? JR Z,S_SYNTEST ; jeśli sprawdzana składnia, naprzód do S-SYNTEST LD A,E ; pobierz ostatnią operację AND $3F ; zamaskuj bity wskaźnikowe, aby otrzymać prawdziwy literał kalkulatora LD B,A ; umieść w rejestrze B dla BREG ; wykonaj pojedynczą operację RST 28H ; KALKULATOR .BYTE $37 ; fp-calc-2 .BYTE $34 ; koniec-obliczeń JR S_RUNTEST ; naprzód do S-RUNTEST ; $10D5 : 4309 S_SYNTEST: LD A,E ; przenieś wymaskowany operator do A XOR (IY+$01) ; wykonaj operację xor z FLAGS, wyniki zresetują bit 6 AND $40 ; testuj bit 6 ; $10DB : 4315 S_RPORT_C: JP NZ,REPORT_C ; wstecz do REPORT-C, jeśli wyniki się nie zgadzają. ; w czasie wykonania przenieś bit 7 operatora do bitu 6 zmiennej FLAGS ; $10DE : 4318 S_RUNTEST: POP DE ; przywróć ostatnią operację. LD HL,FLAGS ; zaadresuj zmienną systemową FLAGS SET 6,(HL) ; załóż wynik liczbowy BIT 7,E ; testuj oczekiwany wynik w operacji JR NZ,S_LOOPEND ; naprzód do S-LOOPEND, jeśli jest liczbowy RES 6,(HL) ; zeruj, aby zasygnalizować wynik łańcuchowy ; $10EA : 4330 S_LOOPEND: POP BC ; odtwórz bieżące wartości JR S_LOOP ; wstecz do S-LOOP ; $10ED : 4333 S_TIGHTER: PUSH DE ; zachowaj ostatnie wartości i zajmij się bieżącymi LD A,C ; pobierz bieżący operator BIT 6,(IY+$01) ; testuj FLAGS - wynik liczbowy czy łańcuchowy? JR NZ,S_NEXT ; jeśli liczbowy, naprzód do S-NEXT AND $3F ; usuń bity znaczników, aby uzyskać czysty literał ADD A,$08 ; dodaj 8 - rozszerzanie literału liczbowego do odpowiadających mu literałów łańcuchowych LD C,A ; umieść czysty literał z powrotem w C. CP $10 ; porównaj z 'AND' JR NZ,S_NOT_AND ; jeśli różne, naprzód do S-NOT-AND SET 6,C ; ustaw argument liczbowy wymagany dla 'AND' JR S_NEXT ; naprzód do S-NEXT ; $1102 : 4354 S_NOT_AND: JR C,S_RPORT_C ; jeśli mniej niż 'AND', to wstecz do S-RPORT-C. Nonsens, jeśli '-', '*' itp. CP $17 ; porównaj z literałem 'strs-add' JR Z,S_NEXT ; jeśli się zgadza, naprzód, sygnalizując wynik łańcuchowy SET 7,C ; dla pozostałych ustaw bit na liczbowe (logiczne) ; $110A : 4362 S_NEXT: PUSH BC ; zapisz na stosie 'bieżące' wartości RST 20H ; NASTĘPNY-ZNAK JP S_LOOP_1 ; skocz wstecz do S-LOOP-1 ; --------------------- ; 'TABLICA PRIORYTETÓW' ; --------------------- ; $110F : 4367 TBL_PRI: .BYTE $06 ; '-' .BYTE $08 ; '*' .BYTE $08 ; '/' .BYTE $0A ; '**' .BYTE $02 ; 'OR' .BYTE $03 ; 'AND' .BYTE $05 ; '<=' .BYTE $05 ; '>=' .BYTE $05 ; '<>' .BYTE $05 ; '>' .BYTE $05 ; '<' .BYTE $05 ; '=' .BYTE $06 ; '+' ; --------------------- ; PROCEDURA 'LOOK-VARS' ; --------------------- ; $111C : 4380 LOOK_VARS: SET 6,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj wynik liczbowy RST 18H ; POBIERZ-ZNAK CALL ALPHA JP NC,REPORT_C PUSH HL LD C,A RST 20H ; NASTĘPNY-ZNAK PUSH HL RES 5,C CP $10 JR Z,V_RUN_SYN SET 6,C CP $0D JR Z,V_STR_VAR SET 5,C ; $1139 : 4409 V_CHAR: CALL ALPHANUM JR NC,V_RUN_SYN RES 6,C RST 20H ; NASTĘPNY-ZNAK JR V_CHAR ; z powrotem w pętli do V-CHAR ; $1143 : 4419 V_STR_VAR: RST 20H ; NASTĘPNY-ZNAK RES 6,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj wynik łańcuchowy ; $1148 : 4424 V_RUN_SYN: LD B,C CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni JR NZ,V_RUN ; naprzód do V-RUN LD A,C AND $E0 SET 7,A LD C,A JR V_SYNTAX ; naprzód do V-SYNTAX ; $1156 : 4438 V_RUN: LD HL,(VARS) ; $1159 : 4441 V_EACH: LD A,(HL) AND $7F JR Z,V_80_BYTE CP C JR NZ,V_NEXT RLA ADD A,A JP P,V_FOUND_2 JR C,V_FOUND_2 POP DE PUSH DE PUSH HL ; $116B : 4459 V_MATCHES: INC HL ; $116C : 4460 V_SPACES: LD A,(DE) INC DE AND A JR Z,V_SPACES ; wstecz do V-SPACES CP (HL) JR Z,V_MATCHES ; wstecz do V-MATCHES OR $80 CP (HL) JR NZ,V_GET_PTR ; naprzód do V-GET-PTR LD A,(DE) CALL ALPHANUM JR NC,V_FOUND_1 ; naprzód do V-FOUND-1 ; $117F : 4479 V_GET_PTR: POP HL ; $1180 : 4480 V_NEXT: PUSH BC CALL NEXT_ONE EX DE,HL POP BC JR V_EACH ; wstecz do V-EACH ; $1188 : 4488 V_80_BYTE: SET 7,B ; $118A : 4490 V_SYNTAX: POP DE RST 18H ; POBIERZ-ZNAK CP $10 JR Z,V_PASS ; naprzód do V-PASS SET 5,B JR V_END ; naprzód do V-END ; $1194 : 4500 V_FOUND_1: POP DE ; $1195 : 4501 V_FOUND_2: POP DE POP DE PUSH HL RST 18H ; POBIERZ-ZNAK ; $1199 : 4505 V_PASS: CALL ALPHANUM JR NC,V_END ; jeśli alfanumeryczne, naprzód do V-END RST 20H ; NASTĘPNY-ZNAK JR V_PASS ; wstecz do V-PASS ; $11A1 : 4513 V_END: POP HL RL B BIT 6,B RET ; ------------------- ; PROCEDURA 'STK-VAR' ; ------------------- ; $11A7 : 4519 STK_VAR: XOR A LD B,A BIT 7,C JR NZ,SV_COUNT ; naprzód do SV-COUNT BIT 7,(HL) JR NZ,SV_ARRAYS ; naprzód do SV-ARRAYS INC A ; $11B2 : 4530 SV_SIMPLE: INC HL LD C,(HL) INC HL LD B,(HL) INC HL EX DE,HL CALL STK_STO RST 18H ; POBIERZ-ZNAK JP IS_SV_SLICE ; skocz naprzód do SV-SLICE? ; $11BF : 4543 SV_ARRAYS: INC HL INC HL INC HL LD B,(HL) BIT 6,C JR Z,SV_PTR ; naprzód do SV-PTR DEC B JR Z,SV_SIMPLE ; naprzód do SV-SIMPLE$ EX DE,HL RST 18H ; POBIERZ-ZNAK CP $10 JR NZ,REPORT_3 ; naprzód do REPORT-3 EX DE,HL ; $11D1 : 4561 SV_PTR: EX DE,HL JR SV_COUNT ; naprzód do SV-COUNT ; $11D4 : 4564 SV_COMMA: PUSH HL RST 18H ; POBIERZ-ZNAK POP HL CP $1A JR Z,SV_LOOP ; naprzód do SV-LOOP BIT 7,C JR Z,REPORT_3 ; naprzód do REPORT-3 BIT 6,C JR NZ,SV_CLOSE ; naprzód do SV-CLOSE CP $11 JR NZ,SV_RPT_C ; naprzód do SV-RPT-C RST 20H ; NASTĘPNY-ZNAK RET ; $11E9 : 4585 SV_CLOSE: CP $11 JR Z,SV_DIM ; naprzód do SV-DIM CP $DF JR NZ,SV_RPT_C ; naprzód do SV-RPT-C ; $11F1 : 4593 SV_CH_ADD: RST 18H ; POBIERZ-ZNAK DEC HL LD (CH_ADD),HL JR SV_SLICE ; naprzód do SV-SLICE ; $11F8 : 4600 SV_COUNT: LD HL,$0000 ; $11FB : 4603 SV_LOOP: PUSH HL RST 20H ; NASTĘPNY-ZNAK POP HL LD A,C CP $C0 JR NZ,SV_MULT ; naprzód do SV-MULT RST 18H ; POBIERZ-ZNAK CP $11 JR Z,SV_DIM ; naprzód do SV-DIM CP $DF JR Z,SV_CH_ADD ; wstecz do SV-CH-ADD ; $120C : 4620 SV_MULT: PUSH BC PUSH HL CALL DE__DE_1 EX (SP),HL EX DE,HL CALL INT_EXP1 JR C,REPORT_3 ; naprzód do REPORT-3 DEC BC CALL GET_HL_DE ADD HL,BC POP DE POP BC DJNZ SV_COMMA ; skocz w pętli wstecz do SV-COMMA BIT 7,C ; $1223 : 4643 SV_RPT_C: JR NZ,SL_RPT_C PUSH HL BIT 6,C JR NZ,SV_ELEM ; naprzód do SV-ELEM$ LD B,D LD C,E RST 18H ; POBIERZ-ZNAK CP $11 ; czy znakiem jest ')' ? JR Z,SV_NUMBER ; jeśli tak, przesuń się naprzód do SV-NUMBER ; $1231 : 4657 REPORT_3: RST 08H ; ERROR-1 .BYTE $02 ; Raport Błędu: zły indeks ; $1233 : 4659 SV_NUMBER: RST 20H ; NASTĘPNY-ZNAK POP HL LD DE,$0005 CALL GET_HL_DE ADD HL,BC RET ; $123D : 4669 SV_ELEM: CALL DE__DE_1 EX (SP),HL CALL GET_HL_DE POP BC ADD HL,BC INC HL LD B,D LD C,E EX DE,HL CALL STK_ST_0 RST 18H ; POBIERZ-ZNAK CP $11 ; czy jest to ')' ? JR Z,SV_DIM ; jeśli tak, naprzód do SV-DIM CP $1A ; czy jest to ',' ? JR NZ,REPORT_3 ; jeśli nie, wstecz do REPORT-3 ; $1256 : 4694 SV_SLICE: CALL SLICING ; $1259 : 4697 SV_DIM: RST 20H ; NASTĘPNY-ZNAK ; $125A : 4698 IS_SV_SLICE: CP $10 JR Z,SV_SLICE ; wstecz do SV-SLICE RES 6,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj wynik łańcuchowy RET ; ------------------- ; PROCEDURA 'SLICING' ; ------------------- ; $1263 : 4707 SLICING: CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni CALL NZ,STK_FETCH RST 20H ; NASTĘPNY-ZNAK CP $11 ; czy jest to ')' ? JR Z,SL_STORE ; jeśli tak, naprzód do SL-STORE PUSH DE XOR A PUSH AF PUSH BC LD DE,$0001 RST 18H ; POBIERZ-ZNAK POP HL CP $DF ; czy jest to 'TO' ? JR Z,SL_SECOND ; jeśli tak, naprzód do SL-SECOND POP AF CALL INT_EXP2 PUSH AF LD D,B LD E,C PUSH HL RST 18H ; POBIERZ-ZNAK POP HL CP $DF ; czy jest to 'TO' ? JR Z,SL_SECOND ; jeśli tak, naprzód do SL-SECOND CP $11 ; $128B : 4747 SL_RPT_C: JP NZ,REPORT_C LD H,D LD L,E JR SL_DEFINE ; naprzód do SL-DEFINE ; $1292 : 4754 SL_SECOND: PUSH HL RST 20H ; NASTĘPNY-ZNAK POP HL CP $11 ; czy jest to ')' ? JR Z,SL_DEFINE ; jeśli tak, naprzód do SL-DEFINE POP AF CALL INT_EXP2 PUSH AF RST 18H ; POBIERZ-ZNAK LD H,B LD L,C CP $11 ; czy jest to ')' ? JR NZ,SL_RPT_C ; jeśli nie, wstecz do SL-RPT-C ; $12A5 : 4773 SL_DEFINE: POP AF EX (SP),HL ADD HL,DE DEC HL EX (SP),HL AND A SBC HL,DE LD BC,$0000 JR C,SL_OVER ; naprzód do SL-OVER INC HL AND A JP M,REPORT_3 ; wstecz do REPORT-3 LD B,H LD C,L ; $12B9 : 4793 SL_OVER: POP DE RES 6,(IY+$01) ; zmienna systemowa FLAGS - sygnalizuj wynik łańcuchowy ; $12BE : 4798 SL_STORE: CALL SYNTAX_Z RET Z ; wróć przy sprawdzaniu składni ; ---------------------------- ; PROCEDURA 'UMIEŚĆ NA STOSIE' ; ---------------------------- ; Umieszcza na szczycie stosu liczbę przekazaną w rejestrach: ; A - wykładnik : DE:BC - mantysa ; $12C2 : 4802 STK_ST_0: XOR A ; zeruj wykładnik ; $12C3 : 4803 STK_STO: PUSH BC ; zachowaj fragment liczby CALL TEST_5_SP ; sprawdź, czy w pamięci jest miejsce na liczbę POP BC ; odtwórz fragment liczby LD HL,(STKEND) ; adresuj koniec stosu LD (HL),A ; prześlij wykładnik INC HL LD (HL),E ; prześlij pozostałe 4 bajty liczby DE:BC INC HL LD (HL),D INC HL LD (HL),C INC HL LD (HL),B INC HL ; teraz HL wskazuje puste miejsce na stosie LD (STKEND),HL ; uaktualnij STKEND RES 6,(IY+$01) ; uaktualnij FLAGS - sygnalizuj wynik łańcuchowy RET ; ------------------- ; PROCEDURY 'INT EXP' ; ------------------- ; ; $12DD : 4829 INT_EXP1: XOR A ; $12DE : 4830 INT_EXP2: PUSH DE PUSH HL PUSH AF CALL CLASS_6 POP AF CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni JR Z,I_RESTORE ; przy sprawdzaniu składni naprzód do I-RESTORE PUSH AF CALL FIND_INT POP DE LD A,B OR C SCF JR Z,I_CARRY ; naprzód do I-CARRY POP HL PUSH HL AND A SBC HL,BC ; $12F9 : 4857 I_CARRY: LD A,D SBC A,$00 ; $12FC : 4860 I_RESTORE: POP HL POP DE RET ; --------------------- ; PROCEDURA 'DE,(DE+1)' ; --------------------- ; INDEXUJ I ŁADUJ ; Jest to emulacja instrukcji procesora 6800 LDX 1,X, która ładuje wartość 2 bajtową z pamięci do rejestru ją indeksującego. Zwykle takich operacji ; nie opłaca się pisać jako podprogramów, a ta nie oszczędza ani miejsca, ani czasu. Widocznie programista był ograniczony czasowo i pamięciowo. ; $12FF : 4863 DE__DE_1: EX DE,HL ; przenieś adres indeksu do HL. INC HL ; zwiększ, aby zaadresować słowo. LD E,(HL) ; pobierz młodszy bajt słowa. INC HL ; indeksuj starszy bajt słowa LD D,(HL) ; i pobierz go RET ; wróć z DE = słowo ; --------------------- ; PROCEDURA 'GET-HL*DE' ; --------------------- ; $1305 : 4869 GET_HL_DE: CALL SYNTAX_Z ; czy sprawdzana jest składnia? RET Z ; jeśli tak, to wróć PUSH BC ; zachowaj BC LD B,$10 ; do B licznik bitów = 16 LD A,H ; starszy bajt do A LD C,L ; młodszy do C LD HL,$0000 ; $1311 : 4881 HL_LOOP: ADD HL,HL ; sprawdź, czy HL nie za duże przesuwając bity w lewo JR C,HL_END ; jeśli tak, skocz naprzód do HL-END RL C ; przesuń bity starego HL w lewo RLA JR NC,HL_AGAIN ; jeśli brak przeniesienia, skocz naprzód do HL-AGAIN ADD HL,DE ; dodaj do HL DE ; $131A : 4890 HL_END: JP C,REPORT_4 ; jeśli za duże, skocz do REPORT-4 ; $131D : 4893 HL_AGAIN: DJNZ HL_LOOP ; wstecz w pętli do HL-LOOP POP BC ; odtwórz BC RET ; --------------- ; PROCEDURA 'LET' ; --------------- ; $1321 : 4897 LET: LD HL,(DEST) ; ustaw wskaźnik znaków BIT 1,(IY+$2D) ; zmienna systemowa FLAGX JR Z,L_EXISTS LD BC,$0005 ; $132D : 4909 L_EACH_CH: INC BC ; test ; $132E : 4910 L_NO_SP: INC HL ; przesuń wskaźnik znaków LD A,(HL) ; pobierz znak AND A ; sprawdź, czy spacja JR Z,L_NO_SP ; jeśli tak, to wstecz do L-NO-SP CALL ALPHANUM ; sprawdź, czy znak lub cyfra JR C,L_EACH_CH CP $0D ; czy jest to '$' ? JP Z,L_NEW ; jeśli tak, naprzód do L-NEW$ RST 30H ; BC-MIEJSC PUSH DE LD HL,(DEST) DEC DE LD A,C SUB $06 LD B,A LD A,$40 JR Z,L_SINGLE ; naprzód do L-SINGLE ; $134B : 4939 L_CHAR: INC HL ; przesuń wskaźnik znaku LD A,(HL) ; pobierz znak AND A ; czy to jest spacja ? JR Z,L_CHAR ; jeśli tak, wstecz do L-CHAR INC DE LD (DE),A DJNZ L_CHAR ; wstecz w pętli do L-CHAR OR $80 ; ustaw bit 7 - ostatni znak nazwy LD (DE),A ; zapisz znak LD A,$80 ; $1359 : 4953 L_SINGLE: LD HL,(DEST) XOR (HL) POP HL CALL L_FIRST ; $1361 : 4961 L_NUMERIC: PUSH HL RST 28H ; KALKULATOR .BYTE $02 ; usuń .BYTE $34 ; koniec-obliczeń POP HL LD BC,$0005 AND A SBC HL,BC JR L_ENTER ; naprzód do L-ENTER ; $136E : 4974 L_EXISTS: BIT 6,(IY+$01) ; zmienna systemowa FLAGS - wynik liczbowy czy łańcuchowy? JR Z,L_DELETE ; naprzód do L-DELETE$ LD DE,$0006 ADD HL,DE JR L_NUMERIC ; wstecz do L-NUMERIC ; $137A : 4986 L_DELETE: LD HL,(DEST) LD BC,(STRLEN) BIT 0,(IY+$2D) ; zmienna systemowa FLAGX JR NZ,L_ADD ; naprzód do L-ADD$ LD A,B OR C RET Z PUSH HL RST 30H ; BC-MIEJSC PUSH DE PUSH BC LD D,H LD E,L INC HL LD (HL),$00 LDDR PUSH HL CALL STK_FETCH POP HL EX (SP),HL AND A SBC HL,BC ADD HL,BC JR NC,L_LENGTH ; naprzód do L-LENGTH LD B,H LD C,L ; $13A3 : 5027 L_LENGTH: EX (SP),HL EX DE,HL LD A,B OR C JR Z,L_IN_W_S ; naprzód do L_IN_W/S LDIR ; $13AB : 5035 L_IN_W_S: POP BC POP DE POP HL ; ------------------- ; PROCEDURA 'L-ENTER' ; ------------------- ; $13AE : 5038 L_ENTER: EX DE,HL LD A,B OR C RET Z PUSH DE LDIR POP HL RET ; $13B7 : 5047 L_ADD: DEC HL DEC HL DEC HL LD A,(HL) PUSH HL PUSH BC CALL L_STRING POP BC POP HL INC BC INC BC INC BC JP RECLAIM_2 ; skocz wstecz i wyjdź poprzez RECLAIM-2 ; $13C8 : 5064 L_NEW: LD A,$60 ; przygotuj maskę %01100000 LD HL,(DEST) ; załaduj wskaźnik znaków XOR (HL) ; -------------------- ; PROCEDURA 'L-STRING' ; -------------------- ; ; $13CE : 5070 L_STRING: PUSH AF CALL STK_FETCH EX DE,HL ADD HL,BC PUSH HL INC BC INC BC INC BC RST 30H ; BC-MIEJSC EX DE,HL POP HL DEC BC DEC BC PUSH BC LDDR EX DE,HL POP BC DEC BC LD (HL),B DEC HL LD (HL),C POP AF ; $13E7 : 5095 L_FIRST: PUSH AF CALL REC_V80 POP AF DEC HL LD (HL),A LD HL,(STKBOT) ; przenieś TKBOT LD (E_LINE),HL ; do E_LINE DEC HL ; przed spodem stosu LD (HL),$80 ; umieść znacznik końca RET ; --------------------- ; PROCEDURA 'STK-FETCH' ; --------------------- ; Procedura pobiera 5 bajtową wartość ze stosu kalkulatora, zmniejszając wskaźnik stosu o 5, aby wskazywał na koniec stosu. Przy liczbie ; zmiennoprzecinkowej wykładnik znajduje się w A, a mantysa ma 32 bity i jest umieszczana w EDCB. Przy łańcuchach początek jest w DE, a długość ; w BC. A nie jest używane. ; $13F8 : 5112 STK_FETCH: LD HL,(STKEND) ; adres końca stosu kalkulatora do HL DEC HL ; Pobierz mantysę do EDBC LD B,(HL) DEC HL LD C,(HL) DEC HL LD D,(HL) DEC HL LD E,(HL) DEC HL LD A,(HL) ; pobierz wykładnik do A LD (STKEND),HL ; Ustaw nowy adres końca stosu kalkulatora RET ; ------------------------- ; PROCEDURA POLECENIA 'DIM' ; ------------------------- ; Tworzona jest tablica i inicjowana na zero, które na ZX-81 jest także spacją. ; $1409 : 5129 DIM: CALL LOOK_VARS ; $140C : 5132 D_RPORT_C: JP NZ,REPORT_C CALL SYNTAX_Z ; wyjdź przy sprawdzaniu składni JR NZ,D_RUN ; jeśli nie, to naprzód do D-RUN RES 6,C CALL STK_VAR CALL CHECK_END ; $141C : 5148 D_RUN: JR C,D_LETTER ; naprzód do D-LETTER PUSH BC CALL NEXT_ONE CALL RECLAIM_2 POP BC ; $1426 : 5158 D_LETTER: SET 7,C LD B,$00 PUSH BC LD HL,$0001 BIT 6,C JR NZ,D_SIZE ; naprzód do D-SIZE LD L,$05 ; $1434 : 5172 D_SIZE: EX DE,HL ; $1435 : 5173 D_NO_LOOP: RST 20H ; NASTĘPNY-ZNAK LD H,$40 CALL INT_EXP1 JP C,REPORT_3 ; skocz wstecz do REPORT-3 POP HL PUSH BC INC H PUSH HL LD H,B LD L,C CALL GET_HL_DE EX DE,HL RST 18H ; POBIERZ-ZNAK CP $1A JR Z,D_NO_LOOP ; wstecz do D-NO-LOOP CP $11 ; czy jest to ')' ? JR NZ,D_RPORT_C ; jeśli nie, wstecz do D-RPORT-C RST 20H ; NASTĘPNY-ZNAK POP BC LD A,C LD L,B LD H,$00 INC HL INC HL ADD HL,HL ADD HL,DE JP C,REPORT_4 PUSH DE PUSH BC PUSH HL LD B,H LD C,L LD HL,(E_LINE) DEC HL CALL MAKE_ROOM INC HL LD (HL),A POP BC DEC BC DEC BC DEC BC INC HL LD (HL),C INC HL LD (HL),B POP AF INC HL LD (HL),A LD H,D LD L,E DEC DE LD (HL),$00 POP BC LDDR ; $147F : 5247 DIM_SIZES: POP BC LD (HL),B DEC HL LD (HL),C DEC HL DEC A JR NZ,DIM_SIZES ; wstecz do DIM-SIZES RET ; ------------------- ; PROCEDURA 'RESERVE' ; ------------------- ; $1488 : 5256 RESERVE: LD HL,(STKBOT) ; pobierz do HL adres spodu stosu kalkulatora DEC HL ; HL wskazuje teraz ostatni bajt w obszarze roboczym CALL MAKE_ROOM INC HL INC HL POP BC LD (E_LINE),BC POP BC EX DE,HL INC HL RET ; --------------------------- ; PROCEDURA POLECENIA 'CLEAR' ; --------------------------- ; $149A : 5274 CLEAR: LD HL,(VARS) LD (HL),$80 INC HL LD (E_LINE),HL ; ------------------ ; PROCEDURA 'X-TEMP' ; ------------------ ; $14A3 : 5283 X_TEMP: LD HL,(E_LINE) ; ---------------------- ; PROCEDURY 'USTAW-STOS' ; ---------------------- ; $14A6 : 5286 SET_STK_B: LD (STKBOT),HL ; $14A9 : 5289 SET_STK_E: LD (STKEND),HL RET ; ------------------------ ; PROCEDURA 'TYLKO KURSOR' ; ------------------------ ; Ta procedura jest wywoływana w celu stworzenia minimalnego wiersza z kursorem i NEWLINE oraz do ustawienia STKEND na początek wolnej przestrzeni ; na następnej pozycji. ; $14AD : 5293 CURSOR_IN: LD HL,(E_LINE) ; pobierz adres początku wiersza edycyjnego z E_LINE LD (HL),$7F ; wstaw znak kursora INC HL ; przejdź na następną pozycję LD (HL),$76 ; wstaw znak NEWLINE INC HL ; przejdź na następną wolną komórkę. LD (IY+$22),$02 ; ustaw wielkość spodu ekranu w DF_SZ JR SET_STK_B ; wyjdź poprzez SET-STK-B ; --------------------- ; PROCEDURA 'USTAW-MIN' ; --------------------- ; $14BC : 5308 SET_MIN: LD HL,MEMBOT ; zwykła pozycja obszaru pamięci kalkulatora LD (MEM),HL ; uaktualnij zmienną systemową MEM LD HL,(STKBOT) ; pobierz STKBOT JR SET_STK_E ; wstecz do SET-STK-E ; ------------------------------------ ; PROCEDURA 'ODZYSKAJ ZNACZNIK KOŃCA' ; ------------------------------------ ; $14C7 : 5319 REC_V80: LD DE,(E_LINE) JP RECLAIM_1 ; ----------------- ; PROCEDURA 'ALPHA' ; ----------------- ; $14CE : 5326 ALPHA: CP $26 JR ALPHA_2 ; przeskocz naprzód do ALPHA-2 ; -------------------- ; PROCEDURA 'ALPHANUM' ; -------------------- ; $14D2 : 5330 ALPHANUM: CP $1C ; $14D4 : 5332 ALPHA_2: CCF RET NC CP $40 RET ; ----------------------------------------------------- ; PROCEDURA 'LICZBA DZIESIĘTNA DO ZMIENNO-PRZECINKOWEJ' ; ----------------------------------------------------- ; $14D9 : 5337 DEC_TO_FP: CALL INT_TO_FP ; procedura INT-TO-FP pobiera pierwszą część CP $1B ; czy znak jest '.' ? JR NZ,E_FORMAT ; jeśli nie, naprzód do E-FORMAT RST 28H ; KALKULATOR .BYTE $A1 ; jeden-na-stos .BYTE $C0 ; stos-do-pamięci-0 .BYTE $02 ; usuń .BYTE $34 ; koniec-obliczeń ; $14E5 : 5349 NXT_DGT_1: RST 20H ; NASTĘPNY-ZNAK CALL STK_DIGIT JR C,E_FORMAT ; naprzód do E-FORMAT RST 28H ; KALKULATOR .BYTE $E0 ; na-stos-paimięć-0 .BYTE $A4 ; na-stos-dziesięć .BYTE $05 ; dziel .BYTE $C0 ; stos-do-pamięci-0 .BYTE $04 ; mnóż .BYTE $0F ; dodaj .BYTE $34 ; koniec-obliczeń JR NXT_DGT_1 ; wróć w pętli do NXT-DGT-1 aż do wyczerpania cyfr ; $14F5 : 5365 E_FORMAT: CP $2A ; czy znakiem jest 'E' ? RET NZ ; wróć, jeśli nie LD (IY+$5D),$FF ; inicjuj zmienną systemową MEM-0-1st na $FF TRUE RST 20H ; NASTĘPNY-ZNAK CP $15 ; czy znakiem jest '+' ? JR Z,SIGN_DONE ; jeśli tak, naprzód do SIGN-DONE CP $16 ; czy jest to '-' ? JR NZ,ST_E_PART ; jeśli nie, naprzód do ST-E-PART INC (IY+$5D) ; zmień MEM-0-1st na FALSE ; $1508 : 5384 SIGN_DONE: RST 20H ; NASTĘPNY-ZNAK ; $1509 : 5385 ST_E_PART: CALL INT_TO_FP RST 28H ; KALKULATOR m, e. .BYTE $E0 ; na-stos-paimięć-0 m, e, (1/0) TRUE/FALSE .BYTE $00 ; skocz-przy-prawdzie .BYTE $02 ; do L1511, E-POSTVE .BYTE $18 ; zmień-znak m, -e ; $1511 : 5393 E_POSTVE:.BYTE $38 ; e-do-potęgi x. .BYTE $34 ; koniec-obliczeń x. RET ; ------------------------- ; PROCEDURA 'CYFRA NA STOS' ; ------------------------- ; $1514 : 5396 STK_DIGIT: CP $1C RET C CP $26 CCF RET C SUB $1C ; --------------------- ; PROCEDURA 'A NA STOS' ; --------------------- ; $151D : 5405 STACK_A: LD C,A ; przenieś A do BC LD B,$00 ; zerując starszy bajt ; ---------------------- ; PROCEDURA 'BC NA STOS' ; ---------------------- ; ZX81 nie posiada wydzielonego formatu dla liczb całkowitych, zatem zawartość rejestru BC musi być zamieniona na pełną postać zmiennoprzecinkową. ; $1520 : 5408 STACK_BC: LD IY,ERR_NR ; ponownie ustaw wskaźnik zmiennych systemowych. PUSH BC ; zachowaj wartość całkowitą. ; teraz zapisz na stosie zero - pięć zerowych bajtów jako punkt startowy. RST 28H ; KALKULATOR .BYTE $A0 ; na-stos-zero 0. .BYTE $34 ; koniec-obliczeń POP BC ; odtwórz wartość całkowitą LD (HL),$91 ; umieść $91 w wykładniku 65536. ; jest to największa dozwolona wartość LD A,B ; pobierz starszy bajt AND A ; sprawdź, czy jest równy zero. JR NZ,STK_BC_2 ; jeśli nie, to naprzód do STK-BC-2 LD (HL),A ; inaczej wyzeruj z powrotem wykładnik OR C ; sprawdź młodszy bajt RET Z ; jeśli BC było równe 0, wróć - koniec roboty. ; inaczej ma być ustawiony bit, jeśli wartością jest tylko jeden. LD B,C ; zachowaj C w B. LD C,(HL) ; pobierz zero do C LD (HL),$89 ; ustaw wykładnik $89 256. ; $1536 : 5430 STK_BC_2: DEC (HL) ; zmniejsz wykładnik - dzieląc liczbę przez 2 SLA C ; C<-76543210<-0 RL B ; C<-76543210<-C JR NC,STK_BC_2 ; jeśli brak przeniesienia, wróć w pętli do STK-BC-2 SRL B ; 0->76543210->C RR C ; C->76543210->C INC HL ; zaadresuj pierwszy bajt mantysy LD (HL),B ; wstaw B INC HL ; zaadresuj drugi bajt mantysy LD (HL),C ; wstaw C DEC HL ; wskaż ponownie DEC HL ; na wykładnik RET ; -------------------------------------------------- ; PROCEDURA 'LICZBA CAŁKOWITA NA ZMIENNOPRZECINKOWĄ' ; -------------------------------------------------- ; $1548 : 5448 INT_TO_FP: PUSH AF RST 28H ; KALKULATOR .BYTE $A0 ; na-stos-zero .BYTE $34 ; koniec-obliczeń POP AF ; $154D : 5453 NXT_DGT_2: CALL STK_DIGIT RET C RST 28H ; KALKULATOR .BYTE $01 ; zamień .BYTE $A4 ; na-stos-dziesięć .BYTE $04 ; mnóż .BYTE $0F ; dodaj .BYTE $34 ; koniec-obliczeń RST 20H ; NASTĘPNY-ZNAK JR NXT_DGT_2 ; ------------------------------------------ ; PROCEDURA 'E-FORMAT NA ZMIENNOPRZECINKOWĄ' ; ------------------------------------------ ; (przesunięcie $38: 'e-to-fp') ; wywoływana z DEC-TO-FP i PRINT-FP. ; np. 2.3E4 to 23000. ; Ta procedura oblicza wartość xEm, gdzie m jest dodatnią lub ujemną liczbą całkowitą. Na prostym poziomie x jest mnożone przez 10 dla każdej ; jednostki w m. Jeśli wykładnik dziesiętny jest ujemny, to x jest dzielone przez dziesięć dla każdej jednostki w m. Skrót powstaje, jeśli wykładnik ; jest większy od siedmiu i w takim przypadku jest on zmniejszany o 7, a x zostaje pomnożone lub podzielone przez dziesięć milionów. ; Uwaga, w ZX-Spectrum zastosowano nawet sprytniejszą metodę wykorzystującą przesunięcia bitów poza wykładnik, w której wynik był osiągany w co ; najwyżej sześciu przesunięciach. Poniższa procedura musiała zostać całkowicie przepisana, w większości w kodzie maszynowym Z80. Chociaż już nie ; używany, literał kalkulatora pozostał ze względów kompatybilności wstecznej, natomiast nowa procedura była wywoływana bezpośrednio z kodu ; maszynowego. ; Na wejściu w ZX-81 wykładnik m jest na szczycie stosu, a zmiennoprzecinkowa mantysa leży na stosie poniżej wykładnika. ; $155A : 5466 E_TO_FP: RST 28H ; KALKULATOR x, m. .BYTE $2D ; duplikuj x, m, m. .BYTE $32 ; mniej-niż-0 x, m, (1/0). .BYTE $C0 ; stos-do-pamięci-0 x, m, (1/0). .BYTE $02 ; usuń x, m. .BYTE $27 ; wartość-bezwzględna x, +m. ; $1560 : 5472 E_LOOP: .BYTE $A1 ; jeden-na-stos x, m,1. .BYTE $03 ; odejmij x, m-1. .BYTE $2D ; duplikuj x, m-1,m-1. .BYTE $32 ; mniej-niż-0 x, m-1, (1/0). .BYTE $00 ; skocz-przy-prawdzie x, m-1. .BYTE $22 ; do L1587, E-END x, m-1. .BYTE $2D ; duplikuj x, m-1, m-1. .BYTE $30 ; dane-na-stos .BYTE $33 ; Wykładnik: $83, Bajty: 1 .BYTE $40 ;(+00,+00,+00) x, m-1, m-1, 6. .BYTE $03 ; odejmij x, m-1, m-7. .BYTE $2D ; duplikuj x, m-1, m-7, m-7. .BYTE $32 ; mniej-niż-0 x, m-1, m-7, (1/0). .BYTE $00 ; skocz-przy-prawdzie x, m-1, m-7. .BYTE $0C ; do L157A, E-LOW ; lecz jeśli wykładnik jest większy od 7, to zastosuj większe mnożenie lub dzielenie (przy ujemnym m) przez 10 milionów - 1e7. .BYTE $01 ; zamień x, m-7, m-1. .BYTE $02 ; usuń x, m-7. .BYTE $01 ; zamień m-7, x. .BYTE $30 ; dane-na-stos .BYTE $80 ; Bajty: 3 .BYTE $48 ; Wykładnik $98 .BYTE $18,$96,$80 ;(+00) m-7, x, 10,000,000 (=f) .BYTE $2F ; skocz .BYTE $04 ; do L157D, E-CHUNK ; $157A : 5498 E_LOW: .BYTE $02 ; usuń x, m-1. .BYTE $01 ; zamień m-1, x. .BYTE $A4 ; na-stos-dziesięć m-1, x, 10 (=f). ; $157D : 5501 E_CHUNK: .BYTE $E0 ; na-stos-paimięć-0 m-1, x, f, (1/0) .BYTE $00 ; skocz-przy-prawdzie m-1, x, f .BYTE $04 ; do L1583, E-DIVSN .BYTE $04 ; mnóż m-1, x*f. .BYTE $2F ; skocz .BYTE $02 ; do L1584, E-SWAP ; $1583 : 5507 E_DIVSN: .BYTE $05 ; dziel m-1, x/f (= new x). ; $1584 : 5508 E_SWAP: .BYTE $01 ; zamień x, m-1 (= new m). .BYTE $2F ; skocz x, m. .BYTE $DA ; do L1560, E-LOOP ; $1587 : 5511 E_END: .BYTE $02 ; usuń x. (-1) .BYTE $34 ; koniec-obliczeń x. RET ; ------------------------------------ ; PROCEDURA 'ZMIENNOPRZECINKOWA DO BC' ; ------------------------------------ ; Liczba zmiennoprzecinkowa zostaje pobrana ze stosu i umieszczona w parze rejestrów BC, w razie konieczności z zaokrągleniem. ; Dopuszczalny zakres od 0 do 65535.4999 ; $158A : 5514 FP_TO_BC: CALL STK_FETCH ; procedura STK-FETCH - wykładnik do A, mantysa do EDCB. AND A ; testuj zero JR NZ,FPBC_NZRO ; jeśli nie zero, skocz naprzód do FPBC-NZRO ; inaczej wartość jest zero LD B,A ; zeruj B LD C,A ; i także C PUSH AF ; zachowaj znaczniki na stosie maszynowym JR FPBC_END ; naprzód do FPBC-END ; EDCB => BCE ; $1595 : 5525 FPBC_NZRO: LD B,E ; przenieś mantysę z EDCB LD E,C ; do BCE. Bit 7 rejestru E jest 17-tym bitem, który będzie LD C,D ; znaczący przy zaokrąglaniu, jeśli liczba już jest znormalizowana. SUB $91 ; odejmij 65536 CCF ; wymień bit przeniesienia na przeciwny BIT 7,B ; testuj bit znaku PUSH AF ; wynik na stos SET 7,B ; ustaw implikowany bit JR C,FPBC_END ; naprzód z przeniesieniem z SUB/CCF do FPBC-END, liczba jest za duża. INC A ; zwiększ wykładnik i NEG ; zaneguj, aby otrzymać zakres $00 - $0F CP $08 ; testuj, czy jest jeden lub dwa bajty JR C,BIG_INT ; z dwoma bajtami naprzód do BIG-INT LD E,C ; przesuń mantysę LD C,B ; 8 bitów w prawo LD B,$00 ; do B wstaw zero SUB $08 ; zmniejsz wykładnik o 8 ; $15AF : 5551 BIG_INT: AND A ; testuj wykładnik LD D,A ; zachowaj wykładnik w D. LD A,E ; bity ułamkowe do A RLCA ; obróć najbardziej znaczący bit do przeniesienia, aby zaokrąglić już znormalizowaną liczbę. JR Z,EXP_ZERO ; jeśli wykładnik jest zerem, naprzód do EXP-ZERO ; liczba jest znormalizowana ; $15B5 : 5557 FPBC_NORM: SRL B ; 0->76543210->C RR C ; C->76543210->C DEC D ; zmniejsz wykładnik JR NZ,FPBC_NORM ; wstecz w pętli do FPBC-NORM, aż będzie zerowy wykładnik ; $15BC : 5564 EXP_ZERO: JR NC,FPBC_END ; bez przeniesienia naprzód do NO-ROUND INC BC ; zaokrąglij w górę. LD A,B ; testuj wynik OR C ; na zero JR NZ,FPBC_END ; jeśli różny od zera, naprzód do GRE-ZERO POP AF ; odtwórz znacznik znaku SCF ; ustaw przeniesienie, aby zaznaczyć przepełnienie PUSH AF ; ponownie zachowaj połączone znaczniki ; $15C6 : 5574 FPBC_END: PUSH BC ; zachowaj wartość BC ; ustaw HL i DE na stos kalkulatora. RST 28H ; KALKULATOR .BYTE $34 ; koniec-obliczeń POP BC ; odtwórz wartość BC POP AF ; odtwórz znaczniki LD A,C ; również skopiuj młodszy bajt do A. RET ; ----------------------------------- ; PROCEDURA 'ZMIENNOPRZECINKOWA DO A' ; ----------------------------------- ; $15CD : 5581 FP_TO_A: CALL FP_TO_BC ; pobierz liczbę do BC i A RET C ; jeśli za duża, wróć z ustawionym przeniesieniem PUSH AF ; zachowaj wynik DEC B ; sprawdź, czy starszy bajt jest równy zero INC B JR Z,FP_A_END ; jeśli tak, to naprzód do FP-A-END POP AF ; odtwórz wynik SCF ; ustaw znacznik przeniesienia, sygnalizując przepełnienie RET ; $15D9 : 5593 FP_A_END: POP AF ; odtwórz wynik RET ; ------------------------------------------ ; PROCEDURA 'PISZ LICZBĘ ZMIENNOPRZECINKOWĄ' ; ------------------------------------------ ; wypisuje 'ostatnią wartość' x na stosie kalkulatora. ; Istnieje wiele różnych formatów: ; PI wypisuje jako 3.1415927 ; .123 wypisuje jako 0.123 ; .0123 wypisuje jako .0123 ; 999999999999 wypisuje jako 1000000000000 ; 9876543210123 wypisuje jako 9876543200000 ; Zaczyna od wyizolowania zera i wypisania dla tego przypadku znaku '0'. Liczby ujemne wypisują wiodący znak '-', a następnie wartość bezwzględną z x. ; $15DB : 5595 PRINT_FP: RST 28H ; KALKULATOR x. .BYTE $2D ; duplikuj x, x. .BYTE $32 ; mniej-niż-0 x, (1/0). .BYTE $00 ; skocz-przy-prawdzie .BYTE $0B ; do L15EA, PF-NGTVE x. .BYTE $2D ; duplikuj x, x .BYTE $33 ; większe-niż-0 x, (1/0). .BYTE $00 ; skocz-przy-prawdzie .BYTE $0D ; do L15F0, PF-POSTVE x. .BYTE $02 ; usuń . .BYTE $34 ; koniec-obliczeń . LD A,$1C ; załaduj akumulator znakiem '0' RST 10H ; PISZ-AKUMULATOR RET ; $15EA : 5610 PF_NEGTVE:.BYTE $27 ; wartość-bezwzględna +x. .BYTE $34 ; koniec-obliczeń +x. LD A,$16 ; załaduj akumulator znakiem '-' RST 10H ; PISZ-AKUMULATOR RST 28H ; KALKULATOR x. ; $15F0 : 5616 PF_POSTVE: .BYTE $34 ; koniec-obliczeń x. ; rejestr HL adresuje wykładnik liczby zmiennoprzecinkowej. Jeśli jest dodatnia i przecinek znajduje się na lewo, to bit 7 ma wartość 1. LD A,(HL) ; pobierz bajt wykładnika CALL STACK_A ; i umieść go na stosie kalkulatora ; teraz zgrubnie wyznacz ilość cyfr n przed przecinkiem, odejmując połowę od właściwego wykładnika i mnożąc przez logarytm dziesiętny z 2. ; Właściwa ilość może być o jeden wyższa jako wynik całkowity. RST 28H ; KALKULATOR x, e. .BYTE $30 ; dane-na-stos .BYTE $78 ; Wykładnik: $88, Bajty: 2 .BYTE $00,$80 ;(+00,+00) x, e, 128.5. .BYTE $03 ; odejmij x, e -.5. .BYTE $30 ; dane-na-stos .BYTE $EF ; Wykładnik: $7F, Bajty: 4 .BYTE $1A,$20,$9A,$85 ; 0.30103 (log10 2) .BYTE $04 ; mnóż x, .BYTE $24 ; na-liczbę-całkowitą .BYTE $C1 ; stos-do-pamięci-1 x, n. .BYTE $30 ; dane-na-stos .BYTE $34 ; Wykładnik: $84, Bajty: 1 .BYTE $00 ;(+00,+00,+00) x, n, 8. .BYTE $03 ; odejmij x, n-8. .BYTE $18 ; zmień-znak x, 8-n. .BYTE $38 ; e-do-potęgi x * (10^n) ; ostatecznie ósma lub dziewiąta cyfra dziesiętna jest zaokrąglana. Dziesięciocyfrowa liczba całkowita może wzrosnąć w tym przypadku, powiedzmy, ; od 999999999.5 do 1000000000. .BYTE $A2 ; na-stos-1/2 .BYTE $0F ; dodaj .BYTE $24 ; na-liczbę-całkowitą i. .BYTE $34 ; koniec-obliczeń ; Jeśli było tylko 8 cyfr, to ostateczne zaokrąglenie będzie miało miejsce na stosie kalkulatora powyżej, a następne dwie instrukcje wprowadzą ; zamaskowane zero, aby już nie było dalszych zaokrągleń. Jeśli wynik jest 9 cyfrową liczbą całkowitą, to zaokrąglenie odbywa się wewnątrz bufora. LD HL,$406B ; zaadresuj zmienną systemową MEM-2-5th, ; która może być 'dziewiątą' cyfrą. LD (HL),$90 ; wstaw wartość $90 10010000 ; teraz, rozpoczynając od najniższej cyfry, wprowadź 8, 9 lub 10 cyfrową liczbę całkowitą, która reprezentuje znaczącą część liczby. ; Np. PI będzie liczbą 9 cyfrową 314159265 LD B,$0A ; licznik na 10 cyfr. ; $1615 : 5653 PF_LOOP: INC HL ; zwiększ wskaźnik PUSH HL ; zachowaj adres bufora PUSH BC ; zachowaj licznik RST 28H ; KALKULATOR i. .BYTE $A4 ; na-stos-dziesięć i, 10. .BYTE $2E ; n-modulo-m i mod 10, i/10 .BYTE $01 ; zamień i/10, reszta. .BYTE $34 ; koniec-obliczeń CALL FP_TO_A ; pobierz do wynik do A $00-$09 OR $90 ; ustaw lewe 4 bity na 9 POP BC ; odtwórz licznik POP HL ; odtwórz adres bufora LD (HL),A ; wstaw wymaskowaną cyfrę do bufora DJNZ PF_LOOP ; wróć w pętli do PF-LOOP dla wszystkich 10 cyfr ; najbardziej znacząca cyfra będzie ostatnia, lecz gdy liczba została wyczerpana, to jedna lub dwie ostatnie pozycje mogą zawierać zera ($90). ; Np. dla 'jeden' mamy zero jako oszacowanie wiodących cyfr. ; 1*10^8 100000000 jako wartość całkowita ; 90 90 90 90 90 90 90 90 91 90 jako zawartość bufora mem3/mem4 INC HL ; zwiększ wskaźnik o 1 poza bufor LD BC,$0008 ; ustaw C na 8 (B i tak jest 0) PUSH HL ; zachowaj wskaźnik ; $162C : 5676 PF_NULL: DEC HL ; zmniejsz wskaźnik LD A,(HL) ; pobierz maskowaną cyfrę CP $90 ; czy jest to wiodące zero ? JR Z,PF_NULL ; jeśli tak, skocz w pętli wstecz do PF-NULL ; w tym punkcie znaleziono znaczącą cyfrę. Przeniesienie jest wyzerowane. SBC HL,BC ; odejmij osiem od adresu. PUSH HL ; ** również ten wskaźnik zachowaj LD A,(HL) ; pobierz adresowany bajt ADD A,$6B ; dodaj $6B - co zaokrągli cyfrę rozpływowo, jeśli ma wartość $95 lub więcej PUSH AF ; zachowaj wynik przeniesienia. ; teraz wejdź do pętli zaokrąglającej liczbę. Po wykonaniu zaokrąglenia zero powstałe z niego lub będące wcześniej na tej pozycji zostaje zmienione ; z $90 na $80. ; $1639 : 5689 PF_RND_LP: POP AF ; odzyskaj przeniesienie ze stosu maszynowego. INC HL ; zwiększ adres LD A,(HL) ; pobierz nowy bajt ADC A,$00 ; dodaj do niego przeniesienie DAA ; wyrównaj dziesiętnie akumulator przeniesienie rozpłynie się po cyfrach '9' PUSH AF ; zachowaj przeniesienie na stosie maszynowym. AND $0F ; wydobądź cyfry 0 - 9 i ustaw znacznik zera, jeśli zero LD (HL),A ; wstaw z powrotem do bufora SET 7,(HL) ; ustaw bit 7, aby uczynić znak drukowalnym. lecz nie w przypadku końcowego zera za przecinkiem dziesiętnym JR Z,PF_RND_LP ; jeśli zero, wstecz do PF-RND-LP aby rozważyć dalsze zaokrąglanie i identyfikację końcowych zer. POP AF ; usuń zbędne dane ze stosu POP HL ; odzyskaj dolny wskaźnik ; teraz wstaw 6 końcowych zer, które są drukowane, jeśli znajdują się przed przecinkiem dziesiętnym, lecz zaznacz koniec wydruku, jeśli są po ; przecinku dziesiętnym. Np.: ; 9876543210123 jest drukowane jako 9876543200000 ; 123.456001 jest drukowane jako 123.456 LD B,$06 ; licznik na sześć. ; $164B : 5707 PF_ZERO_6: LD (HL),$80 ; wstaw maskowane zero DEC HL ; zmniejsz wskaźnik DJNZ PF_ZERO_6 ; dla wszystkich sześciu zer cofnij się w pętli do PF-ZERO-6 ; n-mod-m zredukowało liczbę do zera i zostaje ono obecnie usunięte ze stosu kalkulatora przed pobraniem pierwotnego oszacowania wiodących cyfr. RST 28H ; KALKULATOR 0. .BYTE $02 ; usuń . .BYTE $E1 ; na-stos-paimięć-1 n. .BYTE $34 ; koniec-obliczeń n. CALL FP_TO_A ; pobierz liczbę do A JR Z,PF_POS ; jeśli dodatnia, przeskocz naprzód do PF-POS NEG ; z ujemnych robimy dodatnie ; $165B : 5723 PF_POS: LD E,A ; przenieś licznik cyfr do E INC E ; zwiększ dwukrotnie INC E POP HL ; odzyskaj wskaźnik pozycji o jeden poza buforem ; $165F : 5727 GET_FIRST: DEC HL ; zmniejsz adres DEC E ; zmniejsz licznik cyfr LD A,(HL) ; pobierz wymaskowany bajt AND $0F ; wyizoluj prawe cztery bity. JR Z,GET_FIRST ; jeśli jest to zero wiodące, wstecz do GET-FIRST ; teraz ustal, czy będzie potrzebny format E do wydruku LD A,E ; przenieś teraz właściwą liczbę cyfr do A. SUB $05 ; odejmij pięć CP $08 ; porównaj z 8, skoro maksymalna liczba cyfr wynosi 13. JP P,PF_E_FMT ; jeśli dodatnie, naprzód do PF-E-FMT CP $F6 ; testuj na więcej niż cztery zera za przecinkiem. JP M,PF_E_FMT ; jeśli są, naprzód do PF-E-FMT ADD A,$06 ; testuj na zero wiodących cyfr, np. 0.5 JR Z,PF_ZERO_1 ; jeśli tak, naprzód do PF-ZERO-1 JP M,PF_ZEROS ; jeśli jest więcej niż jedno zero, skocz do PF-ZEROS ; w przeciwnym razie cyfry przed przecinkiem mają zostać wydrukowane LD B,A ; liczba wiodących znaków do B. ; $167B : 5755 PF_NIB_LP: CALL PF_NIBBLE DJNZ PF_NIB_LP ; wstecz w pętli dla kolejnych cyfr do PF-NIB-LP JR PF_DC_OUT ; naprzód do PF-DC-OUT w celu przetworzenia części ułamkowej ; $1682 : 5762 PF_E_FMT: LD B,E ; licznik do B CALL PF_NIBBLE ; procedura PF-NIBBLE drukuje jedną cyfrę. CALL PF_DC_OUT ; procedura PF-DC-OUT obsługuje część ułamkową. LD A,$2A ; przygotuj znak 'E' RST 10H ; PISZ-AKUMULATOR LD A,B ; przenieś wykładnik do A AND A ; sprawdź znak. JP P,PF_E_POS ; jeśli dodatnie, skocz naprzód do PF-E-POS NEG ; zmień ujemny wykładnik na dodatni. LD B,A ; zachowaj dodatni wykładnik w B. LD A,$16 ; przygotuj znak '-' JR PF_E_SIGN ; przeskocz naprzód do PF-E-SIGN ; $1698 : 5784 PF_E_POS: LD A,$15 ; przygotuj znak '+' ; $169A : 5786 PF_E_SIGN: RST 10H ; PISZ-AKUMULATOR ; teraz zamień całkowity wykładnik w B na dwie cyfry. Będzie miał wartość mniejszą od 99. LD A,B ; pobierz dodatni wykładnik. LD B,$FF ; rozpocznij od lewej cyfry równej minus jeden. ; $169E : 5790 PF_E_TENS: INC B ; zwiększ licznik dziesiątek SUB $0A ; odejmij dziesięć od wykładnika JR NC,PF_E_TENS ; skocz wstecz w pętli do PF-E-TENS, jeśli większe od dziesięć ADD A,$0A ; anuluj efekt ostatniego odejmowania LD C,A ; przenieś resztę do C LD A,B ; wartość dziesiątek przenieś do A. AND A ; testuj zero. JR Z,PF_E_LOW ; przeskocz naprzód do PF-E-LOW, jeśli tak, CALL OUT_CODE ; procedura OUT-CODE drukuje jako cyfry '1' - '9' ; $16AD : 5805 PF_E_LOW: LD A,C ; młodszy bajt do A CALL OUT_CODE ; procedura OUT-CODE drukuje ostatnią cyfrę wykładnika. RET ; ta odnoga zajmuje się zerami po przecinku dziesiętnym. Np. .01 lub .0000999 ; $16B2 : 5810 PF_ZEROS: NEG ; zmiana znaku czyni liczbę dodatnią od 1 do 4. LD B,A ; licznik zer do B. LD A,$1B ; przygotuj znak '.' RST 10H ; PISZ-AKUMULATOR LD A,$1C ; przygotuj '0' ; $16BA : 5818 PF_ZRO_LP: RST 10H ; PISZ-AKUMULATOR DJNZ PF_ZRO_LP ; w pętli skocz wstecz do PF-ZRO-LP JR PF_FRAC_LP ; naprzód do PF-FRAC-LP ; istnieje potrzeba wyświetlenia zera wiodącego, np. przy 0.1, lecz nie przy .01 ; $16BF : 5823 PF_ZERO_1: LD A,$1C ; przygotuj znak '0'. RST 10H ; PISZ-AKUMULATOR ; ten podprogram obsługuje przecinek dziesiętny oraz cyfry końcowe. Jeśli kolejnym znakiem jest znaczone zero, $80, to nic więcej nie ma do wydrukowania. ; $16C2 : 5826 PF_DC_OUT: DEC (HL) ; zmniejsz adresowany znak INC (HL) ; zwiększ go z powrotem RET PE ; wróć z przepełnieniem (miał wartość 128), ponieważ brak części ułamkowej ; inaczej część ułamkowa występuje, zatem wydrukuj kropkę dziesiętną. LD A,$1B ; przygotuj znak '.' RST 10H ; PISZ-AKUMULATOR ; teraz wejdź do pętli, aby wydrukować końcowe cyfry ; $16C8 : 5832 PF_FRAC_LP: DEC (HL) ; test na znaczone zero. INC (HL) RET PE ; wróć po wyczerpaniu cyfr CALL PF_NIBBLE ; drukuj cyfrę JR PF_FRAC_LP ; wstecz do PF-FRAC-LP dla wszystkich cyfr ułamkowych. ; procedura do wydruku prawych czterech bitów ; $16D0 : 5840 PF_NIBBLE: LD A,(HL) ; pobierz adresowany bajt AND $0F ; wymaskuj 4 najmłodsze bity CALL OUT_CODE ; wydrukuj je jako cyfrę DEC HL ; zmniejsz wskaźnik RET ; -------------------------------------- ; PROCEDURA 'PRZYGOTOWANIA DO DODAWANIA' ; -------------------------------------- ; Ta procedura jest wywoływana dwukrotnie do przygotowania każdej z liczb zmiennoprzecinkowych do dodawania w miejscu na stosie kalkulatora. ; Wykładnik zostaje pobrany z pierwszego bajtu, który następnie jest czyszczony w celu odgrywania roli bajtu znaku i znacznika przepełnienia. ; Jeśli wykładnik ma wartość zero, to liczba również ma wartość 0 i wykonany zostaje wczesny powrót. Teraz zostaje ustawiony nadmiarowy bit znaku ; mantysy i w przypadku liczby ujemnej wszystkie pięć bajtów zostają zanegowane w kodzie U2 w celu przygotowania liczby do dodawania. Przy drugim ; wywołaniu wykładnik pierwszej liczby jest w rejestrze B. ; $16D8 : 5848 PREP_ADD: LD A,(HL) ; pobierz wykładnik. LD (HL),$00 ; ustaw ten bajt na zero, aby przyjął wszelkie przepełnienia i określał liczbę standardowo jako dodatnią. AND A ; testuj pobrany wykładnik na zero. RET Z ; wróć z ustawionym znacznikiem Z, jeśli liczba jest zerem. INC HL ; wskaż pierwszy bajt mantysy. BIT 7,(HL) ; testuj bit znaku. SET 7,(HL) ; ustaw go na jego wynikową wartość. DEC HL ; ustaw wskaźnik ponownie na pierwszy bajt. RET Z ; wróć, jeśli bit oznaczał liczbę dodatnią. ; jeśli jest ujemna, to wszystkie pięć bajtów zostanie zanegowane w U2, poczynając od najmłodszego. PUSH BC ; zachowaj zawartość rejestru B. LD BC,$0005 ; ustaw BC na pięć. ADD HL,BC ; wskaż na komórkę poza piątym bajtem. LD B,C ; ustaw licznik B na pięć. LD C,A ; umieść oryginalny wykładnik w C. SCF ; ustaw znacznik przeniesienia, aby była dodawana jedynka. ; teraz wejdź do pętli zmieniającej znak liczby na ujemny. Pierwszy z pięciu bajtów otrzyma wartość $FF oznaczającą liczbę ujemną. ; $16EC : 5868 NEG_BYTE: DEC HL ; wskaż na pierwszy, lub bardziej znaczący bajt. LD A,(HL) ; pobierz go do akumulatora. CPL ; zaneguj. ADC A,$00 ; dodaj początkowe przeniesienie lub dalsze przeniesienia. LD (HL),A ; wstaw liczbę z powrotem na swoje miejsce. DJNZ NEG_BYTE ; w pętli skocz wstecz pięć razy do NEG-BYTE LD A,C ; odtwórz wykładnik w akumulatorze. POP BC ; odtwórz zawartość rejestru B. RET ; -------------------------------- ; PROCEDURA 'POBRANIA DWÓCH LICZB' ; -------------------------------- ; Procedurę tę wykorzystują operacje dodawania, mnożenia i dzielenia do pobierania dwóch pięciobajtowych liczb adresowanych przez HL i DE ; ze stosu kalkulatora do rejestrów Z80. Rejestr HL nie może już wskazywać na pierwszą z tych dwóch liczb. Ponieważ 32-bitowe dodawanie ; wykonywane jest przy pomocy 16 bitowych instrukcji Z80, istotne jest, aby młodsze dwa bajty każdej mantysy znajdowały się w jednym zestawie ; rejestrów, a pozostałe bajty w zestawie alternatywnym. ; We: HL = najwyższa liczba, DE= najniższa liczba ; : alt': : ; Wy: :H,B-C:C,B: num1 ; :L,D-E:D-E: num2 ; $16F7 : 5879 FETCH_TWO: PUSH HL ; zachowaj HL PUSH AF ; zachowaj A - wynikowy znak, gdy używane przy dzieleniu. LD C,(HL) INC HL LD B,(HL) LD (HL),A ; wstaw znak, gdy używane przy mnożeniu. INC HL LD A,C ; m1 LD C,(HL) PUSH BC ; na stos m2 m3 INC HL LD C,(HL) ; m4 INC HL LD B,(HL) ; m5 BC zawiera m5 m4 EX DE,HL ; ustaw HL na początek drugiej liczby. LD D,A ; m1 LD E,(HL) PUSH DE ; na stos m1 n1 INC HL LD D,(HL) INC HL LD E,(HL) PUSH DE ; na stos n2 n3 EXX POP DE ; ze stosu n2 n3 POP HL ; ze stosu m1 n1 POP BC ; ze stosu m2 m3 EXX INC HL LD D,(HL) INC HL LD E,(HL) ; DE zawiera n4 n5 POP AF ; odtwórz zachowane rejestry POP HL RET ; -------------------------------- ; PROCEDURA 'PRZESUWANIA SKŁADNIKA' ; -------------------------------- ; Akumulator zawiera różnicę pomiędzy dwoma wykładnikami. Dodana ma być najmniejsza liczba. ; $171A : 5914 SHIFT_FP: AND A ; testuj różnicę pomiędzy dwoma wykładnikami. RET Z ; wróć, gdy zero - oba są znormalizowane. CP $21 ; porównaj z 33 bitami. JR NC,ADDEND_0 ; jeśli większe niż 32, skocz naprzód do ADDEND-0 PUSH BC ; zachowaj część w BC LD B,A ; licznik przesunięć do B. ; Teraz wykonaj B przesunięć na składniku L'D'E'D E w celu zrównania go z dodajną H'B'C'C B ; $1722 : 5922 ONE_SHIFT: EXX SRA L ; 76543210->C bit 7 bez zmian. RR D ; C->76543210->C RR E ; C->76543210->C EXX RR D ; C->76543210->C RR E ; C->76543210->C DJNZ ONE_SHIFT ; w pętli wykonuj B razy od ONE-SHIFT POP BC ; odzyskaj BC RET NC ; wróć, jeśli w ostatnim przesuwie nie było przeniesienia. ; jeśli ustawiony został znacznik przeniesienia, to nastąpiła utrata dokładności, zatem zaokrąglij składnik. CALL ADD_BACK RET NZ ; wróć, jeśli nie FF 00 00 00 00 ; to odgałęzienie ustawia wszystkie pięć bajtów składnika na zero i wykonywane jest, podczas dodawania, gdy wykładniki są zbyt oddalone od siebie, ; aby bity składnika mogły wpłynąć na wynik dodawania. ; $1736 : 5942 ADDEND_0: EXX ; wybierz alternatywny zestaw rejestrów dla bardziej znaczących bajtów. XOR A ; wyzeruj akumulator. ; ten punkt wejścia (z mnożenia) ustawia wszystkie cztery bajty na zero lub przy kontynuowaniu od poprzedniego adresu, podczas dodawania, ; ustawia wszystkie pięć bajtów na zero. ; $1738 : 5944 ZEROS_4_5: LD L,$00 ; ustaw bajt 1 na zero. LD D,A ; ustaw bajt 2 na A. LD E,L ; ustaw bajt 3 na zero. EXX ; wybierz główny zestaw rejestrów LD DE,$0000 ; ustaw niższe bajty 4 i 5 na zero. RET ; ---------------------------- ; PROCEDURA 'DODAJ-Z-POWROTEM' ; ---------------------------- ; Wywoływana z SHIFT-FP powyżej podczas dodawania i po normalizacji z mnożenia. W rzeczywistości jest to 32 bitowa procedura zwiększania o 1, ; która ustawia znacznik zera zgodnie z 32 bitowym wynikiem. Podczas dodawania jedynie liczby ujemne, typu FF FF FF FF FF, wersje dopełnieniowe ; liczb powiedzmy xx 80 00 00 01 dadzą w wyniku pełną kaskadową zamianę na FF 00 00 00 00. Liczba FF FF FF FF FF przy przesuwaniu w prawo nie jest ; zmieniana przez SHIFT-FP, lecz ustawia przeniesienie, co powoduje wywołanie tej procedury. ; $1741 : 5953 ADD_BACK: INC E RET NZ INC D RET NZ EXX INC E JR NZ,ALL_ADDED ; jeśli brak przepełnienia, skocz naprzód do ALL-ADDED INC D ; $174A : 5962 ALL_ADDED: EXX RET ; wróć z ustawionym znacznikiem zera przy zerowej mantysie. ; ---------------------- ; OPERACJA 'ODEJMOWANIA' ; ---------------------- ; po prostu zmień znak odjemnej i wykonaj dodawanie. ; $174C : 5964 SUBTRACT: LD A,(DE) ; pobierz bajt wykładnika drugiej liczby - odjemnej. AND A ; testuj zero RET Z ; jeśli zero, wróć - pierwsza liczba jest wynikiem. INC DE ; adresuj pierwszy bajt mantysy. LD A,(DE) ; pobierz go do akumulatora. XOR $80 ; zmień na przeciwny bit znaku. LD (DE),A ; umieść z powrotem na stosie kalkulatora. DEC DE ; wskaż bajt wykładnika. Przejdź do procedury dodawania. ; -------------------- ; OPERACJA 'DODAWANIA' ; -------------------- ; Operacja dodawania używa większość rejestrów Z80 do dodania dwóch liczb zmiennoprzecinkowych. Jest to operacja dwuargumentowa, a na wejściu HL ; wskazuje pierwszą liczbę i DE drugą. ; $1755 : 5973 ADDITION: EXX PUSH HL ; zachowaj wskaźnik do następnego literału. EXX PUSH DE ; zachowaj wskaźnik do drugiej liczby PUSH HL ; zachowaj wskaźnik do pierwszej liczby - stanie się ; wskaźnikiem wyniku na stosie kalkulatora. CALL PREP_ADD LD B,A ; zachowaj pierwszy wykładnik w B. EX DE,HL ; zamień ze sobą wskaźniki liczb. CALL PREP_ADD LD C,A ; zachowaj drugi wykładnik w C. CP B ; porównaj bajty wykładników. JR NC,SHIFT_LEN ; jeśli drugi większy, skocz naprzód do SHIFT-LEN LD A,B ; inaczej większy wykładnik do A LD B,C ; mniejszy do B EX DE,HL ; zamień ze sobą wskaźniki liczb. ; $1769 : 5993 SHIFT_LEN: PUSH AF ; zachowaj starszy wykładnik SUB B ; odejmij mniejszy wykładnik CALL FETCH_TWO CALL SHIFT_FP POP AF ; odtwórz większy wykładnik. POP HL ; odtwórz wskaźnik wyniku. LD (HL),A ; wstaw bajt wykładnika. PUSH HL ; ponownie zachowaj wskaźnik wyniku. ; teraz wykonaj 32-bitowe dodawanie, wykorzystując 16-bitowe instrukcje dodawania Z80 LD L,B ; przenieś indywidualnie młodsze bajty mantysy do LD H,C ; rejestru HL ADD HL,DE ; operacja dodawania młodszych bajtów ; teraz dwie starsze pary bajtów, które są przechowywane w zapasowym zestawie rejestrów. EXX ; przełącz się na zapasowe rejestry EX DE,HL ; przenieś starsze bajty mantysy do rejestru HL. ADC HL,BC ; dodawanie starszych bajtów z przeniesieniem z poprzedniej operacji. EX DE,HL ; wynik w DE, bajty znaku ($FF lub $00) do HL ; teraz zajmiemy się dwoma bajtami znaków LD A,H ; pobierz bajt znaku z num1 ADC A,L ; dodaj z przeniesieniem z dodawania mantys 00 lub 01 lub FE lub FF LD L,A ; wynik w L. ; możliwe wyniki znaków i nadmiaru z mantysy ; ; H + L + carry = L RRA XOR L RRA ; ------------------------------------------------------------ ; 00 + 00 = 00 00 00 ; 00 + 00 + carry = 01 00 01 carry ; FF + FF = FE C FF 01 carry ; FF + FF + carry = FF C FF 00 ; FF + 00 = FF FF 00 ; FF + 00 + carry = 00 C 80 80 RRA ; C->76543210->C XOR L ; ustaw bit 0, jeśli wymagane jest przesunięcie. EXX ; przełącz na główny zestaw rejestrów EX DE,HL ; pełny wynik mantysy teraz w rejestrach D'E'D E. POP HL ; odtwórz wskaźnik do wynikowego wykładnika na stosie kalkulatora. RRA ; czy wystąpił nadmiar ? JR NC,TEST_NEG ; jeśli nie, przeskocz naprzód do TEST-NEG ; jeśli dodawanie dwóch dodatnich mantys wywołało nadmiar lub jeśli dodawanie dwóch ujemnych mantys nie wywołało nadmiaru, to wynikowy wykładnik ; musi być zwiększony o 1, a mantysa przesunięta jedną pozycję w prawo. LD A,$01 ; wymagane jedno przesunięcie. CALL SHIFT_FP ; procedura SHIFT-FP wykonuje pojedyncze przesunięcie zaokrąglając stracone bity INC (HL) ; zwiększ wykładnik. JR Z,ADD_REP_6 ; naprzód do ADD-REP-6, jeśli wykładnik przewija się z FF na zero, ponieważ liczba jest wtedy zbyt duża dla systemu. ; na tym etapie wykładnik na stosie kalkulatora jest poprawny. ; $1790 : 6032 TEST_NEG: EXX ; przełącz się na alternatywny zestaw rejestrów. LD A,L ; załaduj znak wyniku do akumulatora. AND $80 ; izoluj bit 7 z bajtu znaku, ustawiając znacznik zera, jeśli liczba jest dodatnia. EXX ; wróć do głównego zestawu rejestrów. INC HL ; wskaż pierwszy bajt mantysy LD (HL),A ; wstaw $00 dla liczby dodatniej lub $80 dla liczby ujemnej na tej pozycji na stosie kalkulatora DEC HL ; wskaż ponownie wykładnik. JR Z,GO_NC_MLT ; jeśli liczba jest dodatnia, skocz naprzód do GO-NC-MLT ; liczba ujemna musi być uzupełniona do podstawy 2, zanim zostanie umieszczona na stosie. LD A,E ; pobierz najniższy (pierwszy z prawej) bajt mantysy. NEG ; neguj CCF ; zmień przeniesienie na przeciwne LD E,A ; umieść z powrotem w rejestrze LD A,D CPL ADC A,$00 LD D,A EXX ; przełącz się do wyższych (pierwszych z lewej) 16 bitów. LD A,E CPL ADC A,$00 LD E,A LD A,D CPL ADC A,$00 JR NC,END_COMPL ; bez przepełnienia, naprzód do END-COMPL ; inaczej cała mantysa jest zerem. 00 00 00 00 RRA ; ustaw mantysę na 80 00 00 00 EXX ; przełącz. INC (HL) ; zwiększ wykładnik. ; $17B3 : 6067 ADD_REP_6: JP Z,REPORT_6 ; jeśli wykładnik się wyzerował, skocz naprzód do REPORT-6 'Liczba zbyt duża' EXX ; przełącz się z powrotem na alternatywny zestaw rejestrów. ; $17B7 : 6071 END_COMPL: LD D,A ; wstaw pierwszy bajt mantysy z powrotem do DE. EXX ; przełącz się na główny zestaw rejestrów. ; $17B9 : 6073 GO_NC_MLT: XOR A ; wyzeruj przeniesienie i akumulator, aby nie zostały przeniesione naprzód żadne dodatkowe bity, co zdarza się w mnożeniu. JR TEST_NORM ; naprzód do wspólnego kodu pod adresem TEST-NORM ; --------------------------------------------------- ; PROCEDURA 'PRZYGOTOWANIA DO MNOŻENIA LUB DZIELENIA' ; --------------------------------------------------- ; ta procedura jest wywoływana dwukrotnie z mnożenia i z dzielenia, aby przygotować każdą z dwóch liczb do tych operacji. Początkowo akumulator ; przechowuje zero, a po drugim wywołaniu bit 7 akumulatora stanie się bitem znaku wyniku. ; $17BC : 6076 PREP_M_D: SCF ; ustaw znacznik przeniesienia, aby zasygnalizować, że liczba jest zerem. DEC (HL) ; testuj wykładnik INC (HL) ; na wartość zero. RET Z ; jeśli jest zero, wróć z ustawionym znacznikiem przeniesienia. INC HL ; adresuj pierwszy bajt mantysy. XOR (HL) ; suma modulo 2 bitów znaku. SET 7,(HL) ; ustaw wynikowy bit. DEC HL ; wskaż bajt wykładnika. RET ; ------------------- ; OPERACJA 'MNOŻENIA' ; ------------------- ; $17C6 : 6086 MULTIPLY: XOR A ; zeruj bit 7 - bieżącego znacznika znaku. CALL PREP_M_D RET C ; wróć, jeśli liczba jest zerem. zero * cokolwiek = zero. EXX PUSH HL ; zachowaj wskaźnik do 'następnego literału' EXX PUSH DE ; zachowaj wskaźnik do drugiej liczby EX DE,HL ; ustaw HL na adres drugiej liczby. CALL PREP_M_D EX DE,HL ; HL pierwsza liczba, DE - druga liczba JR C,ZERO_RSLT ; z przeniesieniem naprzód do ZERO-RSLT cokolwiek * zero = zero. PUSH HL ; zachowaj wskaźnik do pierwszej liczby. CALL FETCH_TWO ; procedura FETCH-TWO pobiera dwie mantysy ze stosu kalkulatora do B'C'C,B D'E'D E ; (HL będzie nadpisane, lecz wynikowy znak w A zostaje wstawiony na stos kalkulatora) LD A,B ; przenieś pierwszy bajt mantysy pierwszej liczby AND A ; wyzeruj przeniesienie. SBC HL,HL ; skrót dla LD HL,$0000 w celu ustawienia młodszych dwóch bajtów wyniku. (2 bajty programu) EXX ; przełącz na zapasowe rejestry PUSH HL ; zachowaj HL SBC HL,HL ; ustaw HL na zero również w celu ustawienia starszych dwóch bajtów wyniku i wyzeruj przeniesienie. EXX ; przełącz na zwykłe rejestry. LD B,$21 ; rejestr B może teraz zliczać trzydzieści trzy przesunięcia JR STRT_MLT ; naprzód do punktu wejścia pętli STRT-MLT ; Wejście do pętli mnożenia znajduje się pod adresem STRT-LOOP. ; $17E7 : 6119 MLT_LOOP: JR NC,NO_ADD ; jeśli brak przeniesienia, naprzód do NO-ADD inaczej dodaj mnożnik. ADD HL,DE ; dodaj dwa najmłodsze bajty do wyniku EXX ; przełącz się na starsze bajty. ADC HL,DE ; dodaj starsze bajty mnożnika oraz przeniesienie. EXX ; przełącz na główny zestaw rejestrów. ; w każdym przypadku przesuń wynik w prawo do B'C'C A ; $17EE : 6126 NO_ADD: EXX ; przełącz na rejestry zapasowe RR H ; C > 76543210 > C RR L ; C > 76543210 > C EXX RR H ; C > 76543210 > C RR L ; C > 76543210 > C ; $17F8 : 6136 STRT_MLT: EXX ; przełącz na rejestry zapasowe. RR B ; C > 76543210 > C RR C ; C > 76543210 > C EXX ; teraz główny zestaw rejestrów RR C ; C > 76543210 > C RRA ; C > 76543210 > C DJNZ MLT_LOOP ; wykonuj 33 razy w pętli od MLT-LOOP EX DE,HL EXX EX DE,HL EXX POP BC POP HL LD A,B ADD A,C JR NZ,MAKE_EXPT AND A ; $180E : 6158 MAKE_EXPT: DEC A CCF ; Zaneguj znacznik przeniesienia ; $1810 : 6160 DIVN_EXPT: RLA CCF ; Zaneguj znacznik przeniesienia RRA JP P,OFLW1_CLR JR NC,REPORT_6 AND A ; $1819 : 6169 OFLW1_CLR: INC A JR NZ,OFLW2_CLR JR C,OFLW2_CLR EXX BIT 7,D EXX JR NZ,REPORT_6 ; $1824 : 6180 OFLW2_CLR: LD (HL),A EXX LD A,B EXX ; dodawanie łączy się tutaj z wyzerowanym znacznikiem przeniesienia. ; $1828 : 6184 TEST_NORM: JR NC,NORMALIZE LD A,(HL) AND A ; $182C : 6188 NEAR_ZERO: LD A,$80 ; przygotuj się do ratowania najbardziej znaczącego bitu mantysy, jeśli jest ustawiony. JR Z,SKIP_ZERO ; skocz naprzód do SKIP-ZERO ; $1830 : 6192 ZERO_RSLT: XOR A ; stwórz maskę zerową bajtu, aby zasygnalizować ustawienie pięciu bajtów na zero. ; $1831 : 6193 SKIP_ZERO: EXX ; przełącz na rejestry zapasowe AND D ; wyizoluj najbardziej znaczący bit, jeśli A ma wartość $80. CALL ZEROS_4_5 ; procedura ZEROS-4/5 ustawia mantysę bez zmiany znaczników. RLCA ; testuj ustawienie MSB. Bit 7 idzie do bitu 0 albo $00 -> $00, albo $80 -> $01 LD (HL),A ; utwórz wykładnik $01 (najmniejszy) lub $00 dla zero JR C,OFLOW_CLR ; w pierwszym przypadku skocz naprzód do OFLOW-CLR INC HL ; adresuj pierwszy bajt mantysy na stosie kalkulatora. LD (HL),A ; wstaw zero dla bitu znaku. DEC HL ; wskaż zerowy wykładnik JR OFLOW_CLR ; naprzód do OFLOW-CLR ; ta gałąź jest wspólna dla dodawania i mnożenia, gdy wynik mantysy jest wciąż w rejestrach D'E'D E . ; $183F : 6207 NORMALIZE: LD B,$20 ; będzie potrzeba co najmniej 32 przesuwy w lewo. ; $1841 : 6209 SHIFT_ONE: EXX ; adresuj starsze 16 bitów. BIT 7,D ; testuj pierwszy bit od lewej EXX ; adresuj młodsze 16 bitów. JR NZ,NORML_NOW ; jeśli pierwszy od lewej bit był ustawiony, skocz naprzód do NORML-NOW RLCA ; to przechowuje zero z dodawania, 33-ci bit dla mnożenia RL E ; C < 76543210 < C RL D ; C < 76543210 < C EXX ; adresuj starsze 16 bitów. RL E ; C < 76543210 < C RL D ; C < 76543210 < C EXX ; przełącz na główne rejestry. DEC (HL) ; zmniejsz bajt wykładnika na stosie kalkulatora. JR Z,NEAR_ZERO ; jeśli wykładnik osiąga zero, wróć do NEAR-ZERO, jest możliwe, że ostatnia rotacja ustawiła bit 7 rejestru D. ; Sprawdzimy to. DJNZ SHIFT_ONE ; wróć wstecz w pętli do SHIFT-ONE ; Jeśli wykonano trzydzieści dwa przesuwy w lewo bez ustawienia najbardziej znaczącego bitu, to wynik jest zerem. JR ZERO_RSLT ; wstecz do ZERO-RSLT ; $1859 : 6233 NORML_NOW: RLA ; dla ścieżki dodawania A ma zawsze wartość zero. Dla ścieżki mnożenia ... JR NC,OFLOW_CLR ; naprzód do OFLOW-CLR ; ta gałąź jest wykonywana tylko przy mnożeniu. CALL ADD_BACK JR NZ,OFLOW_CLR ; naprzód do OFLOW-CLR EXX LD D,$80 EXX INC (HL) JR Z,REPORT_6 ; naprzód do REPORT-6 ; teraz przenosimy mantysę ze zestawu rejestrów na stos kalkulatora dołączając do niej bit znaku, który już się tam znajduje. ; $1868 : 6248 OFLOW_CLR: PUSH HL ; zachowaj wskaźnik wykładnika na stosie. INC HL ; adresuj pierwszy bajt mantysy, który został poprzednio załadowany bitem znaku $00 lub $80. EXX PUSH DE ; umieść na stosie dwa najbardziej znaczące bajty. EXX POP BC ; pobierz ze stosu - właściwa mantysa jest teraz w BCDE. ; teraz bit znaku. LD A,B ; pierwszy bajt mantysy do A RLA ; wyprowadź bit 7, który jest ustawiony na 1 RL (HL) ; wprowadź bit znaku ze stosu do znacznika przeniesienia. RRA ; wprowadź bit znaku do 7 bitu bajtu mantysy. ; przenosimy mantysę z głównych rejestrów na stos kalkulatora. LD (HL),A INC HL LD (HL),C INC HL LD (HL),D INC HL LD (HL),E POP HL ; odtwórz wskaźnik do num1, które jest teraz wynikiem. POP DE ; odtwórz wskaźnik do num2, który jest teraz STKEND. EXX POP HL ; odtwórz wskaźnik do następnego literału kalkulatora. EXX RET ; $1880 : 6272 REPORT_6: RST 08H ; ERROR-1 .BYTE $05 ; Raport Błędu: Przepełnienie arytmetyczne. ; -------------------- ; OPERACJA 'DZIELENIE' ; -------------------- ; "Ze wszystkich operacji arytmetycznych dzielenie jest najbardziej skomplikowane oraz najmniej zrozumiałe. Szczególnie interesujące jest to, ; że programista w firmie Sinclair sam popełnił błąd w swoim kodzie (lub skopiował czyjś błąd!), ponieważ PRINT PEEK 6352 [ $18D0 ] ; ('niepoprawiony' ROM, 6351 [ $18CF ] ) powinno dawać 218 a nie 225." - Dr Ian Logan, czasopismo Syntax sierpień/wrzesień 1982. ; [ tj. skok powinien być wykonywany do div-34th ] ; Najpierw sprawdź dzielenie przez zero ; $1882 : 6274 DIVISION: EX DE,HL ; zajmij się najpierw drugą liczbą XOR A ; ustaw znacznik znaku CALL PREP_M_D JR C,REPORT_6 ; wstecz do REPORT-6, jeśli zero 'Przepełnienie arytmetyczne' EX DE,HL ; teraz przygotuj drugą liczbę i sprawdź ją na zero. CALL PREP_M_D RET C ; jeśli zero, wróć EXX PUSH HL ; zachowaj wskaźnik do następnego literału kalkulatora. EXX PUSH DE ; zachowaj wskaźnik do dzielnika - będzie to STKEND. PUSH HL ; zachowaj wskaźnik do dzielnej - będzie to wynik. CALL FETCH_TWO ; procedura FETCH-TWO pobiera te dwie liczby ; do rejestrów H'B'C'C B ; L'D'E'D E EXX PUSH HL ; zachowaj oba wykładniki. LD H,B ; przenieś dzielną do H'L'H L LD L,C EXX LD H,C LD L,B XOR A ; wyzeruj przeniesienie oraz akumulator. LD B,$DF ; licz wprzód od -33 dziesiętnie JR DIV_START ; naprzód do punktu wewnątrz pętli pod adres DIV-START ; $18A2 : 6306 DIV_LOOP: RLA ; wymnóż częściowy iloraz przez dwa, RL C ; ustawiając bit wynikowy z przeniesienia. EXX RL C RL B EXX ; $18AB : 6315 DIV_34TH: ADD HL,HL EXX ADC HL,HL EXX JR C,SUBN_ONLY ; naprzód do SUBN-ONLY ; $18B2 : 6322 DIV_START: SBC HL,DE ; odejmij część dzielnika. EXX SBC HL,DE EXX JR NC,NO_RSTORE ; jeśli da się odejmować, naprzód do NO-RSTORE ADD HL,DE ; inaczej odtwórz EXX ADC HL,DE EXX AND A ; wyczyść przeniesienie JR COUNT_ONE ; naprzód do COUNT-ONE ; $18C2 : 6338 SUBN_ONLY: AND A SBC HL,DE EXX SBC HL,DE EXX ; $18C9 : 6345 NO_RSTORE: SCF ; ustaw znacznik przeniesienia ; $18CA : 6346 COUNT_ONE: INC B ; zwiększ licznik JP M,DIV_LOOP ; jeśli wciąż minus, wróć do DIV-LOOP PUSH AF JR Z,DIV_START ; wstecz do DIV-START ; "Ten skok jest wykonywany w złe miejsce. 34-ty bit nigdy nie zostanie osiągnięty bez wcześniejszego przesunięcia dzielnej. Dlatego ważne wyniki, ; takie jak 1/10 i 1/1000, nie są zaokrąglane tak jak powinny być. Zaokrąglenie nigdy nie zachodzi, jeśli zależy od 34-tego bitu. Skok powinien być ; wykonywany do DIV-34th powyżej." - Dr Frank O'Hara, "The Complete Spectrum ROM Disassembly", 1983, wydane przez Melbourne House. ; Jednakże, gdy dokona się tej zmiany, to (1/2=.5) będzie teraz dawało wynik true, natomiast (.25=1/4), które dawało true, już nie będzie tak działać. LD E,A LD D,C EXX LD E,C LD D,B POP AF RR B POP AF RR B EXX POP BC POP HL LD A,B SUB C JP DIVN_EXPT ; skocz wstecz do DIVN-EXPT ; ------------------------------------------------------- ; PROCEDURA 'OBCINANIA LICZBY CAŁKOWITEJ W KIERUNKU ZERA' ; ------------------------------------------------------- ; $18E4 : 6372 TRUNCATE: LD A,(HL) ; pobierz wykładnik CP $81 ; porównaj z +1 JR NC,T_GR_ZERO ; jeśli 1 lub więcej, skocz naprzód do T-GR-ZERO ; inaczej ta liczba jest mniejsza niż plus lub minus jeden i można uczynić ją zerem LD (HL),$00 ; zrób wykładnik zero. LD A,$20 ; przygotuj się na wyzerowanie 32 bitów mantysy. JR NIL_BYTES ; naprzód do NIL-BYTES ; $18EF : 6383 T_GR_ZERO: SUB $A0 ; odejmij +32 od wykładnika RET P ; wróć, jeśli wynik dodatni, ponieważ wszystkie 32 bity mantysy odnoszą się do części całkowitej. ; Pływający przecinek jest gdzieś na prawo od mantysy NEG ; inaczej zaneguj, aby utworzyć liczbę, której prawe bity będą wyczyszczone. ; przykładowo, zaniedbując bit znaku, liczba 3.5 jest przechowywana jako wykładnik $82 mantysa .11100000 00000000 00000000 00000000 ; Potrzebujemy ustawić $82 - $A0 = $E2 NEG = $1E (trzydzieści) bitów na zero, aby utworzyć liczbę całkowitą. ; Znak liczby nigdy nie jest rozważany, ponieważ pierwszy bit mantysy musi być częścią liczby całkowitej. ; $18F4 : 6388 NIL_BYTES: PUSH DE ; zachowaj wskaźnik do STKEND EX DE,HL ; HL wskazuje na STKEND DEC HL ; teraz na ostatni bajt mantysy. LD B,A ; Przenieś licznik bitów do rejestru B. SRL B ; podziel SRL B ; przez SRL B ; osiem JR Z,BITS_ZERO ; jeśli zero, naprzód do BITS-ZERO ; inaczej pierwotny licznik zawierał osiem lub więcej i całe bajty można wyczyścić. ; $1900 : 6400 BYTE_ZERO: LD (HL),$00 ; ustaw osiem bitów na zero. DEC HL ; wskaż bardziej znaczący bajt mantysy. DJNZ BYTE_ZERO ; skocz w pętli wstecz do BYTE-ZERO ; teraz rozważ bity resztowe. ; $1905 : 6405 BITS_ZERO: AND $07 ; wyizoluj pozostałe bity JR Z,IX_END ; jeśli ich brak, skocz naprzód do IX-END LD B,A ; przenieś licznik bitów do rejestru B. LD A,$FF ; utwórz maskę 11111111 ; $190C : 6412 LESS_MASK: SLA A ; 1 <- 76543210 <- o przesuń maskę w lewo. DJNZ LESS_MASK ; w pętli powtarzaj aż do wyzerowania licznika AND (HL) ; usuń niechciane prawe bity LD (HL),A ; i umieść w bajcie mantysy. ; $1912 : 6418 IX_END: EX DE,HL ; odtwórz wskaźnik wyniku z DE. POP DE ; odtwórz STKEND ze stosu. RET ;************************************ ;** KALKULATOR ZMIENNOPRZECINKOWY ** ;************************************ ; Ogólnie kalkulator unika używania rejestru IY. ; Wyjątkami są val i str$. ; Więc programista w asemblerze, który wyłączył przerwania w celu używania IY do innych celów, może wciąż korzystać z kalkulatora do celów matematycznych. ; ----------------- ; 'TABLICA STAŁYCH' ; ----------------- ; ZX81 posiada tylko liczby zmiennoprzecinkowe. Zarówno ZX80 jak i ZX Spectrum posiadają również liczby całkowite w pewnej postaci. ; $1915 : 6421 STK_ZERO: .BYTE $00 ; Bajty: 1 .BYTE $B0 ; Wykładnik $00 .BYTE $00 ;(+00,+00,+00) ; $1918 : 6424 STK_ONE: .BYTE $31 ; Wykładnik $81, Bajty: 1 .BYTE $00 ;(+00,+00,+00) ; $191A : 6426 STK_HALF: .BYTE $30 ; Wykładnik: $80, Bajty: 1 .BYTE $00 ;(+00,+00,+00) ; $191C : 6428 STK_PI_2: .BYTE $F1 ; Wykładnik: $81, Bajty: 4 .BYTE $49,$0F,$DA,$A2 ; $1921 : 6433 STK_TEN: .BYTE $34 ; Wykładnik: $84, Bajty: 1 .BYTE $20 ;(+00,+00,+00) ; ----------------- ; 'TABLICA ADRESÓW' ; ----------------- ; rozpoczyna się od operacji dwuargumentowych, które posiadają dwa argumenty i jeden wynik. Na początku trzy pseudooperacje dwuargumentowe. ; $1923 : 6435 TBL_ADDRS: .WORD JUMP_TRUE ; $00 Adres: $1C2F - skocz-true .WORD EXCHANGE ; $01 Adres: $1A72 - wymień .WORD DELETE ; $02 Adres: $19E3 - usuń ; prawdziwe operacje dwuargumentowe .WORD SUBTRACT ; $03 Adres: $174C - odejmij .WORD MULTIPLY ; $04 Adres: $176C - mnóż .WORD DIVISION ; $05 Adres: $1882 - dziel .WORD TO_POWER ; $06 Adres: $1DE2 - potęguj .WORD OR_LOGIC ; $07 Adres: $1AED - logiczne-lub .WORD NO_AND_NO ; $08 Adres: $1B03 - no-&-no .WORD NO_L_EQL ; $09 Adres: $1B03 - no-l-eql .WORD NO_L_EQL ; $0A Adres: $1B03 - no-gr-eql .WORD NO_L_EQL ; $0B Adres: $1B03 - nos-neql .WORD NO_L_EQL ; $0C Adres: $1B03 - no-grtr .WORD NO_L_EQL ; $0D Adres: $1B03 - no-less .WORD NO_L_EQL ; $0E Adres: $1B03 - nos-eql .WORD ADDITION ; $0F Adres: $1755 - dodaj .WORD STR_AND_NO ; $10 Adres: $1AF8 - str-&-no .WORD NO_L_EQL ; $11 Adres: $1B03 - str-l-eql .WORD NO_L_EQL ; $12 Adres: $1B03 - str-gr-eql .WORD NO_L_EQL ; $13 Adres: $1B03 - strs-neql .WORD NO_L_EQL ; $14 Adres: $1B03 - str-grtr .WORD NO_L_EQL ; $15 Adres: $1B03 - str-less .WORD NO_L_EQL ; $16 Adres: $1B03 - strs-eql .WORD STRS_ADD ; $17 Adres: $1B62 - strs-add ; operacje jednoargumentowe .WORD NEGATE ; $18 Adres: $1AA0 - neguj .WORD CODE ; $19 Adres: $1C06 - code .WORD VAL ; $1A Adres: $1BA4 - val .WORD LEN ; $1B Adres: $1C11 - len .WORD SIN ; $1C Adres: $1D49 - sin .WORD COS ; $1D Adres: $1D3E - cos .WORD TAN ; $1E Adres: $1D6E - tan .WORD ASN ; $1F Adres: $1DC4 - asn .WORD ACS ; $20 Adres: $1DD4 - acs .WORD ATN ; $21 Adres: $1D76 - atn .WORD LN ; $22 Adres: $1CA9 - ln .WORD EXP ; $23 Adres: $1C5B - exp .WORD INT ; $24 Adres: $1C46 - int .WORD SQR ; $25 Adres: $1DDB - sqr .WORD SGN ; $26 Adres: $1AAF - sgn .WORD ABS ; $27 Adres: $1AAA - abs .WORD PEEK ; $28 Adres: $1A1B - peek .WORD USR_NO ; $29 Adres: $1AC5 - usr-no .WORD STR ; $2A Adres: $1BD5 - str$ .WORD CHRS ; $2B Adres: $1B8F - chrs .WORD NOT_LOGIC ; $2C Adres: $1AD5 - logiczne-nie ; koniec operacji jednoargumentowych .WORD MOVE_FP ; $2D Adres: $19F6 - duplikuj .WORD N_MOD_M ; $2E Adres: $1C37 - n-modulo-m .WORD JUMP ; $2F Adres: $1C23 - skocz .WORD STK_DATA ; $30 Adres: $19FC - dane-na-stos .WORD DEC_JR_NZ ; $31 Adres: $1C17 - dec-jr-nz .WORD LESS_0 ; $32 Adres: $1ADB - mniej-niż-0 .WORD GREATER_0 ; $33 Adres: $1ACE - więcej-niż-0 .WORD END_CALC ; $34 Adres: $002B - koniec-liczenia .WORD GET_ARGT ; $35 Adres: $1D18 - pobierz-argt .WORD TRUNCATE ; $36 Adres: $18E4 - obetnij .WORD FP_CALC_2 ; $37 Adres: $19E4 - fp-calc-2 .WORD E_TO_FP ; $38 Adres: $155A - e-do-fp ; kolejne adresy są po prostu następnymi dostępnymi slotami dla złożonych literałów o zakresie od $80 do $FF. .WORD SERIES_XX ; $39 Adres: $1A7F - series-xx $80 - $9F. .WORD STK_CONST_XX ; $3A Adres: $1A51 - stk-const-xx $A0 - $BF. .WORD ST_MEM_XX ; $3B Adres: $1A63 - st-mem-xx $C0 - $DF. .WORD GET_MEM_XX ; $3C Adres: $1A45 - get-mem-xx $E0 - $FF. ; Na boku: 3D - 7F są stąd nieużywanymi literałami kalkulatora. ; 39 - 7B byłyby dostępne dla rozszerzeń. ; ----------------------------- ; KALKULATOR ZMIENNOPRZECINKOWY ; ----------------------------- ; $199D : 6557 CALCULATE: CALL STK_PNTRS ; procedura ta jest wywoływana w celu ustawienia wskaźników kalkulatora dla standardowej operacji jednoargumentowej. ; HL wskazuje ostatnią wartość na stosie, DE wskazuje pierwszą pozycję po stosie ; w tym punkcie procedura kalkulatora jest wywoływana przez generator ciągów funkcyjnych ... ; $19A0 : 6560 GEN_ENT_1: LD A,B ; przechowaj zawartość rejestru B mikroprocesora Z80 LD (BREG),A ; w zmiennej systemowej BREG, będzie on służył jako licznik dla rozkazu djnz lub za instrukcję dla kalkulatora ; ... a później od tego miejsca ; $19A4 : 6564 GEN_ENT_2: EXX ; przełącz rejestry EX (SP),HL ; i zachowaj adres następnej instrukcji, adres powrotny w H'L'. ; Jeśli jest to wywołanie rekurencyjne, to H'L' z poprzedniego wywołania idzie na stos c.f. koniec obliczeń. EXX ; przełącz z powrotem na główny zestaw rejestrów. ; to jest punkt wejścia pętli przy obsłudze literałów łańcuchowych. ; $19A7 : 6567 RE_ENTRY: LD (STKEND),DE ; zachowaj koniec stosu w zmiennej systemowej STKEND EXX ; przełącz na zapasowe rejestry LD A,(HL) ; pobierz kolejny literał INC HL ; zwiększ wskaźnik w HL' ; przy pojedynczej operacji wykonywany jest skok wstecz do tego miejsca ; $19AE : 6574 SCAN_ENT: PUSH HL ; zachowaj wskaźnik na stosie AND A ; teraz sprawdź, czy literał JP P,FIRST_3D ; jeśli w zakresie $00 - $3D, skocz naprzód do FIRST-3D wszystko z ustawionym bitem 7 będzie jednym ze złożonych literałów. ; Literały złożone posiadają następujący format. ; bit 7 ustawiony - oznacza literał złożony. ; bity 6-5 są podgrupą 0-3 ; bity 4-0 są osadzonym parametrem $00 - $1F. ; Podgrupa 0-3 musi być obsłużona w celu utworzenia dostępnych dalej czterech miejsc adresowych po prostych literałach w tablicy adresów. LD D,A ; zachowaj literał w rejestrze D AND $60 ; dokonaj koniunkcji z 01100000, aby wyizolować podgrupę RRCA ; obróć bity RRCA ; 4 pozycje w prawo RRCA ; nie pięć, ponieważ potrzebne nam jest przesunięcie * 2 RRCA ; 00000xx0 ADD A,$72 ; dodaj ($39 * 2), aby otrzymać poprawne przesunięcie. LD L,A ; umieść w L późniejsze indeksowanie. LD A,D ; odtwórz literał złożony AND $1F ; użyj maski do wyizolowania bitów parametru JR ENT_TABLE ; naprzód do ENT-TABLE ; tutaj następuje skok przy literałach prostych. ; $19C2 : 6594 FIRST_3D: CP $18 ; porównaj z pierwszymi operacjami jednoargumentowymi. JR NC,DOUBLE_A ; przy operacjach dwuargumentowych skocz do DOUBLE-A ; operacja jednoargumentowa, więc ustaw wskaźniki. EXX LD BC,$FFFB ; wartość -5 LD D,H ; przenieś HL, ostatnią wartość, do DE. LD E,L ADD HL,BC ; odejmij 5, aby HL wskazywało na drugą wartość. EXX ; $19CE : 6606 DOUBLE_A: RLCA ; podwój literał LD L,A ; i umieść w L do indeksowania ; $19D0 : 6608 ENT_TABLE: LD DE,TBL_ADDRS ; Adres: tbl-addrs LD H,$00 ; przygotuj indeks ADD HL,DE ; dodaj, aby otrzymać adres procedury LD E,(HL) ; młodszy bajt do E INC HL LD D,(HL) ; starszy bajt do D LD HL,RE_ENTRY ; Adres: RE-ENTRY EX (SP),HL ; idzie na stos maszynowy adres następnego literału idzie do HL. PUSH DE ; teraz na stos trafia adres procedury. EXX ; przełącz na główne rejestry unikaj używania rejestru IY. LD BC,($401D) ; STKEND_hi do C nic nie trafia, ale do B idzie BREG i przejdź do następnej instrukcji RET, ; która posiada podwójną tożsamość. ; ------------------ ; PROCEDURA 'USUŃ' ; ------------------ ; offset $02: 'delete' ; Prosty powrót, lecz przy użyciu jako literał kalkulatora usuwa on ostatnią wartość ze stosu. Na wejściu, jak zwykle z operacjami dwuargumentowymi, ; HL=pierwsza liczba, DE=druga liczba ; Na wyjściu, HL=wynik, DE=STKEND. ; Więc nic do roboty ; $19E3 : 6627 DELETE: RET ; powróć - skocz pośrednio, jeśli kontynuuje się powyższą procedurę. ; -------------------------------- ; PROCEDURA 'POJEDYNCZEJ OPERACJI' ; -------------------------------- ; offset $37: 'fp-calc-2' ; Ta pojedyncza operacja jest używana do obliczania wartości większości funkcji matematycznych i łańcuchowych, które znajdują się w wyrażeniach ; języka BASIC. ; $19E4 : 6628 FP_CALC_2: POP AF ; porzuć adres powrotny. LD A,(BREG) ; załaduj akumulator ze zmiennej systemowej BREG wartością będzie literał, np. 'tan' EXX ; przełącz na rejestry zapasowe JR SCAN_ENT ; wstecz do SCAN-ENT, następnym literałem będzie end-calc ; ---------------------------- ; PROCEDURA "TEST NA 5 MIEJSC' ; ---------------------------- ; Procedura ta jest wywoływana z MOVE-FP, STK-CONST i STK-STORE w celu sprawdzenia, czy jest wystarczająco miejsca pomiędzy stosem kalkulatora a ; stosem maszynowym na wartość 5-cio bajtową. Wraca z parą BC zawierającą wartość 5, gotową dla ewentualnej instrukcji LDIR. ; $19EB : 6635 TEST_5_SP: PUSH DE ; zachowaj PUSH HL ; rejestry na stosie maszynowym LD BC,$0005 ; potrzeba 5 bajtów CALL TEST_ROOM ; procedura TEST-ROOM testuje wolną pamięć RAM, generując, jeśli jej brak. POP HL ; inaczej odtwórz POP DE ; rejestry RET ; wróć z parą BC ustawioną na 5. ; --------------------------------------------- ; PROCEDURA 'PRZESUŃ LICZBĘ ZMIENNOPRZECINKOWĄ' ; --------------------------------------------- ; offset $2D: 'duplicate' ; Ta prosta procedura jest instrukcją LDIR przesuwającą 5 bajtów, która wykorzystuje testy pamięci. Gdy używa się jej jako literał kalkulatora, ; duplikuje ostatnią wartość na stosie kalkulatora. Jednoargumentowa, więc na wejściu HL wskazuje na ostatnią wartość, DE na STKEND. ; $19F6 : 6646 MOVE_FP: CALL TEST_5_SP ; procedura TEST-5-SP sprawdza wolną pamięć i ustawia BC na 5 LDIR ; kopiuj te pięć bajtów. RET ; wróć z parą DE adresującą nowe STKEND i HL adresującą nową ostatnią wartość. ; --------------------------------- ; PROCEDURA 'UMIEŚĆ DANE NA STOSIE' ; --------------------------------- ; offset $30: 'stk-data' ; Gdy jakiś podprogram kalkulatora potrzebuje umieścić jakąś wartość na jego stosie, a nie jest ona typową stałą, to zostaje wywołana ta ; procedura ze zmienną liczbą następujących za nią bajtów danych, które przenoszą do tej procedury pożądaną wartość zmiennoprzecinkową ; przedstawioną w sposób najbardziej treściwy ; $19FC : 6652 STK_DATA: LD H,D ; prześlij STKEND LD L,E ; do HL dla wyniku. ; $19FE : 6654 STK_CONST: CALL TEST_5_SP ; procedura TEST-5-SP sprawdza, czy jest miejsce i ustawia BC na $05. EXX ; przełącz na zapasowe rejestry PUSH HL ; zachowaj na stosie wskaźnik do następnego literału EXX ; przełącz na główne rejestry EX (SP),HL ; wskaźnik do HL, adres przeznaczenia na stos. PUSH BC ; zachowaj BC - wartość 5 z testowania miejsca??. LD A,(HL) ; pobierz bajt za kodem 'stk-data' AND $C0 ; wyizoluj bity 7 i 6 RLCA ; obróć RLCA ; na bity 1 i 0 zakres $00 - $03. LD C,A ; przenieś do C INC C ; i zwiększ o 1, aby otrzymać liczbę bajtów do odczytania $01 - $04 LD A,(HL) ; ponownie załaduj pierwszy bajt AND $3F ; wymaskuj, aby otrzymać możliwy wykładnik. JR NZ,FORM_EXP ; jeśli dało się dołączyć wykładnik, skocz naprzód do FORM-EXP ; inaczej ten bajt podaje jedynie liczbę bitów, a wykładnik jest w następnym bajcie. INC HL ; adresuj następny bajt LD A,(HL) ; i pobierz wykładnik ( - $50). ; $1A14 : 6676 FORM_EXP: ADD A,$50 ; teraz dodaj $50, aby utworzyć właściwy wykładnik LD (DE),A ; i załaduj go do pierwszego bajtu docelowego. LD A,$05 ; umieść w akumulatorze $05 i SUB C ; odejmij C, aby otrzymać liczbę końcowych zer plus jeden. INC HL ; zwiększ adres źródła INC DE ; zwiększ adres przeznaczenia LD B,$00 ; przygotuj się do kopiowania LDIR ; przekopiuj C bajtów POP BC ; odtwórz licznik 5 w BC ??. EX (SP),HL ; umieść HL na stosie jako wskaźnik następnego literału, a wartość ze stosu - wskaźnik wyniku - pobierz do HL. EXX ; przełącz na rejestry zapasowe. POP HL ; odtwórz ze stosu w H'L' wskaźnik następnego literału EXX ; przełącz z powrotem na rejestry główne LD B,A ; licznik zer do B XOR A ; wyczyść akumulator ; $1A27 : 6695 STK_ZEROS: DEC B ; zmniejsz o 1 licznik w B RET Z ; wróć przy zerze, DE wskazuje na nowe STKEND, HL wskazuje na nową liczbę. LD (DE),A ; inaczej umieść zero w miejscu docelowym INC DE ; zwiększ wskaźnik przeznaczenia JR STK_ZEROS ; cofnij się w pętli wstecz do STK-ZEROS, aż zadanie zostanie wykonane. ; ------------------------- ; PROCEDURA 'POMIJAJ STAŁE' ; ------------------------- ; Procedura ta przechodzi przez elementy tablicy stałych o zmiennej długości, umieszczając pośrednie, niechciane stałe na fikcyjnym stosie kalkulatora, ; który znajduje się w pierwszych pięciu bajtach pamięci ROM w ZX81. ; $1A2D : 6701 SKIP_CONS: AND A ; testuj, czy początkowo jest zero. ; $1A2E : 6702 SKIP_NEXT: RET Z ; Jeśli jest zero, powróć. PUSH AF ; zachowaj licznik. PUSH DE ; i normalny adres STKEND LD DE,$0000 ; fikcyjna wartość dla STKEND na początku ROM. Uwaga, nie jest to błąd, ale ten adres trzeba przenieść gdzieś indziej, ; jeśli program działa w RAM. CALL STK_CONST ; procedura STK-CONST przechodzi przez rekordy o zmiennej długości. POP DE ; odtwórz prawdziwy STKEND POP AF ; odtwórz licznik DEC A ; zmniejsz go o 1 JR SKIP_NEXT ; skocz wstecz w pętli do SKIP-NEXT ; ----------------------------- ; PROCEDURA 'POZYCJA W PAMIĘCI' ; ----------------------------- ; Procedura ta po otrzymaniu adresu bazowego w HL i indeksu w A oblicza adres A-tego elementu, gdzie każdy z tych elementów zajmuje w pamięci ; pięć bajtów. Używana jest do adresowania liczb zmiennoprzecinkowych w obszarze pamięci kalkulatora. ; $1A3C : 6716 LOC_MEM: LD C,A ; zachowaj oryginalny numer $00-$1F. RLCA ; A x 2 RLCA ; A x 4 ADD A,C ; dodaj oryginalny numer, otrzymując pomnożenie przez pięć. LD C,A ; umieść wynik w C. LD B,$00 ; ustaw B na 0. ADD HL,BC ; dodaj w celu otrzymania w HL adresu startu elementu. RET ; ------------------------------------- ; PROCEDURA 'POBIERZ Z OBSZARU PAMIĘCI' ; ------------------------------------- ; offsets $E0 to $FF: 'get-mem-0', 'get-mem-1' itd. ; A zawiera przesunięcie $00-$1F. Stos kalkulatora rośnie o 5 bajtów. ; $1A45 : 6725 GET_MEM_XX: PUSH DE ; zachowaj STKEND LD HL,(MEM) ; MEM jest adresem bazowym komórek pamięci. CALL LOC_MEM ; ustaw w HL adres pierwszego z 5 bajtów CALL MOVE_FP ; przenieś 5 bajtów ze sprawdzeniem dostępności pamięci, DE teraz wskazuje na nowy STKEND. POP HL ; oryginalny STKEND jest teraz wskaźnikiem wyniku. RET ; ------------------------- ; PROCEDURA 'STAŁA NA STOS' ; ------------------------- ; offset $A0: 'stk-zero' - 0 na stos ; offset $A1: 'stk-one' - 1 na stos ; offset $A2: 'stk-half' - 1/2 na stos ; offset $A3: 'stk-pi/2' - pi/2 na stos ; offset $A4: 'stk-ten' - 10 na stos ; Procedura ta pozwala jednobajtowej instrukcji umieścić na stosie do 32 stałych przechowywanych w skróconej postaci w tablicy stałych. ; W rzeczywistości potrzebne jest tylko 5 stałych. Na wejściu rejestr A zawiera literał poddany operacji AND z $1F. Nie jest to specjalnie ; efektywne i byłoby lepiej przechowywać te liczby w pełnej, 5 bajtowej postaci i umieszczać je na stosie w podobny sposób do tego, który ; później będzie używany dla tablicy wartości półtonów. ; $1A51 : 6737 STK_CONST_XX: LD H,D ; zachowaj STKEND - potrzebne dla wyniku LD L,E EXX ; przełącz na zapasowe rejestry PUSH HL ; zachowaj wskaźnik do kolejnego literału LD HL,STK_ZERO ; początek tablicy stałych do H'L' EXX ; przełącz na główne rejestry CALL SKIP_CONS ; przejdź do pożądanej stałej CALL STK_CONST ; umieść stałą na stosie EXX POP HL ; odtwórz wskaźnik do następnego literału. EXX RET ; ------------------------------------- ; PROCEDURA 'ZAPISZ W OBSZARZE PAMIĘCI' ; ------------------------------------- ; Offsets $C0 to $DF: 'st-mem-0', 'st-mem-1' etc. ; Chociaż mogą być adresowane 32 lokacje pamięci, to dla ROM potrzebne jest tylko sześć od $C0 do $C5 i dla nich przeznaczono trzydzieści ; bajtów (6*5). Programiści ZX81, którzy chcą używać procedur zmiennoprzecinkowych z poziomu asemblera, mogą zmienić zmienną systemową ; MEM, aby wskazywała na obszar 160 bajtów RAM w celu pełnego wykorzystania całego zakresu. A zawiera wyprowadzone przesunięcie $00-$1F. ; Jednoargumentowa, zatem na wejściu HL wskazuje na ostatnią wartość, DE na STKEND. ; $1A63 : 6755 ST_MEM_XX: PUSH HL ; zachowaj wskaźnik wyniku. EX DE,HL ; przenieś do DE. LD HL,(MEM) ; pobierz z MEM adres bazowy obszaru pamięci. CALL LOC_MEM ; procedura LOC-MEM ustawia HL na adres przeznaczenia. EX DE,HL ; zamień - HL jest początkiem, DE jest przeznaczeniem. CALL MOVE_FP ; Uwaga: krótkie LD BC,5; LDIR ; test pamięci nie jest potrzebny, zatem te instrukcje byłyby szybsze! EX DE,HL ; DE = STKEND POP HL ; odtwórz oryginalny wskaźnik wyniku RET ; ------------------ ; PROCEDURA 'ZAMIEŃ' ; ------------------ ; offset $01: 'exchange' ; Procedura ta zamienia dwie ostatnie wartości na stosie kalkulatora. Na wejściu jak zawsze przy operacjach dwuargumentowych, ; HL=pierwsza liczba, DE=druga liczba ; Na wyjściu: HL=wynik, DE=STKEND. ; $1A72 : 6770 EXCHANGE: LD B,$05 ; należy zamienić pięć bajtów ; początek pętli. ; $1A74 : 6772 SWAP_BYTE: LD A,(DE) ; każdy bajt drugiej liczby LD C,(HL) ; każdy bajt pierwszej liczby EX DE,HL ; zamień wskaźniki LD (DE),A ; zapisz każdy bajt pierwszej liczby LD (HL),C ; zapisz każdy bajt drugiej liczby INC HL ; przesuń oba wskaźniki INC DE DJNZ SWAP_BYTE ; skocz wstecz w pętli do SWAP-BYTE, aż wszystkie 5 bajtów będzie przesłane. EX DE,HL ; parzysta liczba zamian przywraca stan wskaźników, aby DE adresowało STKEND. RET ; ----------------------------- ; PROCEDURA 'GENERATORA CIĄGÓW' ; ----------------------------- ; offset $86: 'series-06' ; offset $88: 'series-08' ; offset $8C: 'series-0C' ; ZX81 wykorzystuje wielomiany Czybyszewa do tworzenia przybliżeń dla SIN, ATN, LN i EXP. Ich nazwa pochodzi od nazwiska rosyjskiego matematyka, ; Pafunty Czybyszewa, urodzonego w 1821, który dokonał wielu prac pionierskich w dziedzinie ciągów liczbowych. w przypadku kalkulatorów ; wielomiany Czybyszewa posiadają taką zaletę nad innymi ciągami, przykładowo nad ciągami Taylora, iż szybciej osiągają przybliżenia funkcji: ; SIN w 6 iteracjach, EXP w 8, a LN i ATN w 12. Sposób pracy tej procedury jest interesujący, lecz pełne jej wyjaśnienie wraz z demonstracją ; w BASIC'u ZX81 znajduje się "The Complete Spectrum ROM Disassembly" autorstwa dr Iana Logana i dr Franka O'Hary, opublikowanym w 1983 przez ; Melbourne House. ; $1A7F : 6783 SERIES_XX: LD B,A ; parametr $00 - $1F do licznika B CALL GEN_ENT_1 ; Rekurencyjne wywołanie specjalnego punktu wejścia w kalkulatorze, który umieszcza rejestr B w zmiennej systemowej BREG. ; Adres powrotny jest następną pozycją, gdzie kalkulator oczekuje swojej pierwszej instrukcji - obecnie wskazywanej ; przez H'L'. Poprzedni wskaźnik ciągów pięciobajtowych liczb zostaje umieszczony na stosie maszynowym. ; Faza wstępna. .BYTE $2D ; duplikuj x,x. .BYTE $0F ; dodaj x+x. .BYTE $C0 ; stos-do-pamięci-0 2x. .BYTE $02 ; usuń . .BYTE $A0 ; na-stos-zero 0. .BYTE $C2 ; stos-do-pamięci-2 0. ; teraz następuje wejście do pętli w celu wykonania obliczeń algebraicznych dla każdej z liczb w ciągu ; $1A89 : 6793 G_LOOP: .BYTE $2D ; duplikuj v,v. .BYTE $E0 ; na-stos-paimięć-0 v,v,2x .BYTE $04 ; mnóż v,v*2x .BYTE $E2 ; na-stos-paimięć-2 v,v*2x,v' .BYTE $C1 ; stos-do-pamięci-1 .BYTE $03 ; odejmij v,v*2x-v' .BYTE $34 ; koniec-obliczeń ; na stosie kalkulatora umieszczona zostaje kolejna stała CALL STK_DATA ; procedura STK-DATA jest wywoływana, aby bezpośrednio wstawić tą stałą na stos i zwiększyć wskaźnik H'L'. CALL GEN_ENT_2 ; procedura GEN-ENT-2 rekurencyjnie wchodzi do kalkulatora bez zmian w zmiennej systemowej BREG ; zawartość H'L' idzie na stos maszynowy i zostaje załadowana jak zwykle następnym adresem. .BYTE $0F ; dodaj v,2*v*x-v'+v'' .BYTE $01 ; zamień 2*v*x-v'+v'',v .BYTE $C2 ; stos-do-pamięci-2 .BYTE $02 ; usuń 2*v*x-v'+v'' .BYTE $31 ; zmniejsz-skocz-jeśli-nie-zero .BYTE $EE ; wstecz do $1A89, G-LOOP ; gdy wyliczana pętla zostanie zakończona, ostatnie odejmowanie da nam wynik, np. SIN X. .BYTE $E1 ; na-stos-paimięć-1 .BYTE $03 ; odejmij .BYTE $34 ; koniec-obliczeń RET ; wróć z H'L' wskazującym na pozycję za ostatnią liczbą w ciągu. ; -------------------------------------- ; Obsługa jednoargumentowego minusa ($18) ; -------------------------------------- ; Procedura zmienia znak liczby na szczycie stosu kalkulatora. Operacja jednoargumentowa, zatem na wejściu HL wskazuje ostatnią wartość, ; DE wskazuje STKEND. ; $1AA0 : 6816 NEGATE: LD A,(HL) ; pobierz wykładnik ostatniej wartości na stosie kalkulatora. AND A ; testuj go. RET Z ; wróć, jeśli zero - liczba jest zerem. INC HL ; adres bajtu z bitem znaku. LD A,(HL) ; pobierz go do akumulatora. XOR $80 ; zmień bit znaku na przeciwny. LD (HL),A ; włóż z powrotem pobrany bajt. DEC HL ; ponownie wskaż ostatnią wartość. RET ; ----------------------- ; Wartość bezwzględna ($27) ; ----------------------- ; Ta procedura oblicza wartość bezwzględną liczby na szczycie stosu kalkulatora. ; $1AAA : 6826 ABS: INC HL ; wskaż bajt z bitem znaku. RES 7,(HL) ; ustaw znak na plus. DEC HL ; wskaż z powrotem ostatnią wartość. RET ; ----------- ; Signum ($26) ; ----------- ; Ta procedura zastępuje ostatnią wartość na stosie kalkulatora jedną z liczb: ; -1, jeśli liczba jest ujemna ; 1, jeśli jest dodatnia ; 0, jeśli jest równa 0 - wtedy liczba zostaje pozostawiona bez zmian ; $1AAF : 6831 SGN: INC HL ; wskaż na pierwszy bajt 4-bajtowej mantysy. LD A,(HL) ; pobierz bajt z bitem znaku. DEC HL ; wskaż na wykładnik. DEC (HL) ; testuj wykładnik na wartość zero INC (HL) SCF ; Ustaw znacznik przeniesienia. CALL NZ,FP_0_1 ; procedura FP-0/1 zastępuje ostatnią wartość liczbą 1, jeśli wykładnik wskazuje, iż wartość jest różna od zera. ; W każdym przypadku mantysa składa się teraz z czterech zer. INC HL ; wskaż pierwszy bajt mantysy. RLCA ; wstaw oryginalny bit znaku do przeniesienia. RR (HL) ; wstaw przeniesienie do bitu znaku wyniku. DEC HL ; wskaż na ostatnią wartość. RET ; ------------------------- ; obsługa funkcji PEEK ($28) ; ------------------------- ; Ta funkcja zwraca zawartość komórki pamięci o podanym adresie. Można pobrać komórkę z całego obszaru adresowego, łącznie z ROM. ; $1ABE : 6846 PEEK: CALL FIND_INT ; procedura FIND-INT umieszcza adres w BC. LD A,(BC) ; pobierz zawartość do rejestru A. ; $1AC2 : 6850 IN_PK_STK: JP STACK_A ; wyjdź poprzez STACK-A, aby umieścić A na stosie kalkulatora. ; --------------- ; USR liczba ($29) ; --------------- ; Funkcja USR, za którą następuje liczba od 0 do 65535, pozwala wywołać komputerowi ZX81 program w kodzie maszynowym. Funkcja ta zwraca jako swoją ; wartość parę rejestrów BC. ; Uwaga: procedura STACK-BC odtwarza stan rejestru IY na $4000, jeśli program użytkownika go zmienił. ; $1AC5 : 6853 USR_NO: CALL FIND_INT ; procedura FIND-INT umieszcza dostarczony adres w BC. LD HL,STACK_BC ; na stosie maszynowym zostaje umieszczony adres STACK-BC PUSH HL PUSH BC ; a następnie adres procedury w kodzie maszynowym. RET ; wykonany zostanie skok pośredni do tej procedury a przy powrocie z niej również do STACK-BC. ; ----------------------- ; Większe od zera ($33) ; ----------------------- ; Test, czy ostatnia wartość na stosie kalkulatora jest większa od zera. Ta procedura jest również wywoływana z końcowych testów procedury porównania. ; $1ACE : 6862 GREATER_0: LD A,(HL) ; pobierz wykładnik. AND A ; test na zero. RET Z ; jeśli tak, wróć. LD A,$FF ; przygotuj maskę XOR na bit znaku JR SIGN_TO_C ; naprzód do SIGN-TO-C, aby wstawić znak do przeniesienia (przeniesienie zostanie ustawione, jeśli znak jest dodatni) ; a następnie zapisz tę lokację 1 lub 0 zgodnie z wynikiem ; --------------------------- ; Obsługa operatora NOT ($2C) ; --------------------------- ; Powoduje zapisanie ostatniej wartości 1, jeśli była równa 0, lub 0 dla każdej innej wartości. ; tj. NOT 0 zwraca 1, NOT 1 zwraca 0, NOT -3 zwraca 0. ; Ta procedura jest również bezpośrednio wywoływana z końcowych testów operatora porównania. ; $1AD5 : 6869 NOT_LOGIC: LD A,(HL) ; pobierz bajt wykładnika. NEG ; zaneguj - ustawia przeniesienie, jeśli był różny od zera. CCF ; zaneguj przeniesienie, aby było ustawione, gdy liczba była zerem, inaczej wyzerowane JR FP_0_1 ; naprzód do FP-0/1. ; ---------------------- ; Mniejsze od zera ($32) ; ---------------------- ; Niszcząco sprawdź, czy ostatnia wartość na stosie kalkulatora jest mniejsza od 0. Jeśli tak, bit nr 7 drugiego bajtu będzie ustawiony na 1. ; $1ADB : 6875 LESS_0: XOR A ; zeruj maskę XOR (przeniesienie zostanie ustawione, jeśli znak był ujemny). ; przenieś znak mantysy do znacznika przeniesienia. ; $1ADC : 6876 SIGN_TO_C: INC HL ; zaadresuj drugi bajt. XOR (HL) ; jeśli liczba jest ujemna, bit 7 rejestru A będzie ustawiony na 1. DEC HL ; adresuj ponownie pierwszy bajt. RLCA ; obróć bit 7 rejestru A do przeniesienia. ; -------------- ; Zero lub jeden ; -------------- ; Ta procedura umieszcza liczbę całkowitą o wartości 0 lub 1 na adresowanej lokacji stosu kalkulatora lub obszaru MEM. Wartość 1 jest wpisywana, ; jeśli ustawione jest przeniesienie, inaczej wpisywane jest zero. ; $1AE0 : 6880 FP_0_1: PUSH HL ; zachowaj wskaźnik pierwszego bajtu LD B,$05 ; pięć bajów do roboty. ; $1AE3 : 6883 FP_LOOP: LD (HL),$00 ; w pętli wstaw 5 zer. INC HL ; adres kolejnego bajtu DJNZ FP_LOOP ; powtarzaj POP HL ; odzyskaj adres pierwszego bajtu RET NC ; jeśli brak przeniesienia, zero jest gotowe LD (HL),$81 ; inaczej wpisz 1 RET ; -------------------------- ; Obsługa operatora OR ($07) ; -------------------------- ; Operator logiczny OR, np. X OR Y ; Wynikiem jest zero, jeśli obie wartości są zerami, inaczej wynik jest niezerowy. ; np. 0 OR 0 zwraca 0. ; -3 OR 0 zwraca -3. ; 0 OR -3 zwraca 1. ; -3 OR 2 zwraca 1. ; Operacja dwuargumentowa. ; Na wejściu HL wskazuje na pierwszy argument (X) a DE na drugi (Y). ; $1AED : 6893 OR_LOGIC: LD A,(DE) ; pobierz wykładnik drugiej liczby AND A ; testuj go. RET Z ; jeśli zero, wróć. SCF ; ustaw znacznik przeniesienia JR FP_0_1 ; wstecz do FP-0/1 w celu nadpisania pierwszego argumentu wartością 1 ; ----------------------------------------- ; Obsługa operatora liczba AND liczba ($08) ; ----------------------------------------- ; Operator logiczny AND. Zwraca zero, jeśli jeden z argumentów jest zerem. ; inaczej zwraca pierwszy argument. ; np. -3 AND 2 zwraca -3. ; -3 AND 0 zwraca 0. ; 0 AND -2 zwraca 0. ; 0 AND 0 zwraca 0. ; Porównaj z procedurą OR powyżej ; $1AF3 : 6899 NO_AND_NO: LD A,(DE) ; pobierz wykładnik drugiej liczby AND A ; testuj go. RET NZ ; wróć, jeśli różne od zera JR FP_0_1 ; wstecz do FP-0/1 w celu nadpisania pierwszego argumentu zerem. ; ------------------------------------------ ; Obsługa operatora łańcuch AND liczba ($10) ; ------------------------------------------ ; np. "WYGRYWASZ" AND WYNIK>99 zwróci ten łańcuch, jeśli warunek będzie prawdziwy lub pusty łańcuch, jeśli warunek będzie fałszywy. ; $1AF8 : 6904 STR_AND_NO: LD A,(DE) ; pobierz wykładnik drugiej liczby. AND A ; testuj go. RET NZ ; wróć, jeśli liczba była różna od zero - wynikiem będzie łańcuch. ; jeśli liczba była równa zero (fałsz), to musi być zwrócony pusty łańcuch przez zmianę długości łańcucha na stosie kalkulatora na zero. PUSH DE ; zachowaj wskaźnik do już zbędnej liczby (który stanie się nowym STKEND) DEC DE ; wskaż piąty bajt deskryptora łańcucha. XOR A ; wyczyść akumulator. LD (DE),A ; umieść zero w starszym bajcie długości. DEC DE ; zaadresuj młodszy bajt długości. LD (DE),A ; umieść tam zero - teraz łańcuch będzie pusty. POP DE ; odtwórz wskaźnik - nowe STKEND. RET ; ------------------------------------- ; Wykonaj porównanie ($09-$0E, $11-$16) ; ------------------------------------- ; Operacje dwuargumentowe. ; Ta procedura używana jest do wykonania dwunastu możliwych operacji porównań. Na wejściu rejestr B zawiera literał operacji porównania. ; $1B03 : 6915 NO_L_EQL: LD A,B ; przenieś literał do akumulatora SUB $08 ; teraz zakres jest od 01-06 lub 09-0E BIT 2,A ; wyodrębnij ">', '<', '='. JR NZ,EX_OR_NOT ; z tymi operatorami przeskocz do EX-OR-NOT. DEC A ; inaczej zmień na $00-$02, $08-$0A, 0C-0E, aby zgadzały się bity 0-2. ; $1B0B : 6923 EX_OR_NOT: RRCA ; pierwsze RRCA ustawia przeniesienie dla wymiany. JR NC,NU_OR_STR ; naprzód do NU-OR-STR w ośmiu pozostałych przypadkach ; dla 4 innych przypadków dwie wartości na stosie kalkulatora są zamieniane miejscami. PUSH AF ; zachowaj A i przeniesienie. PUSH HL ; zachowaj HL - wskaźnik do pierwszego argumentu. (DE wskazuje na drugi argument). CALL EXCHANGE ; procedura zamienia te dwie wartości. (HL = drugi argument, DE = STKEND) POP DE ; DE = pierwszy argument EX DE,HL ; jak było wcześniej. POP AF ; odtwórz A i przeniesienie. ; Uwaga, byłoby lepiej, jeśli drugie RRCA poprzedzałoby test łańcuchowy. Zachowałoby to dwa zdublowane bajty i jeślibyśmy również pozbyli się ; tego SUB 8 na początku, nie musielibyśmy zamieniać miejscami testowanych bitów. ; $1B16 : 6934 NU_OR_STR: BIT 2,A ; test na porównanie łańcuchowe. JR NZ,STRINGS ; jeśli tak, naprzód do STRINGS. ; kontynuuj z porównaniami liczbowymi. RRCA ; drugie RRCA powoduje ustawienie przeniesienia przez eql/neql. PUSH AF ; zachowaj A i przeniesienie. CALL SUBTRACT ; procedura odejmowania pozostawia wynik na stosie. JR END_TESTS ; naprzód do END-TESTS ; $1B21 : 6945 STRINGS: RRCA ; drugie RRCA powoduje ustawienie przeniesienia przez eql/neql. PUSH AF ; zachowaj A i przeniesienie. CALL STK_FETCH ; procedura STK-FETCH pobiera parametry drugiego łańcucha PUSH DE ; zachowaj początek drugiego łańcucha. PUSH BC ; oraz jego długość. CALL STK_FETCH ; procedura STK-FETCH pobiera parametry pierwszego łańcucha początek w DE, długość w BC. POP HL ; odtwórz długość drugiego łańcucha w HL. ; Teraz następuje wejście do pętli w celu porównania przez odejmowanie kolejnych znaków w obu łańcuchach. Jeśli znaki są zgodne, wskaźniki ; zostają zwiększone o 1, a długość zmniejsza się o 1 i wykonywany jest skok względny do tego miejsca. Jeśli oba łańcuchy zostaną przeglądnięte ; i będą one zgodne, to są równe. ; $1B2C : 6956 BYTE_COMP: LD A,H ; testuj, czy drugi łańcuch jest pusty OR L EX (SP),HL ; umieść długość 2 na stosie, a początek 2 w HL. LD A,B ; starszy bajt długości do A JR NZ,SEC_PLUS ; jeśli drugi łańcuch nie jest pusty, naprzód do SEC-PLUS. OR C ; testuj długość pierwszego łańcucha. ; $1B33 : 6963 SECND_LOW: POP BC ; pobierz długość drugiego ze stosu. JR Z,BOTH_NULL ; naprzód do BOTH-NULL, jeśli pierwszy łańcuch jest również pusty. ; warunek prawdy - pierwszy łańcuch jest dłuższy od drugiego (SECND-LESS) POP AF ; odtwórz przeniesienie (ustawione, gdy eql/neql) CCF ; Zaneguj znacznik przeniesienia. ; Uwaga. Równość staje się fałszywa. Nierówność jest prawdziwa. Poprzez zamianę lub zastosowanie końcowego NOT, ; wszystkie porównania zostały przetworzone, jest to zatem ścieżka sukcesu. JR STR_TEST ; wyjdź poprzez STR-TEST ; Skok następuje tutaj przy zgodności ; $1B3A : 6970 BOTH_NULL: POP AF ; odtwórz przeniesienie - ustawione dla eql/neql JR STR_TEST ; naprzód do STR-TEST ; skok tutaj jest wtedy, gdy drugi łańcuch nie jest pusty, a młodszy bajt pierwszego musi zostać przetestowany. ; $1B3D : 6973 SEC_PLUS: OR C ; sprawdź długość pierwszego łańcucha. JR Z,FRST_LESS ; jeśli długość wynosi zero, skocz naprzód do FRST-LESS. ; w obu łańcuchach pozostało przynajmniej po jednym znaku. LD A,(DE) ; pobierz znak z pierwszego łańcucha. SUB (HL) ; odejmij od niego znak z drugiego łańcucha. JR C,FRST_LESS ; jeśli ustawione przeniesienie, naprzód do FRST-LESS JR NZ,SECND_LOW ; wstecz do SECND-LOW a następnie do STR-TEST, jeśli brak zgodności DEC BC ; zmniejsz długość pierwszego łańcucha. INC DE ; zwiększ wskaźnik pierwszego łańcucha. INC HL ; zwiększ wskaźnik drugiego łańcucha. EX (SP),HL ; zamień go z długością na stosie DEC HL ; zmniejsz długość drugiego łańcucha JR BYTE_COMP ; wstecz do BYTE-COMP ; fałszywy warunek. ; $1B4D : 6989 FRST_LESS: POP BC ; usuń długość POP AF ; pobierz A AND A ; wyzeruj przeniesienie dla wyniku false. ; zgodność oraz x$>y$ spotykają się tutaj ; $1B50 : 6992 STR_TEST: PUSH AF ; dla testów łańcuchowych na stosie kalkulatora umieszczane jest zero RST 28H ; KALKULATOR .BYTE $A0 ; zero-na-stos .BYTE $34 ; koniec-obliczeń ; ścieżka numeryczna i łańcuchowa schodzą się tutaj. ; $1B54 : 6996 END_TESTS: POP AF ; te trzy testy, wywoływane wg konieczności PUSH AF ; dają poprawny wynik dla wszystkich dwunastu porównań. Wstępne przeniesienie jest ustawiane dla '<>' i '=', CALL C,NOT_LOGIC ; a końcowe przeniesienie jest ustawiane dla '>', '<' i '='. CALL GREATER_0 POP AF ; odtwórz literał RRCA ; trzecie RRCA - test na '<=', ">=' lub '<>'. CALL NC,NOT_LOGIC ; jeśli tak, zastosuj końcowe NOT. RET ; ----------------------- ; Łączenie łańcuchów($17) ; ----------------------- ; Ten literał łączy dwa łańcuchy w jeden, np. LET A$ = B$ + C$. Parametry dwóch łańcuchów do złączenia są na stosie. ; $1B62 : 7010 STRS_ADD: CALL STK_FETCH ; procedura STK-FETCH pobiera parametry pierwszego łańcucha i usuwa je ze stosu kalkulatora. PUSH DE ; zachowaj adres startu. PUSH BC ; i długość. CALL STK_FETCH ; procedura STK-FETCH dla drugiego łańcucha POP HL ; ponownie pobierz pierwszą długość PUSH HL ; i zachowaj ponownie na stosie PUSH DE ; zachowaj początek drugiego łańcucha PUSH BC ; i jego długość. ADD HL,BC ; dodaj obie długości. LD B,H ; przenieś do BC LD C,L ; i stwórz RST 30H ; BC-miejsc w obszarze roboczym. DE wskazuje na start tego obszaru. CALL STK_STO ; procedura STK-STO-$ umieszcza parametry nowego łańcucha na stosie, uaktualniając STKEND. POP BC ; długość pierwszego POP HL ; adres początku LD A,B ; test na zerową długość OR C JR Z,OTHER_STR ; jeśli zerowa długość, idź do OTHER-STR LDIR ; skopiuj łańcuch do przestrzeni roboczej. ; $1B7D : 7037 OTHER_STR: POP BC ; teraz druga długość POP HL ; i początek łańcucha LD A,B ; test na zerową długość OR C JR Z,STK_PNTRS ; przeskocz naprzód do STK-PNTRS, jeśli długość zerowa. LDIR ; inaczej kopiuj bajty i kontynuuj w następnej procedurze, która ustawia wskaźniki stosu kalkulatora. ; --------------------------- ; Wskaźniki stosu kalkulatora ; --------------------------- ; Rejestr DE jest ustawiony na STKEND a HL, wskaźnik wyniku, jest ustawiony na 5 komórek poniżej. Procedura jest używana, gdy zapis tych ; wartości jest niewygodny w czasie używania stosu kalkulatora podczas innych operacji na stosie maszynowym. Procedura jest również wykorzystywana ; do zakończenia procedury VAL z tego samego powodu i do inicjowania stosu kalkulatora na początku procedury CALCULATE. ; $1B85 : 7045 STK_PNTRS: LD HL,(STKEND) ; pobierz wartość STKEND ze zmiennej systemowej. LD DE,$FFFB ; wartość -5 PUSH HL ; zachowaj wartość STKEND. ADD HL,DE ; odejmij 5 od HL. POP DE ; pobierz STKEND do DE. RET ; ----------------- ; Obsługa CHR$ (2B) ; ----------------- ; Funkcja zwraca jednoznakowy łańcuch, który jest wynikiem zamiany liczby z zakresu 0-255 na łańcuch, np. CHR$ 38 = "A". ; Uwaga. ZX81 nie posiada zestawu znaków ASCII. ; $1B8F : 7055 CHRS: CALL FP_TO_A ; procedura FP-TO-A umieszcza tę liczbę w A. JR C,REPORT_BD ; jeśli nadmiar, naprzód do REPORT-BD JR NZ,REPORT_BD ; jeśli ujemna, naprzód do REPORT-BD PUSH AF ; zachowaj argument. LD BC,$0001 ; potrzebne jedno miejsce. RST 30H ; BC-MIEJSC ustawia DE na początek obszaru POP AF ; odtwórz liczbę ze stosu. LD (DE),A ; i umieść ją w obszarze roboczym. CALL STK_STO ; procedura STK-STO-$ umieszcza na stosie deskryptor. EX DE,HL ; ustaw HL na wskazywanie wyniku a DE na STKEND. RET ; $1BA2 : 7074 REPORT_BD: RST 08H ; ERROR-1 .BYTE $0A ; Raport Błędu: Liczba całkowita poza zakresem ; ----------------- ; Obsługa VAL ($1A) ; ----------------- ; VAL traktuje znaki w łańcuchu jak wyrażenie liczbowe. ; np. VAL "2.3" = 2.3; VAL "2+4" = 6, VAL ("2" + "4") = 24. ; $1BA4 : 7076 VAL: LD HL,(CH_ADD) ; pobierz wartość zmiennej systemowej CH_ADD PUSH HL ; i zapisz ją na stosie maszynowym. CALL STK_FETCH ; procedura STK-FETCH pobiera argument łańcuchowy ze stosu kalkulatora. PUSH DE ; zachowaj adres początku łańcucha. INC BC ; zwiększ długość na znak nowego wiersza. RST 30H ; BC-MIEJSC tworzy miejsce w obszarze roboczym. POP HL ; odtwórz początek łańcucha w HL. LD (CH_ADD),DE ; załaduj CH_ADD początkiem DE w obszarze roboczym. PUSH DE ; zachowaj początek w obszarze roboczym LDIR ; skopiuj łańcuch z programu, zmiennych lub obszaru roboczego do zarezerwowanego miejsca. EX DE,HL ; do HL koniec łańcucha + 1 DEC HL ; zmniejsz HL, aby wskazywało na koniec nowego obszaru. LD (HL),$76 ; wstaw na końcu znak końca wiersza - ZX81 nie używa kodu ASCII. RES 7,(IY+$01) ; uaktualnij FLAGS - sygnalizuj sprawdzanie składni. CALL CLASS_6 ; procedura CLASS-06 - sprawdza składnię wyrażenia. CALL CHECK_2 ; procedura CHECK-2 sprawdza osiągnięcie końca wiersza. POP HL ; odtwórz początek łańcucha w obszarze roboczym. LD (CH_ADD),HL ; ustaw ponownie CH_ADD na początek łańcucha. SET 7,(IY+$01) ; uaktualnij FLAGS - sygnalizuj wykonywanie programu. CALL SCANNING ; procedura SCANNING oblicza w całości wyrażenie w łańcuchu, pozostawiając wynik na stosie kalkulatora. POP HL ; odtwórz oryginalną wartość CH_ADD. LD (CH_ADD),HL JR STK_PNTRS ; wyjdź poprzez STK-PNTRS, co resetuje wskaźniki stosu kalkulatora. ; ----------------- ; Obsługa STR$ (2A) ; ----------------- ; Ta funkcja zwraca reprezentację łańcuchową argumentu liczbowego. Użyta metoda polega na oszukaniu procedury PRINT-FP, tak aby sądziła ; ona, że zapisuje do ściśniętego bufora wideo, gdy w rzeczywistości zapisuje do obszaru roboczego łańcucha. ; Jeśli na pozycji druku znajduje się znak newline a liczba kolumn nie została zredukowana do zera, to procedura wydruku zakłada, że w systemie ; jest tylko 1KB pamięci RAM i pamięć ekranu, jak i reszta pamięci dynamicznej, rozszerza się według potrzeb za pomocą wywołań do procedury ; ONE-SPACE. Ekran jest odzwierciedlony znakowo, nie bitowo. ; $1BD5 : 7125 STR: LD BC,$0001 ; utwórz początkowy bajt w obszarze roboczym RST 30H ; wykorzystując procedurę BC-SPACES. LD (HL),$76 ; umieść tam znak końca wiersza. LD HL,(S_POSN) ; pobierz wartość S_POSN - kolumna i wiersz PUSH HL ; zachowaj je na stosie. LD L,$FF ; ustaw wartość kolumny na 255, co da wymyślony bufor o długości 254 znaków LD (S_POSN),HL ; i zapisz go w zmiennej systemowej S_POSN. LD HL,(DF_CC) ; pobierz wartość DF_CC PUSH HL ; i również zachowaj na stosie. LD (DF_CC),DE ; teraz wstaw adres początku obszaru roboczego do DF_CC, które zwykle wskazuje adres gdzieś wewnątrz bufora ekranu. PUSH DE ; zachowaj adres nowego łańcucha. CALL PRINT_FP ; wydrukuj wartość argumentu w obszarze roboczym. POP DE ; odtwórz początek łańcucha. LD HL,(DF_CC) ; pobierz adres końca łańcucha z DF_CC. AND A ; przygotuj się do odejmowania. SBC HL,DE ; odejmij, aby otrzymać długość. LD B,H ; i przenieś ją do BC LD C,L ; register. POP HL ; odtwórz pierwotną wartość DF_CC LD (DF_CC),HL POP HL ; odtwórz pierwotne wartości S_POSN LD (S_POSN),HL CALL STK_STO ; procedura STK-STO-$ umieszcza deskryptor łańcucha na stosie kalkulatora. EX DE,HL ; HL = ostatnia wartość, DE = STKEND. RET ; -------------- ; FUNKCJA 'CODE' ; -------------- ; (offset $19: 'code') ; Zwraca kod znaku lub kod pierwszego znaku w łańcuchu. Np. CODE "AARDVARK" = 38 (nie 65, ponieważ ZX81 nie stosuje kodu ASCII). ; $1C06 : 7174 CODE: CALL STK_FETCH ; procedura STK-FETCH pobiera parametry łańcucha i usuwa je ze stosu kalkulatora. ; DE wskazuje na początek, BC zawiera długość. LD A,B ; test na długość łańcucha OR C JR Z,STK_CODE ; jeśli pusty łańcuch, przeskocz do STK-CODE z zerem. LD A,(DE) ; inaczej pobierz pierwszy znak. ; $1C0E : 7182 STK_CODE: JP STACK_A ; skocz wstecz do STACK-A (z testem pamięci) ; ---------------- ; PODPROGRAM 'LEN' ; ---------------- ; (offset $1b: 'len') ; Zwraca długość łańcucha. W BASICu firmy Sinclair łańcuchy mogą posiadać długość przekraczającą 20.000 znaków, więc do przechowania długości ; wymagany jest rejestr szesnastobitowy. ; $1C11 : 7185 LEN: CALL STK_FETCH ; procedura STK-FETCH pobiera parametry łańcucha i usuwa je ze stosu kalkulatora. ; para rejestrów BC zawiera teraz długość łańcucha. JP STACK_BC ; skocz wstecz do STACK-BC, aby umieścić wynik na stosie kalkulatora (z testem pamięci). ; ----------------------------- ; PODPROGRAM 'ZMNIEJSZ LICZNIK' ; ----------------------------- ; (offset $31: 'dec-jr-nz') ; Kalkulator posiada instrukcję, która zmniejsza jednobajtowy pseudorejestr i wykonuje wynikłe z tego skoki względne w identyczny sposób, ; jak instrukcja DJNZ mikroprocesora Z80. ; $1C17 : 7191 DEC_JR_NZ: EXX ; przełącz na zestaw adresujący kod PUSH HL ; zachowaj wskaźnik do bajtu z przesunięciem LD HL,BREG ; zaadresuj BREG w zmiennych systemowych DEC (HL) ; zmniejsz go POP HL ; odtwórz wskaźnik JR NZ,JUMP_2 ; jeśli nie było zera, skocz do JUMP-2 INC HL ; idź poza bajt z długością skoku. EXX ; wróć do głównego zestawu rejestrów RET ; ----------------- ; PODPROGRAM 'SKOCZ' ; ----------------- ; (Offset $2F; 'jump') ; Procedura umożliwia kalkulatorowi wykonywanie skoków względnych, podobnych do instrukcji JR obecnej w zestawie poleceń mikroprocesora Z80. ; $1C23 : 7203 JUMP: EXX ; przełącz na zestaw wskazujący ; $1C24 : 7204 JUMP_2: LD E,(HL) ; bajt skoku 0-127 naprzód, 128-255 wstecz. XOR A ; wyczyść akumulator. BIT 7,E ; sprawdź, czy skok wstecz JR Z,JUMP_3 ; jeśli dodatni, przeskocz do JUMP-3. CPL ; inaczej zmień na przeciwny. ; $1C2B : 7211 JUMP_3: LD D,A ; przenieś do starszego bajtu. ADD HL,DE ; przesuń wskaźnik kalkulatora naprzód lub wstecz. EXX ; wyjdź z zestawu wskaźnikowego. RET ; -------------------------------- ; PODPROGRAM 'SKOCZ PRZY PRAWDZIE' ; -------------------------------- ; (Offset $00; 'jump-true') ; Procedura pozwala kalkulatorowi wykonywać warunkowe skoki względne zależne od wyniku ostatniego testu. W ZX81 wykładnik będzie równy 0 dla zera ; lub $81 dla wyniku jeden. ; $1C2F : 7215 JUMP_TRUE: LD A,(DE) ; pobierz bajt wykładnika AND A ; wynik 0 czy 1 ? JR NZ,JUMP ; jeśli 1, wstecz do JUMP. EXX ; inaczej przełącz na zestaw wskaźnikowy. INC HL ; przejdź ponad bajtem z długością skoku. EXX ; wróć do głównego zestawu rejestrów. RET ; ------------------- ; PODPROGRAM 'MODULO' ; ------------------- ; ( Offset $2E: 'n-mod-m' ) ; ( i1, i2 -- i3, i4 ) ; Ten podprogram oblicza wartość N mod M, gdzie M jest liczbą naturalną, ostatnią wartością na stosie kalkulatora, a N jest liczbą naturalną ; leżącą poniżej. Procedura zwraca wynik dzielenia jako ostatnią wartość oraz leżącą pod nią resztę z dzielenia. ; Np. 17 MOD 3 = 5 i reszta 2 ; Podprogram jest wywoływany podczas obliczania liczby pseudolosowej oraz również przez procedurę PRINT-FP. ; $1C37 : 7223 N_MOD_M: RST 28H ; KALKULATOR 17, 3. .BYTE $C0 ; stos-do-pamięci-0 17, 3. .BYTE $02 ; usuń 17. .BYTE $2D ; duplikuj 17, 17. .BYTE $E0 ; pobierz-pamięć-0 17, 17, 3. .BYTE $05 ; dziel 17, 17/3. .BYTE $24 ; zamień-na-całkowitą 17, 5. .BYTE $E0 ; pobierz-pamięć-0 17, 5, 3. .BYTE $01 ; zamień 17, 3, 5. .BYTE $C0 ; stos-do-pamięci-0 17, 3, 5. .BYTE $04 ; mnóż 17, 15. .BYTE $03 ; odejmij 2. .BYTE $E0 ; pobierz-pamięć-0 2, 5. .BYTE $34 ; koniec-obliczeń 2, 5. RET ; -------------------------- ; FUNKCJA 'LICZBA CAŁKOWITA' ; -------------------------- ; (offset $24: 'int') ; Funkcja ta zwraca część całkowitą z x, która dla liczb dodatnich jest taka sama jak dla zaokrąglania. Literał zaokrąglij ; obcina liczby ujemne w górę, zatem -3.4 daje wynik -3, natomiast funkcja INT w języku BASIC musi zaokrąglać liczby ujemne w dół, aby otrzymać ; INT -3.4 równe -4. Najlepiej przejść przez polecenia, używając jako przykładowych wartości liczb 3.4 i -3.4 ; $1C46 : 7238 INT: RST 28H ; KALKULATOR x. (= 3.4 lub -3.4). .BYTE $2D ; duplikuj x, x. .BYTE $32 ; mniej-niż-0 x, (1/0) .BYTE $00 ; skocz-przy-prawdzie x, (1/0) .BYTE $04 ; do L1C46, X-NEG .BYTE $36 ; zaokrąglij trunc 3.4 = 3. .BYTE $34 ; koniec-obliczeń 3. RET ; wróć z wynikiem INT x na stosie kalkulatora. ; $1C4E : 7246 X_NEG: .BYTE $2D ; duplikuj -3.4, -3.4. .BYTE $36 ; zaokrąglij -3.4, -3. .BYTE $C0 ; stos-do-pamięci-0 -3.4, -3. .BYTE $03 ; odejmij -.4 .BYTE $E0 ; na-stos-paimięć-0 -.4, -3. .BYTE $01 ; zamień -3, -.4. .BYTE $2C ; neguj-logicznie -3, (0). .BYTE $00 ; skocz-przy-prawdzie -3. .BYTE $03 ; do $1C59, EXIT -3. .BYTE $A1 ; jeden-na-stos -3, 1. .BYTE $03 ; odejmij -4. ; $1C59 : 7257 EXIT: .BYTE $34 ; koniec-obliczeń -4. RET ; ---------------- ; Potęgowanie (23) ; ---------------- ; $1C5B : 7259 EXP: RST 28H ; KALKULATOR .BYTE $30 ; dane-na-stos .BYTE $F1 ; Wykładnik: $81, Bajty: 4 .BYTE $38,$AA,$3B,$29 .BYTE $04 ; mnóż .BYTE $2D ; duplikuj .BYTE $24 ; na-liczbę-całkowitą .BYTE $C3 ; stos-do-pamięci-3 .BYTE $03 ; odejmij .BYTE $2D ; duplikuj .BYTE $0F ; dodaj .BYTE $A1 ; jeden-na-stos .BYTE $03 ; odejmij .BYTE $88 ; serie-08 .BYTE $13 ; Wykładnik: $63, Bajty: 1 .BYTE $36 ;(+00,+00,+00) .BYTE $58 ; Wykładnik: $68, Bajty: 2 .BYTE $65,$66 ;(+00,+00) .BYTE $9D ; Wykładnik: $6D, Bajty: 3 .BYTE $78,$65,$40 ;(+00) .BYTE $A2 ; Wykładnik: $72, Bajty: 3 .BYTE $60,$32,$C9 ;(+00) .BYTE $E7 ; Wykładnik: $77, Bajty: 4 .BYTE $21,$F7,$AF,$24 .BYTE $EB ; Wykładnik: $7B, Bajty: 4 .BYTE $2F,$B0,$B0,$14 .BYTE $EE ; Wykładnik: $7E, Bajty: 4 .BYTE $7E,$BB,$94,$58 .BYTE $F1 ; Wykładnik: $81, Bajty: 4 .BYTE $3A,$7E,$F8,$CF .BYTE $E3 ; na-stos-paimięć-3 .BYTE $34 ; koniec-obliczeń CALL FP_TO_A JR NZ,N_NEGTV JR C,REPORT_6B ADD A,(HL) JR NC,RESULT_OK ; $1C99 : 7321 REPORT_6B: RST 08H ; ERROR-1 .BYTE $05 ; Raport Błędu: Liczba zbyt duża ; $1C9B : 7323 N_NEGTV: JR C,RSLT_ZERO SUB (HL) JR NC,RSLT_ZERO NEG ; $1CA2 : 7330 RESULT_OK: LD (HL),A RET ; $1CA4 : 7332 RSLT_ZERO: RST 28H ; KALKULATOR .BYTE $02 ; usuń .BYTE $A0 ; na-stos-zero .BYTE $34 ; koniec-obliczeń RET ; ---------------------------- ; FUNKCJA 'LOGARYTM NATURALNY' ; ---------------------------- ; (offset $22: 'ln') ; Jak sam ZX81, logarytmy 'naturalne' pochodzą ze Szkocji. Zostały wymyślone w 1614 roku przez obytego w podróżach Szkota o nazwisku John Napier, ; który zapisał "Nic nie jest bardziej dokuczliwe i utrudniające w obliczeniach od mnożeń, dzieleń, kwadratów i sześcianów dużych liczb". ; Logarytmy Napiera umożliwiły wykonywanie powyższych operacji przez proste dodawanie i odejmowanie, ułatwiając obliczenia nawigacyjne i astronomiczne, ; które dręczyły jego erę. Logarytmy naturalne zostały szybko zastąpione logarytmami przy podstawie 10, które wraz z Napierem wynalazł Henry Briggs, ; wyuczony w Cambridge profesor geometrii na Uniwersytecie Oksfordzkim. Uprościły one układanie tablic, które pozwalały ludziom łatwo skalować ; obliczenia. ; Dopiero niedawno, wraz z pojawieniem się kalkulatorów kieszonkowych i komputerów takich jak ZX81, logarytmy naturalne odzyskały swoją pozycję, ; chociaż niektóre komputery wciąż zachowują logarytmy dziesiętne. Logarytmy naturalne są potęgami podstawy 'e', która, podobnie jak liczba pi, ; w sposób naturalny pojawia się w różnych dziedzinach matematyki. Również jak 'pi' liczba 'e' jest niewymierna i zaczyna się jako 2.718281828... ; Tabelaryczne używanie logarytmów polegało na tym, iż aby pomnożyć przez siebie dwie liczby a i b, należało znaleźć ich logarytmy, następnie ; znalezione logarytmy dodać i otrzymaną sumę odszukać w tablicy antylogarytmów, w której dostawaliśmy pożądany iloczyn. ; Funkcja EXP jest odpowiednikiem antylogarytmu w języku BASIC. Biorąc dwie dowolne liczby, powiedzmy 1.72 i 6.89, uruchom poniższy program: ; 10 PRINT EXP ( LN 1.72 + LN 6.89 ) ; dostaniesz taki sam wynik jak: ; 20 PRINT 1.72 * 6.89. ; Dzielenie wykonuje się za pomocą odejmowania dwóch logarytmów. ; Napier wspominał również o rachunkach związanych z kwadratowymi i sześciennymi potęgami oraz pierwiastkami. Aby podnieść pewną liczbę do 3 potęgi, ; znajdź jej logarytm naturalny, pomnóż go przez 3 i znajdź antylogarytm wyniku, np. ; PRINT EXP( LN 4 * 3 ) ; daje 64. ; Podobnie, aby znaleźć n-ty pierwiastek podziel logarytm przez 'n'. ROM komputera ZX81 wykorzystuje następujący wzór do wyszukiwania wartości ; pierwiastków kwadratowych (tutaj pierwiastka z liczby 9): ; PRINT EXP ( LN 9 / 2 ) ; Funkcja Napiera dotycząca pierwiastka kwadratowego jest jedynie specjalnym przypadkiem funkcji 'potęgowej'. Pierwiastek sześcienny lub ; dowolny inny liczy się równie prosto. ; Najpierw sprawdzane jest, czy argument LN jest liczbą większą od zera. ; $1CA9 : 7337 LN: RST 28H ; KALKULATOR x. .BYTE $2D ; duplikuj x,x. .BYTE $33 ; większe-niż-0 x,(0/1). .BYTE $00 ; skocz-przy-prawdzie x. .BYTE $04 ; do L1CB1, VALID .BYTE $34 ; koniec-obliczeń ; $1CAF : 7343 REPORT_AB: RST 08H ; ERROR-1 .BYTE $09 ; Raport Błędu: zły argument ; $1CB1 : 7345 VALID: .BYTE $A0 ; na-stos-zero x,0. - usunięte ze stosu 1 zostaje nadpisane zerem .BYTE $02 ; usuń x. - operacja jest zbędna .BYTE $34 ; koniec-obliczeń LD A,(HL) ; pobierz wykładnik e LD (HL),$80 ; zredukuj x do mantysy - x' CALL STACK_A ; stos zawiera teraz x',e. RST 28H ; KALKULATOR x',e. .BYTE $30 ; dane-na-stos x',e,128. .BYTE $38 ; Wykładnik: $88, Bajty: 1 .BYTE $00 ;(+00,+00,+00) .BYTE $03 ; odejmij x',e-128. - zredukuj do prawdziwego wykładnika .BYTE $01 ; zamień e',x'. .BYTE $2D ; duplikuj e',x',x'. .BYTE $30 ; dane-na-stos e',x',x',0.8. .BYTE $F0 ; Wykładnik: $80, Bajty: 4 .BYTE $4C,$CC,$CC,$CD ; .BYTE $03 ; odejmij e',x',x'-0.8. .BYTE $33 ; większe-niż-0 e',x'(0/1). .BYTE $00 ; skocz-przy-prawdzie e',x'. .BYTE $08 ; do L1CD2, GRE_8 .BYTE $01 ; zamień x',e'. .BYTE $A1 ; jeden-na-stos x',e',1. .BYTE $03 ; odejmij x',e'-1. .BYTE $01 ; zamień e'-1,x'. .BYTE $34 ; koniec-obliczeń INC (HL) ; powiększ x' dwa razy e'-1,2x'. RST 28H ; KALKULATOR e'-1,2x'. ; $1CD2 : 7378 (x' <= 0.8) (x' > 0.8) - tutaj zbiegają się obie wersje GRE_8: .BYTE $01 ; zamień 2x',e'-1. | x',e'. .BYTE $30 ; dane-na-stos 2x',e'-1,LN 2. | x',e',LN 2. .BYTE $F0 ; Wykładnik: $80, Bajty: 4 .BYTE $31,$72,$17,$F8 ; .BYTE $04 ; mnóż 2x',(e'-1)LN 2. | x',e'LN 2. .BYTE $01 ; zamień (e'-1)LN 2,2x'. | e'LN 2,x'. .BYTE $A2 ; na-stos-1/2 (e'-1)LN 2,2x',0.5. | e'LN 2,x',0.5. .BYTE $03 ; odejmij-1/2 (e'-1)LN 2,2x'-0.5. | e'LN 2,x'-0.5. .BYTE $A2 ; na-stos-1/2 (e'-1)LN 2,2x'-0.5,0.5. | e'LN 2,x'-0.5,0.5. .BYTE $03 ; odejmij (e'-1)LN 2,2x'-1. | e'LN 2,x'-1. .BYTE $2D ; duplikuj (e'-1)LN 2,2x'-1,2x'-1. | e'LN 2,x'-1,x'-1. .BYTE $30 ; dane-na-stos (e'-1)LN 2,2x'-1,2x'-1,2.5. | e'LN 2,x'-1,x'-1,2.5. .BYTE $32 ; Wykładnik: $82, Bajty: 1 .BYTE $20 ;(+00,+00,+00) .BYTE $04 ; mnóż (e'-1)LN 2,2x'-1,5x'-2.5. | e'LN 2,x'-1,2.5x'-2.5. .BYTE $A2 ; na-stos-1/2 (e'-1)LN 2,2x'-1,5x'-2.5,0.5. | e'LN 2,x'-1,2.5x'-2.5,0.5. .BYTE $03 ; odejmij (e'-1)LN 2,2x'-1,5x'-3. | e'LN 2,x'-1,2.5x'-3. .BYTE $8C ; serie-0C uruchom generator szeregów .BYTE $11 ; Wykładnik: $61, Bajty: 1 .BYTE $AC ;(+00,+00,+00) .BYTE $14 ; Wykładnik: $64, Bajty: 1 .BYTE $09 ;(+00,+00,+00) .BYTE $56 ; Wykładnik: $66, Bajty: 2 .BYTE $DA,$A5 ;(+00,+00) .BYTE $59 ; Wykładnik: $69, Bajty: 2 .BYTE $30,$C5 ;(+00,+00) .BYTE $5C ; Wykładnik: $6C, Bajty: 2 .BYTE $90,$AA ;(+00,+00) .BYTE $9E ; Wykładnik: $6E, Bajty: 3 .BYTE $70,$6F,$61 ;(+00) .BYTE $A1 ; Wykładnik: $71, Bajty: 3 .BYTE $CB,$DA,$96 ;(+00) .BYTE $A4 ; Wykładnik: $74, Bajty: 3 .BYTE $31,$9F,$B4 ;(+00) .BYTE $E7 ; Wykładnik: $77, Bajty: 4 .BYTE $A0,$FE,$5C,$FC ; .BYTE $EA ; Wykładnik: $7A, Bajty: 4 .BYTE $1B,$43,$CA,$36 ; .BYTE $ED ; Wykładnik: $7D, Bajty: 4 .BYTE $A7,$9C,$7E,$5E ; .BYTE $F0 ; Wykładnik: $80, Bajty: 4 .BYTE $6E,$23,$80,$93 ; .BYTE $04 ; mnóż .BYTE $0F ; dodaj .BYTE $34 ; koniec-obliczeń RET ; -------------------------- ; FUNKCJE 'TRYGONOMETRYCZNE' ; -------------------------- ; Trygonometria to technika kosmiczna. Używali jej również stolarze i budowniczowie piramid. Niektóre zastosowania trygonometrii mogą być ; zupełnie abstrakcyjne, lecz jej zasady można zaobserwować w prostych trójkątach prostokątnych. Trójkąty posiadają kilka specjalnych własności: ; 1) Suma wszystkich trzech kątów wynosi zawsze PI radianów (180 stopni). Bardzo pomocne, gdy znasz dwa kąty i chcesz znaleźć trzeci. ; 2) W każdym trójkącie prostokątnym suma kwadratów przyprostokątnych jest równa kwadratowi przeciwprostokątnej. Bardzo pomocne, gdy znasz ; długości dwóch boków trójkąta prostokątnego i chcesz znaleźć długość boku trzeciego. ; 3) Funkcje sinus, cosinus i tangens umożliwiają wyliczenie nieznanej długości boku, jeśli znamy długość innego boku oraz kąt pomiędzy ; przyprostokątną a przeciwprostokątną. ; 4) Funkcje arcus sinus, arcus cosinus i arcus tangens pozwalają wyliczyć nieznany kąt, jeśli są znane długości dwóch boków. ; ----------------------------- ; PROCEDURA 'ZREDUKUJ ARGUMENT' ; ----------------------------- ; (offset $35: 'get-argt') ; Ta funkcja wykonuje dwie funkcje na kącie wyrażonym w radianach, które przygotowują go jako argument dla funkcji sinus i cosinus. ; Najpierw upewnia się, czy kąt redukuje się do normalnego zakresu. Np. jeśli statek zawraca o kąt, powiedzmy, 3PI radianów (540 stopni), ; to efektywny obrót wyniesie PI radianów (180 stopni). ; Następnie zamienia kąt w radianach na ułamek kąta prostego w zależności od tego, w której ćwiartce układu współrzędnych leży ten kąt. ; wynikiem jest liczba z zakresu od -1 do 1. ; 90 stopni ; (pi/2) ; II +1 I ; | ; sin+ |\ | /| sin+ ; cos- | \ | / | cos+ ; tan- | \ | / | tan+ ; | \|/) | ; 180 stopni (pi) 0 -|----+----|-- 0 (0) 0 stopni ; | /|\ | ; sin- | / | \ | sin- ; cos- | / | \ | cos+ ; tan+ |/ | \| tan- ; | ; III -1 IV ; (3pi/2) ; 270 stopni ; $1D18 : 7448 GET_ARGT: RST 28H ; KALKULATOR x. .BYTE $30 ; dane-na-stos .BYTE $EE ; Wykładnik: $7E, Bajty: 4 .BYTE $22,$F9,$83,$6E ; x, 1/(2*PI). .BYTE $04 ; mnóż x/(2*PI). .BYTE $2D ; duplikuj x/(2*PI),x/(2*PI). .BYTE $A2 ; na-stos-1/2 x/(2*PI),x/(2*PI),0.5. .BYTE $0F ; dodaj x/(2*PI),x/(2*PI)+0.5. .BYTE $24 ; na-liczbę-całkowitą x/(2*PI),x/INT((2*PI)+0.5). .BYTE $03 ; odejmij x/(2*PI)-x/INT((2*PI)+0.5) = y .BYTE $2D ; duplikuj y,y. .BYTE $0F ; dodaj 2y. .BYTE $2D ; duplikuj 2y,2y. .BYTE $0F ; dodaj 4y. .BYTE $2D ; duplikuj 4y,4y. .BYTE $27 ; wartość-bezwzględna 4y,ABS(4y). .BYTE $A1 ; jeden-na-stos 4y,ABS(4y),1. .BYTE $03 ; odejmij 4y,ABS(4y)-1 = z .BYTE $2D ; duplikuj 4y,z,z. .BYTE $33 ; większe-niż-0 4y,z,(0/1). .BYTE $C0 ; stos-do-pamięci-0 mem-0 zawiera wynik testu .BYTE $00 ; skocz-przy-prawdzie 4y,z .BYTE $04 ; do L1D35, ZPLUS .BYTE $02 ; usuń 4y. .BYTE $34 ; koniec-obliczeń 4y. RET ; Jeśli skok nastąpił do tego miejsca, kontynuuj. ; $1D35 : 7477 ZPLUS: .BYTE $A1 ; jeden-na-stos 4y,z,1. .BYTE $03 ; odejmij 4y,z-1. .BYTE $01 ; zamień z-1,4y. .BYTE $32 ; mniej-niż-0 z-1,(1/0). .BYTE $00 ; skocz-przy-prawdzie z-1. .BYTE $02 ; do $1D3C, YNEG .BYTE $18 ; zmień-znak 1-z. ; $1D3C : 7484 YNEG: .BYTE $34 ; koniec-obliczeń RET ; ----------------- ; FUNKCJA 'COSINUS' ; ----------------- ; (offset $1D: 'cos') ; Cosinus jest obliczany jako sinus przeciwnego kąta w trójkącie prostokątnym z poprawą znaku w zależności od numeru ćwiartki, w której ; ten kąt się znajduje. ; /| ; h /y| ; / |o ; /x | ; /----| ; a ; Cosinus kąta x jest równy długości boku a podzielonej przez długość przeciwprostokątnej h. Jednakże, gdy rozważymy kąt y, to okaże się, że ; a/h jest równe jego sinusowi. Ponieważ kąty x i y sumują się do kata prostego, kąt y możemy znaleźć przez odjęcie kąta x od pi/2. Jednakże ; równie łatwe jest wstępne zredukowanie argumentu, a następnie odjęcie go od wartości 1 (zredukowany kąt prosty). Jest jeszcze prościej odjąć ; 1 od tego kąta i skorygować znak. W rzeczywistości po zredukowaniu argumentu wykorzystywana jest jego wartość bezwzględna, a następnie sprawdzany ; jest wynik redukcji, zachowany w obszarze pamięci kalkulatora w mem-0. Na podstawie tego wyniku dokonuje się korekcji znaku argumentu przed ; obliczeniem sinusa. ; $1D3E : 7486 COS: RST 28H ; KALKULATOR x. - kąt w radianach. .BYTE $35 ; get-argt x. - zredukuj do -1 to +1 .BYTE $27 ; wartość-bezwzględna ABS(x) .BYTE $A1 ; jeden-na-stos ABS(x),1. .BYTE $03 ; odejmij ABS(x)-1. - teraz kąt przeciwny .BYTE $E0 ; na-stos-paimięć-0 ABS(x)-1,(0/1). - pobierz wskaźnik znaku. .BYTE $00 ; skocz-przy-prawdzie ABS(x)-1. - jeśli zgodny, skocz do obliczeń sinusa .BYTE $06 ; naprzód do $1D4B, C-ENT .BYTE $18 ; zmień-znak 1-ABS(x). - inaczej zmień znak na przeciwny .BYTE $2F ; skocz 1-ABS(x). - i teraz skocz do obliczania sinusa .BYTE $03 ; naprzód do $1D4B, C-ENT ; --------------- ; FUNKCJA 'SINUS' ; --------------- ; (offset $1C: 'sin') ; Jest to podstawowa funkcja, z której są wyliczane bezpośrednio lub pośrednio pozostałe funkcje trygonometryczne - cos i tg. ; Wykorzystuje ona generator szeregów do wyznaczenia wartości wielomianów Czybyszewa. ; /| ; 1 / | ; / |x ; /a | ; /----| ; y ; $1D49 : 7497 SIN: RST 28H ; KALKULATOR x. - kąt w radianach .BYTE $35 ; get-argt x. - zredukuj do -1 to +1 ; $1D4B : 7499 C_ENT: .BYTE $2D ; duplikuj x,x. .BYTE $2D ; duplikuj x,x,x. .BYTE $04 ; mnóż x,x^2. .BYTE $2D ; duplikuj x,x^2,x^2. .BYTE $0F ; dodaj x,2x^2. .BYTE $A1 ; jeden-na-stos x,2x^2,1. .BYTE $03 ; odejmij x,2x^2-1. .BYTE $86 ; serie-06 uruchom generator szeregów .BYTE $14 ; Wykładnik: $64, Bajty: 1 .BYTE $E6 ;(+00,+00,+00) .BYTE $5C ; Wykładnik: $6C, Bajty: 2 .BYTE $1F,$0B ;(+00,+00) .BYTE $A3 ; Wykładnik: $73, Bajty: 3 .BYTE $8F,$38,$EE ;(+00) .BYTE $E9 ; Wykładnik: $79, Bajty: 4 .BYTE $15,$63,$BB,$23 ; .BYTE $EE ; Wykładnik: $7E, Bajty: 4 .BYTE $92,$0D,$CD,$ED ; .BYTE $F1 ; Wykładnik: $81, Bajty: 4 .BYTE $23,$5D,$1B,$EA ; .BYTE $04 ; mnóż .BYTE $34 ; koniec-obliczeń RET ; ----------------- ; FUNKCJA 'TANGENS' ; ----------------- ; (offset $1E: 'tan') ; Oblicza tangens z x jako sin(x) / cos(x). ; /| ; h / | ; / |o ; /x | ; /----| ; a ; Tangens kąta x jest ilorazem długości naprzeciwległego boku o przez długość boku przyległego a. Ponieważ długość naprzeciwległego boku można ; obliczyć wykorzystując sin(x), a długość boku przyległego wykorzystując cos(x), to tangens można zdefiniować jak powyżej. ; Błąd nr 6 powstaje, jeśli argument w radianach jest zbyt bliski +/-pi/2 - dla takiego kata tangens osiąga wartość nieskończoną. ; Np. PRINT TAN (PI/2) jest obliczane jak 1/0. ; Podobnie PRINT TAN (3*PI/2), TAN (5*PI/2) itd. ; $1D6E : 7534 TAN: RST 28H ; KALKULATOR x. .BYTE $2D ; duplikuj x,x. .BYTE $1C ; sinus x,SIN(x). .BYTE $01 ; zamień SIN(x),x. .BYTE $1D ; cosinus SIN(x),COS(x). .BYTE $05 ; dziel SIN(x)/COS(x) (= TAN(x)). .BYTE $34 ; koniec-obliczeń TAN(x). RET ; ----------------------- ; FUNKCJA 'ARCUS TANGENS' ; ----------------------- ; (Offset $21: 'atn') ; Funkcja odwrotna do tangensa, której wynik jest w radianach. ; Jest to podstawowa funkcja, z której wyprowadzane są pośrednio lub bezpośrednio pozostałe funkcje, takie jak arcus sinus i arcus cosinus. Zwracany ; wynik leży w zakresie od -pi/2 do pi/2. ; Jest ostatnią z czterech procedur, które wykorzystują generator szeregów do utworzenia wielomianów Chybyszewa. ; $1D76 : 7542 ATN: LD A,(HL) ; pobierz wykładnik CP $81 ; porównaj go z wykładnikiem jedynki JR C,SMALL ; jeśli mniejszy, naprzód do SMALL RST 28H ; KALKULATOR x. .BYTE $A1 ; jeden-na-stos x,1. .BYTE $18 ; zmień-znak x,-1. .BYTE $01 ; zamień -1,x. .BYTE $05 ; dziel -1/x. .BYTE $2D ; duplikuj -1/x,-1/x. .BYTE $32 ; mniej-niż-0 -1/x,(-1/x<0?). .BYTE $A3 ; na-stos-pi/2 -1/x,(0/1),pi/2. .BYTE $01 ; zamień -1/x,pi/2,(0,1). .BYTE $00 ; skocz-przy-prawdzie -1/x,pi/2. .BYTE $06 ; do L1D8B, CASES .BYTE $18 ; zmień-znak -1/x,-pi/2. .BYTE $2F ; skocz -1/x,-pi/2. .BYTE $03 ; do L1D8B, CASES ; $1D89 : 7561 (x > 0) (x <= 0) SMALL: RST 28H ; KALKULATOR -1/x,pi/2. | -1/x,-pi/2. .BYTE $A0 ; na-stos-zero -1/x,pi/2,0. | -1/x,-pi/2,0. ; $1D8B : 7563 CASES: .BYTE $01 ; zamień -1/x,0,pi/2. | -1/x,0,-pi/2. .BYTE $2D ; duplikuj -1/x,0,pi/2,pi/2. | -1/x,0,-pi/2,-pi/2. .BYTE $2D ; duplikuj -1/x,0,pi/2,pi/2,pi/2. | -1/x,0,-pi/2,-pi/2,-pi/2. .BYTE $04 ; mnóż -1/x,0,pi/2,pi^2/4. | -1/x,0,-pi/2,pi^2/4. .BYTE $2D ; duplikuj -1/x,0,pi/2,pi^2/4,pi^2/4. | -1/x,0,-pi/2,pi^2/4,pi^2/4. .BYTE $0F ; dodaj -1/x,0,pi/2,pi^2/2. | -1/x,0,-pi/2,pi^2/2. .BYTE $A1 ; jeden-na-stos -1/x,0,pi/2,pi^2/2,1. | -1/x,0,-pi/2,pi^2/2,1. .BYTE $03 ; odejmij -1/x,0,pi/2,pi^2/2-1. | -1/x,0,-pi/2,pi^2/2-1. .BYTE $8C ; serie-0C uruchom generator szeregów .BYTE $10 ; Wykładnik: $60, Bajty: 1 .BYTE $B2 ;(+00,+00,+00) .BYTE $13 ; Wykładnik: $63, Bajty: 1 .BYTE $0E ;(+00,+00,+00) .BYTE $55 ; Wykładnik: $65, Bajty: 2 .BYTE $E4,$8D ;(+00,+00) .BYTE $58 ; Wykładnik: $68, Bajty: 2 .BYTE $39,$BC ;(+00,+00) .BYTE $5B ; Wykładnik: $6B, Bajty: 2 .BYTE $98,$FD ;(+00,+00) .BYTE $9E ; Wykładnik: $6E, Bajty: 3 .BYTE $00,$36,$75 ;(+00) .BYTE $A0 ; Wykładnik: $70, Bajty: 3 .BYTE $DB,$E8,$B4 ;(+00) .BYTE $63 ; Wykładnik: $73, Bajty: 2 .BYTE $42,$C4 ;(+00,+00) .BYTE $E6 ; Wykładnik: $76, Bajty: 4 .BYTE $B5,$09,$36,$BE ; .BYTE $E9 ; Wykładnik: $79, Bajty: 4 .BYTE $36,$73,$1B,$5D ; .BYTE $EC ; Wykładnik: $7C, Bajty: 4 .BYTE $D8,$DE,$63,$BE ; .BYTE $F0 ; Wykładnik: $80, Bajty: 4 .BYTE $61,$A1,$B3,$0C ; .BYTE $04 ; mnóż .BYTE $0F ; dodaj .BYTE $34 ; koniec-obliczeń RET ; --------------------- ; FUNKCJA 'ARCUS SINUS' ; --------------------- ; (Offset $1F: 'asn') ; Funkcja odwrotna do sinus z wynikiem w radianach. Obliczana z wykorzystaniem powyższej funkcji arcus tangens. Błąd A jest generowany, jeśli ; argument wykracza poza przedział <-1,1>. Do obliczeń wykorzystana została tożsamość trygonometryczna: ; TAN(x/2) = SIN(x/(1+COS x)) ; Z TAN(x/2) wyliczany jest kat x/2 za pomocą wywołania ATN i na koniec samo x przez dodanie do siebie połówki kąta - x/2. ; $1DC4 : 7620 ASN: RST 28H ; KALKULATOR x. .BYTE $2D ; duplikuj x,x. .BYTE $2D ; duplikuj x,x,x. .BYTE $04 ; mnóż x,x^2. .BYTE $A1 ; jeden-na-stos x,x^2,1. .BYTE $03 ; odejmij x,x^2-1. .BYTE $18 ; zmień-znak x,1-x^2. .BYTE $25 ; pierwiastek x,sqr(1-x^2) = y. .BYTE $A1 ; jeden-na-stos x,y,1. .BYTE $0F ; dodaj x,y+1. .BYTE $05 ; dziel x/(y+1). .BYTE $21 ; arcus tangens a/2 - połówka kąta .BYTE $2D ; duplikuj a/2,a/2. .BYTE $0F ; dodaj a. .BYTE $34 ; koniec-obliczeń a. RET ; ----------------------- ; FUNKCJA 'ARCUS COSINUS' ; ----------------------- ; (Offset $20: 'acs') ; Funkcja odwrotna do cosinus z wynikiem w radianach. ; Błąd A, jeśli argument nie jest w zakresie od -1 do 1. ; Wynik w zakresie od 0 do pi. ; Wyprowadzona z powyższego asn, które z kolei jest wyprowadzone z poprzedzającego atn. Mogłoby być wyliczone bezpośrednio z atn wg wzoru ; acs(x) = atn(sqr(1-x*x)/x). ; Jednakże, ponieważ sinus i cosinus są pionowymi translacjami jednego w drugi, użyto ; acs(x) = pi/2 - asn(x) ; tj. arcus cosinus znanej wartości x da poszukiwany kąt b w radianach. Z powyższego wiemy, jak policzyć kąt a używając asn(x). Ponieważ trzy ; kąty dowolnego trójkata dodają się do pi radianów, a największym kątem w tym przypadku jest kąt prosty (pi/2 radianów), to możemy obliczyć ; kąt b jako pi/2 (oba katy) minus asn(x) (kąt a). ; ; /| ; 1 /b| ; / |x ; /a | ; /----| ; y ; $1DD4 : 7636 ACS: RST 28H ; KALKULATOR x. .BYTE $1F ; arcus-sinus asn(x). .BYTE $A3 ; na-stos-pi/2 asn(x), pi/2. .BYTE $03 ; odejmij asn(x) - pi/2. .BYTE $18 ; zmień-znak pi/2 - asn(x) = acs(x). .BYTE $34 ; koniec-obliczeń acs(x) RET ; --------------------------------- ; OPERACJA 'PIERWIASTEK KWADRATOWY' ; --------------------------------- ; (Offset $25: 'sqr') ; Błąd A, jeśli argument jest ujemny. Ta procedura jest godna uwagi ze względu na jej rozmiar - 7 bajtów. Pierwotnie kod ZX81 zajmował 9KB ; i musiano zastosować różne techniki, aby wcisnąć go w pamięć 8K. ; $1DDB : 7643 SQR: RST 28H ; KALKULATOR x. .BYTE $2D ; duplikuj x, x. .BYTE $2C ; neguj-logicznie x, 1/0 .BYTE $00 ; skocz-przy-prawdzie x, (1/0). .BYTE $1E ; do L1DFD, LAST, wyjdź przy argumencie równym zero - wynik zero. ; inaczej kontynuuj obliczanie jako x ** .5 .BYTE $A2 ; na-stos-1/2 x, .5. .BYTE $34 ; koniec-obliczeń x, .5. ; ---------------------- ; OPERACJA 'POTĘGOWANIE' ; ---------------------- ; (Offset $06: 'to-power') ; Podnosi pierwszą liczbę x do potęgi drugiej liczby y. ; 0 ** +n = 0 ; 0 ** -n = nadmiar arytmetyczny. ; $1DE2 : 7650 TO_POWER: RST 28H ; KALKULATOR x, y. .BYTE $01 ; zamień y, x. .BYTE $2D ; duplikuj y, x, x. .BYTE $2C ; neguj-logicznie y, x, (1/0). .BYTE $00 ; skocz-przy-prawdzie .BYTE $07 ; naprzód do $1DEE, XISO, jeśli x jest równe zero. ; inaczej X jest niezerowe. Funkcja 'ln' przechwyci ujemne wartości x. .BYTE $22 ; logarytm-naturalny y, LN y. .BYTE $04 ; mnóż y * LN x. .BYTE $34 ; koniec-obliczeń JP EXP ; skocz wstecz do procedury EXP ; Te procedury tworzą trzy proste wyniki, gdy liczba ma wartość zero. Rozpocznij od usunięcia znanego zera, aby pozostawić y do potęgi czynnika. ; $1DEE : 7662 XISO: .BYTE $02 ; usuń y. .BYTE $2D ; duplikuj y, y. .BYTE $2C ; neguj-logicznie y, (1/0). .BYTE $00 ; skocz-przy-prawdzie .BYTE $09 ; naprzód do $1DFB, ONE jeśli y jest równe zero. ; czynnik potęgowy nie jest zerem. Jeśli jest ujemny, powstanie błąd. .BYTE $A0 ; na-stos-zero y, 0. .BYTE $01 ; zamień 0, y. .BYTE $33 ; większe-niż-0 0, (1/0). .BYTE $00 ; skocz-przy-prawdzie 0. .BYTE $06 ; do $1DFD, LAST jeśli y był liczbą dodatnią. ; inaczej wymuś dzielenie przez zero, co spowoduje powstanie błędu nadmiaru arytmetycznego. Istnieją pewne jedno i dwubajtowe zamienniki, ; lecz najbardziej formalnym zakończeniem powinno być end-calc; RST 08 .BYTE 05. .BYTE $A1 ; jeden-na-stos 0, 1. .BYTE $01 ; zamień 1, 0. .BYTE $05 ; dziel 1/0 >> błąd ; $1DFB : 7675 ONE: .BYTE $02 ; usuń . .BYTE $A1 ; jeden-na-stos 1. ; $1DFD : 7677 LAST: .BYTE $34 ; koniec-obliczeń ostatnia wartość 1 lub 0. RET ; ------------------ ; 'ZAPASOWE KOMÓRKI' ; ------------------ ; $1DFF : 7679 SPARE: .BYTE $FF ; to już wszystko ; -------------------- ; 'ZESTAW ZNAKÓW ZX81' ; -------------------- ; $1E00 : 7680 CHAR_SET: ; $00 - Znak: ' ' CHR$(0) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $01 - Znak: mozaika CHR$(1) .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $02 - Znak: mozaika CHR$(2) .BYTE %00001111 .BYTE %00001111 .BYTE %00001111 .BYTE %00001111 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $03 - Znak: mozaika CHR$(3) .BYTE %11111111 .BYTE %11111111 .BYTE %11111111 .BYTE %11111111 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $04 - Znak: mozaika CHR$(4) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 ; $05 - Znak: mozaika CHR$(5) .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 ; $06 - Znak: mozaika CHR$(6) .BYTE %00001111 .BYTE %00001111 .BYTE %00001111 .BYTE %00001111 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 ; $07 - Znak: mozaika CHR$(7) .BYTE %11111111 .BYTE %11111111 .BYTE %11111111 .BYTE %11111111 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 .BYTE %11110000 ; $08 - Znak: mozaika CHR$(8) .BYTE %10101010 .BYTE %01010101 .BYTE %10101010 .BYTE %01010101 .BYTE %10101010 .BYTE %01010101 .BYTE %10101010 .BYTE %01010101 ; $09 - Znak: mozaika CHR$(9) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %10101010 .BYTE %01010101 .BYTE %10101010 .BYTE %01010101 ; $0A - Znak: mozaika CHR$(10) .BYTE %10101010 .BYTE %01010101 .BYTE %10101010 .BYTE %01010101 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $0B - Znak: '"' CHR$(11) .BYTE %00000000 .BYTE %00100100 .BYTE %00100100 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $0C - Znak: L CHR$(12) .BYTE %00000000 .BYTE %00011100 .BYTE %00100010 .BYTE %01111000 .BYTE %00100000 .BYTE %00100000 .BYTE %01111110 .BYTE %00000000 ; $0D - Znak: '$' CHR$(13) .BYTE %00000000 .BYTE %00001000 .BYTE %00111110 .BYTE %00101000 .BYTE %00111110 .BYTE %00001010 .BYTE %00111110 .BYTE %00001000 ; $0E - Znak: ':' CHR$(14) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00010000 .BYTE %00000000 .BYTE %00000000 .BYTE %00010000 .BYTE %00000000 ; $0F - Znak: '?' CHR$(15) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %00000100 .BYTE %00001000 .BYTE %00000000 .BYTE %00001000 .BYTE %00000000 ; $10 - Znak: '(' CHR$(16) .BYTE %00000000 .BYTE %00000100 .BYTE %00001000 .BYTE %00001000 .BYTE %00001000 .BYTE %00001000 .BYTE %00000100 .BYTE %00000000 ; $11 - Znak: ')' CHR$(17) .BYTE %00000000 .BYTE %00100000 .BYTE %00010000 .BYTE %00010000 .BYTE %00010000 .BYTE %00010000 .BYTE %00100000 .BYTE %00000000 ; $12 - Znak: ">' CHR$(18) .BYTE %00000000 .BYTE %00000000 .BYTE %00010000 .BYTE %00001000 .BYTE %00000100 .BYTE %00001000 .BYTE %00010000 .BYTE %00000000 ; $13 - Znak: '<' CHR$(19) .BYTE %00000000 .BYTE %00000000 .BYTE %00000100 .BYTE %00001000 .BYTE %00010000 .BYTE %00001000 .BYTE %00000100 .BYTE %00000000 ; $14 - Znak: '=' CHR$(20) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00111110 .BYTE %00000000 .BYTE %00111110 .BYTE %00000000 .BYTE %00000000 ; $15 - Znak: '+' CHR$(21) .BYTE %00000000 .BYTE %00000000 .BYTE %00001000 .BYTE %00001000 .BYTE %00111110 .BYTE %00001000 .BYTE %00001000 .BYTE %00000000 ; $16 - Znak: '-' CHR$(22) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00111110 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 ; $17 - Znak: '*' CHR$(23) .BYTE %00000000 .BYTE %00000000 .BYTE %00010100 .BYTE %00001000 .BYTE %00111110 .BYTE %00001000 .BYTE %00010100 .BYTE %00000000 ; $18 - Znak: '/' CHR$(24) .BYTE %00000000 .BYTE %00000000 .BYTE %00000010 .BYTE %00000100 .BYTE %00001000 .BYTE %00010000 .BYTE %00100000 .BYTE %00000000 ; $19 - Znak: ';' CHR$(25) .BYTE %00000000 .BYTE %00000000 .BYTE %00010000 .BYTE %00000000 .BYTE %00000000 .BYTE %00010000 .BYTE %00010000 .BYTE %00100000 ; $1A - Znak: ',' CHR$(26) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00001000 .BYTE %00001000 .BYTE %00010000 ; $1B - Znak: '"' CHR$(27) .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00000000 .BYTE %00011000 .BYTE %00011000 .BYTE %00000000 ; $1C - Znak: '0' CHR$(28) .BYTE %00000000 .BYTE %00111100 .BYTE %01000110 .BYTE %01001010 .BYTE %01010010 .BYTE %01100010 .BYTE %00111100 .BYTE %00000000 ; $1D - Znak: '1' CHR$(29) .BYTE %00000000 .BYTE %00011000 .BYTE %00101000 .BYTE %00001000 .BYTE %00001000 .BYTE %00001000 .BYTE %00111110 .BYTE %00000000 ; $1E - Znak: '2' CHR$(30) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %00000010 .BYTE %00111100 .BYTE %01000000 .BYTE %01111110 .BYTE %00000000 ; $1F - Znak: '3' CHR$(31) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %00001100 .BYTE %00000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $20 - Znak: '4' CHR$(32) .BYTE %00000000 .BYTE %00001000 .BYTE %00011000 .BYTE %00101000 .BYTE %01001000 .BYTE %01111110 .BYTE %00001000 .BYTE %00000000 ; $21 - Znak: '5' CHR$(33) .BYTE %00000000 .BYTE %01111110 .BYTE %01000000 .BYTE %01111100 .BYTE %00000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $22 - Znak: '6' CHR$(34) .BYTE %00000000 .BYTE %00111100 .BYTE %01000000 .BYTE %01111100 .BYTE %01000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $23 - Znak: '7' CHR$(35) .BYTE %00000000 .BYTE %01111110 .BYTE %00000010 .BYTE %00000100 .BYTE %00001000 .BYTE %00010000 .BYTE %00010000 .BYTE %00000000 ; $24 - Znak: '8' CHR$(36) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %00111100 .BYTE %01000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $25 - Znak: '9' CHR$(37) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %01000010 .BYTE %00111110 .BYTE %00000010 .BYTE %00111100 .BYTE %00000000 ; $26 - Znak: 'A' CHR$(38) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %01000010 .BYTE %01111110 .BYTE %01000010 .BYTE %01000010 .BYTE %00000000 ; $27 - Znak: 'B' CHR$(39) .BYTE %00000000 .BYTE %01111100 .BYTE %01000010 .BYTE %01111100 .BYTE %01000010 .BYTE %01000010 .BYTE %01111100 .BYTE %00000000 ; $28 - Znak: 'C' CHR$(40) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %01000000 .BYTE %01000000 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $29 - Znak: 'D' CHR$(41) .BYTE %00000000 .BYTE %01111000 .BYTE %01000100 .BYTE %01000010 .BYTE %01000010 .BYTE %01000100 .BYTE %01111000 .BYTE %00000000 ; $2A - Znak: 'E' CHR$(42) .BYTE %00000000 .BYTE %01111110 .BYTE %01000000 .BYTE %01111100 .BYTE %01000000 .BYTE %01000000 .BYTE %01111110 .BYTE %00000000 ; $2B - Znak: 'F' CHR$(43) .BYTE %00000000 .BYTE %01111110 .BYTE %01000000 .BYTE %01111100 .BYTE %01000000 .BYTE %01000000 .BYTE %01000000 .BYTE %00000000 ; $2C - Znak: 'G' CHR$(44) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %01000000 .BYTE %01001110 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $2D - Znak: 'H' CHR$(45) .BYTE %00000000 .BYTE %01000010 .BYTE %01000010 .BYTE %01111110 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %00000000 ; $2E - Znak: 'I' CHR$(46) .BYTE %00000000 .BYTE %00111110 .BYTE %00001000 .BYTE %00001000 .BYTE %00001000 .BYTE %00001000 .BYTE %00111110 .BYTE %00000000 ; $2F - Znak: 'J' CHR$(47) .BYTE %00000000 .BYTE %00000010 .BYTE %00000010 .BYTE %00000010 .BYTE %01000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $30 - Znak: 'K' CHR$(48) .BYTE %00000000 .BYTE %01000100 .BYTE %01001000 .BYTE %01110000 .BYTE %01001000 .BYTE %01000100 .BYTE %01000010 .BYTE %00000000 ; $31 - Znak: 'L' CHR$(49) .BYTE %00000000 .BYTE %01000000 .BYTE %01000000 .BYTE %01000000 .BYTE %01000000 .BYTE %01000000 .BYTE %01111110 .BYTE %00000000 ; $32 - Znak: 'M' CHR$(50) .BYTE %00000000 .BYTE %01000010 .BYTE %01100110 .BYTE %01011010 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %00000000 ; $33 - Znak: 'N' CHR$(51) .BYTE %00000000 .BYTE %01000010 .BYTE %01100010 .BYTE %01010010 .BYTE %01001010 .BYTE %01000110 .BYTE %01000010 .BYTE %00000000 ; $34 - Znak: 'O' CHR$(52) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $35 - Znak: 'P' CHR$(53) .BYTE %00000000 .BYTE %01111100 .BYTE %01000010 .BYTE %01000010 .BYTE %01111100 .BYTE %01000000 .BYTE %01000000 .BYTE %00000000 ; $36 - Znak: 'Q' CHR$(54) .BYTE %00000000 .BYTE %00111100 .BYTE %01000010 .BYTE %01000010 .BYTE %01010010 .BYTE %01001010 .BYTE %00111100 .BYTE %00000000 ; $37 - Znak: 'R' CHR$(55) .BYTE %00000000 .BYTE %01111100 .BYTE %01000010 .BYTE %01000010 .BYTE %01111100 .BYTE %01000100 .BYTE %01000010 .BYTE %00000000 ; $38 - Znak: 'S' CHR$(56) .BYTE %00000000 .BYTE %00111100 .BYTE %01000000 .BYTE %00111100 .BYTE %00000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $39 - Znak: 'T' CHR$(57) .BYTE %00000000 .BYTE %11111110 .BYTE %00010000 .BYTE %00010000 .BYTE %00010000 .BYTE %00010000 .BYTE %00010000 .BYTE %00000000 ; $3A - Znak: 'U' CHR$(58) .BYTE %00000000 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %00111100 .BYTE %00000000 ; $3B - Znak: 'V' CHR$(59) .BYTE %00000000 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %00100100 .BYTE %00011000 .BYTE %00000000 ; $3C - Znak: 'W' CHR$(60) .BYTE %00000000 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %01000010 .BYTE %01011010 .BYTE %00100100 .BYTE %00000000 ; $3D - Znak: 'X' CHR$(61) .BYTE %00000000 .BYTE %01000010 .BYTE %00100100 .BYTE %00011000 .BYTE %00011000 .BYTE %00100100 .BYTE %01000010 .BYTE %00000000 ; $3E - Znak: 'Y' CHR$(62) .BYTE %00000000 .BYTE %10000010 .BYTE %01000100 .BYTE %00101000 .BYTE %00010000 .BYTE %00010000 .BYTE %00010000 .BYTE %00000000 ; $3F - Znak: 'Z' CHR$(63) .BYTE %00000000 .BYTE %01111110 .BYTE %00000100 .BYTE %00001000 .BYTE %00010000 .BYTE %00100000 .BYTE %01111110 .BYTE %00000000 .END ;dyrektywa asemblera TASM
|
 | I Liceum Ogólnokształcące |
Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl
W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe
