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

• Zapomniane hasło?
• Poproś o członkostwo

1. • 1: CommentAuthorAlex
   • CommentTime29 Sep 2009

    
   Czy ktoś próbował korzystać z tego środowiska?
   
   ->link<-
   
   Wygląda bardzo ciekawie... :)
2. • 2: CommentAuthorilmenit
   • CommentTime29 Sep 2009

    
   Nie udostępniają wersji demo, nie udostępniają nawet ceny... :/ Pozostanę raczej przy CC65.
3. • 3: CommentAuthormaÅ‚y
   • CommentTime30 Sep 2009

    
   Jest i demo i cena, ale trzeba przyznać, że dość zaporowa.
   ->link<-
4. • 4: CommentAuthorAlex
   • CommentTime30 Sep 2009 zmieniony

    
   Może składka?... :-) 40 osób po $20 i mamy :-)
5. • 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. • 6: CommentAuthorAlex
   • CommentTime30 Sep 2009

    
   Dobra myśl. Z bibliotekami do 6502 only może puścili by za 1/3 ceny.
7. • 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. • 8: CommentAuthor0xF
   • CommentTime30 Sep 2009

    
   W takim razie można lepiej wydać te $745.
9. • 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. • 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. • 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.