Tekst źródłowy strony CC65

Sam program piszemy na PC w dowolnym edytorze tekstu jak Notatnik czy CodeGenie itp, a kompilator C czyli cc65 zamieni nam go na kod maszynowy 6502.
Cały pakiet programów do tworzenia w C znajdziemy na stronie domowej projektu
[http:\\www.cc65.org CC65]

<br />
<br />

Możemy też od razu wpaść na ftp-a <a href="ftp://ftp.musoftware.de/pub/uz/cc65/">ftp.musoftware.de/pub/uz/cc65/</a> i pobrać plik z bibliotekami dla Atari XE/XL "cc65-atari-2.10.0-1.zip" oraz plik z kompilatorem przeznaczonym dla konkretnej platformy OS/2, Linux, Windows, np. "cc65-win32-2.10.0a-1.zip" czyli Windows.
<br />
<br />
W tym arykule skupie się właśnie na wersji cc65 dla Windows. Jeśli mamy już ściągnięte oba pliki, znajdujemy dla nich miejsce na którejś z partycji (ja wybrałem C) i rozpakowujemy je do np. katalogu C:\CC65
<br />
<br />
Teraz musimy jeszcze ustawić troche zmiennych środowiskowych, aby kompilator, linker wiedział gdzie co jest. W przypadku rodziny Windows 9x, dopisujemy w pliku AUTOEXEC.BAT:
<pre>
PATH=tutaj cos juz jest;C:\CC65\BIN

SET CC65_INC=C:\CC65\INCLUDE
SET CC65_LIB=C:\CC65\LIB
SET LD65_CFG=C:\CC65\DOC
</pre>

W przypadku Windows XP (i chyba też 2000), robimy to następująco:
<br />
<br />
<tt>
Mój Komputer -> Właściwości -> Zaawansowane -> Zmienne środowiskowe -></tt> dopisujemy w oknie <tt>Zmienne systemowe</tt>, czyli klikamy <tt>"Nowa"</tt> i uzupełniamy oba pola <tt>"Nazwa zmiennej"</tt> i <tt>"Wartość zmiennej"</tt> podobnie jak ma to miejsce w AUTOEXEC-u.
<br />
<br />
Teraz resetujemy komputer i możemy zacząć bawić się cc65 pod Windowsem.
<br />
<br />
W katalogu C:\CC65\BIN znajdują się wszystkie pliki wykonywalne pakietu cc65:
<pre>
    ar65 - program do tworzenia bibliotek *.lib i operacji na nich, np. ar65 l atari.lib
           wyswietli nam listę modułów wchodzących w skład bibioteki atari.lib

    ca65 - makro assembler dla procesorów 6502, 65C02 i 65816
    
    cc65 - kompilator języka C przeznaczony dla rodziny procesorów 6502
    
    cl65 - kompilator i linker w jednym
    
    co65 - programik do operacji na skompilowanych plikach *.o
    od65 - też coś robi z plikami *.o
    
    da65 - disassemler, stosuje zapis strawny na makro assemblera ca65
    
    grc  - to się Atarowcom nie przyda, bo jest to kompilator dla systemu GEOS z C64
    
    ld65 - linker, czyli programik który składa do kupy wszystko i tworzy atarowskiego exe-ka
</pre> 
<br />

Teraz wypadałoby coś skompilować, czas więc na nieśmiertelny przykład, pewnie w Basic'u też to pisaliście.
<br />
<br />

<b><u>Przykład 1:</u></b>
<pre>
#include < stdio.h >

int main (void)
{
 printf("Hello, world!\n");
 return 0;
}
</pre>

Nasz program zapiszemy do pliku np. "hello.c", aby go skompilować piszemy "<b>cl65 -O -t atari hello.c -o hello.xex</b>" i to wszystko, powstał plik HELLO.XEX który możemy już wczytać spod DOS-a. Uruchomienie go bezpośrednio nic nie da, musi być uruchomiony spod DOS-a.
<br />
<br />
Parametry które przekazaliśmy kompilatorowi cl65 oznaczają (wielkość liter jest rozróżniana):
<pre>
    -O        optymalizacja kodu, tworzy szybszy kod maszynowy
    -t sys    docelowy system, domyślnie jest to C64 :P
    -o plik   nazwa pliku wyjściowego
</pre>
Wywołanie <b>cl65</b> to najszybszy i najprostszy sposób kompilacji. Skompilowany program domyślnie ładuje się od <b>$2E00</b>, startuje od <b>$2E01</b>, maksymalna długość skompilowanego programu może wynieść <b>$8E20</b> bajtów. Stos programowy liczy <b>$0800</b> bajtów pamięci. Strona zerowa używana jest od bajtu <b>$82-$FF</b>.
<br />
<br />


Domyślne ustawienia dla linkera (plik ATARI.CFG):
<pre>
MEMORY {
    ZP: start = $82, size = $7E, type = rw, define = yes;
    HEADER: start = $0000, size = $6, file = %O;
    RAM: start = $2E00, size = $8E20, file = %O;    # $8E1F: matches upper bound $BC1F
}
SEGMENTS {
    EXEHDR: load = HEADER, type = wprot;
    CODE: load = RAM, type = wprot, define = yes;
    RODATA: load = RAM, type = wprot;
    DATA: load = RAM, type = rw;
    BSS: load = RAM, type = bss, define = yes;
    ZEROPAGE: load = ZP, type = zp;
    AUTOSTRT: load = RAM, type = wprot;
}
FEATURES {
    CONDES: segment = RODATA,
	    type = constructor,
	    label = __CONSTRUCTOR_TABLE__,
	    count = __CONSTRUCTOR_COUNT__;
    CONDES: segment = RODATA,
	    type = destructor,
	    label = __DESTRUCTOR_TABLE__,
	    count = __DESTRUCTOR_COUNT__;
}
SYMBOLS {
    __STACKSIZE__ = $800;	# 2K stack
}
</pre>
Jednak jakiekolwiek zmiany w pliku <b>*.CFG</b> nie zostaną zauważone jeśli
będziemy kompilować używając komendy <b>"-t atari"</b>, trzeba ją zastąpić przez <b>"-C atari.cfg"</b>. Jeśli chcemy mieć też wpływ na typ CPU dla którego będzie generowany kod, lepiej jeśli rozbijemy proces generowania pliku wyjściowego na kompilację, asemblację i linkowanie, wtedy wszystko będzie pod kontrolą.
<br />
<pre>
    cc65 -O --cpu 6502 -t atari hello.c -o hello.s
    ca65 -t atari hello.s -o hello.o
    ld65 -C atari.cfg -o hello.xex atari.o hello.o atari.lib
</pre>
Kompilator <b>cc65</b> tworzy z pliku <b>hello.c</b> plik <b>hello.s</b>,
następnie makro assembler <b>ca65</b> z pliku <b>hello.s</b> tworzy <b>hello.o</b> i ostatecznie linker <b>ld65</b> z pliku <b>hello.o</b> i przy pomocy biblioteki <b>atari.lib</b> i <b>atari.o</b> oraz pliku konfiguracyjnego <b>atari.cfg</b> tworzy wykonywalny plik Atari <b>hello.xex</b>
<br />
<br />
Jeśli chcemy aby kod programu był wykonywany na 65816, zmieniamy zapis
<b>--cpu 6502</b> na <b>--cpu 65816</b>. Czyż nie jest to cudownie proste :).

<br />
<br />

<b><u>Przykład 2:</u></b>
<pre>
#include < stdio.h >

int main (void)
{
 char str1[30],str2[30];
 int i;
 
 puts("wprowadz lancuch 1"),gets(str1);
 puts("wprowadz lancuch 2"),gets(str2);

 for (i=0; str1[i]==str2[i]; i++)
 {
 }
 
  if (str1[i]==0)       // standard ansi, ciag znakow zakonczony zerem
  {
   puts("oba lancuchy sa identyczne");
   return 0;
  }

   puts("lancuchy sa rozne");
 
 return 0;
}
</pre>
Progamik pyta się o dwa łańcuchy znaków, potem je porównuje i informuje czy łańcuchy są identyczne, czy też różne. Jest jeszcze biblioteczna funkcja C -> "strcmp" która porówna ciągi, ale przecież jej użycie byłoby zbyt proste :)
<br />
<br />


<b><u>Przykład 3:</u></b>
<pre>
/* clock example: countdown */
#include < stdio.h >
#include < time.h >

void wait ( int seconds )
{
  clock_t endwait;
  endwait = clock () + seconds * CLK_TCK ;
  while (clock() < endwait) {}
}

int main ()
{
  int n;
  printf ("Starting countdown...\n");
  for (n=10; n>0; n--)
  {
    printf ("%d\n",n);
    wait (1);
  }
  printf ("FIRE!!!\n");
  return 0;
}
</pre>
Programik zlicza od 10 do 0, wypisując stosowny komunikat na ekranie. Jest to też przykład wykonania opóźnienie z użyciem "time.h"
<br />

<br />
<hr />
<br />

Ci co programują w C, na pewno ucieszą się z w/w kompilatora. Można stworzyć np. bibliotekę do odczytu obrazków w różnych formatach (HIP, TIP), czy playerów, dzięki temu w łatwy sposób powstałaby przeglądarka pod Sparte czy zwykły DOS. Może Macgyver napisze jeszcze raz MegaPlayera :)
<br />
<br />
Można też kazać kompilatorowi aby generował kod dla 65816, dzięki czemu
w prosty sposób napiszemy aplikację dla 16-bitowej wersji 6502 :) nie zagłębiając się w poznawanie nowych rozkazów i trybów adresowania CPU.

<br />
<br />
Nie ma jednak róży bez kolców. Wstawianie wstawek assemblerowych musi odbywać się poprzez pliki z rozszerzeniem *.s, a tak zwiększona liczba plików nie sprzyja ogólnej czytelności projektu. Przydzialana programowi pamięć w zasadzie mieści się w granicy $2000-$BFFF, troche mało jeśli ktoś myśli o większym projekcie. Tego typu ograniczenia skutecznie przychamowały zapał Konopa do napisania dema w C. Problem z pamięcią miał też autor atarowskiej wersji systemu Contiki, który posłużył się specjalnie okrojoną wersją DOS - PicoDos aby tylko wcisnąć więcej kodu poniżej adresu $2000.
<br />
<br />

p.s.
<br />
podziękowania dla Konopa, za oświecenie w kwestiach związanych z C :)