atarionline.pl Porownanie jezykow programowania - Forum Atarum

Jeśli chcesz wziąć udział w dyskusjach na forum - zaloguj się. Jeżeli nie masz loginu - poproś o członkostwo.

  • :
  • :

Vanilla 1.1.4 jest produktem Lussumo. Więcej informacji: Dokumentacja, Forum.

    • 1: CommentAuthorxxl
    • CommentTime5 Sep 2010 zmieniony
     
    stoje na stanowisku, ze w kazdym j.wysokiego poziomu wywolanie funkcji niedomaga oraz ze mowac o szybkosci mozna mowic tylko o szybkosci pisania kodu, dla systemow 8bitowych jedynym jezykiem byl, jest i bedzie tylko asembler ( troche podpuszczam :D )

    proponuje napisac w kazdym z nich bardzo krotki programik (pare linii) i przedstawic kod zrodlowy (disasemblacje tez) i porownac. jesli ktos ma ochote wyprowadzic mnie z bledu to zapraszam.

    ok. w zalaczniku jest rysunek przedstawiajacy 64 punkty. niech wynikiem dzialania testowego programu bedzie tablica zawierajaca pozycje x,y 64 punktow rozmieszczonych mniej wiecej (a najlepiej dokladnie) tak jak na rysunku.
    • 2: CommentAuthoremka
    • CommentTime6 Sep 2010
     
    Oczywiście masz rację, nic nie przebije asemblera, ale w grach większość czasu zajmuje czekanie na synchronizacje pionową i tutaj program może pracować 50% wolniej i nikt tego nie zauważy. Inną kategorię stanowią dema przeładowane efektami do granic możliwości, lub przekraczające te granice. Tam każdy cykl zegarowy jest ważny.

    PS.
    Twój program mocno faworyzuje asembler. Prawdopodobnie zakończysz rysowanie zanim procedura plot rozpozna w jakim trybie graficznym pracuje, ale nikt nie zauważy że jeden program wykonuje się 2ms a drugi 20ms .
    • 3: CommentAuthornosty
    • CommentTime6 Sep 2010
     
    XXL - zadaniem programu ma byc wyszukanie tych punktow w jakims obszarze pamieci (czyli np jedynek na tle zer)i zwrocenie ich wspolrzednych?
    To moze podaj ich wspolrzedne. Bedzie latwiej przygotowac identyczne warunki poczatkowe testu.
    Nie chce mi sie konwertowac i wczytywac obrazka z pliku.
    • 4: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    emka ten program ma stworzyc 128 bajtowa tablice a nie rysowac cokolwiek. caly program to zagniezdzona petla - 5 cio inijkowiec?

    nosty program ma stworzyc tablice wspolrzednych punktow przyklad: x0,y0,x1,y1,x2,y2.... kolejnosc punktow nie ma znaczenia a rozmieszczenie jest przykladowe. moze to zupelnie inaczej wygladac, wazne zeby punkty byly oddalone od krawedzi ekranu i od siebie oraz co drugi w poziomie i pionie bylt przesuniety o jakas stala wartosc - i wlasnie dlatego jest obrazek - nie zastapi slowa pisanego ;-)
    • 5: CommentAuthorrudla
    • CommentTime6 Sep 2010 zmieniony
     
    Of course you are right. High level languages are about speed (and easiness) of writing code, and not so much about speed of generated code.

    I would like the Atalan to generate as fast code as possible, but more important is the ease of use.

    I believe many people capable of programming simple game are intimidated by assembler. They would never dream of starting to write the game in assembler. On the other side, they may feel they would be able to write the same game in high level language. Later, when they successfully finish their first (second, n-th) project, they may be lured to assembler. :-)

    There is a question of time, too. We all can probably invest only limited amount of time into our Atari projects, so assembler program can never came into existence simply because someone would not be willing to invest so much time, even if he would be capable of writing the program.
    • 6: CommentAuthor0xF
    • CommentTime6 Sep 2010 zmieniony
     
    Różne języki programowania mają różne zastosowania. Nie ma jednego najlepszego języka. Trzeba dobrać właściwe narzędzie do zadania (czyli np. jednorazowego przetworzenia plików tekstowych nie robimy w C, tylko w Perlu).
    Różne języki działają z różną prędkością. Ten sam kod ASAP wykonuje się z inną prędkością w C, C#, Javie, Flashu i JavaScript. W przypływie wolnego czasu opublikuję benchmarki.

    Nie wiem, co chcesz osiągnąć swoim testem, ale proszę, oto pierwszy program, który mi przychodzi do głowy:
    require 'RMagick'
    img = Magick::Image.read('test.gif').first
    w = img.columns
    raw = img.dispatch(0, 0, w, img.rows, 'I')
    coords = []
    raw.each_index { |i| coords.push(i % w, i / w) if raw[i] > 128 }
    puts coords.inspect


    Edit: forum pododawało backslashe.
    Może nie chodziło Ci o program, który wyświetla współrzędne punktów z obrazka, tylko o rozszyfrowanie wzoru, którym zostały one wygenerowane?
    • 7: CommentAuthorrudla
    • CommentTime6 Sep 2010 zmieniony
     
    Here is Atalan program, that (I hope :-) computes the required points.
    ;XXL Benchmark

    idx:0..63
    px,py:array(idx)
    x,y:0..255

    const
    OFFSET = 10
    XSPACE = 20
    YSPACE = 20

    y = 0
    idx = 0
    for line:0..7
    x = 0
    if line mod 2 <> 0 then x = OFFSET
    for row:0..7
    py(idx) = y
    px(idx) = x
    x = x + XSPACE
    inc idx
    y = y + YSPACE

    ;Print the result

    for idx
    x = px(idx)
    y = py(idx)
    "[idx] [x] [y]"


    And here the generated assembler code (please don't get confused by some misplaced comment lines with source code - that will get fixed later):

    on__vbi__x equ 128
    idx equ 130
    x equ 131
    y equ 132
    root__OFFSET equ 10
    root__XSPACE equ 20
    root__YSPACE equ 20
    _s0__line equ 133
    _s0___3 equ 134
    _s1__row equ 135
    org $2e0
    dta a($2000)
    org $2000
    ;### xxlb.atl(12) y = 0
    lda #0
    sta y
    ;### xxlb.atl(13) idx = 0
    sta idx
    ;### xxlb.atl(26) for idx
    sta _s0__line
    _lbl5:
    ;### xxlb.atl(15) x = 0
    lda #0
    sta x
    ;### xxlb.atl(16) if line mod 2 <> 0 then x = OFFSET
    lda _s0__line
    and #1
    sta _s0___3
    cmp #0
    jeq _lbl2
    lda #root__OFFSET
    sta x
    ;### xxlb.atl(17) for row:0..7
    _lbl2:
    ;### xxlb.atl(22) y = y + YSPACE
    lda #0
    sta _s1__row
    ldx idx
    tay
    _lbl4:
    ;### xxlb.atl(18) py(idx) = y
    lda y
    sta py,x
    ;### xxlb.atl(19) px(idx) = x
    lda x
    sta px,x
    ;### xxlb.atl(20) x = x + XSPACE
    clc
    adc #root__XSPACE
    sta x
    ;### xxlb.atl(21) inc idx
    inx
    iny
    tya
    cpy #8
    jne _lbl4
    sty _s1__row
    stx idx
    lda y
    clc
    adc #root__YSPACE
    sta y
    inc _s0__line
    lda _s0__line
    cmp #8
    jne _lbl5
    ;### xxlb.atl(30) "[idx] [x] [y]"
    lda #0
    sta idx
    ;### xxlb.atl(30) "[idx] [x] [y]"
    _lbl7:
    ;### xxlb.atl(27) x = px(idx)
    ldx idx
    lda px,x
    sta x
    ;### xxlb.atl(28) y = py(idx)
    lda py,x
    sta y
    ;### xxlb.atl(29) "[idx] [x] [y]"
    jsr _std_print_out
    dta b(129),a(idx)
    dta b(1),c' '
    dta b(129),a(x)
    dta b(1),c' '
    dta b(129),a(y)
    dta b(128)
    dta b(0)
    ;### xxlb.atl(30) "[idx] [x] [y]"
    inc idx
    ;### xxlb.atl(30) "[idx] [x] [y]"
    lda idx
    cmp #64
    jne _lbl7
    _lbl8:
    jmp _lbl8
    px:
    .ds 64
    py:
    .ds 64
    icl 'C:\Users\Rudla\Projects\atalan\src\platform\atari\atari.asm'

    • 8: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    0xF oczywiscie ze rozne j. maja swoje zastosowania i jesli nie licvzymy sie z dlugoscia programu i czasem jego wykonania a zalezy nam tylko na czasie uruchomienia programu to wybor innego niz assembler jezyka jest uzasadniony. wywolywanie funkcji jest bardzo widocznym przykladem ale chcialem pokazac ze i najprostrze konstrukcje jak w tym przypadku zagniezdzona petla tez nie bedzie optymalnie kompilowana. odnosnie Twojego programiku... zapomnij o rysunku (wiedzialem ze beda problemy ;-) to ma byc programik dzialajacy na atari, dwie petelki zrzucajace do tablicy wspolrzedne 64 punktow (na rys. byl przyklad jak te punkty na przyklad mogly by byc ulozone - przeczytaj wyzej dlaczego akurat tak)

    rudla: plik .obj ?
    • 9: CommentAuthorilmenit
    • CommentTime6 Sep 2010
     
    Nie rozumiem co ten test ma dowieść... Że asembler można ręcznie optymalizować znacznie bardziej niż kod pisany w języku wyższego poziomu? Że da się w nim stworzyć szybszy kod? Że kompilatory nie generują optymalnego kodu, a człowiek jest w stanie? Przecież to oczywiste.
    • 10: CommentAuthor0xF
    • CommentTime6 Sep 2010
     
    Moim zdaniem dowodzi, że Atalan generuje rewelacyjny kod (patrząc na powyższe listingi) i warto się nim zainteresować.
    • 11: CommentAuthorilmenit
    • CommentTime6 Sep 2010 zmieniony
     
    To wersja w C powyższego ATALANowego kodu:
    // cc65 -Cl -T -Osir --cpu 6502 -t atari main.c 

    #define OFFSET 10
    #define XSPACE 20
    #define YSPACE 20

    unsigned char px[64];
    unsigned char py[64];
    unsigned char idx,line,row,x,y;

    void main(void)
    {
    for (line=0;line<8;++line)
    {
    x=0;
    if (line%2!=0)
    x=OFFSET;
    for (row=0;row<8;++row)
    {
    px[idx]=y;
    py[idx]=x;
    ++idx;
    x+=XSPACE;
    }
    y+=YSPACE;
    }
    }


    wynikowy ASM:
    .segment	"BSS"

    _px:
    .res 64,$00
    _py:
    .res 64,$00
    _idx:
    .res 1,$00
    _line:
    .res 1,$00
    _row:
    .res 1,$00
    _x:
    .res 1,$00
    _y:
    .res 1,$00

    ; ---------------------------------------------------------------
    ; void __near__ main (void)
    ; ---------------------------------------------------------------

    .segment "CODE"

    .proc _main: near

    .segment "CODE"

    ;
    ; for (line=0;line<8;++line)
    ;
    lda #$00
    sta _line
    L0005: lda _line
    cmp #$08
    bcs L0006
    ;
    ; x=0;
    ;
    lda #$00
    sta _x
    ;
    ; if (line%2!=0)
    ;
    lda _line
    and #$01
    beq L000F
    ;
    ; x=OFFSET;
    ;
    lda #$0A
    sta _x
    ;
    ; for (row=0;row<8;++row)
    ;
    L000F: lda #$00
    sta _row
    L0014: lda _row
    cmp #$08
    bcs L0015
    ;
    ; px[idx]=y;
    ;
    ldy _idx
    lda _y
    sta _px,y
    ;
    ; py[idx]=x;
    ;
    ldy _idx
    lda _x
    sta _py,y
    ;
    ; ++idx;
    ;
    inc _idx
    ;
    ; x+=XSPACE;
    ;
    lda #$14
    clc
    adc _x
    sta _x
    ;
    ; for (row=0;row<8;++row)
    ;
    inc _row
    jmp L0014
    ;
    ; y+=YSPACE;
    ;
    L0015: lda #$14
    clc
    adc _y
    sta _y
    ;
    ; for (line=0;line<8;++line)
    ;
    inc _line
    jmp L0005
    ;
    ; }
    ;
    L0006: rts

    .endproc

    • 12: CommentAuthorrudla
    • CommentTime6 Sep 2010
     
    @xxl: .xex added to original comment
    • 13: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    ilmenit ma dowiesc, ze kompilatory robia niepotrzebne narzuty nawet w najprostrzych konstrukcjach i ze pietrza sie one przy zagniezdzeniach. ciekawy jestem czy nie dojdzie tu do syt. ze lepiej taka tablice 128 bajtow zadeklarowac niz ja generowac... poza tym nie chodzi o optymalizacje reczna bo tu zawsze mozna sie przyczepic.
    moim zdaniem j. takiej atalan, action!, c sa rewelacyjne ze wzgle3du na to ze pozwalaja kazdemu napisac szybko program ale nie ze wzgledu na jakosc generowanego kodu.

    > Moim zdaniem dowodzi, że Atalan generuje rewelacyjny kod

    0xF jesli juz Atalan zostal pierwszy wyciagniety to lecimy od gory (nie sprawdzam programu, czekam na obj):

    ;### xxlb.atl(16) if line mod 2 <> 0 then x = OFFSET
    lda _s0__line
    and #1
    sta _s0___3
    cmp #0
    jeq _lbl2
    lda #root__OFFSET
    sta x

    po co kompilator dodal to:
    sta _s0___3
    cmp #0
    to nie ma nic wspolnego z reczna optymalizacja. na 14 bajtow 4 sa niepotrzebne (licze na oko)

    ciekawe jak action! lub c skompilowal by takiego ifa
    • 14: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    rudla: program nie dziala tak jak trzeba, marginesy wynosza 0 oraz punkty w poziomie maja taka sama wspolrzedna...

    ilmenit o widzisz, z ifem c sobie poradzil duzo lepiej nic atalan, pomijam ze algorytm programu nie jest taki jak trzeba moglbys to skompilowasc i podac obj?
    • 15: CommentAuthorilmenit
    • CommentTime6 Sep 2010 zmieniony
     
    Tu nie ma co dowodzić - kompilatory CC65, Atalan i Action! robią dodatkowe i niepotrzebne narzuty. Co z tego, gdy narzut taki jest w większości przypadków pomijalny...
    Nawet patrząc na Twoje gry ( ->link<- ) większość z nich można by napisać w C z tylko kilkoma procedurami asemblerowymi.
    EDIT: Plik wykonywalny dołączyłem. Algorytm starałem się dać ten sam co w Atalanie (języka nie znam).
    • 16: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    bo czesc z nich byla napisana w c a pozniej przepisana na assemblera. Twoj programik sie nie uruchamia na emulu.
    • 17: CommentAuthorilmenit
    • CommentTime6 Sep 2010 zmieniony
     
    Programik się uruchamiał i wypełniał tablicę. Nie kończył się poprawnie - dodałem na końcu pętlę nieskończoną.
    Tak więc przepisanie z C na asm było albo w ramach nauki, albo sztuką dla sztuki... ;)
    • 18: CommentAuthor0xF
    • CommentTime6 Sep 2010
     

    xxl:

    na 14 bajtow 4 sa niepotrzebne

    14 lat temu bym Ci przytaknął. Teraz się nie zgodzę: za cenę tych 4 bajtów (które nawet na platformie Atari 2600 są zaniedbywalne) kod źródłowy jest bardziej czytelny dla 99% programistów.
    • 19: CommentAuthorxxl
    • CommentTime6 Sep 2010 zmieniony
     
    ilmenit, fakt dziala, musialem zle sciagnac poprzednio. a wiec zeby wygenerowac tablice 128 bajtow potrzeba skompilowanego programu w c zajmujacego ponad 512 bajtow, w tym wypadku atalan jest duzo lepszy

    > 14 lat temu bym Ci przytaknął. Teraz się nie zgodzę: za cenę tych 4 bajtów (które nawet na platformie Atari 2600 są zaniedbywalne) kod źródłowy jest bardziej czytelny dla 99% programistów.

    kod zrodlowy jest tak samo czytelny, to niedociagniecia kompilatora kod wynikowy zawiera niepotrzebnych kilka bajtow i nie wynika to z optymalizacji.

    ---
    nie mozna sie rozpisywac o jakosci kodu bo ten algorytm jest bledny, tablica tez nie jest przechowywana jak bylo w zalozeniach...
    • 20: CommentAuthorilmenit
    • CommentTime6 Sep 2010
     
    XXL, dajesz zadanie, które jest sformułowane w niejasny sposób, nie mówisz co będzie oceniane i twierdzisz, że powyższy kod w C jest skomplikowany... Gdybyś napisał, że będziesz patrzył na wielkość pliku wynikowego, to skompilowałbym go tak, żeby był sam kod bez runtime C. Ale już mi się nie chce. Z mojej strony EOT, temat bez sensu.
    • 21: CommentAuthor0xF
    • CommentTime6 Sep 2010
     
    Zgadzam się, również EOT.
    • 22: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    w 13 poscie pisalem, ze boje sie ze dojdzie do syt. ze kod generujacy bedzie dluzszy od samej tablicy... ilmenit przeciez nawet nie czepialem sie tego ze zmienne niue sa przechowywane na stronie 0, to nie o to chodzi, czy ten kod moze dzialac bez runtime? sprawa nastepna, specjalnie problem zostal tak przedstawiony zeby wymusic pewna konstrukcje algorytmu szkoda, ze nie zostal prawidlowo napisany bo mozna by bylo przesledzic gdzie faktycznie jest cos nie tak, szkoda po prostu ze sam nie napisales (zadanie jest bardzo jasno i jednoznacznie zdefiniowane) tylko oparles sie na tym co rudla pokazal. dobrze ze chociaz udalo sie zlapac tego ifa z atalana, kompilator jest w fazie tworzenia mam nadzieje to zostanie poprawione.
    • 23: CommentAuthorrudla
    • CommentTime6 Sep 2010 zmieniony
     
    @xxl: ok, maybe I do not understand correctly the assignment. Also I didn't see any requirements considering layout of the resulting array so I chose the most logical arrangement I would use on 6502.

    In fact, I expected you to write 'optimal' assembler code, that could be used as holy grail that our compilers should achieve :-)
    That would also greatly clarify the expected result of the program.
    • 24: CommentAuthorrudla
    • CommentTime6 Sep 2010
     
    sta _s0___3
    cmp #0

    was not added, it was not removed.

    Atalan is not finished yet, and I'm sure it will remove this artifacts. It does not perform data flow analysis yet (that's the sta _s0___3).
    And I didn't write rule, for ignoring cmp#0 after and (or other flag modifying instructions).
    • 25: CommentAuthorxxl
    • CommentTime6 Sep 2010
     
    rudla wiem, ze czytasz po polsku ale jednak nie wszystko mogles zrozumiec... dzieki ze napisales program, bo moglem zaznajomic sie z atalanem lepiej.
    nie, nie napisze tego w asemblerze bo nie chodzi o to zeby porownywac program napisany z palca z kompilowanym ale chcialbym jeszcze porownac program napisany w action.

    co do tego tego konkretnego ifa z atalana uwazam, ze c lepiej sobie z nim poradzil. wiem, ze atalan jest w produkcji te uwagi moga pomoc. zwoc tez uwage na for, w tej petli warunek powinien byc sprawdzany na poczatku a tu tak nie jest, co jesli w for podstawiona bedzie zmienna. chyba, ze wyglad petli uzalezniasz od deklaracji wprost to szacunek.
    • 26: CommentAuthorrudla
    • CommentTime6 Sep 2010 zmieniony
     
    Yes, I can read polish, but some nuances and not very common words are out of my skill. Btw. that's an interesting story I think: I learned polish by watching polish TV. We were able to watch polish program 1 when I was small child and at that time I was watching Smurfs and Bee Maja and 'kino nocne' (when parents were not at home) :-) And I still remember quite a lot :-)

    Even if checking condition at the beginning of loop is on my todo list, in this particular case compiler knowns it is not necessary. It should also be possible to switch the loop from 0..7 to 7..0 and remove the extra test.

    Etc... :-)

    However, to praise Atalan a little. It detected that it is possible to use y register for inner loop index.
    • 27: CommentAuthorxxl
    • CommentTime7 Sep 2010 zmieniony
     
    napisalem w action! ten programik,

    proc main()

    byte idx=[$00],my=[$f8],mx=[$05]
    ,xmargin=[34],ymargin=[24]
    ,x=[5],y=[4]
    ,i
    byte array tab=$600

    do
    for i=0 to 7 do
    tab[idx]=x
    idx==+1
    tab[idx]=y
    idx==+1
    my==*-1
    y==+my
    x==+xmargin
    od
    y==+ymargin
    if idx&$80 then exit fi
    mx==!9
    x=mx
    od
    return


    deasemblowany kod wynikowy jest najgorszy w porownaniu z atalanem i c.
    przyklad:
    idx==+1
    kompiluje mniej wiecej tak:
    clc
    lda idx
    adc #1
    sta idx
    zamiast
    inc idx

    indeksowanie tablicy:
    action:
    tab[idx]=x
    kompiluje tak:
    clc
    lda <tab
    adc idx
    sta zeropage
    lda >tab
    sta zeropage+1
    ldy #0
    lda x
    sta (zeropage),y

    nie wiem jak zadeklarowac w action tablice, deklarujac jej rozmiar i polozenie moze to by cos zmienilo w kompilacji

    moze uda sie komus ten program napisac 'pod' action! zeby jezyk nie wypadl tak blado ale jak narazie action bardzo mocno przegrywa z atalanem i c.
    • 28: CommentAuthorstc
    • CommentTime7 Sep 2010
     
    • 29:
       
      CommentAuthorjhusak
    • CommentTime7 Sep 2010
     
    Siłą atalana jest możliwość włąsnoręcznej optymalizacji kodu przed kompilacją. Mnożysz przez 77? i zajmuje to zbyt długo? No to piszesz swoją własną procedurkę jako regułę w mnożeniu przez 77 i atalan posłusznie używa tej reguły przy mnożeniu przez 77. I tylko przez 77.

    Rudla pracuje nad optymalizacją, więc ta dyskusja ma sens dla niego. Zwłaszcza te próbki kodu w C.

    @xxl. Napisz taką gierkę (silnik) jak snake, tetris czy little 15 w asemblerze w 1 dzień.

    Mi to właśnie tyle zajęło (jeden wieczór - kilka godzin kodowania i namawiania atalana, aby dobrze kompilował) potem było dopieszczanie.

    I to jest zabawa! Jest kodowanie - jest efekt!

    A jak będziecie kodować w atalanie i skrzętnie zapisywać błędy oraz wyślecie je do Rudli lub mnie, to będziecie mieli wkład w tworzenie NOWEGO.
    • 30: CommentAuthorxxl
    • CommentTime8 Sep 2010
     
    nie napisze :-) szybkosc pisania to wielki pozytek z j. takich jak np. atalan.

    > I to jest zabawa! Jest kodowanie - jest efekt!

    gdybys ja pisal 10 dni mialbys 10 * wiecej przyjemnosci :p
    • 31:
       
      CommentAuthorjhusak
    • CommentTime8 Sep 2010
     
    Przyjemności nie, ale satysfakcji tak!
    • 32:
       
      CommentAuthorKaz
    • CommentTime8 Sep 2010
     
    A to teraz rozumiem, czemu koderzy pisza gry latami! Dozuja sobie przyjemnosc :D
    • 33:
       
      CommentAuthorjhusak
    • CommentTime8 Sep 2010
     
    W sumie w seksie jest podobnie. Można stosować języki wysokiego poziomu, jak i zwykłe hardcore.

    Dajmy na to taki Python ... Albo Lua... Lub Java ... Lub Ass...Embler.

    Mam nadzieję, że to forum od 30 lat.
    • 34: CommentAuthorxxl
    • CommentTime9 Sep 2010
     
    niewazne jaki temat i tak skonczy sie na dxxxx ;-)

    ten programik wyzej mozna zapisac krocej ale... w action nie ma continue? czy w atalanie mozna przerwac biezacy krok petli i przejsc do nastepnego?
    • 35: CommentAuthorrudla
    • CommentTime9 Sep 2010 zmieniony
     
    Atalan currently does not have anything like C++ break or continue. It should be possible to use goto.
    Hopefully in some future release :-)
    • 36: CommentAuthoremka
    • CommentTime9 Sep 2010
     
    Śledzę ten wątek od samego początku, kompiluję dołączone programy i porównuję kody wynikowe, xxl mój ACTION! Nie potrafi skompilować twojego programu. Masz może jakiś inny kompilator?
    PS.
    Walczysz o każdy cykl zegarowy więc dlaczego mnożysz zmienną byte przez -1? to przecież wywoła procedurę biblioteczną.
    • 37: CommentAuthorxxl
    • CommentTime9 Sep 2010 zmieniony
     
    emka pisalem progrmik na pc a pozniej wstukiwalem do emulatora wiec jesli sie nie kompiluje to stawiam na wielkosc liter - action! lyka tylko duze.

    doczytalem juz ze action! dla mnozen zawsze wola biblioteke, tylko ze to jest dosc specyficzne mnozenie (zmiena znaku) po cichu liczylem na inteligencje kompilatora:
    lda byte
    eor #$ff
    clc
    adc #1
    sta byte
    mysle, ze gdyby ten programik napisal ktos kto zna action! (ja znam tylko na poziomie czytania programu :) to wygladalby duzo lepiej, ale jak narazie action! bardzo mnie rozczarowal mimo ze i tak za wiele sie nie spodziewalem ;-)

    rudla, goto na poczatek/koniec petli bylo by dobre bo mam nadzieje mozna bedzie zrobic goto do poczatku/konca petli zewnetrznej :)

    ---
    a nawet mozna to jeszcze lepiej napisac tylko potrzebna bedzie samomodyfikacja programu, czy atalan umozliwia samomodyfikacje programu?
    • 38:
       
      CommentAuthorCosi
    • CommentTime9 Sep 2010
     

    xxl:

    stawiam na wielkosc liter - action! lyka tylko duze.

    Ojjj, niekoniecznie ;-)
    • 39: CommentAuthoremka
    • CommentTime9 Sep 2010
     
    Xxl naprawdę programy pisane na PC wklepujesz ręcznie do emulatora?
    Emulator atari800win posiada możliwość odczytania katalogu PC jako twardego dysku. Tworzy w systemie urządzenie H1:-H4: i H6:-H9: przy czym katalog podpisany jako H6 to ten sam katalog co H1: itd... tylko że przy wczytywaniu lub zapisie przez H6: PC-towy znak końca linii $0a jest zamieniany na atatowski $9b i odwrotnie. Istnieje jeszcze jeden problem, w starych edytorach PC-towych koniec linii jest zapisany przy pomocy dwóch bajtów $0d i $0a i przed wczytanie do emulatora należy wczytać do jakiegoś edytora który zgubi bajt $0d.
    Myślałem że to wiedzą wszyscy.
    • 40: CommentAuthorxxl
    • CommentTime9 Sep 2010 zmieniony
     
    emka jak widac nie wszyscy ;)

    zalaczam zrzut dla atari win plus
    oraz obrazek z dzialania
    • 41: CommentAuthorrudla
    • CommentTime9 Sep 2010
     
    I have been working on the data-flow analysis and have finished first version. There will be lot new errors, but current results look promising.
    Here is how the Atalan version of the generated code looks now. (cmp #0 still remains, as it is different kind of optimization).

    idx equ 128
    x equ 129
    y equ 130
    root__OFFSET equ 10
    root__XSPACE equ 20
    root__YSPACE equ 20
    _s0__line equ 131
    org $2e0
    dta a($2000)
    org $2000
    ;### xxlb.atl(12) y = 0
    lda #0
    sta y
    ;### xxlb.atl(13) idx = 0
    sta idx
    ;### xxlb.atl(14) for line:0..7
    sta _s0__line
    _lbl5:
    ;### xxlb.atl(15) x = 0
    lda #0
    sta x
    ;### xxlb.atl(16) if line mod 2 <> 0 then x = OFFSET
    lda _s0__line
    and #1
    cmp #0
    jeq _lbl2
    lda #root__OFFSET
    sta x
    _lbl2:
    ;### xxlb.atl(17) for row:0..7
    lda #0
    ldx idx
    tay
    _lbl4:
    ;### xxlb.atl(18) py(idx) = y
    lda y
    sta py,x
    ;### xxlb.atl(19) px(idx) = x
    lda x
    sta px,x
    ;### xxlb.atl(20) x = x + XSPACE
    clc
    adc #root__XSPACE
    sta x
    ;### xxlb.atl(21) inc idx
    inx
    iny
    cpy #8
    jne _lbl4
    stx idx
    ;### xxlb.atl(22) y = y + YSPACE
    lda y
    clc
    adc #root__YSPACE
    sta y
    inc _s0__line
    lda _s0__line
    cmp #8
    jne _lbl5
    ;### xxlb.atl(26) for idx
    lda #0
    sta idx
    _lbl7:
    ;### xxlb.atl(27) x = px(idx)
    ldx idx
    lda px,x
    sta x
    ;### xxlb.atl(28) y = py(idx)
    lda py,x
    sta y
    ;### xxlb.atl(29) "[idx] [x] [y]"
    jsr _std_print_out
    dta b(129),a(idx)
    dta b(1),c' '
    dta b(129),a(x)
    dta b(1),c' '
    dta b(129),a(y)
    dta b(128)
    dta b(0)
    inc idx
    lda idx
    cmp #64
    jne _lbl7
    _lbl8:
    jmp _lbl8
    px:
    .ds 64
    py:
    .ds 64
    icl 'C:\Users\Rudla\Projects\atalan\src\platform\atari\atari.asm'