Hallo,

da ich recht viel mit C Programmiere auch auf Mikrocontroller basis, habe ich mich gefragt welche C Compiler es für den 8bitter gibt. Denn CC65 Crosscompiler habe ich mir schon gezogen aber ich würde doch schon gern Nativ am XL Proggen.

Tschau Ingo

Hast Du mal in der PD-Bibliotheck nachgesehen?

Da müßte es eigentlich einen geben.

Sleepy

Es gibt da noch den Deep Blue C Compiler von 1982,
enthält den Compiler den Linker und etliche Bibliotheken.

ob es den in der PD-Bibiliothek gibt weis ich aber nicht

Ich habe auch noch eine Diskette mit deutschen Text-Files zu dem Programm

Hmm,
was sagt meine DOSe und die ATR`s in der DIR Pgming?
- Act
- Asm
- Bas
- CCC
- FTH
- other
- Pas
- Qik

Also, "CCC" aufrufen und man findet u.a.:
- A8 C
- ACE C
- Deep Blue C
- DVC C
und einige andere (sowie Sourcen und anderer Kram). Ok, ist leider meine DOSe und meine ATR`s - aber bei Interesse kannst du mir ja mailen und ich schicke dir die sachen gezippt zu. -Andreas Koch.

Oh na das wäre ne feine sache. P.N. ist unterwegs.

hi,

was mich hier noch interessieren würde: welcher dieser c-compiler wirklich was taugt? ich hatte mal den dvc-probiert, aber meine version damals kam mit nem eigenen dos daher und lief nicht mit ramdisk, war irgendwie recht beschränkt. und der alte c65 - der mit mac65 kooperiert - erscheint mir etwas lahm, was seine erzeugnisse angeht.

danke

tot

Der Vollständigkeit halber sollte auch "Lightspeed C" genannt werden. Ich habe das Original (allerdings ist das Handbuch verschollen).

Es sind 2 ATR Images.

von OSS (Optimized System Software) gabe es auch einen C-Compiler. Ich habe das Handbuch hier, aber leider nicht die Software.

Nach meinen Erfahrungen sind alle 8bit C-Compiler umstaendlich und langsam.

Der CC65 CrossCompiler liefert gute Ergebnisse.

Ansonsten ist ACTION! das bessere "C" auf dem 8bit Atari (ACTION! ist im Grunde wie C mit einer ein wenig anderen Syntax)

Ciao

Carsten

Ich habe mir ernsthaft überlegt, c# für den 6502 zu verwenden.

Das geht in lahm und in schnell. Auf jeden Fall hätte man das dann in der Hand, wie man es möchte. Es gibt natürlich reichlich Randbedingungen und mein erster Enztwurf zum Atari-XL Framework belegt schon mal 4 bis 6k RAM. Das Arbeiten geschieht aber auf dem PC, denn die Arbeit macht ein Mono oder Visual Studio.
Insofern wäre das nicht das, was gesucht wird.

MasterI hat geschrieben:Ich habe mir ernsthaft überlegt, c# für den 6502 zu verwenden.

Das geht in lahm und in schnell. Auf jeden Fall hätte man das dann in der Hand, wie man es möchte. Es gibt natürlich reichlich Randbedingungen und mein erster Enztwurf zum Atari-XL Framework belegt schon mal 4 bis 6k RAM. Das Arbeiten geschieht aber auf dem PC, denn die Arbeit macht ein Mono oder Visual Studio.
Insofern wäre das nicht das, was gesucht wird.

Wäre das ein CIL (http://en.wikipedia.org/wiki/Common_Int ... e_Language) zu 6502 compiler?

Carsten

cas hat geschrieben:
Wäre das ein CIL (http://en.wikipedia.org/wiki/Common_Int ... e_Language) zu 6502 compiler?

Carsten

Ja genau. Entweder macht man das komplett auf dem PC und am Ende kommt 6502 Assembler raus (schnell) oder man lässt den ILCode fasst wie er ist und macht auf dem 6502 die Interpretation (langsam aber platzsparend).

Man kann einfach ein C# Programm schreiben. Dann macht man

Code: Alles auswählen

"C:\Programme\Microsoft SDKs\Windows\v6.0A\bin\ildasm.exe" "c:\c#\A6502Code1\bin\release\A6502Code1.exe" /out=code.il


und erhält ein Listing als code.il, welches man schön parsen kann um 6502 draus zu machen.

Sieht so aus:

Code: Alles auswählen

namespace A6502Code1
{
   class Program
   {
      static void Main(string[] args)
      {
         int a = 0;
         for (int i = 0; i < 5; i++)
         {
            a = a + i;
         }
         a = a * 2;
         a <<= 2;
      }
   }
}


wird zu

Code: Alles auswählen

    .locals init ([0] int32 a,
             [1] int32 i)
    IL_0000:  ldc.i4.0
    IL_0001:  stloc.0
    IL_0002:  ldc.i4.0
    IL_0003:  stloc.1
    IL_0004:  br.s       IL_000e

    IL_0006:  ldloc.0
    IL_0007:  ldloc.1
    IL_0008:  add
    IL_0009:  stloc.0
    IL_000a:  ldloc.1
    IL_000b:  ldc.i4.1
    IL_000c:  add
    IL_000d:  stloc.1
    IL_000e:  ldloc.1
    IL_000f:  ldc.i4.5
    IL_0010:  blt.s      IL_0006

    IL_0012:  ldloc.0
    IL_0013:  ldc.i4.2
    IL_0014:  mul
    IL_0015:  stloc.0
    IL_0016:  ldloc.0
    IL_0017:  ldc.i4.2
    IL_0018:  shl
    IL_0019:  stloc.0
    IL_001a:  ret


Int ist immer int32, muss man aber so ja nicht in 6502 als Standardtyp verwenden, es sei denn, man möchte komplett auf dem PC ohne Emulator entwickeln. Byte und short gibt´s auch.

Für 8-Bit Integer könnte das dann so aussehen:

Code: Alles auswählen

IL_0000:
IL_0001: LDA #0
         STA $1000
IL_0002:
IL_0003:
         STA $1001
IL_0004: BRA IL_000d
IL_0008: CLC
         LDA $1001
         ADC $1000
IL_0009: STA $1000
         
IL_000b:
IL_000c: CLC
         LDA #1
         ADC $1001
IL_000d: STA $1001
IL_000f: CMP #5
         BNE IL_0008
IL_0013:
IL_0014: LDA $1000
         ASL
IL_0015: STA $1000
IL_0017:
IL_0018: LDA $1000
         SHL $1000
IL_0019: STA $1000
         RTS         


Das ist noch nicht optimiert, geht ja auch erstmal um ein CTP. Ich denke aber man könnte es realisieren. Käme auf einen Versuch an.

Es gibt noch einige Feinheiten, aber grundsätzlich kann man aus dem Beispiel sehen, wie es geht.