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 23:09 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 00:09
       
      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 00:09
       
      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 08:09
       
      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 09:09 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 10:09 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 10:09 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 10:09
       
      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 11:09
       
      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 11:09
       
      Moim zdaniem dowodzi, że Atalan generuje rewelacyjny kod (patrząc na powyższe listingi) i warto się nim zainteresować.
      • 11: CommentAuthorilmenit
      • CommentTime6 Sep 2010 12:09 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 12:09
       
      @xxl: .xex added to original comment
      • 13: CommentAuthorxxl
      • CommentTime6 Sep 2010 12:09
       
      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 12:09
       
      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 12:09 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 13:09
       
      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 14:09 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 14:09
       

      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 15:09 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 15:09
       
      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 15:09
       
      Zgadzam się, również EOT.
      • 22: CommentAuthorxxl
      • CommentTime6 Sep 2010 16:09
       
      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 18:09 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 18:09
       
      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 20:09
       
      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 21:09 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 14:09 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 18:09
       
      • 29:
         
        CommentAuthorjhusak
      • CommentTime7 Sep 2010 22:09
       
      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 15:09
       
      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 17:09
       
      Przyjemności nie, ale satysfakcji tak!
      • 32:
         
        CommentAuthorKaz
      • CommentTime8 Sep 2010 18:09
       
      A to teraz rozumiem, czemu koderzy pisza gry latami! Dozuja sobie przyjemnosc :D
      • 33:
         
        CommentAuthorjhusak
      • CommentTime8 Sep 2010 21:09
       
      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 15:09
       
      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 16:09 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 16:09
       
      Ś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 19:09 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 19:09
       

      xxl:

      stawiam na wielkosc liter - action! lyka tylko duze.

      Ojjj, niekoniecznie ;-)
      • 39: CommentAuthoremka
      • CommentTime9 Sep 2010 21:09
       
      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 21:09 zmieniony
       
      emka jak widac nie wszyscy ;)

      zalaczam zrzut dla atari win plus
      oraz obrazek z dzialania
      • 41: CommentAuthorrudla
      • CommentTime9 Sep 2010 22:09
       
      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'