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
     
    Czy ktoś próbował korzystać z tego środowiska?

    ->link<-

    Wygląda bardzo ciekawie... :)
    • 2: CommentAuthorilmenit
    • CommentTime29 Sep 2009
     
    Nie udostępniają wersji demo, nie udostępniają nawet ceny... :/ Pozostanę raczej przy CC65.
    • 3: CommentAuthormaÅ‚y
    • CommentTime30 Sep 2009
     
    Jest i demo i cena, ale trzeba przyznać, że dość zaporowa.
    ->link<-
    • 4: CommentAuthorAlex
    • CommentTime30 Sep 2009 zmieniony
     
    Może składka?... :-) 40 osób po $20 i mamy :-)
    • 5:
       
      CommentAuthorKaz
    • CommentTime30 Sep 2009
     
    "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
     
    Dobra myśl. Z bibliotekami do 6502 only może puścili by za 1/3 ceny.
    • 7: CommentAuthorilmenit
    • CommentTime30 Sep 2009 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
     
    W takim razie można lepiej wydać te $745.
    • 9: CommentAuthorilmenit
    • CommentTime30 Sep 2009
     
    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
     
    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 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.