Frage zu Kick Assembler

Es gibt 8 Antworten in diesem Thema, welches 2.046 mal aufgerufen wurde. Der letzte Beitrag (1. April 2015 um 16:58) ist von flashback.

  • Moin,

    ich hoffe, daß meine Frage in diesem Unterforum richtig aufgehoben ist.

    Mir ist bekannt, daß man Variablen definieren und die dann im Quelltext verwenden kann, also z.B. so:

    .var myColor = 1

    ...

    lda #myColor
    sta $d020


    Soweit so gut. Geht denn auch der umgekehrte Weg? Ich habe z.B. einen Wert im Akku oder in einer bestimmten Speicherstelle, und möchte den direkt einer Variable zuweisen. Also sowas hier in der Art:

    lda flag // flag ist ein label, der Inhalt der Flag soll in einer Variable weiterverarbeitet werden

    Sowas hier klappte nicht:

    .var myFlag = lda flag
    .eval myFlag = flag

    Gibt's diese Möglichkeit überhaupt, oder ist das gar nicht vorgesehen? ;)

  • Die Variablen eines Assemblers werden nur zum Zeitpunkt des assemblierens ausgewertet.
    Der Wert des Akkus, einesanderen Registers oder einer Speicherstelle kann aber erst zur
    Laufzeit des Programms bestimmt werden.

  • Jau. Versuch mal zu beschreiben, was der Assembler Deiner Meinung nach tun soll, unabhängig von der Syntax. Bei der Formulierung wird Dir sicher klar, warum das nicht gehen kann (oder uns wird klar, dass wir die Frage nicht verstanden haben).

    Yes, I'm the guy responsible for the Bitte melde dich an, um diesen Link zu sehen. cross assembler. And some Bitte melde dich an, um diesen Link zu sehen..

  • Die Variablen eines Assemblers werden nur zum Zeitpunkt des assemblierens ausgewertet.

    Stimmt, das hatte ich nicht bedacht, ist ja auch logisch. Aber man hat ja einfach manchmal ein Brett vorm Kopp. :whistling:

    Es soll anhand eines Tabellenwerts eine Rasterbar anders eingefärbt werden. Die Bars sind mit Variablenwerten definiert, also z.B. so:

    Die Bars werden dann wie folgt angezeigt, das habe ich so eingerichtet, um schneller verschiedenfarbige Bars ausprobieren zu können.

    Code
    .var colsrc = col1 // col2
    
    
    ...
    
    
    lda colsrc
    sta $d020
    sta $d021

    Dabei kam mir die Idee, auch während des Ablaufs so die angezeigten Farben schnell wechseln zu können. Aber wie's aussieht muß ich mir da was anderes einfallen lassen.
    ;)

  • Du könntest ja die Bytes mit Bitte melde dich an, um diesen Link zu sehen./Bitte melde dich an, um diesen Link zu sehen./Bitte melde dich an, um diesen Link zu sehen. definieren und dann eine kleine Schleife drüber laufen lassen.

    so sinngemäß:

    - ldx anzahl werte
    lda farbtabelle,x
    tay
    lda farben123,y
    sta farbtabelle,x
    dex
    bne -

    Bitte melde dich an, um diesen Link zu sehen. Bitte melde dich an, um diesen Link zu sehen. Bitte melde dich an, um diesen Link zu sehen.

    Ex-TLI (The Level 99 Industries) & Ex-TNP (The New Patriots) & Ex-TEA (The East Agents) & ?

  • Mal unabhängig von der Assemblersyntax '.var' betrachtet: Die Art und Weise, wie Du cl1, cl2 und sep verwendest, entspricht eher der Definition einer Konstanten, nicht einer Variablen, also in C bzw. Pascal so etwas wie

    Code
    #define CL1 0x02
    bzw.
    CONST
      CL1 = $02;

    Deutlich wird das z. B. an Deinem Beispiel

    Code
    .var myColor = 1
    
    
    ...
    
    
    lda #myColor
    sta $d020

    Das '#' bei lda signalisiert bereits das Laden einer Konstanten, nicht einer Variablen. Es ist daher nicht ganz klar, was Dein Programm eigentlich leisten soll. Mit den Befehlen

    Code
    .byte cl1
    .byte cl2
    ...

    wird im Speicher nur eine Liste von konstanten Werten erzeugt. Diese dann einzeln über

    Code
    lda colsrc

    in den Akkumulator zu laden, dürfte kaum viel Sinn ergeben. colsrc ist nur die Basisadresse der Konstantenliste, und 'lda colsrc' lädt den ersten dort abgelegten konstanten Wert, entspricht also direkt

    Code
    lda #cl1

    Um Sinn zu ergeben, müßte man auf diese Liste in irgendeiner Form indiziert zugreifen, sei es über

    Code
    lda colsrc, x
    oder
    lda #<colsrc
    sta zp
    lda #>colsrc
    sta zp + 1
    ...
    lda (zp), y

    Natürlich kann man den Wert an der Adresse colsrc mit einem neuen Wert überschreiben. In dem Fall wäre colsrc eine echte Variable, bzw. die Basisadresse eines Arrays. Das hängt ganz davon ab, was Du vorhast.

  • Vielen Dank an alle für die Denkanstöße, die Idee mit den Pointern hat mir weitergeholfen. :thumbsup:

    Ich habe jetzt die Pointer auf die Farben in einer Tabelle abgelegt, auf die ich dann über einen Index zugreife. Dieser Index wird dann einfach alle paar Frames hochgezählt:


    Mal noch eine weitere Frage: Liefert der Kick Assembler die Größe eines Speicherbereichs auch als Variable zurück und nicht nur im Ausgabebereich? Dann könnte man die Länge der Tabelle noch dynamisch bestimmen, bis jetzt definiere ich den Wert für "rasterPointerTableLength" selbst. Die Tabelle ist mit .pc = $c000 direkt am Anfang einer Page abgelegt.

  • Definier einfach noch ein Label am Ende der Tabelle, dann ergibt "table_end - table_start" die Größe. Das geht mit allen Assemblern.

    Yes, I'm the guy responsible for the Bitte melde dich an, um diesen Link zu sehen. cross assembler. And some Bitte melde dich an, um diesen Link zu sehen..