An alle ACTION!-in-depth-user,

bei meiner Arbeit mit ACTION! ist mir eine Besonderheit im kompilierten Code aufgefallen.

Immer dann, wenn an eine Prozedur mehr als 2 Byte übergeben werden, also 3 Byte oder 1 Word und 1 Byte, erfolgt im kompilierten Code ein Sprung ins Modul.

Dadurch stellen sich bei mir 1 Frage:

Wieso funktioniert ACTION! überhaupt ohne Modul ???

Beispiel 1 (Keine Parameter)

Code: Alles auswählen

 MODULE
 
 PROC TEST()
   BYTE I
   FOR I = 1 TO 10 DO
   OD
 RETURN

Maschinensprache zu Beispiel 1

Code: Alles auswählen

  2083  4C 86 20     JMP $2086
  2086  A0 01        LDY #$01      ;SET I=1
  2088  8C 82 20     STY $2082
  208B  A9 0A        LDA #$0A      ;Vergleiche 10 mit I
  208D  CD 82 20     CMP $2082
  2090  B0 03        BCS $2095     ;ist größer
  2092  4C 9B 20     JMP $209B     ;10 wurde erreicht
  2095  EE 82 20     INC $2082     ;I=I+1
  2098  4C 8B 20     JMP $208B     ;weiter
  209B  60           RTS

Beispiel 2 (1 Parameter)

Code: Alles auswählen

 MODULE
 
 PROC TEST(BYTE A)
   BYTE I
   FOR I = 1 TO 10 DO
   OD
 RETURN

Maschinensprache zu Beispiel 2

Code: Alles auswählen

  20A2  4C A5 20     JMP $20A5
  20A5  8D A0 20     STA $20A0 ;hier wird das übergebene Byte gesichert
  20A8  A0 01        LDY #$01
  20AA  8C A1 20     STY $20A1
  20AD  A9 0A        LDA #$0A
  20AF  CD A1 20     CMP $20A1
  20B2  B0 03        BCS $20B7
  20B4  4C BD 20     JMP $20BD
  20B7  EE A1 20     INC $20A1
  20BA  4C AD 20     JMP $20AD
  20BD  60           RTS

Beispiel 3 (2 Parameter)

Code: Alles auswählen

 MODULE
 
 PROC TEST(BYTE A, B)
   BYTE I
   FOR I = 1 TO 10 DO
   OD
 RETURN

Maschinensprache zu Beispiel 3

Code: Alles auswählen

  208A  4C 8D 20     JMP $208D
  208D  8E 88 20     STX $2088 ;hier wird das 2. übergebene Byte gesichert
  2090  8D 87 20     STA $2087 ;hier wird das 1. übergebene Byte gesichert
  2093  A0 01        LDY #$01
  2095  8C 89 20     STY $2089
  2098  A9 0A        LDA #$0A
  209A  CD 89 20     CMP $2089
  209D  B0 03        BCS $20A2
  209F  4C A8 20     JMP $20A8
  20A2  EE 89 20     INC $2089
  20A5  4C 98 20     JMP $2098
  20A8  60           RTS

Beispiel 3 (3 Byte Parameter)

Code: Alles auswählen

 MODULE
 
 PROC TEST(BYTE A, B, C)
   BYTE I
   FOR I = 1 TO 10 DO
   OD
 RETURN

Maschinensprache zu Beispiel 3

Code: Alles auswählen

  2091  4C 94 20     JMP $2094
  2094  20 F5 A0     JSR $A0F5 ;tja - hier gehts ins Modul und es
                               ;werden wohl die Parameter gesichert
  2097  8D 20 02     STA $0220
  209A  A0 01        LDY #$01
  209C  8C 90 20     STY $2090
  209F  A9 0A        LDA #$0A
  20A1  CD 90 20     CMP $2090
  20A4  B0 03        BCS $20A9
  20A6  4C AF 20     JMP $20AF
  20A9  EE 90 20     INC $2090
  20AC  4C 9F 20     JMP $209F
  20AF  60           RTS

Wenn hier also ein Sprung ins Modul erfolgt, welches aber nicht notwendigerweise vorhanden ist - wieso funktioniert es denn trotzdem?

Ich harre gespannt eurer Ideen.

PS: Wozu dient eigentlich der JMP-Befehl, der gleich immer am Anfang kommt und der nur sich selbst überspringt? Sollten die lokalen Variablen vielleicht ursprünglich mal nach diesem JMP-Befehl stehen statt davor? Übersichtlicher wäre es ja.

Viele Grüße

Erhard

Nur ganz kurz und auch nicht aus der tiefen Tiefe...

Der Sprung wird vermutlich ohne Modul leicht anders aussehen.
Da wird dann wohl in die entsprechende Routine der Runtime gesprungen.
Könnte man ausprobieren, in dem man unter Benutzung einer Runtime kompiliert.

Über den Startsprung hatte ich mich auch schon gewundert...

Hi,

eda70 hat geschrieben:Der Sprung wird vermutlich ohne Modul leicht anders aussehen.
Da wird dann wohl in die entsprechende Routine der Runtime gesprungen.
Könnte man ausprobieren, in dem man unter Benutzung einer Runtime kompiliert.

ich glaube nicht, daß das so ist. ACTION! weiß beim Kompilieren nicht, ob ich die Runtime einbinde - die könnte ja auch Klaus heißen. Mit den Befehlen wie PRINTE funktioniert das, weil die in der Runtime genauso heißen und deshalb die Sprünge ins Modul überschreiben.

Aber "mehr als 2 Byte Parameter" hat in der Runtime ja keinen Namen.

Viele Grüße

Erhard

Ohne Runtime springt er bei mir auch so:

Code: Alles auswählen

26F6: 20 F5 A0          JSR $A0F5

Mit Runtime sieht das Compilat bei mir so aus, er springt nach $4E40

Code: Alles auswählen

53DD: 4C E0 53          JMP $53E0
53E0: 20 40 4E          JSR $4E40
53E3: D9 53 02          CMP $0253,Y
53E6: A0 01             LDY #$01
53E8: 8C DC 53          STY $53DC
53EB: A9 0A             LDA #$0A
53ED: CD DC 53          CMP $53DC
53F0: B0 03             BCS $53F5
53F2: 4C FB 53          JMP $53FB
53F5: EE DC 53          INC $53DC
53F8: 4C EB 53          JMP $53EB

Er springt zu folgendem Code, das scheint die PROC SArgs=*() zu sein

Code: Alles auswählen

4E40: 85 A0             STA $A0
4E42: 86 A1             STX $A1
4E44: 84 A2             STY $A2
4E46: 18                CLC
4E47: 68                PLA
4E48: 85 84             STA $84
4E4A: 69 03             ADC #$03
4E4C: A8                TAY
4E4D: 68                PLA
4E4E: 85 85             STA $85
4E50: 69 00             ADC #$00
4E52: 48                PHA
4E53: 98                TYA
4E54: 48                PHA
4E55: A0 01             LDY #$01
4E57: B1 84             LDA ($84),Y
4E59: 85 82             STA $82
4E5B: C8                INY
4E5C: B1 84             LDA ($84),Y
4E5E: 85 83             STA $83
4E60: C8                INY
4E61: B1 84             LDA ($84),Y
4E63: A8                TAY
4E64: B9 A0 00          LDA $00A0,Y
4E67: 91 82             STA ($82),Y
4E69: 88                DEY
4E6A: 10 F8             BPL $4E64
4E6C: A5 11             LDA BRKKEY
4E6E: D0 0F             BNE $4E7F
4E70: E6 11             INC BRKKEY
4E72: 4C 32 4D          JMP $4D32
4E75: 08                PHP
4E76: 63 09             RRA ($09,X)
4E78: 11 19             ORA ($19),Y
4E7A: 18                CLC
4E7B: 13 21             SLO (ICDNOZ),Y
4E7D: 23 33             RLA (BUFRHI,X)
4E7F: 60                RTS

Ziemlich viel overhead?

Mit Proc TEST=*(...
Lässt er die Springerei ganz weg...

Hallo Eda,

tja, offenbar weiß ACTION! wohl doch, wann eine Runtime da ist ...

Jetzt will ich erst recht wissen, wieso.

Und den Code verstehe ich (noch) nicht.

An eine Prozedur oder Funktion können ja bis zu 16 Byte Parameter übergeben werden. Diese werden wie folgt abgelegt:

Code: Alles auswählen

AKKU             :   01. übergebener Byte-Parameter
X-REG            :   02. übergebener Byte-Parameter
Y-REG            :   03. übergebener Byte-Parameter
$00A3            :   04. übergebener Byte-Parameter
$00A4            :   05. übergebener Byte-Parameter
$00A5            :   06. übergebener Byte-Parameter
$00A6            :   07. übergebener Byte-Parameter
$00A7            :   08. übergebener Byte-Parameter
$00A8            :   09. übergebener Byte-Parameter
$00A9            :   10. übergebener Byte-Parameter
$00AA            :   11. übergebener Byte-Parameter
$00AB            :   12. übergebener Byte-Parameter
$00AC            :   13. übergebener Byte-Parameter
$00AD            :   14. übergebener Byte-Parameter
$00AE            :   15. übergebener Byte-Parameter
$00AF            :   16. übergebener Byte-Parameter

Und das soll dieser PLAPHAORAPLP-Code machen?

Ok, werde ich mir ansehen.

Viele Grüße

Erhard