Nie ma. Najlepiej to chyba zrobić USR-em:

FP0 = $D4

  pla    ;ilosc argumentow ignorujemy

  pla    ;pierwszy argument
  sta FP0+1
  pla
  sta FP0

  pla    ;drugi argument
  AND/EOR/ORA FP0+1
  sta FP0+1
  pla
  AND/EOR/ORA FP0
  sta FP0
  rts

Wywołujemy

X=USR(ADR("powyzszy_kod"),A,B)

Edit: Załączniki.

Ostatnio edytowany przez mono (2022-04-05 15:20:47)

Jeszcze dla uściślenia - BASIC wbudowany w serii XL/XE to nie jest BASIC XL, tylko Atari BASIC :) Popraw tytuł wątku, żeby nie wprowadzać potomnych w błąd :)

Edit: Uzupełniłem jeszcze pierwszy post o załączniki.

Ostatnio edytowany przez mono (2022-04-05 15:17:10)

To nie Basic, poprawnie dla zapalania bitów będzie  :D

10 A=40042:REM $9C6A to pamiec obrazu
20 B=PEEK(A)
30 IF B<128 THEN B=B+128
40 POKE A,B

Tak bokiem, cykl nauk ścisłych z AAge "Simple Assembly for Atari BASIC" część 6/11 "Bit Manipulations"

Ostatnio edytowany przez pajero (2022-04-05 18:30:57)

Próbowałem na szybko zerować bity, ale tylko INT jest zdatne do tego, i znowu IFy
I mnie tylko ciśnienie skoczyło.
Cóż, Basic to tylko Basic i to lat 70tych.

Wersja całkowicie bez IF-ów:

5 READ QH
10 ? "0-255,0-255 ";:INPUT A,B
20 T=A*QH:A=INT(T):A0=SGN(T-A)
21 T=A*QH:A=INT(T):A1=SGN(T-A)
22 T=A*QH:A=INT(T):A2=SGN(T-A)
23 T=A*QH:A=INT(T):A3=SGN(T-A)
24 T=A*QH:A=INT(T):A4=SGN(T-A)
25 T=A*QH:A=INT(T):A5=SGN(T-A)
26 T=A*QH:A=INT(T):A6=SGN(T-A)
27 T=A*QH:A7=SGN(T-INT(T))
29 ? A7;A6;A5;A4;A3;A2;A1;A0
30 T=B*QH:B=INT(T):B0=SGN(T-B)
31 T=B*QH:B=INT(T):B1=SGN(T-B)
32 T=B*QH:B=INT(T):B2=SGN(T-B)
33 T=B*QH:B=INT(T):B3=SGN(T-B)
34 T=B*QH:B=INT(T):B4=SGN(T-B)
35 T=B*QH:B=INT(T):B5=SGN(T-B)
36 T=B*QH:B=INT(T):B6=SGN(T-B)
37 T=B*QH:B7=SGN(T-INT(T))
39 ? B7;B6;B5;B4;B3;B2;B1;B0
40 ? "-------- AND"
41 ? A7 AND B7;A6 AND B6;A5 AND B5;A4 AND B4;A3 AND B3;A2 AND B2;A1 AND B1;A0 AND B0
50 ? "-------- OR"
51 ? A7 OR B7;A6 OR B6;A5 OR B5;A4 OR B4;A3 OR B3;A2 OR B2;A1 OR B1;A0 OR B0
61 ? "-------- XOR"
62 ? (A7 OR B7) AND NOT (A7 AND B7);(A6 OR B6) AND NOT (A6 AND B6);
63 ? (A5 OR B5) AND NOT (A5 AND B5);(A4 OR B4) AND NOT (A4 AND B4);
64 ? (A3 OR B3) AND NOT (A3 AND B3);(A2 OR B2) AND NOT (A2 AND B2);
65 ? (A1 OR B1) AND NOT (A1 AND B1);(A0 OR B0) AND NOT (A0 AND B0)
90 ? :GOTO 10
99 DATA .5

Edit: Po dokładniejszym sprawdzeniu wychodzi na to, że moja wersja jest nieco wolniejsza od wersji Xxl-a. Sprawdzałem też jednak osobno niektóre składowe operacje i np. AND działa szybciej niż "*", więc jest jeszcze miejsce na optymalizację. Wydaje mi się, że gdzieś widziałem jeszcze inny sposób na te obliczenia, ale nie pamiętam szczegółów... teraz nic takiego nie znalazłem. Jak wyżej również tu występuje niejawna pętla - trzeba obliczyć poprzednie bity, aby obliczyć kolejny - tu tradycyjnie - czyli w odwrotnym kierunku niż u Xxl-a. Dodatkowo dopisałem OR i XOR. Edit2: krótsza wersja XOR - można jeszcze użyć wartości z AND i OR i nie "liczyć" ich ponownie przy XOR.

Ostatnio edytowany przez QTZ (2022-04-09 03:53:33)

130 DIM A$(8),B$(8),OA$(8),OO$(8),OX$(8):A$(8)="#":B$=A$:OA$=A$:OO$=A$:OX$=A$
140 GRAPHICS 8:E=PEEK(88)+256*PEEK(89):AD=ADR(A$)
150 TRAP 150:? "0-255,0-255 ";:INPUT IA,IB:POKE E,IA:POKE E+1,IB:TRAP 0
160 FOR X=0 TO 7
170 LOCATE X,0,A:POKE AD+X,A+48:LOCATE X+8,0,B:POKE AD+X+8,B+48
180 OA=A AND B:POKE AD+X+16,OA+48:REM COLOR OA:PLOT X+16,0
190 OO=A OR B:POKE AD+X+24,OO+48:REM COLOR OO:PLOT X+24,0
200 OX=OO AND  NOT OA:POKE AD+X+32,OX+48:REM COLOR OX:PLOT X+32,0
210 NEXT X:? CHR$(125);:POSITION 0+16,0:? #6;OA$;OO$;OX$
220 OA=PEEK(E+2):? "AND: ";OA$;"(";OA;")",A$;"(";IA;")"
230 OO=PEEK(E+3):? "OR:  ";OO$;"(";OO;")",B$;"(";IB;")"
240 OX=PEEK(E+4):? "EXOR:";OX$;"(";OX;")"
250 GOTO 150

MAW rozwaliłeś system :) Chyba ciężko będzie wymyślić coś lepszego w Basicu ;) To nie to rozwiązanie które widziałem, tamto było sprytnie 'liczone', a to nawet nie wymaga liczenia :) Najtrudniej wpaść na najprostsze rozwiązanie.

Wykorzystując to rozwiązanie napisałem krótki program w którym jest konwersja dec->bin (dla użytkownika) i bin->dec (wewnętrznie) i operacje AND, OR, XOR.

Pewnie nie wymaga to tłumaczenia, ale napiszę kilka zdań.

Wyniki są zapisane w zmiennych tekstowych (8bit) i liczbowych (byte). Nadal mamy tu pętlę, jednak nie musimy jej wykonywać jeżeli chcemy odczytać czy ustawić tylko wybrane bity (jak widać w oryginalnym programie).
Operacje wykonywane są na poszczególnych bitach i zapisywane przez POKE do zmiennych tekstowych umieszczonych ciągiem w pamięci (zapis przez COLOR i PLOT umieściłem zaremowany).
Gotowe zmienne tekstowe z ciągami binarnymi do konwersji na liczby dziesiętne są printowane przez "#6;" w całości, a ich wartości odczytywane są jak wyżej przez PEEK.

Przy użyciu tej metody zmieniając GRAPHICS na 9+32 można też konwertować z/na hex. Niestety nie mamy trybu 3 bitowego, więc z oct nie będzie chyba tak łatwo. Za to mamy tryby 2 bitowe, więc można konwertować na mało popularny system czwórkowy.

Myślę, że linijkę obrazu w której wstawiamy liczby do konwersji można spróbować ukryć w DL ustawiając "setcolor" aby kolory 0 i 1 się nie różniły, lub w przypadku GR.8 można tę linię umieścić pod oknem tekstowym.

100 DIM S$(1),HA$(2),HB$(2),A$(8),B$(8),OA$(8),OO$(8),OX$(8)
105 GRAPHICS 8:E=PEEK(88)+256*PEEK(89):AD=ADR(A$):YS=191:E=E+40*YS

110 ? "[b]IN, DEC, [h]EX ";:INPUT S$:ON (S$="B")*1+(S$="H")*2 GOTO 125,135

115 TRAP 115:? "0-255 (A) ";:INPUT IA:POKE E,IA
120 TRAP 120:? "0-255 (B) ";:INPUT IB:POKE E+1,IB:TRAP 0:GOTO 155

125 ? "0-11111111 (A) ";:INPUT A$:POKE E,0:POSITION 8-LEN(A$),YS:? #6;A$
130 ? "0-11111111 (B) ";:INPUT B$:POKE E+1,0:POSITION 8+8-LEN(B$),YS:? #6;B$:GOTO 155

135 ? "0-FF (A) ";:INPUT HA$:? "0-FF (B) ";:INPUT HB$
140 FOR X=1 TO 4:A=AD-X:B=PEEK(A):IF B>64 AND B<71 THEN POKE A,B-7
145 NEXT X:GRAPHICS 9+32:POKE E,0:POSITION 2-LEN(HA$),YS:? #6;HA$
150 POKE E+1,0:POSITION 2+2-LEN(HB$),YS:? #6;HB$:GRAPHICS 8+32

155 IA=PEEK(E):IB=PEEK(E+1):A$(8)="#":B$=A$:OA$=A$:OO$=A$:OX$=A$
160 FOR X=0 TO 7
170 LOCATE X,YS,A:POKE AD+X,A+48:LOCATE X+8,YS,B:POKE AD+X+8,B+48
180 OA=A AND B:POKE AD+X+16,OA+48:REM COLOR OA:PLOT X+16,YS
190 OO=A OR B:POKE AD+X+24,OO+48:REM COLOR OO:PLOT X+24,YS
200 OX=OO AND  NOT OA:POKE AD+X+32,OX+48:REM COLOR OX:PLOT X+32,YS
210 NEXT X:? CHR$(125);:POSITION 0+16,YS:? #6;OA$;OO$;OX$
220 OA=PEEK(E+2):? "AND: ";OA$;"(";OA;")",A$;"(";IA;")"
230 OO=PEEK(E+3):? "OR:  ";OO$;"(";OO;")",B$;"(";IB;")"
240 OX=PEEK(E+4):? "EXOR:";OX$;"(";OX;")"
250 GOTO 110

Edit2: Nowy listing wstawiam tu bo główny program jest praktycznie bez zmian.
Dodałem możliwość wpisania liczb w hex lub binarnie (obydwu). Linię z wartościami przesunąłem na dół ekranu - po wpisywaniu w hex jest widoczna podczas zmiany trybu graficznego (można na tę chwilę wyłączyć ekran).
Mimo, że wpisywane wartości w hex i bin teoretycznie są znane, to zostaną odczytane z ekranu, jest to zabezpieczenie w przypadku gdyż użytkownik wpisze krótki ciąg lub wstawi znaki spoza zakresu. Nieprzewidziane znaki zostaną skonwertowane przez Atari na "przypadkowe", ale poprawne wartości, i w takiej postaci zostaną odczytane.
Wyniki nie są wyświetlane w hex - wystarczyłoby zmienić tryb na 9+32, wykonać 10 x LOCATE i zmienić odczytane wartości na zapis hex (np. podobnie jak to zrobiłem przy konwersji hex->byte - aby uniknąć wielu IF-ów - przez POKE).

Ostatnio edytowany przez QTZ (2022-04-10 21:14:19)

Może nie do końca na temat, ale przeczytawszy ostatnio opowiadanie hm... erotyczne, postanowiłem rozebrać bajt na bity i złożyć ponownie, przy okazji zmieniając któryś z bitów na przeciwny. Oczywiście wszystko w Atari BASIC-u.

0 DATA 128,64,32,16,8,4,2,1
50 DIM B(8)
55 REM Wartosc bajtu i numer bitu (0-7), ktory ma byc zmieniony:
60 INPUT BAJT,BIT:B(8)=BAJT
100 FOR X=7 TO 0 STEP -1
110 READ Q:BAJT=BAJT-Q
120 IF BAJT>=0 THEN B(X)=1:B(8)=BAJT:GOTO 150
130 BAJT=B(8):B(X)=0
150 NEXT X
200 B(BIT)= NOT B(BIT):BAJT=0:RESTORE
300 FOR X=7 TO 0 STEP -1:READ Q:BAJT=BAJT+B(X)*Q:NEXT X
5000 ? "---TEST---"
5010 FOR X=7 TO 0 STEP -1
5020 ? X,B(X)
5030 NEXT X
5040 ? "BAJT=";BAJT

Jeśli używasz GR.8 (czyli z oknem tekstowym) to można skorzystać z faktu że ekran graficzny jest większy niż 160 linii :) A wtedy

COLOR 1:PLOT 7-N,160:? PEEK(E+40*160)

zwróci interesujący nas bajt a na ekranie nie będziemy mieć śmiecia :)
Nie wpadłem tylko na pomysł jak zrobić XOR. Ale @maw - pomysł jest genialny! "Szkoda że nie mój" :)

Edit: No chyba że LOCATE'm weźmiemy kolor i go "zanegujemy" inkrementując. A wtedy procedura negująca bit a bajcie będzie wyglądać mniej więcej tak:

10 POKE E+40*160,B:LOCATE 7-N,160,C:COLOR C+1:PLOT 7-N,160:B=PEEK(E+40*160):RETURN

B to bajt wejściowy i wyjściowy, N to numer bitu.

Ostatnio edytowany przez mono (2022-04-11 08:17:57)

No i kolejna wersja z konwersją i wyświetlaniem danych/wyników również w hex (w sumie niewielkie zmiany do poprzedniej wersji). Zająłem się pisaniem i nie widziałem, że coś napisaliście po Blukim (fajne uproszczenie poprzez wrzucenie wag do danych). Teraz zerkam i ukrycie linii jak pisałem zrobiłem pod oknem tekstowym, ale wychodzi przy zmianie GRAPHICS. Później doczytam jak to jest u was... Tu wyniki są wyświetlane w kolejności tak jak mamy wybór: bin, hex, dec (pytanie jest jednocześnie opisem). W pierwszej kolumnie wyniki, w drugiej dane wejściowe.

100 DIM S$(1),H1$(2),H2$(2),HA$(2),HO$(2),HX$(2),A$(8),B$(8),OA$(8),OO$(8),OX$(8)
105 GRAPHICS 8:E=PEEK(88)+256*PEEK(89):AD=ADR(A$):YS=191:E=E+40*YS
110 ? "(B)IN, (H)EX, DEC ";:INPUT S$:ON (S$="B")*1+(S$="H")*2 GOTO 125,135
115 TRAP 115:? "0-255 (A) ";:INPUT IA:POKE E,IA
120 TRAP 120:? "0-255 (B) ";:INPUT IB:POKE E+1,IB:TRAP 0:GOTO 155
125 ? "0-11111111 (A) ";:INPUT A$:POKE E,0:POSITION 8-LEN(A$),YS:? #6;A$
130 ? "0-11111111 (B) ";:INPUT B$:POKE E+1,0:POSITION 8+8-LEN(B$),YS:? #6;B$:GOTO 155
135 ? "0-FF (A) ";:INPUT H1$:? "0-FF (B) ";:INPUT H2$
140 FOR X=7 TO 10:A=AD-X:B=PEEK(A):IF B>64 AND B<71 THEN POKE A,B-7
145 NEXT X:GRAPHICS 9+32:POKE E,0:POSITION 2-LEN(H1$),YS:? #6;H1$
150 POKE E+1,0:POSITION 2+2-LEN(H2$),YS:? #6;H2$:GRAPHICS 8+32
155 IA=PEEK(E):IB=PEEK(E+1):A$(8)="#":B$=A$:OA$=A$:OO$=A$:OX$=A$:H1$(2)="#":H2$=H1$:HA$=H1$:HO$=H1$:HX$=H1$
160 FOR X=0 TO 7
170 LOCATE X,YS,A:POKE AD+X,A+48:LOCATE X+8,YS,B:POKE AD+X+8,B+48
180 OA=A AND B:POKE AD+X+16,OA+48:REM COLOR OA:PLOT X+16,YS
190 OO=A OR B:POKE AD+X+24,OO+48:REM COLOR OO:PLOT X+24,YS
200 OX=OO AND  NOT OA:POKE AD+X+32,OX+48:REM COLOR OX:PLOT X+32,YS
210 NEXT X:POSITION 0+16,YS:? #6;OA$;OO$;OX$
215 GRAPHICS 9+32:FOR X=0 TO 9:LOCATE X,YS,A:POKE AD-10+X,A+48+(A>9)*7:NEXT X:GRAPHICS 8+32:? CHR$(125);
220 OA=PEEK(E+2):? "AND:";OA$;" ";HA$;" ";OA;CHR$(127);A$;" ";H1$;" ";IA
230 OO=PEEK(E+3):? "OR: ";OO$;" ";HO$;" ";OO;CHR$(127);B$;" ";H2$;" ";IB
240 OX=PEEK(E+4):? "XOR:";OX$;" ";HX$;" ";OX
250 GOTO 110

Edit: Forum zamienia duże "B" w nawiasie kwadratowym występujące w kodzie na małe "b", podobnie z "H"->"h", więc zmieniam nawias na okrągły - linia 110.

Edit2: Ukrywania danych za oknem tekstowym użyłem w mojej wersji Computer Inhabitant - tam w tym obszarze ukryte są dane animacji przedmiotów i elementów domu ;) Więc tu mi to od razu przyszło do głowy. Wybrałem linię 191, bo jest to ostatnia lina ekranu, gdzie bardziej prawdopodobne, że nic tam nie umieścimy, jeszcze lepiej byłoby przenieść dane na koniec tej linii. Można też przed konwersją zrobić backup tego co tam się znajduje, a po skończonym 'liczeniu' przywrócić.

Do DL pochodzę jak do jeża, ale być może ostatnią lub inną wybraną linię da się ukryć. Jeden minus, że pewnie trzeba będzie użyć kilku instrukcji assemblera, których unikamy w tej metodzie.

@Mono nie rozumiem, dlaczego najpierw robisz POKE, a na końcu po ustawieniu koloru, PEEK? OK, chyba rozumiem, to taki niepełny przykład abstrakcja - brakuje PLOTa :)
EXOR pierwotnie zrobiłem wg wzoru z Wikipedii, czy czegoś podobnego, jednak wydawał mi się zbyt długi i poszukałem krótszego :)
@Maw a czy próbowałeś zmienić GRAPHICS na NR+32, to znaczy z zachowaniem zawartości ekranu? Ja użyłem tego powyżej wraz z Twoim sposobem konwersji - do konwersji hex - zmiana na GR.9+32 4 bity na pixel, i z powrotem na GR.8+32 1 bit na pixel.

Edit3: Zastanawia mnie czy można użyć #6 do czegoś innego niż PRINT? Wpisanie INPUT #6,A$ powoduje dłuższe jakby zawieszenie i ERROR - 141? Czyżby dało się w ten sposób odczytać ciąg Bajtów? Spróbuję umieścić bajt 155 na ekranie i zobaczyć czy uda się odczytać kilka Bajtów... Gdyby to działało można by w ten sposób odczytać kilka zmiennych jednocześnie... i np. przekopiować dane...

Edit4: Działa GR. 8 i POS.X,Y:PUT#6,1-A:POS.X,Y:GET#6,A:?A;
PUT i GET zapala/gasi i odczytuje bit (piksel). W GR.8 nie ma chyba możliwości aby INPUT #6,A$ odczytało koniec linii?

Edit5: Wygląda na to, że INPUT #6,A$ czyta dane z całego ekranu od miejsca wskazanego przez POS.X,Y. Tylko jak ten odczyt zakończyć? Może gdyby ustawić TRAP i wtedy... no właśnie co? Niestety zmienna A$ pozostaje niezmieniona (obecne dane pozostają bez zmian). Nieważne też jak długa jest ta zmienna odczyt i tak dochodzi do końca ekranu.

Ostatnio edytowany przez QTZ (2022-04-11 08:19:51)

Sprawdzałem, wpisanie w 87($57) wartości 40 nie wpływa na LOCATE, wygląda jakby BASIC pobierał sobie tą wartość tylko przy inicjacji trybu.

Można to zrobić wybierając tryb graficzny: GR.8, GR.15, GR.9/10/11.