Als ich zuerst davon hörte war ich verwundert, eine Programmiersprache für den Pofo von der ich noch nichts gehört habe? Ein Arbeitskollege erzählte mir er habe auf www.profan.de etwas über den ATARI Porfolio gelesen. Er sagte PROFAN sei eine praktische Programmiersprache, halb Script, halb Batch, für diverse Plattformen mit Open-Source Quell-dateien. Tatsächlich, es gab auch eine Version für den POFO.

Halb BASIC, halb PASCAL mit C-Ansätzen, ist es eine Script-Sprache mit gewissen Eigenheiten. Die vorliegende Version wurde speziell für den Portfolio angepasst, bietet also nicht alle Funktionen die die PC-Versionen beinhalten. Um Entäuschungen vorzubeugen sei hier gesagt: PROFAN unterstützt keine Grafik (nur Text-Modus), keine Dezimalzahlen (nur Integer) und keine Operatoren (+ - * / …), hierzu gibt es spezielle Funktionen wie @ADD(a,b) oder @MUL(a,b). @SQR(N) bildet die Quadratzahl (N hoch 2), Wurzel gibt es nicht. Dafür bietet PROFAN interessante String-Manipulationen wie @SUBSTR$(S1,N,S2), hiermit kann man Teile eines Strings in ein anderes lesen, oder @TRANSLATE$(S1,S2,S3) um Teilstücke eines Strings durch ein anderes zu ersetzen. Ich fürchte, daß der folgende Bericht die Nutzbarkeit der Programmiersprache nicht entgültig beurteilen kann, es gibt zu viele unterschiedliche Anforderungen. Welche diese Sprache erfüllt muß jeder selbst herausfinden. Sie kann mit PBASIC, PowerBasic, oder Swift!Basic insgesamt sicher nicht mithalten, aber als Script-Sprache irgendwo zwischen BATCH-Dateien und Basic mit einer Größe von 18kB vielleicht ein manchmal akzeptabler Kompromiss. Beim Aufbauen von Text-Screens ist es auf jeden Fall flexibler als DOS und, so scheint mir, schneller als PBASIC. Da es keine Runtime-Module wie PowerBasic und Swift! benötigt ist es autark. Allerdings muß man einen neuen Dialekt lernen den ich, für mich, als „Ceisches BASCAL vom DOS“ getauft habe.

PPM.EXE kann nur vom aktuellen Pfad aus gestartet werden, egal ob es im Systempfad (set path=….) liegt. Die Fehlermeldungen sind häufig irreführend, die Ursache liegt ganz wo anders.

Vorsicht mit der Anleitung die dem Programm beigefügt ist. Da die Portfolio-Version eine abgespeckte PC-Version ist wurden die nicht unterstützten Features aus der Anleitung entfernt, nicht aber die Querverweise. Bei vielen Beschreibungen werden Funktionen erwähnt die diese Version nicht unterstützt.

kein GOTO oder JUMP, kein Label oder Zeilenzahl. kein FOR… TO… NEXT… kein PEEK, kein POKE.

In PROFAN müssen alle Variablen (zeitlich) vor der ersten Benutzung deklariert werden. String-Variablen werden durch ein $, LongInt-Variablen durch ein &, Float-Variablen durch ein !, Integer-Variablen durch ein % und Bereichsvariablen durch ein # gekennzeichnet. Mit Ausnahme der Bereichsvariablen sind alle Variablen, die in Prozeduren oder Unterprogrammen deklariert werden nur dort lokal gültig. Der verwandte Speicherplatz wird bei Verlassen des Unterprogrammes/der Prozedur wieder freigegegen. Beispliel:

Systemvariablen geben Auskunft über Zustände des Systems, z.B. die aktuelle Cursorposition, das aktuelle Laufwerk, etc. Es gibt zwei Typen von Systemvariablen:

• $Name - Der Ergebnistyp ist ein String
• %Name - Der Ergebnistyp ist ein Integer
  

Es gibt insgesamt 9 Systemvariablen:

• $Drive - Das aktuelle Laufwerk (ohne Pfadangabe).

Beispiel:

Print "Aktuelles Laufwerk: ";$Drive

• %Error - Der zuletzt aufgetretene Fehlercode. Wie %IOResult wird %Error beim Auslesen wieder auf 0 gesetzt.
  • Die Error-Werte:
    • 0 - kein Fehler
    • 1 - Warnung
    • 2 - Fehler
• %ErrNumber - enthält die Nummer des zuletzt aufgetretenen Fehlers. Beim Auslesen wird %ERRNUMBER auf 0 zurückgesetzt.
• %GetCount - Die Anzahl der Einträge in der ListBox-Liste (beginnend bei 0, also immer n+1).

Beispiel:

ClearList
AddFiles "C:\DOS\*.EXE"
Print %GetCount;" EXE-Dateien"

• %GetCurSel - Nummer des in einer Listbox gewählten Eintrages.
• %IOResult - Nach einer Dateioperation oder einer Directory-Suche enthält diese Variable den entsprechenden Wert:
  • Die Werte entsprechenden den von Turbo-Pascal her bekannten Ergebnissen:
    • 0 - kein Fehler aufgetreten
    • 2 - Datei nicht gefunden
    • 3 - Pfad nicht gefunden
    • 5 - Zugriff verweigert (ReadOnly?)
    • 12 - Ungültiger Dateimodus
    • 15 - Laufwerksnummer unzuzulässig
    • 16 - Verzeichnis kann nicht gelöscht werden (noch Dateien drin?)
    • 17 - RENAME nicht über Laufwerksgrenzen möglich (siehe Rename)
    • 18 - Kein weiterer Eintrag (bei @FindFirst/@FindNext)
    • 100 - Lesefehler von Diskette/Platte
    • 101 - Schreibfehler auf Diskette/Platte
    • 102 - Dateinummer ist keiner Datei mit ASSIGN zugeordnet (siehe Assign)
    • 103 - Datei nicht offen (Reset, Rewrite oder Append fehlt)
    • 104 - Datei nicht zum Lesen geöffnet (Reset fehlt)
    • 105 - Datei nicht zum Schreiben geöffnet (Rewrite oder Append fehlt)
    • 106 - Falsches Format (bei Input #N,..)
• %Key - Der ANSI-Code der zuletzt gedrückten Taste. Anwendung nach den Befehlen WAITKEY und WAITINPUT:

WaitInput
  If @Equ(Key,90)
  Print "Du hast 'Z' gedrückt"
EndIf

• %ParCount - Die Anzahl der beim Programmaufruf übergebenen Kommandozeilen-Parameter. Parameter 0 ist beim Interpreter der Interpreter selber, bei der Runtime das Runtime-Modul und bei einer EXE-Datei die EXE-Datei. Parameter 1 ist bei Interpreter und Runtime das ausgeführte Programm. Da eine EXE-Datei auch als Runtime fungieren kann, ist er dort entweder der Name der PRF-Datei oder ein String, der mit einem der folgenden Zeichen beginnt:

! „ # $ % & ' ( ) * + , - . / Weitere Hinweise siehe unter @PAR$.

• %ScanKey - Der Scancode (virtueller Code) der zuletzt gedrückten Taste.
  • Wichtige Scancodes:
    • 16 - Shift
    • 17 - Strg
    • 27 - Esc
    • 33 - BildHoch
    • 34 - BildRunter
    • 35 - Ende
    • 36 - Pos1
    • 37 - Links
    • 38 - Hoch
    • 39 - Rechts
    • 40 - Runter
    • 45 - Einfg
    • 46 - Entf
    • 112 - F1
    • … - …
    • 123 - F12

Eine Funktion gibt einen Wert zurück, der in der Regel von den Parametern der Funktion abhängig ist. Überall da, wo in PROFAN Variablen oder konstante Werte (Literale) eingesetzt werden können, dürfen auch Funktionen stehen. Der Rückgabewert der Funktion sollte der gleiche Typ sein, wie der erwartete Wert. Alle Funktionsnamen in PROFAN beginnen mit einem @. Funktionen, deren Funktionsnamen mit dem $ enden, geben in vielen Fällen einen String zurück, die übrigen Funktionen einen numerischen Wert. In einigen Fällen enden auch Vergeleichsfunktionen, die entweder 1 oder 0 zurückgeben mit einem $, um deutlich zu machen, das hiermit Strings verglichen werden.

Wenn der Rückgabewert einer Funktion uninteressant ist, kann die Zuweisung auch weggelassen werden. Bis auf die immer noch notwendigen Klammern, wird die Funktion dann wie ein Befehl verwandt. Beispiel:

@LISTBOX$("Das ist die Liste",0)

In diesem Fall wird die Listbox nur zum Anschauen angezeigt oder aber das Ergebnis der Auswahl über die Systemvariable $GETTEXT gelesen.

• @$(N)
  • N : Integer (0 … 8)
  • Ergebnis: String

Der N-te übergebene Parameter in einer selbstdefinierten Funktion (oder Prozedur) als String.

• @%(N)
  • N : Integer (0 … 8)
  • Ergebnis: Integer

Der N-te übergebene Parameter in einer selbstdefinierten Funktion (oder Prozedur) als Integer.

• @&(N)
  • N : Integer (0 … 8)
  • Ergebnis: LongInt

Der N-te übergebene Parameter in einer selbstdefinierten Funktion (oder Prozedur) als LongInt. Der 0. Parameter ist nach Aufruf einer Prozedur oder einem Unterprogramm mit RETURN <Wert> zurückgegebene Wert.

• @Abs(N)
  • N : Wert
  • Ergebnis: Wert

Absolutwert der Zahl N.

• @Add$(S1,S2)
  • S1 : String
  • S2 : String
  • Ergebnis: String

Verknüpfung der Strings S1 und S2. S2 wird an S1 angehängt.

• @Add(N1,N2)
  • N1 : Wert - Summand
  • N2 : Wert - Summand
  • Egebnis: Wert

Die Summe von N1 und N2. Siehe auch: @Add$

• @And(N1,N2)
  • N1 : Wert
  • N2 : Wert
  • Ergebnis: Wert

Die Werte von N1 und N2 werden mit der AND-Funktion verknüpft. Das Ergebnis ist 0 wenn ein oder beide Werte 0 sind. Vergleiche: @OR, @NOT

• @Chr$(N)
  • N : Wert (0 .. 255)
  • Ergebnis: String (1 Zeichen)
  • Das Zeichen mit dem ANSI-Code N.

• @Date$(N)
  • N : Integer (0..9) Dummy-Wert
  • Ergebnis: String - Datum

Die Funktion zeigt das aktuelle Datum an (TT.MM.JJ).

• @Del$(S,N1,N2)
  • S : String
  • N1 : Wert - Position
  • N2 : Wert - Zeichenzahl
  • Ergebnis: String

Ab der Position N1 werden N2 Zeichen aus dem String entfernt.

• @DiskFree(S)
  • S : String - Laufwerksbezeichnung
  • Ergebnis: LongInt

Das Ergebnis ist der freie Speicher auf Laufwerk S in kb. Ist das Ergebnis z.B. 430, so sind noch 430 kB frei. Ist das Laufwerk nicht vorhanden oder nicht lesbar, ist das Ergebnis 0. Beispiel:

Print @DiskFree("C:");" kB frei"

• @DiskSize(S)
  • S : String - Laufwerksbezeichnung
  • Ergebnis: Wert

Das Ergebnis ist der Gesamtspeicher auf Laufwerk S in kb. Ist das Ergebnis z.B. 43000, so hat das Laufwerk 43000 kb bzw. 43 MB. Ist das Laufwerk nicht vorhanden oder nicht lesbar, ist das Ergebnis 0. Beispiel:

Print @DiskSize("C:");" kB"

• @Div&(N1,N2)
  • N1 : Wert
  • N2 : Wert
  • Ergebnis: Integer / LongInt

Ganzzahliges Ergebnis der Division von N1 durch N2.

• @Div(N1,N2)
  • N1 : Wert
  • N2 : Wert
  • Ergebnis: Wert

Ergebnis der Division von N1 durch N2.

• @Eof(#N)
  • N : Integer - Dateinummer (1..8)
  • Ergebnis: Integer (0 oder 1)

Wenn mit dem letzten Lesen aus der Datei das Ende der Datei erreicht wurde, ergibt @Eof(#N) den Wert 1, ansonsten ist es 0. (Wegen Kompatibilität zu PROFAN 1.x kann das # auch weggelassen werden.)

• @Equ$(S1,S2)
  • S1 : String 1
  • S2 : String 2
  • Ergebnis: Integer (0 oder 1)

Das Ergebnis ist WAHR (1), wenn beide Strings gleich sind, UNWAHR (0), wenn die Strings verschieden sind.

• @EQU(N1,N2)
  • N1 : Wert - Wert 1
  • N2 : Wert - Wert 2
  • Ergebnis: Integer (0 oder 1)

Das Ergebnis ist WAHR (1), wenn beide Werte gleich sind, UNWAHR (0), wenn die Werte verschieden sind.

• @FilePos(#N)
  • #N: Dateikennung
  • Ergebnis: LongInt - Aktuelle Position in der Datei

Die aktuelle Position des Dateizeigers einer mit OPENRW geöffneten Datei wird ermittelt, wobei 0 das erste Byte der Datei bezeichnet.

• @FileSize(S)
  • S : String - Dateiname (auch mit Pfad)
  • Ergebnis : LongInt - Größe der Datei in Bytes

Die Funktion ermittelt die Größe der angegebenen Datei in Bytes.

• @FindFirst$(S)
  • S : String - Datei-Maske
  • Ergebnis: String

Die Funktion sucht die erste Datei im aktuellen Verzeichnis, die der Dateimaske entspricht. Das Ergebnis ist die gefundene Datei. Handelt es sich um ein Verzeichnis, steht es in eckigen Klammern.

• @FindNext$()
  • Ergebnis: String

Findet die nächste Datei, die zur mit @FINDFIRST$(S) gegebenen Maske paßt. War die Suche erfolgreich, ist %IORESULT = 0! Beispiel:

Print @FindFirst$("*.PRF")
WhileNot %IOResult
  Print @FindNext$()
Wend

• @GetByte(#N)
  • #N: Dateikennung
  • Ergebnis: Integer - Wert (0…255)

Es wird ein Byte aus einer mit OPENRW geöffneten Datei gelesen. Der Dateizeiger wird auf das nächste Byte positioniert. Zum Positionieren des Zeigers ist der Befehl SEEK zu verwenden.

• @GetDir$(S)
  • S : Laufwerkskennzeichen
  • Ergebnis: String (Pfad)

Der Pfad des angegebenen Laufwerks wird ermittelt, wobei “@„ für das aktuelle Laufwerk steht. Beispiel:

Let CPfad$=@GetDir$("C:")
Let Pfad$=@GetDir$("@")

• @GetEnv$(S)
  • S : String - Name der Variablen
  • Ergebnis : String - Inhalt der Variablen

Die Funktion liest die entsprechenden Environmentvariable aus. Beispiel:

LET Pfad$ = @GetEnv$("PATH")

• @GetFAttr(#N)
  • #N: Dateikennung
  • Ergebnis: Integer - Attribut

Das Attribut einer Datei wird ermittelt. Der Dateikennung muß zuvor mit ASSIGN einer Datei zugewiesen worden sein. Die Datei darf nicht geöffnet sein. Die Werte für Attribute:

• $01 = ReadOnly
• $02 = Hidden
• $04 = SystemDatei
• $08 = Label
• $10 = Directory-Eintrag
• $20 = Archiv

Werden mehrer Attribute verwandt, so sind sie zu addieren. Eine Systemdatei, die zusätzlich versteckt (hidden) ist, hat demzufolge $06 als Attribut.

• @GetFDate$(#N)
  • #N: Dateikennung
  • Ergebnis: String- Datum im Format „JJJJMMTT“

Das Datum der Datei wird ermittelt. Der Dateikennung muß zuvor mit ASSIGN einer Datei zugewiesen worden sein. Die Datei muß (z.B. mit RESET) geöffnet sein.

• @GetFileSize(#N)
  • #N: Dateikennung
  • Ergebnis: LongInt - Größe der Datei in Bytes.

Die aktuelle Größe einer mit OPENRW geöffneten (!) Datei in Bytes wird ermittelt. Um die Größe einer ungeöffneten Datei zu ermitteln ist die Funktion @FileSize zu verwenden. Der Vorteil von @GetFileSize liegt darin, daß die Größe einer gerade zum Bearbeiten geöffneten Datei ermittelt werden kann.

• @GetKey$()
  • Ergebnis: String (1 Zeichen)

Wartet auf einen Tastendruck und gibt das Ergebnis zurück.

• @GT(N1,N2)
  • N1 : Wert - Wert 1
  • N2 : Wert - Wert 2
  • Ergebnis: Wert (0 oder 1)

Das Ergebnis ist WAHR (1), wenn Wert 1 größer als (Greater Than) Wert 2 ist.

• @GT$(S1,S2)
  • S1 : String 1
  • S2 : String 2
  • Ergebnis: Integer (0 oder 1)

Das Ergebnis ist WAHR (1), wenn String 1 größer als (Greater Than) String 2 ist.

• @KeyIn(S)
  • S : String
  • Ergebnis: Wert (0 oder 1)

Das Ergebnis ist dann 1, wenn die zuletzt gedrückte Taste im String S vorkommt. Beispiel:

WaitKey
  Case @KeyIn("AaBb"):Print "A oder B"

• @Len(S)
  • S : String
  • Ergebnis: Wert

Länge des Strings S

• @ListBoxItem$(N)
  • N : Integer (0 … 9999)
  • Ergebnis: String

Der N-te Eintrag der ListBox-Liste wird ermittelt.

• @LT(N1,N2)
  • N1 : Wert 1
  • N2 : Wert 2
  • Ergebnis: Wert (0 oder 1)

Das Ergebnis ist WAHR (1), wenn Wert 1 kleiner als (Less Than) Wert 2 ist.

• @LT$(S1,S2)
  • S1 : String 1
  • S2 : String 2

Ergebnis: Integer (0 oder 1) Das Ergebnis ist WAHR (1), wenn String 1 kleiner als (Less Than) String 2 ist.

• @Mid$(S,N1,N2)
  • S : String
  • N1 : Integer - Position
  • N2 : Integer - Anzahl
  • Ergebnis: String

Das Ergebnis ist ein String, der N2 Zeichen ab Position N1 aus String S enthält.

• @Mod(N1,N2)
  • N1 : Integer
  • N2 : Integer
  • Ergebnis: Integer

Das Ergebnis ist N1 modulo N2.

• @Mul(N1,N2)
  • N1 : Wert
  • N2 : Wert
  • Ergebnis: Wert

Multiplikation von N1 mit N2.

• @Neq(N1,N2)
  • N1 : Wert - Wert 1
  • N2 : Wert - Wert 2
  • Ergebnis: Integer (0 oder 1)

Das Ergebnis ist UNWAHR (0), wenn beide Werte gleich sind, WAHR (1), wenn die Werte verschieden sind.

• @Neq$(S1,S2)
  • S1 : String 1
  • S2 : String 2
  • Ergebnis: Integer (0 oder 1)

Das Ergebnis ist UNWAHR (0), wenn beide Strings gleich sind, WAHR (1), wenn die Strings verschieden sind.

• @Not(N)
  • N : Wert
  • Ergebnis: Integer (0 oder 1)

Das Ergebnis ist 1, wenn N den Wert 0 hat, ansonsten ist es 0.

• @Or(N1,N2)
  • N1 : Wert
  • N2 : Wert
  • Ergebnis: Integer

ODER-Funktion: Das Ergerbnis ist ungleich 0, wenn N1 ODER N2 (oder beide) ungleich 0 sind. Anders ausgedrückt: Es ist nur dann 0, wenn beide Argumente 0 sind.

• @Ord(S)
  • S : String
  • Ergebnis: Integer

Der ASCII-Code des ersten Zeichens von S.

• @Par$(N)
  • N : Integer - Parameter-Nummer
  • Ergebnis: String - Parameter

Die Kommandozeilenparameter werden ausgelesen. Die Anzahl wird mit %PARCOUNT festgestellt.

• @Rnd(N)
  • N : Wert
  • Ergebnis: Integer bzw. LongInt

Zufallszahl zwischen 0 und N-1.

• @ScanKey(N)
  • N : Integer - Scancode
  • Ergebnis: Integer (1 oder 0)

Wenn der letzte Scancode (virtueller Tastencode) mit N (0 bis 254) übereinstimmt, ist das Ergebnis 1, anderenfalls ist es 0. Tabelle der Scancodes siehe unter %SCANKEY.

• @Sqr(N)
  • N : Wert
  • Ergebnis : Float

Das Quadrat von N (N²).

• @Str$(S)
  • N : Wert
  • S : String

Der Wert von N wird in einen String ohne folgende Leerzeichen umgewandelt. Die Länge des Strings und (bei Float) die Anzahl der Nachkommastellen werden durch die Befehle NUMWIDTH und DECIMALS eingestellt.

• @Sub(N1,N2)
  • N1 : Wert
  • N2 : Wert
  • Ergebnis: Wert

N2 wird von N1 abgezogen (subtrahiert).

• @SubStr$(S1,N,S2)
  • S1 - String: Der zu bearbeitende String
  • N - Integer: Nummer des Teilstrings
  • S2 - String: Trennzeichen
  • Ergebnis: Substring aus S1

Aus dem String S1 wird der N-te Teilstring herausgefiltert, wobei S2 das Trennzeichen zwischen den Teilstrings ist. Beispiel:

LET A$ = "eins,zwei,drei,vier,fünf"
PRINT @SUBSTR$(A$,3,",")

Das Ergebnis wäre der String „drei“. Wird das Trennzeichen im String S1 nicht gefunden, ist das Ergebnis für den ersten Teilstring der gesamte String und für alle weiteren der Leerstring. Ist N kleiner als 1, erfolgt eine Fehlermeldung. Ist N hingegen größer als die Anzahl der vorhandenen Teilstrings, so ist das Ergebnis ein Leerstring.
HINWEIS: S2 darf auch aus mehreren Zeichen bestehen!

• @Time$(N)
  • N : Integer (0 .. 9) Dummy-Wert
  • Ergebnis: String

Die Funktion ermittelt die aktuelle Uhrzeit in Stunden und Minuten (z.B. „23:45“)

• @Translate$(S1,S2,S3)
  • S1: String - der zu bearbeitende String
  • S2: String - Suchtext
  • S3: String - Ersatztest

Ergebnis: String, in dem S2 durch S3 ersetzt wurde. Alle Vorkommen des Strings S2 werden in S1 durch S3 ersetzt.

• @Trim$(S)
  • S : String
  • Ergebnis: String

Die führenden und endenden Leerzeichen eines Strings werden abgeschnitten.

• @Upper$(S)
  • S : String
  • Ergebnis: String

Der String S wird komplett in Großbuchstaben umgewandelt, wobei die deutschen Umlaute korrekt berücksichtigt werden.

• @Val(S)
  • S : String
  • Ergebnis: Wert

Der String S wird in einen numerischen Wert umgewandelt. Das Ergebnis ist 0, wenn der String nichtnumerische Zeichen enthält.

Jede Programmzeile beginnt mit einem Befehl, wobei auch Funktionen wie Befehle verwandt werden können. So darf also auf keinen Fall bei einer Zuweisung das LET weggelassen werden. Nach dem Befehlswort muß immer mindestens 1 Leerzeichen stehen, ansonsten wird der Befehl nicht als solcher erkannt.
In jeder Programmzeile darf auch immer nur ein Befehl stehen. Mehrere Befehle in einer Zeile (wie z.B. in BASIC, PASCAL oder C) sind nicht zulässig. Einzige Ausnahme ist der CASE-Befehl.

• ' … (Kommentarzeichen)

Kommentarzeichen. Im Gegensatz zu REM kann (sollte) es auch hinter einem Befehl in einer Zeile stehen:

' Unterprogramm
  Let X%=125  'X-Position zuweisen

• Add VAR,N
  • VAR - Variablenname (Integer)
  • N - Integer

N wird zur Variablen VAR addiert. (Ist schneller und einfacher als die @ADD-Funktion.) Beispiel:

ADD Punkte%,10

• AddFiles S
  • S : String - Dateimaske

Mit diesem Befehl wird eine Dateiliste der Listbox-Liste hinzugefügt. Beispiel:

ClearList
AddFiles "*.RGH"

• AddString S
  • S : String

Mit diesem Befehl wird der String der Listbox-Liste hinzugefügt. Beispiel:

ClearList
AddString "Item 1"
AddString "Item 2"

• Append #N
  • N: Wert - Dateinummer (1 .. 8)

Die Datei #N wird geöffnet, um Daten anzufügen. Tritt ein Fehler auf, ist %IoResult größer als 0. Beispiel:

Assign #1,"TEST.DAT"
Append #1
Case %IoResult:MessageBox "Fehler:",\
        "Kann Datei nicht öffnen!",16
Print #1,"Testdaten",56,Hugo$
Close #1

• Assign #N,S
  • N : Wert - Dateinummer (1 .. 8)
  • S : String - Dateiname (+ Pfad)

Der Datei Nummer N wird die Datei S zugewiesen. Beispiel:

Assign #1,"DEMO.PRF"
Reset #1
WhileNot @Eof(#1)
  Input #1,Zeile$
  Print Zeile$
Wend
Close #1

• Beep

Gibt einen Signalton aus.

• ChDir S
  • S : String - Pfadangabe

Es wird zum Verzeichnis S gewechselt. Enthält S eine Laufwerksangabe, so wird auch das aktuelle Laufwerk gewechselt! Beispiel:

ChDir "A:\PROFAN\DATEN"
AddFiles "*.DAT"

• ClearList

Die ListBox-Liste wird gelöscht, d.h. der Zeiger wird auf den Anfang gesetzt. Mit AddFiles oder AddString wird die Liste gefüllt.

• Close #N
  • N : Wert - Dateinummer (1 .. 8)

Die mit RESET, APPEND oder REWRITE geöffnete Datei mit der Dateinummer N wird geschlossen. Beispiel:

Close #Nr%

• CloseRW #N
  • N: Dateikennung (1.. 8)

Eine im Binärmodus geöffnete (OpenRW) Datei wird wieder geschlossen. Hinweis: Wenn der Befehl auf eine mit RESET, APPEND oder REWRITE geöffnete Datei angewandt wird, erfolgt ein Fehler (%IOResult wird gesetzt), ebenso im umgekehrten Falle!

• Cls

Löscht den Bildschirm.

• Dec VAR
  • VAR : Variablenname (Integer)
  • VAR wird um 1 erniedrigt. (Ist identisch mit SUB VAR,1)

• Declare VAR [,VAR[,VAR]…]
  • VAR : Variablen-Name

In PROFAN müssen alle Variablen (zeitlich) vor der ersten Benutzung deklariert werden. String-Variablen werden durch ein $, LongInt-Variablen durch ein &, Float-Variablen durch ein !, Integer-Variablen durch ein % und Bereichsvariablen durch ein # gekennzeichnet. Mit Ausnahme der Bereichsvariablen sind alle Variablen, die in Prozeduren oder Unterprogrammen deklariert werden nur dort lokal gültig. Der verwandte Speicherplatz wird bei Verlassen des Unterprogrammes/der Prozedur wieder freigegegen. Beispliel:

Decalare XPos%,YPos%,Text$

• End

Programmende. Ohne weitere Abfrage wird das Profan-Programm verlassen.

• Erase #N
• N : Wert - Dateinummer (1 .. 8)

Die Datei mit dem Dateikennzeichen N wird gelöscht. Beispiel:

ASSIGN #1,"TEST.BAK"
ERASE #1

• FileMode N
  • N: Integer - Filemodus (siehe DOS-Dokumentation)

Der Filemodus der für das Öffnen von Dateien (mit RESET, REWRITE oder OPENRW) und den Zugriff auf diesen gilt, wird eingestellt. Unter allen DOS-Versionen sind folgende Filemodi vorhanden:

• 0: Nur lesen
• 1: Nur schreiben
• 2: Lesen und Schreiben

Neuere DOS-Versionen kennen noch weitere Modi, die besonders im Netzwerk von Interesse sind. Standardmäßig wird bei allen oben genannten Befehlen FileMode 2 benutzt. Will man jedoch eine Datei lesen, die das Attribut ReadOnly (Nur lesen) hat, so muß vor dem RESET bzw. OPENRW der FileMode auf 0 gesetzt werden.

• Font N

Wird erkannt, ist beim Portfolio aber wirkungslos.

• If N … [ElseIf N …] [Else … ]
• EndIf
  • N : Wert . Bedingungsausdruck

Die zwischen IF und ENDIF stehenden Zeilen werden nur dann ausgeführt, wenn N ungleich 0 ist. Beispiel:

If @Equ(Test%,78)
Print "Test% ist 78!"
Print "-------------"
EndIf

Auch eine Abrage auf mehrere Bedingungen (z.B. bei der Auswertung eines Menüs) ist mit ELSEIF möglich. Sobald eine Bedingung erfüllt ist, wird der zugehörige Programmteil abgearbeitet und anschließend mit der Zeile nach dem ENDIF fortgefahren:

IF @Lt(A%,1)
PRINT "A ist kleiner als 1"
ELSEIF @Equ(A%,1)
PRINT "A ist gleich 1"
ELSEIF @Equ(A%,2)
PRINT "A ist gleich 2"
ELSE
PRINT "A ist größer als 2"
ENDIF

ACHTUNG: Hinter ELSEIF muß ein Bedingungsausdruck stehen. Fehlt dieser würde der Interpreter das ELSEIF zwar wie ELSE behandeln, aber das Runtime-Modul würde den Fehler merken und mit einer Fehlermeldung „Zu wenig Parameter“ abbrechen.

• IfNot N … [ElseIf N … ] [Else …]
• EndIf

Als Kurzform für If @Not(N) kann auch das kürzere (und schnellere) IfNot verwandt werden: IfNot @Equ(Test%,78)

Print "Test% ist nicht 78!"
Print "-------------------"
EndIf

• Inc VAR
  • VAR - Variablenname (Integer)

VAR wird um 1 erhöht. (Ist identisch mit ADD VAR%,1)

• Input #N,VAR
  • N : Wert - Dateikennzeichen (1..8)
  • VAR : Variable

Aus der Datei #N wird ein Wert in die Variable gelesen. Beispiel:

Assign #1,"TEST.DAT"
Reset #1
Input #1,Titel$
Input #1,Anzahl%
Close #1

• Input VAR
  • VAR : Variable

Von der Tastatur wird ein Wert in die Variable gelesen (Textmodus). Beispiel:

Print "Geben Sie den Titel ein: ";
Input Titel$
Print "Geben Sie die Anzahl ein: ";
Input Anzahl%

Windowstypischer ist jedoch die Verwendung des Eingabedialoges mit der Funktion @Input$.

• Let VAR=N|S
  • VAR : Variablenname
  • N : Wert
  • S : String

Einer zuvor mit DECLARE declarierten Variablen wird ein Wert zugewiesen. Das LET darf nicht weggelassen werden! Beim LET-Befehl für Stringvariablen können nun - ähnlich wie beim PRINT-Befehl - mehrere Stringausdrücke durch Semikolon bzw. Komma getrennt angegeben werden. Werden zwei Stringausdrücke mit einem Komma getrennt, wird ein Leerzeichen eingefügt. Diese Methode ist einfacher und deutlich (!) schneller als das Zusammenfügen von Strings mittels der @ADD$-Funktion. Beispiel:

LET Text$ = "Du hast",@Str$(Score%),"Punkte erzielt!"

HINWEIS: Die automatische Typumwandlung funktioniert bei einfachen Variablen. Bei Funktionen, die einen numerischen Wert zurükgegeben, wird nicht immer automatisch umgewandelt, daher ist hier immer die Funktion @Str$ zu verwenden!

• ListBoxItem$ N = S
  • N : Integer - Index (0 .. 999)
  • S : String

Der String S wird wird an Position N in die ListBox-Liste übernommen.

• Locate X,Y
  • X : Wert - Zeile
  • Y : Wert - Spalte

Der nächste PRINT- oder INPUT-Befehl wird auf Zeile X, Spalte Y positioniert.

• MkDir S
  • S : String - Pfadangabe

Das Verzeichnis S wird angelegt. Im Falle eines Fehlers hat %IORESULT einen von 0 verschiedenen Wert. Beispiel:

MkDir "C:\DOS\TEST"

Siehe auch: ChDir, RmDir

• NumWidth N
  • N: Integer - Mindestweite

Mindestweite der Ausgabe numerischer Werte. Dieser Wert wird auch von der @STR$-Funktion und dem Befehl DrawText verwandt. Ist der Ausgabestring kürzer wird er mit führenden Leerzeichen aufgefüllt. Standarteinstellung ist 7. Siehe auch: Decimals

• OpenRW #N
  • #N: Dateikennung (1 - 8)

Die Datei mit der Kennung #N wird im Binärmodus zum Lesen und Schreiben geöffnet. Es können beliebige Bytes aus der Datei gelesen (@GetByte) und beliebige Bytes in die Datei geschrieben (PutByte) werden. Mit @FilePos kann die Position des Dateizeigers ermittelt werden und mit SEEK wird sie verändert.

• Parameters VAR [,VAR[,VAR] …]
  • VAR - Variablennamen

Die Aufrufparameter einer Prozedur werden Variablen zugewiesen, die innerhalb der Prozedur bekannt sind. Ein Beispiel findet sich unter PROC. Die Anzahl der Variablen sollte gleich der Anzahl der Übergabeparameter sein; überprft wird dieses aber ebensowenig, wie die Datentypen. Gegebenenfalls erfolgt eine automatische Umwandlung. Siehe auch: Proc

• Print #N,f;f,f …
  • N : Wert - Dateikennzeichen (1..8)
  • f : druckbarer Ausdruck

Der Ausdruck, bzw. die Ausdrücke werden in die mit N bezeichnete Datei geschrieben. Steht zwischen den Ausdrücken ein Semikolon, so werden sie direkt aneinander gehängt, bei einem Komma wird ein Leerzeichen eingefügt. Siehe auch unter ASSIGN, REWRITE, APPEND und CLOSE.

• Print f;f,f…
  • f : druckbarer Ausdruck

Der Ausdruck, bzw. die Ausdrücke werden auf den Bildschirm geschrieben. Steht zwischen den Ausdrücken ein Semikolon, so werden sie direkt aneinander gehängt, bei einem Komma wird ein Leerzeichen eingefügt. Siehe auch unter LOCATE. Beispiel:

Print "Dies ist der",N%;". Test"

• Proc <Name> … EndProc
  • <Name> : Name der Prozedur

Eine Prozedur wird definiert, die im nachfolgenden Programm wie ein neuer Befehl verwandt werden kann. Über den PARAMETERS-Befehl werden die übergebenen Parameter eingelesen. Beispiel:

PROC Wiederhole
PARAMETERS Text$, Anzahl%
DECLARE I%
LET I%=0
WHILE @LT(I%,Anzahl%)
	PRINT Text$
	INC I%
WEND
ENDPROC
Wiederhole "Testtext",10

Die in der Prozedur über PARAMETERS oder DECLARE deklarierten Variablen sind nur innerhalb der Prozedur bekannt (lokal). Alle Variablen, die außerhalb (oberhalb) der Prozedur definiert wurden sind in der Prozedur auch bekannt (wie in PASCAL). Die Prozedur kann auch schon vor Erreichen der Zeile ENDPROC über RETURN verlassen werden, wobei dann die Übergabe eines Wertes an das aufrufende Programm möglich ist.

• PutByte #N1,N2
  • #N1: Dateikennung (1 - 8)
  • N2: Integer - zu schreibender Wert (0 … 255)

Das Byte N2 wird an die aktuelle Position des Dateizeigers in die Datei mit der Kennung #N1 geschrieben und der Dateizeiger um 1 weitergesetzt. Befindet sich dadurch der Zeiger hinter dem Ende der Datei, liefert @EOF(#N) den Wert 1. Durch weitere Schreiboperationen mit PUTBYTE würde die Datei vergrößert werden. Siehe auch: @GetByte

• Randomize

Sorgt dafür, daß die Zufallszahlen (@RND) auch wirklich zufälligen Charakter haben.

• Rem …

Alles was dahinter steht, ist Kommentar. REM steht immer am Anfang der Kommentarzeile. Für Kommentare hinter anderen Befehlen ist das ' zu benutzen.

• Rename #N,S
  • N : Wert - Dateikennzeichen (1..8)
  • S : String - neuer Name (mit Pfad)

Die Datei mit dem Kennzeichen N wird in S umbenannt. Enthält S eine Pfadangabe (mit oder ohne Laufwerksbezeichnung), so wird sie verschoben. Verschieben ist nur innerhalb eines Laufwerks möglich. Beispiel:

Assign #3,"C:\TEST.DAT"
Rename #3,"C:\UTILS\TOAST.DAT"

• Reset #N
  • N : Wert - Dateikennzeichen (1..8)

Die Datei N wird zum Lesen geöffnet. Beispiel:

Declare Zeile$  Assign #2,"TEST.DAT"
Reset #2
WhileNot @Eof(#2)
Input #2,Zeile$
Print Zeile$
Wend

Siehe auch: Rewrite, Append und OpenRW.

• Return [<Wert>]

Beenden einer Prozedur. Es ist möglich einen Wert zurückzugeben. Dieser steht dann in @$(0), @%(0), @&(0) und/oder @!(0):

PROC Test
Print "Das ist ein Test"
Return "OK!"
ENDPROC
Print "Im Hauptprogramm"
Test
Print "Wieder zurück! Ergebnis:",@$(0)

Der zurückgegebene Wert darf auch eine lokale Variable sein. WICHTIG: Auch wenn eine Prozedur mit RETURN verlassen wird, muß die Definition der Prozedur mit ENDPROC abgeschlossen werden.

• Rewrite #N
  • N : Wert - Dateikennzeichen (1..8)

Die Datei N wird zum Schreiben geöffnet. Der bisherige Dateiinhalt geht verloren. Existiert sie nicht, wird sie erzeugt. Beispiel:

Assign #2,"C:\UTILS\TEST.DAT"
Rewrite #2
Print #2,Zeile$
Close #2

Um eine bestehende Datei zu erweitern, ist der Befehl APPEND zu verwenden. Siehe auch: Reset und OpenRW.

• RmDir S
  • S : String - Verzeichnisnamen

Das Verzeichnis S wird gelöscht. Enthält es noch Dateien oder Unterverzeichnisse, kann es nicht gelöscht werden. Bei erfolgreicher Operation hat %IORESULT den Wert 0. Sie auch: ChDir MkDir

• Seek #N,A
  • #N: Dateikennung (1 - 8)
  • A: LongInt - Position in der Datei

Der Dateizeiger der im Binärmodus geöffneten Datei mit der Kennung #N wird auf die Position A gesetzt. Das erste Byte in der Datei hat die Position 0. Hinweis: SEEK #N,@GETFILESIZE(#N) setzt den Zeiger hinter das letzte Byte. Damit wird die Datei vergrößert.

• SetErrorLevel N
  • N: Integer - Errorlevel

Je nach Wunsch kann der Errorlevel auf einen der möglichen Werte gesetzt werden. Damit wird das Verhalten des Systems bei Auftreten eines Fehlers oder einer Warnung definiert:

• 2 - Für ganz Vorsichtige: Warnungen werden wie Fehler behandelt und führen zu einer Fehlermeldung mit Programmabbruch.
• 1 - Für die Programmentwicklung: Auch Warnungen werden ausgeben, aber das Programm läuft auf Wunsch weiter.
• 0 - Der Normalzustand: Warnungen werden nicht angezeigt. Diesen Errorlevel sollte man bei einem fertigen Programm verwenden.
• -1 - Fast schon kriminell: Auch Fehlermeldungen werden übergangen. Das kann unter Umständen zu einem DOS-Fehler oder Absturz des Systemes mit Datenverlust führen.

Warnungen treten auf, wenn ein Ausdruck nicht als numerischer Wert zu interpretieren ist oder z.B. eine Bilddatei nicht gefunden wird …

• SetFAttr #N1,N2
  • #N1: Dateikennung
  • N2: Integer - Attribut(e)

Setzt das Attribut der Datei #N. Der Kennung #N muá eine Datei mit ASSIGN zugewiesen worden sein. Die Datei darf aber nicht geöffnet sein. Geöffnet wird eine Dartei durch die Befehle REWRITE, APPEND, RESET oder OPENRW. Die Attribute:

• $01 = ReadOnly
• $02 = Hidden
• $04 = SystemDatei
• $08 = Label
• $10 = Directory-Eintrag
• $20 = Archiv

Werden mehrer Attribute verwandt, so sind sie zu addieren.

• StrWidth N
  • N: Integer (Mindestweite)

Die Mindest-Ausgabeweite für Strings (mittels des PRINT-Befehles) wird festgelegt. Strings, die kürzer als N sind, werden entsprechend mit vorangestellten Leerzeichen verlängert. Voreingestellt ist der Wert 0 (= „normales“ Verhalten der Strings).

• Sub VAR,N
  • VAR - Variablenname (Integer)
  • N - Integer

N wird von Variablen VAR subtrahiert. (Ist schneller und einfacher als die @SUB-Funktion.) Beispiel:

SUB Punkte%,10

• TBox X1,Y1 - X2,Y2; N
  • X1,Y1 : Wert - linke obere Ecke
  • X2,Y2 : Wert - rechte untere Ecke
  • N : Rahmentyp

Es wird im Textmodus eine Box gezeichnet. Die Koordinaten werden wie bei LOCATE in Zeichen eingegeben. Benutzt werden die Grafikzeichen des OEM-Zeichensatzes.

• 0 - Einfacher Rahmen
• 1 - Doppelter Rahmen
• 2 - Senkrecht doppelt/waagrecht einf.
• 3 - Ohne Rahmen

• WaitInput

Wartet auf einen Tastendruck. Das Ergebnis steht in den Systemvariablen %SCANKEY und %KEY. Unter DOS identisch mit WAITSCAN

• WaitKey

Wartet auf einen Tastendruck. Das Ergebnis steht in der Systemvariablen %KEY. (Funktionstasten werden nicht erkannt. Wird dies benötigt, ist WAITSCAN zu verwenden.)

• WaitScan

Wartet auf einen beliebigen Tastendruck. Auch Funktionstasten, Kusortasten, Shift- und Ctrltasten werden erkannt. Das Ergebnis steht als virtueller Tastencode in %SCANKEY und - im Falle einer „normalen“ Taste - als ASCII- Code in %KEY. Wichtige Scancodes:

16 -	Shift
17 -	Strg
27 -	Esc
33 -	BildHoch
34 -	BildRunter
35 -	Ende
36 -	Pos1
37 -	Links
38 -	Hoch
39 -	Rechts
40 -	Runter
45 -	Einfg
46 -	Entf
112 -	F1
... -	...
123 -	F12

Die übrigen lassen sich durch Ausprobieren mit folgendem Programm leicht austesten:

Cls
While 1    'Endlosschleife!
WaitScan
Print %ScanKey
Wend
End

Das Programm ist mit Strg-C zu beenden.

• While N … EndWhile
  • N : Wert - Bedingungsausduck

Die zwischen WHILE und WEND stehenden Befehle werden solange wiederholt, solange N ungleich 0 ist. Beispiel:

While N%
Print "Gebe eine Zahl ein: ";
Input N%
Wend

Anstelle von ENDWHILE kann auch die von Basic her gewohnte Schreibweise WEND verwandt werden.

• WhileNot N … EndWhile
  • N : Wert - Bedingungsausduck

Die zwischen WHILENOT und WEND stehenden Befehle werden solange wiederholt, solange N gleich 0 ist. Beispiel:

WhileNot @Eof(#2)
Input #2,Zeile$
Print Zeile$
Wend

Folgende Fehlermeldungen und Warnungen werden vom Interpreter bzw. Compiler und Runtime-System erzeugt:

pp.zip – Freeware-Vollversion PROFAN-CONSOLE 4.0 für den ATARI PORTFOLIO (ab 128 kB)