atarionline.pl Prawdziwe C na 6502 - 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:
         
        CommentAuthorAlex
      • CommentTime29 Sep 2009 15:09
       
      Czy ktoś próbował korzystać z tego środowiska?

      ->link<-

      Wygląda bardzo ciekawie... :)
      • 2: CommentAuthorilmenit
      • CommentTime29 Sep 2009 22:09
       
      Nie udostępniają wersji demo, nie udostępniają nawet ceny... :/ Pozostanę raczej przy CC65.
      • 3: CommentAuthormaÅ‚y
      • CommentTime30 Sep 2009 07:09
       
      Jest i demo i cena, ale trzeba przyznać, że dość zaporowa.
      ->link<-
      • 4:
         
        CommentAuthorAlex
      • CommentTime30 Sep 2009 15:09 zmieniony
       
      Może składka?... :-) 40 osób po $20 i mamy :-)
      • 5:
         
        CommentAuthorKaz
      • CommentTime30 Sep 2009 15:09
       
      "Prices are for reference only."

      Wiec mozna sprobowac sie dogadac, w koncu do amatorskich produkcji mogli by dac jakas wersje darmowa, okrojona z podrecznika czy co tam daja.
      • 6:
         
        CommentAuthorAlex
      • CommentTime30 Sep 2009 16:09
       
      Dobra myśl. Z bibliotekami do 6502 only może puścili by za 1/3 ceny.
      • 7: CommentAuthorilmenit
      • CommentTime30 Sep 2009 16:09 zmieniony
       
      Pobawiłem się trochę tym kompilatorem. Poniżej wynik dla prostej funkcji ustawiającej zmienną w pamięci w zależności od tego, czy funkcja znajdzie w tablicy jedną z dwóch wartości. W obydwu kompilatorach włączona optymalizacja i wykorzystanie słowa register.
      Szybkość i możliwości optymalizacji obydwu kompilatorów nie zachwycają, ale szybszy wydaje się być kod CC65 - dokładnych testów nie robiłem.
      W środowisku ADC-65 przyjemną rzeczą jest debugger, który potrafi też rozwijać struktury danych.
      Przewagą kompilatora CC65 jest dla nas możliwość generacji plików wykonywalnych dla Atari i rozwinięte dla tej platformy biblioteki np. dla operacji IO.

      Kod w C
      unsigned char found=0;

      void find_A_or_B(unsigned char *items, unsigned char size)
      {
      register unsigned char i;
      for (i=0;i<size;++i)
      {
      if (items[i]=='A' || items[i]=='B')
      {
      found=1;
      break;
      }
      }
      }

      unsigned char data[100]="Q35FZABC1AASDFKQJTWEPIOUBXCVBJKLJ@#$%LKJ!@#$QQWER";

      int main(void)
      {
      find_A_or_B(data,30);
      return 0;
      }


      Kompilacja CC65:
      ; void __near__ find_A_or_B (unsigned char*, unsigned char)
      ; ---------------------------------------------------------------

      .segment "CODE"

      .proc _find_A_or_B: near

      .segment "CODE"

      ;
      ; register unsigned char i;
      ;
      lda regbank+5
      jsr pusha
      ;
      ; for (i=0;i<size;++i)
      ;
      lda #$00
      sta regbank+5
      L0004: ldx #$00
      lda regbank+5
      jsr pushax
      ldy #$03
      lda (sp),y
      jsr tosicmp
      bcs L0005
      ;
      ; if (items[i]=='A' || items[i]=='B')
      ;
      ldy #$03
      jsr ldaxysp
      ldy regbank+5
      sta ptr1
      stx ptr1+1
      lda (ptr1),y
      cmp #$41
      beq L000D
      ldy #$03
      jsr ldaxysp
      ldy regbank+5
      sta ptr1
      stx ptr1+1
      lda (ptr1),y
      cmp #$42
      bne L0006
      ;
      ; found=1;
      ;
      L000D: lda #$01
      sta _found
      ;
      ; break;
      ;
      jmp L0005
      ;
      ; for (i=0;i<size;++i)
      ;
      L0006: inc regbank+5
      jmp L0004
      ;
      ; }
      ;
      L0005: ldy #$00
      lda (sp),y
      sta regbank+5
      jmp incsp4

      .endproc

      Wygenerowany przez ADC-65 (poprawiłem trochę czytelność).
      _find_A_or_B:	.equal	$
      php
      sei
      sec
      lda __stack_ptr
      sbc #.low.+?LSC0+?TSC0
      sta __stack_ptr
      lda __stack_ptr+1
      sbc #.high.+?LSC0+?TSC0
      sta __stack_ptr+1
      plp
      ;{
      ;register unsigned char i;
      ;
      ;i=0;
      ldy #-1+?LSC0
      lda #0
      sta (__stack_ptr),y
      ;i<size;
      .for_top 0c1h,?BOL0,?FLB0,?FLA0,1,10
      ldy #-1+?LSC0
      lda (__stack_ptr),y
      ldy #+2+?LSC0+?TSC0
      sec
      sbc (__stack_ptr),y
      bcs ?BOL0
      jmp ?FLB0
      ;++i)
      ;
      ldy #-1+?LSC0
      lda (__stack_ptr),y
      clc
      adc #1
      sta (__stack_ptr),y
      jmp ?FLC0
      ;(items[i]=='A' || items[i]=='B')
      ;
      ldy #-1+?LSC0
      lda (__stack_ptr),y
      sta __oper1
      lda #0
      sta __oper1+1
      ldy #+0+?LSC0+?TSC0
      clc
      lda (__stack_ptr),y
      adc __oper1
      sta __oper1
      iny
      lda (__stack_ptr),y
      adc __oper1+1
      sta __oper1+1
      ldy #0
      lda (__oper1),y
      sec
      sbc #65
      beq ?PLC0
      ?OCC0: .equal $
      ldy #-1+?LSC0
      lda (__stack_ptr),y
      sta __oper1
      lda #0
      sta __oper1+1
      ldy #+0+?LSC0+?TSC0
      clc
      lda (__stack_ptr),y
      adc __oper1
      sta __oper1
      iny
      lda (__stack_ptr),y
      adc __oper1+1
      sta __oper1+1
      ldy #0
      lda (__oper1),y
      sec
      sbc #66
      bne ?BOL1
      ?PLC0: .equal $
      ;found=1
      lda #1
      sta _found
      ;break;
      ;
      jmp ?BOL0
      ?BOL1: .equal $
      jmp ?FLA0
      ?BOF0: .equal $
      php
      sei
      clc
      lda __stack_ptr
      adc #.low.+?LSC0+?TSC0+0
      sta __stack_ptr
      lda __stack_ptr+1
      adc #.high.+?LSC0+?TSC0+0
      sta __stack_ptr+1
      plp
      rts
      • 8: CommentAuthor0xF
      • CommentTime30 Sep 2009 16:09
       
      W takim razie można lepiej wydać te $745.
      • 9: CommentAuthorilmenit
      • CommentTime30 Sep 2009 17:09
       
      Jak dla mnie nie warto - ADC-65 nie wspiera w ogóle Atari a generowany kod jest niekompatybilny z żadnym innym asemblerem. Asembler w CC65 jest na tyle elastyczny, że może kompilować źródła z innych istniejących asemblerów.

      CC65 eksportuje symbole, które po małej przeróbce formatu można wczytać do emulatora. Jak znajdę chwilę to dostosuję moje skrypty do formatu debuggera Altirry, co będzie już w zupełności wystarczające.
      • 10:
         
        CommentAuthorAlex
      • CommentTime30 Sep 2009 18:09
       
      Niewątpliwie CC65 jest pod wieloma względami lepszy, ale przypominam, że nie jest w pełni kompatybilny z prawdziwym C. Jedną z najpowazniejszych niedogodności przy przenoszeniu kodu jest brak obsługi zmiennych double i float ("The datatypes float and double are not available"). Są też inne braki, których lista jest podana na stronie.

      ADC-65 ma w mojej opinii większe możliwości kompilacji kodu z innych komputerów i to mi się właśnie podoba :) Obsługuje nawet 64-bitowe operacji zmiennoprzecinkowe ("32-bit and 64-bit floating point").
      • 11: CommentAuthorilmenit
      • CommentTime1 Oct 2009 12:10 zmieniony
       
      ADC-65 jest jeszcze mniej zgodny z ANSI C :)
      Na przykład w powyższym przykładzie musiałem tablicę 'data' uczynić globalną, bo ten kompilator nie wspiera zadeklarowania jej lokalnie w funkcji (niezależnie od wielkości tablicy).
      Brak float i double w kompilatorze mnie nie dziwi - w przypadku procesora 6502 wiesz jak koszmarnie wolno by działały, gdyby były zgodne z IEEE 754-1985?
      Dyskusja o tym była już dawno:
      ->link<-

      Dla CC65 jest dostępna biblioteka dla float point math (FP65) na
      ->link<-
      Nie testowałem jej.

      I tak uważam, że jest dobrze, bo np. z88dk - najlepszy kompilator C dla Spectrum nie wspiera tak podstawowej rzeczy jaką są wielowymiarowe tablice.
      Zaletą z88dk jest świetna biblioteka podstawowa - ma np. obsługę duszków programowych.