G-Pascal

Dieser Artikel befindet sich im Aufbau und ist vorläufig als Entwurf einzustufen.

G-Pascal
Entwickler	Nick Gammon, Sue Gobbett
Firma	Gambit Games
Release	1983
Lizenz	Vollversion, seit 2011 Open Source (siehe Interview)
Plattform(en)	C64, Apple II
Genre	Entwicklungssystem für die Sprache Pascal
Steuerung
Medien
Sprache(n)	, Anleitung
Information	Mehrere Versionen, aktuell Version 3.0

Beschreibung

G-Pascal ist ein Entwicklungssystem, das 1983 vom Australier Nick Gammon entwickelt und vertrieben wurde. Es besteht aus einem 16 KByte großen Programm, das Texteditor, Compiler, Debugger und P-Code-Interpreter enthält. Eine Besonderheit ist die stark eingeschränkte Auswahl von Datentypen - unter G-Pascal stehen nur die beiden Typen CHAR (1 Byte, ohne Vorzeichen) und INTEGER (3 Byte, vorzeichenbehaftet) zur Verfügung. Im Gegenzug verfügt G-Pascal über einen umfangreichen Befehlssatz für Benutzung von Sprites, Grafik und Sound.

Konstanten

Konstanten werden wie Integer-Variablen (siehe unten) als vorzeichenbehaftete 24-Bit-Zahlen gespeichert. Ihr Wertebereich reicht von -8388608 bis +8388607. Die Werte können in dezimaler oder hexadezimaler Form angegeben werden.

G-Pascal untertützt String-Konstanten mit ein bis drei Zeichen. Dafür wird der 24-Bit-Bereich eines Integerwerts in drei Bytes aufgeteilt, die Platz für je ein Zeichen bieten. Hat die String-Konstante weniger als drei Zeichen, werden die oberen Bytes auf null gesetzt. Das erste Zeichen wird im niedrigsten Byte, das zweite Zeichen im mittleren Byte und das dritte Zeichen im höchsten Byte gespeichert. Ein String "abc" wird mit

"a" or "b" shl 8 or "c" shl 16

in einen 24-Bit-Integerwert umgewandelt (shl steht für bitweises Verschieben nach links). Die folgende Tabelle zeigt die hexadezimalen Werte für die Strings "c", "ab" und "abc":

String	24-Bit-Wert
"a"	$000041
"ab"	$004241
"abc"	$434241

Um wieder an die einzelnen Zeichen zu gelangen, zerlegt man den 24-Bit-Integerwert mit shr (bitweises Verschieben nach rechts) in seine Bestandteile:

const
  c = "abc"
var
  c1, c2, c3: char;

begin
  c1 := c and 255;
  c2 := c shr 8 and 255;
  c3 := c shr 16 and 255;
  writeln(chr(c1), chr(c2), chr(c3));
end.

Die Verwendung dieser bis zu drei Zeichen langen Strings ist eine Alternative zu Variablen vom Typ ARRAY[3] OF CHAR. Der Programmautor nennt als Beispiel Adventure-Spiele, bei denen viel mit kurzen Wörtern gearbeitet wird.

Datentypen

• Integer: Integer-Variablen sind als vorzeichenbehaftete 24-Bit-Zahlen angelegt. Sie können Werte im Bereich von -8388608 bis +8388607 annehmen.
• Char: Char-Variablen sind 8-Bit-Werte im Bereich von 0 bis 255.
• Array: Arrays können nur eindimensional sein und Elemente vom Typ Integer oder Char enthalten. Sie beginnen immer beim Index 0. Ein array[10] of char hat demnach 11 Elemente (Index 0 bis 10). Es findet beim Zugriff auf Array-Elemente keine Kontrolle statt, ob der Index im gültigen Bereich liegt! Eine Besonderheit sind das MEM ARRAY bzw. MEMC ARRAY, mit dem direkt auf den Arbeitsspeicher zugegriffen werden kann (vergleichbar mit PEEK/POKE in Basic).

Integer- und Char-Variablen können einander zugewiesen werden, d.h. der Compiler führt hier keine Typen-Kontrolle durch. Allerdings gibt es Besonderheiten, die beachtet werden müssen:

• Beim READ-Befehl haben Integer- und Char-Variablen eine unterschiedliche Bedeutung.
• Bei der Zuweisung von einer Integer- an eine Char-Variable wird nur das niedrigste Byte berücksichtigt (MOD 256).

Andere Datentypen, wie REAL oder BOOLEAN, werden von G-Pascal nicht unterstützt. Außerdem gibt es keinen TPYE-Ausdruck. Der Programmautor gibt ein paar Empfehlungen, wie sich dieser Mangel (teilweise) ausgleichen lässt.

Ersatz für REAL

Wenn man z.B. Variablen für Euro-Beträge anlegen möchte, kann statt in anderen Pascal-Versionen

var
  r: real;

begin
  r := 12.5;
  writeln(r);
end.

in G-Pascal mit Cent-Werten gerechnet werden

var
  r: integer;

begin
  r := 1250; (* 12.5 mal 100 *)
  write(r/100, ".");
  if r mod 100 < 10 then
    write("0");
  writeln(r mod 100);
end.

Ersatz für BOOLEAN

Statt der BOOLEAN-Variablen in anderen Pascal-Versionen

var
  t,f: boolean;

begin
  t := true; f := false;
end.

kann man in G-Pascal CHAR-Variablen verwenden

const
  true = 1; false = 0;
var
  t,f: char;

begin
  t := true; f := false;
end.

Ersatz für TYPE

Statt dem TYPE-Ausdruck in anderen Pascal-Versionen

type
  farbe = (rot, gruen, blau);
var
  f: farbe;

begin
  f := blau;
end.

kann man in G-Pascal Konstanten definieren

const
  rot = 0; gruen = 1; blau = 2;
var
  f: integer;

begin
  f := blau;
end.

Prozeduren und Funktionen

Prozeduren und Funktionen sind Unterprogramme, die sich darin unterscheiden, dass Funktionen einen Wert zurückgeben. In beiden können eigene Konstanten und Variablen definiert werden, die dann nur innerhalb der Prozedur bzw. Funktion gelten. Prozeduren und Funktionen können wiederum eigene Unterprozeduren bzw. -funktionen besitzen. Außerdem können Prozeduren und Funktionen sich selbst aufrufen (Rekursion).

Als Parameter akzeptiert G-Pascal nur Integerwerte. Es entfällt die sonst in Pascal übliche Typenangabe bei den Parametern.

Das folgende Programm errechnet für einen gewünschten Bereich an Ganzzahlen (hier 1 bis 10) die Quardratwerte dieser Zahlen:

procedure berechnequadrat(von, bis);
  var
    zahl: integer;
  
  function quadrat(x);
     begin
       quadrat := x * x;
     end;
  
  begin
     for zahl := von to bis do
       writeln(zahl, " * ", zahl, " = ", quadrat(zahl));
  end;
  
begin
  berechnequadrat(1, 10);
end.

Array als Parameter

Wenn man ein ARRAY als Parameter übergeben möchte, muss man einen Umweg gehen, da G-Pascal nur Integerwerte als Parameter akzeptiert. Statt des ARRAYs selbst wird nur die Adresse des ersten Elements mit dem Schlüsselwort address übergeben und die Prozedure greift über das ARRAY memc direkt auf den Speicher zu. De facto wird also ein Zeiger auf das ARRAY übergeben. Eine Besonderheit von G-Pascal ist, dass ARRAYs in umgekehrte Reihenfolge im Speicher abgelegt werden, also das letzte Element zuerst und das erste Element am Schluss.

Zur Veranschaulichung hier ein Beispiel, in dem das Alphabet in einem ARRAY als Zeichenkette abgelegt und mittels der Prozedure strout ausgegeben wird. Im ersten Element des Arrays (Index 0) ist die Länge der Zeichenkette gespeichert.

const
  max = 26;
var
  s: array [max] of char ;
  i: integer ;

procedure strout(adr);
  var i: integer ;
  begin
    if memc [adr] > 0 then
      for i := 1 to memc [adr] do
        write (chr (memc [adr - i]));
    end ;

begin
  for i:= 1 to max do
    s[i] := i + 64;
  s[0] := max;
  strout(address (s[0])); writeln ;
end .

In anderen Pascal-Versionen, die den Type-Ausdruck unterstützen, würde der Prozedure das Array direkt als Paremeter übergeben werden:

const
  max = 26;
type
  str = array[0..max] of char;
var
  s: str ;
  i: integer ;

procedure strout(s: str);
  var i: integer ;
  begin
    if s[0] > 0 then
      for i := 1 to s[0] do
        write (s[i]);
    end ;

begin
  for i:= 1 to max do
    s[i] := i + 64;
  s[0] := max;
  strout(s); writeln ;
end .

Weblinks

• Great Australian software developers: Nick Gammon & G-Pascal Interview von 2011 mit Nick Gammon, dem Autor von G-Pascal
• G-Pascal V3.0 Diskettenimage von G-Pascal (Link aus Interview)
• G-Pascal Binaries Diskettenimages, Handbücher und Werbematerial zu G-Pascal
• Sources Quelltexte von G-Pascal, hier im ca65-Format
• CSDb