ACTION! FAQ

[Erhard]

Hi,

ich habe seit Mai 2022 zwei Programmierarbeiten in ACTION! durchgeführt.

Trotz des hervorragenden, von GoodByte basierend auf dem Originalhandbuch erstellten und überarbeiteten ACTION! Reference Manual (ARM) hat mich das Arbeiten mit ACTION! in einigen Punkten an den Rand des Wahnsinns getrieben.

Einer der Punkte ist, wenn ACTION! beim Kompilieren eine Fehlermeldung a la

"Da war ein Fehler. Was falsch war weiß ich nicht und wo der Fehler war weiß ich auch nicht so genau. Aber so gehts nicht."

ausspuckt.

Eine wichtige Sache, die auch nicht funktioniert ist, daß man SET LIST=1 nur am Programmanfang definieren kann. Bei der Fehlersuche will ich doch nur das auf den Bildschirm ausgegeben bekommen, wo ich gerade dran arbeite (z.B. eine .INC Datei) und nicht hunterte oder tausende von Programmzeilen, die in Ordnung sind. Ich bin bei der Fehlersuche mit dem wiederholten Kompilieren eh schon zunehmend ungeduldig und dann noch das Kompilieren derart verlangsamen? Ich sehe ja ein, daß das vielleicht bei 16k nicht anders zu lösen war, ist aber trotzdem doof.

Eine andere Sache ist: man schreibt irgendwas, was eigentlich funktionieren müßte, aber aus bestimmten Gründen (die man erraten muß), funktioniert es an der Stelle nicht.

Eine dritte Sache war: wenn ich von etwas nicht genau wußte, wie es zu schreiben ist, gibt es zwar im ARM theoretische und allgemeingültige Syntaxerläuterungen, aber da ich mir gerade beim Programmieren ohnehin den Kopf zerbreche weigert sich mein Gehirn, die zusäztliche Aufgabe der Syntaxerläuterung in benutzbare Programmzeilen zu übersetzen durchzuführen.

Was ich zum Beispiel trotz mehrfachem schnellen überfliegen und Suchen mit Suchbegriffen nicht gefunden habe ist, wie man in ACTION! einen Teil einer Zeichenkette auf den Bildschirm ausgibt, also das was in Atari BASIC mit

PRINT A$(4,17)

zu lösen ist.

Ich gehe davon aus, daß die notwendige Information dazu sich irgendwo im ARM verbirgt, aber ich hab sie bis jetzt nicht gefunden und während des Programmierens kostet die Suche nach solchen Informationen einfach zu viel Zeit.

ACTION! ist sicherlich superleistungsfähig. Dummerweise hat ACTION! auch extrem viele Eigenheiten und die muß man quasi alle gleichzeitig auswendig wissen und routinemäßig anwenden können, um diese Leistungsfähigkeit ausnutzen zu können.

Ich hätte also gerne eine nach Themen sortierte Liste von Programmierbeispielen.

Anbei ein Beispiel für ein Beispiel (a ist ein Bytewert und kann die Werte 0 oder 1 annehmen):

Thema: Stringausgabe mit Bedingung
=========================

nicht funktionierende Lösung
-------------------------------------------
BYTE a
BYTE ARRAY TXT="XY"

POSITION (6,7)
PRINT(TXT(a+1,a+1))


schlechte Lösung
-------------------------
(eine aufwendige Abfrage, unter welcher Bedingung welcher Wert auszugeben ist und bei wiederholter Verwendung muß der ganze Codeabschnitt wiederholt werden, bei Ausgliederung als eigene Prozedur wird das Programm zwar kürzer, aber wegen des Prozeduraufrufs noch langsamer)

BYTE a
POSITION (6,7)
IF
a=0 THEN
PRINT("X")
ELSE
PRINT("Y")
FI

meines Erachtens bessere Lösung
-----------------------------------------------
(ist im Qellcode kürzer, wird schneller ausgeführt und für die wiederholte Verwendung braucht es nur die zwei letzten Zeilen)

BYTEa
CARD ARRAY TXT(2)
TXT(1)="X"
TXT(2)="Y"

POSITION(6,7)
PRINT(TXT(a+1))

PS: wer hat es denn hier in Punkto ACTION! richtig drauf und bietet sich zur Beantwortung von Fragen an? Das sollte dann aber eher per PN oder eMail sein, sonst wird das Thema hier endlos lang und auf den Punkt gebrachte Infos stehen nur in jedem zigsten Beitrag.

CU, Erhard

[FlorianD]

ich stimme Dir zu, man muss bei Action! einiges an Spezialitäten im Kopf haben. Oder ein DIN A4 Blatt mit den wichtigsten Dingen, die man gelernt hat als Referenz.

Dein Problem:

definiere einen String A, der für das Printen benutzt wird
definier einen String B, in dem das X und Y drin sind
dann nutze SCopyS(source,dest,start,stop)
also so SCopyS(B,A,a+1,a+1)
dann PRINTE(B)

sollte klappen

[Erhard]

Hi,

meines Erachtens bessere Lösung
-----------------------------------------------
(ist im Qellcode kürzer, wird schneller ausgeführt und für die wiederholte Verwendung braucht es nur die zwei letzten Zeilen)

BYTEa
CARD ARRAY TXT(2)
TXT(1)="X"
TXT(2)="Y"
...
POSITION(6,7)
PRINT(TXT(a+1))

Ich widerrufe das, bitte streicht das aus dem Gedächtnis. Oder noch besser, merkt euch das als unter Umständen schlechte Lösung.

Ich habe mir heute einmal den produzierten Maschinencode für beide Lösungen angeschaut. Das was in ACTION! ein schöner kurzer Quelltext ist wird zu grauenhaftem Maschinencode. Das eigentliche PRINT geht noch, aber das Aufsetzen der Arrays produziert ellenlangen Code, den ich nicht einmal zur Gänze verstehe. Das der schneller zu laufen schien - woran das lag muß ich noch rausfinden. Der kann nur langsamer sein (weil mehr Taktzyklen), auch wenn man berücksichtigt, daß die Definition der Arrays nicht Bestandteil einer Schleife sind.

Das Ganze ist so abgefahren, wenn ich den Compiler schreiben müßte, der aus den o.g. paar Zeilen ACTION! Maschinencode produzieren soll, würde ich nicht mal den ins Modul kriegen. Wenn ich dann bedenke, was das Modul alles kann und drin hat ... der Typ der das hinbekommen hat ... was der an IQ hat habe ich mit negativem Vorzeichen.

SCopyS

Das werde ich auch mal antesten. Vermutlich wird der produzierte Code einfacher (weil kein "durch die Brust ins Knie indirekter verbieg das Hirn Pointer Sch*** "), aber vielleicht auch nicht kürzer.