Pawn (Programmiersprache)

Dieser Artikel oder Abschnitt bedarf einer Überarbeitung: Der Artikel ist eine sprachliche Katastrophe.
Bitte hilf mit, ihn zu verbessern, und entferne anschließend diese Markierung.

Pawn ist eine einfache, typenlose, 32-Bit-Erweiterungssprache mit einer C-ähnlichen Syntax. Ein Pawn-'Quellcode'-Programm wird in eine Binärdatei kompiliert. Der Pawn-Compiler generiert P-Code (oder Bytecode), der anschließend auf einer abstrakten Maschine ausgeführt wird. Ausführungsgeschwindigkeit, Stabilität, Einfachheit und ein kleiner Speicherbedarf waren wesentliche Designkriterien sowohl für die Sprache als auch für die abstrakte Maschine.^[1]

Geschichte[Bearbeiten]

Die Pawn-Programmiersprache wurde erstmals in den späten 1990er Jahren von IT-Studenten der Universität Uppsala in Schweden entwickelt. Das Hauptziel war es, eine einfache und leistungsstarke Skriptsprache zu schaffen, die in unterschiedlichen Anwendungsfällen verwendet werden kann.^[2]

Versionsverlauf[Bearbeiten]

Version 3.3.4026 (27. Oktober 2008)[Bearbeiten]

Sicherheitslücke ("Arbitrary Code Execution") behoben
Unterstützung für "exit"-Statusfunktionen hinzugefügt
Trailing-Kommata in Array-Initialisierungen erlaubt
Makro-Substitutionsprozessor erkennt "#" zur Stringisierung von Parametern
Unterstützung für Tausender-Trennzeichen in Zahlen
Verbesserte Handshake-Geschwindigkeit des Debuggers in Remote-Debugging-Konfigurationen
Unterstützung für ncurses
Verwendung von dyncall anstelle von libffi im amxProcess-Modul
Optionaler "binreloc"-Modul für Linux
Portabler INI-Dateiparser im amxFile-Modul
Unterstützung für Code-Snippets und Ballon-"Info-Tipps" in Quincy
Workspace-Unterstützung in Quincy
Fehlerbehebungen in verschiedenen Modulen, einschließlich amxFile, amxString und amxpool^[3]

Version 3.3.4058 (15. Januar 2009)[Bearbeiten]

Behebung eines Fehlers in der Funktion amx_GetString(), der gepackte ANSI-Strings mit zwei zusätzlichen Nullbytes beendete, was zu einem Pufferüberlauf führte.
Wenn der Compiler aufgrund eines schwerwiegenden Fehlers in einer Include-Datei abbrach, wurden die "übergeordneten Dateien" nicht ordnungsgemäß geschlossen.
Der Compiler konnte nicht mehr mit den Optionen PAWN_LIGHT oder PAWN_NO_CODEPAGE kompiliert werden, da einige neue Abschnitte die entsprechenden bedingten Kompilierungshüllen nicht hatten.
Ein Fehler in amx_Clone() wurde behoben, der von Luke Salisbury im pawn Forum gemeldet wurde.
Ein Fehler, bei dem der Compiler bei erneutem Start Daten aus dem vorherigen Lauf verwenden konnte, wurde behoben. Dieser Fehler wurde von Soren Hannibal im pawn Forum gemeldet.
Quincy wurde um eine neue "Suche in Dateien"-Funktion erweitert, die eine modifizierte Version von GNU grep verwendet.
Warnungen beim Kompilieren mit Visual Studio 2008 wurden entfernt.^[3]

Version 3.3.4097 (8. April 2009)[Bearbeiten]

Der pawn Compiler kann nun eine Konfigurationsdatei mit spezifischen Einstellungen für eine Umgebung verwenden. Neue Befehlszeilenoption: -T.
Die Linux-Distribution erhielt eine minimalistische IDE namens wxQuincy.
Uncrustify ersetzt "artistic style" als Code-Verschönerungswerkzeug für Quincy.
Änderungen in Quincy: Erkennung schreibgeschützter Pfade (oder Laufwerke), eine Option zum Speichern der Datei an einem anderen Ort ohne Abbruch des Kompilierens, eine Meldung im "Build-Protokoll", die anzeigt, dass eine Quelldatei seit dem letzten Build geändert wurde (und daher neu kompiliert werden muss), ein Fenster zum Anzeigen von über die serielle Schnittstelle empfangenen Zeichenfolgen.
Update des GraphApp-Terminal (plattformübergreifend).^[3]

Merkmale[Bearbeiten]

Merkmale von Pawn

C-ähnliche Syntax: Die Syntax von Pawn ist an C/C++ angelehnt, was sie für Entwickler, die mit diesen Sprachen vertraut sind, leicht verständlich macht.
Kompaktheit: Pawn zeichnet sich durch seine geringe Größe aus und erfordert wenig Speicherplatz, was für den Einsatz in ressourcenbeschränkten Umgebungen wie Mikrocontrollern vorteilhaft ist.
Precompiler-System: Das Precompiler-System von Pawn ermöglicht es Entwicklern, benutzerdefinierte Befehle und Funktionen zu erstellen, um ihre Arbeitsabläufe zu automatisieren und zu optimieren.
Portabilität: Pawn ist auf verschiedenen Plattformen verfügbar und bietet somit eine hohe Portabilität für Entwickler.
Modularität: Entwickler können Bibliotheken und Module in Pawn schreiben und wiederverwenden, um die Entwicklung von Skripten zu beschleunigen.

Anwendungsbereiche[Bearbeiten]

Pawn ist eine Programmiersprache, die in verschiedenen Anwendungsbereichen Verwendung findet. Sie wird häufig als Skriptsprache für das Modding des Spiels "GTA San Andreas" im Rahmen der Multiplayer-Modifikation SAMP (San Andreas Multiplayer) eingesetzt. Obwohl Pawn häufig mit SAMP in Verbindung gebracht wird, wurde es nicht ausschließlich für SAMP entwickelt, sondern existierte bereits als eigenständige Programmiersprache, vor SAMP.

Diese Programmiersprache wird nicht nur für die Modifikation von Spielen wie GTA SA genutzt, sondern auch für die Entwicklung von kleineren Softwareanwendungen. Des Weiteren kommt Pawn bei der Programmierung von Mikrocontrollern und anderen eingebetteten Systemen zum Einsatz. Darüber hinaus wird Pawn auch in anderen Spielmodifikationen und Projekten verwendet.^[4]^[5]

Pawn und die GTA SA Mod SAMP[Bearbeiten]

In der SAMP-Community wird Pawn hauptsächlich mit dem Scripting von Gamemods in Verbindung gebracht. Viele Mitglieder dieser Community neigen dazu, Pawn ausschließlich mit SAMP zu assoziieren und es als eine spezielle Scriptsprache für diese Modifikation zu betrachten. Dies führt manchmal zu Missverständnissen in allgemeinen Foren und Diskussionen über Pawn.

Es ist wichtig zu verstehen, dass Pawn als eigenständige Skriptsprache existiert und nicht auf SAMP beschränkt ist. Wenn Pawn für SAMP verwendet wird, erfolgt dies durch das Einbinden von SAMP-spezifischen Includes wie

#include <a_samp>

in das Skript, um alle relevanten Publics, Funktionen und Callbacks von SAMP zu nutzen.

Variablen[Bearbeiten]

Die Variablentypen in Pawn sind im Vergleich zu C eingeschränkter, und ihre Deklaration erfolgt auf eine andere Weise. Statt der üblichen C-Deklaration verwenden wir das Schlüsselwort "new", gefolgt vom Typ (falls erforderlich), und dem Namen der Variablen. In der Standardeinstellung werden Variablen als Ganzzahlen deklariert, weshalb in diesem Fall keine explizite Typangabe erforderlich ist. Es ist jedoch eine bewährte Praxis, jede deklarierte Variable zu initialisieren, um sicherzustellen, dass sie keinen fehlerhaften Wert enthält, auch wenn ihr standardmäßig ein Wert zugewiesen wird. Dies trägt zur Robustheit und Fehlervermeidung in Pawn-Programmen bei.


Typ	Dekleration	Spezifizierer
Integer	new a = 3;	%d, %i
Float	new Float:pi = 3.14;	%f (%.2f → 2 Dezimalstellen)
Boolean	new bool:lightOn = false;	%b
Charakter	new lettreB = 'B';	%c (%d → code ASCII)
Zeichenkette/String	new monEncyclopedie[] = "Wikipédia";	%s

main()
{
   new Float:pi = 3.14;
   printf("Näherungswert von pi : %f");
}

Kontroll Strukturen[Bearbeiten]

Bedingte Strukturen, sind wie in anderenprogramiersprachen, ein wichtiger Bestandteil der Programmierung in PAWN. Mit bedingten Strukturen können Sie Entscheidungen in Ihrem Code treffen, abhängig von bestimmten Bedingungen. PAWN bietet hierfür die folgenden Hauptkonstrukte:^[6]

Die if Struktur[Bearbeiten]

Die if-Anweisung in PAWN ermöglicht es, Codeblöcke basierend auf einer bestimmten Bedingung auszuführen. Wenn die Bedingung wahr ist, wird der Code innerhalb des if-Blocks ausgeführt, ansonsten wird er übersprungen oder optional in einem else-Block behandelt.

if (Bedingung)
{
    // Code, der ausgeführt wird, wenn die Bedingung wahr (true) ist
}
else
{
    // Code, der ausgeführt wird, wenn die Bedingung falsch (false) ist
}

Konkrete Beispiele

main()
{
   new a = -4;
   if (a < 0)
   {
      printf("Die Zahl ist negativ! (%d)", a);
   }
}

main()
{
   new a = -4;
   if (a < 0)
   {
      printf("Die Zahl ist negativ! (%d)", a);
   }
   else
   {
      printf("Die Zahl ist positiv! (%d)", a);
   }
}

main()
{
   new a = -4;
   if (a < 0)
   {
      printf("Die Zahl ist negativ! (%d)", a);
   }
   else if (a == 0)
   {
      printf("Die Zahl ist null!");
   }
   else
   {
      printf("Die Zahl ist strikt positiv! (%d)", a);
   }
}

Die Switch Struktur[Bearbeiten]

Die "switch"-Struktur wird verwendet, wenn sukzessive der Werte einer Variablen überprüft werden soll.^[6] Es kann zwar eine "if"-Struktur mit einer beträchtlichen Anzahl von "else if"-Bedingungen verwenden, jedoch passt die "switch"-Struktur besser zu solchen Fällen.

main()
{
   new a = 3;
   switch(a)
   {
       case 1:
       {
          printf("Die Variable 'a' enthält den Wert 1");
       }
       case 0, -1:
       {
          printf("Die Variable 'a' enthält den Wert 0 oder -1");
       }
       case 2..5:
       {
          printf("Die Variable 'a' enthält einen Wert zwischen 2 und 5");
       }
       default:
       {
          printf("Die Variable 'a' enthält einen Wert, der von den zuvor überprüften Werten abweicht");
       }
   }
}

Schleife[Bearbeiten]

"For"-Schleife[Bearbeiten]

Eine "for"-Schleife ist eine häufig verwendete Kontrollstruktur in der Programmierung, die verwendet wird, um eine bestimmte Anweisungssequenz wiederholt auszuführen, wobei die Anzahl der Durchläufe im Voraus bekannt ist oder auf eine bestimmte Weise berechnet wird. Sie besteht aus drei Hauptteilen: der Initialisierung, der Bedingung und der Inkrementierung. Die Initialisierung legt den Anfangszustand fest, die Bedingung bestimmt, ob die Schleife weiterhin ausgeführt wird, und die Inkrementierung ändert den Zustand für den nächsten Durchlauf. Die "for"-Schleife ist besonders nützlich, wenn nicht genau bekannt ist, wie oft ein bestimmter Codeblock ausgeführt werden soll, beispielsweise wenn Sie durch Elemente in einem Array iterieren oder eine Zählschleife benötigen.^[6]

//Beispiel für eine "for"-Schleife
new i
new sum
for (i=1; i<=10; i++)
{
   sum += i
}

While Schleifen[Bearbeiten]

Schleifen sind in PAWN von grundlegender Bedeutung, und die nächste Art von Schleife ist einfacher als eine "for"-Schleife. Sie wird als "while"-Schleife bezeichnet und benötigt nur einen Parameter: eine Bedingung. Solange die Bedingung wahr ist, wird der Code ausgeführt.

// Grundschleife
new i = 0;
new sum;

while (++i <= 10)
{
   sum += i;
}

sum_of_array(array[], size)
{
   new i = 0, sum = 0;

   // Führe diese Schleife aus, solange i kleiner als die Größe ist.
   // i wird am Ende jeder Schleife inkrementiert.
   while (i < size)
   {
      sum += array[i];
      i++;
   }

   return sum;
}

bool:compare_arrays(array1[], array2[], size)
{
   new i = 0;

   while (i < size)
   {
      if (array1[i] != array2[i])
      {
         return false;
      }
      i++;
   }

   return true;
}

Do while - Schleife[Bearbeiten]

Eine "do-while"-Schleife ist eine Kontrollstruktur in der Programmierung, die dazu verwendet wird, einen bestimmten Codeblock mindestens einmal auszuführen und dann zu überprüfen, ob eine Bedingung erfüllt ist, um fortzufahren oder die Schleife zu beenden. Anders ausgedrückt, wird der Code innerhalb der "do-while"-Schleife zuerst ausgeführt und die Bedingung erst am Ende der Schleife überprüft. Wenn die Bedingung wahr ist, wird die Schleife erneut durchlaufen, andernfalls wird sie beendet.

Die "do-while"-Schleife ist nützlich, wenn Sie sicherstellen müssen, dass ein bestimmter Code mindestens einmal ausgeführt wird, unabhängig von der Bedingung. Sie wird häufig für Benutzereingaben und wiederholte Operationen verwendet, bei denen die Anzahl der Durchläufe im Voraus nicht bekannt ist.

/* Programm zur Berechnung der Summe der ersten N positiven ganzen Zahlen (wobei N vom Benutzer eingegeben wird) */
main()
{
    new n_entiers = 0, sum = 0;
    /* Benutzereingabe überwachen */
    do
    {
        printf("Geben Sie an, bis zu welcher ganzen Zahl die Summe berechnet werden soll (Zahl > 1): ");
        n_entiers = getvalue(); // Die Funktion getvalue() liest die vom Benutzer in der Konsole eingegebene ganze Zahl ein

    }
    while(n_entiers <= 1);

    /* Berechnung der Summe der aufeinanderfolgenden ganzen Zahlen bis zu n_entiers */
    for(new i = 1; i <= n_entiers; i++)
        sum += i;

    /* Ergebnis ausgeben */
    printf("Die Summe der ganzen Zahlen von 1 bis %d beträgt %d", n_entiers, sum);
}

Ausdrücke[Bearbeiten]

Ausdrücke sind analog zu Ausdrücken in der Mathematik. Es handelt sich um Gruppierungen von Symbolen, die ein Datenstück zurückgeben. Ausdrücke bestehen normalerweise aus Klammern und werden in einer bestimmten Reihenfolge ausgewertet (von innersten zu äußersten, zuerst Klammern, dann Multiplikation, Division, Addition, Subtraktion usw.). Ausdrücke können überall platziert werden. Sie können Variablen gleichsetzen oder sie an Funktionen übergeben.^[7]^[6]

//Einfacher Ausdruck.  Gibt die Zahl Null zurück.
0
//Ebenfalls ein Valider gleichwertiger Ausdruck:
(0)

Wenn ein Ausdruck nicht null ist oder nicht falsch ist, gibt er nicht nur einen Wert zurück, sondern auch "wahr" ("true"). Andernfalls gibt er 0 zurück, was auch "falsch" ("false") ist.

//Mehr Mathematische ausdrücke.  Mathematische Grundoperationen sind:
// + für Addition
// - für Subtraktion
// * für Multiplikation
// / für Division
// % für Modulo (gibt den Rest bei einer ganzzahligen Division (5%2 ist 1)
(5+6)                       //Gibt 11 zurück
((5*6)+3)                   //Gibt 33 zurück
((((5+3)/2)*4)-9)           //Gibt 7 zurück
((5*6) % 7)                 //Gibt 2 zurück
//Andere Ausdrücke:
(true)                      //Gibt true zurück
(5.0 + 2.3)                 //Gibt 7.3 als Fließkommazahl zurück

Es gibt auch Erweiterungen dieser Operatoren, die direkt auf Variablen angewendet werden können.

new a = 5
new b = 6
//Die ersten sind die Post-Inkrement- und Post-Dekrement-Operatoren.
a++          //Gibt a+1, oder 6 zurück.  Das ist Post inkremetierung
++a          //gibt auch a+1, oder 6 zurück.  Das ist Pre inkrementierung

Der Unterschied zwischen den beiden ist subtil, aber wichtig. a++ wird ZULETZT in einem Ausdruck ausgewertet, während ++a ZUERST ausgewertet wird. Dieser Unterschied ist nützlich bei Code, der Schleifen auf bestimmte Weisen verwendet. Es ist auch wichtig zu wissen, dass die Inkrement-/Dekrementoperatoren nicht nur a+1 zurückgeben, sondern auch die Variable a auf a+1 setzen.

a--          //Gibt 4 zurück, post dekrementierung
--a          //Gibt 4 zurück, pre dekrementierung

Beachten Sie, dass a++ im Wesentlichen diesen Code vereinfacht:

a = a + 1

Es gibt jedoch eine andere Möglichkeit, Zeilen von Code in dieser Form zu schreiben:

a = a OP y

Wo OP ein mathematischer Operator ist, kann verkürzt werden zu:

a OP= x

Beispiel

a += 1       //Setst a auf a + 1
a -= b       //Setzt a auf a - b
a *= 0       //Multipliziert a mit 0
a /= 2       //Dividiert a mit 2.

Allerdings sind mathematische Operatoren nicht die einzigen Operatoren, die zu Verfügung stehen. Es gibt auch boolesche Operatoren, die Ihnen bei logischen Schaltkreisen oder logischen Entscheidungen helfen.

Der "und"-Operator nimmt den linken Ausdruck und den rechten Ausdruck auf. Wenn beide "wahr" sind, gibt er "wahr" zurück.

//Dies ist falsch (false), weil 1 "wahr" zurückgibt und 0 "falsch" zurückgibt.
//Da beide nicht "wahr" (true) sind, gibt && "falsch" (false) zurück.
(1 && 0)
(1 && 2)                    //Beide zahlen sind "true" also wahr, daraus folgt der Ausdruck ist "true" also wah.
(true && false)             //false
(false && false)            //false
(true && true)              //true

Der andere wichtige Operator ist "oder". Er gibt "wahr" zurück, wenn einer von zwei Ausdrücken "wahr" ist.

(1 || 0)                    //true, da eine der Variablen Wahr ist
(1 || 2)                    //true
(true || false)             //true
(false || false)            //false
(true || true)              //true

Es gibt auch andere Operatoren, die Sie möglicherweise nicht so oft verwenden. Der "bitweise und"-Operator gibt zurück, ob eine binäre Bitfolge in einer anderen enthalten ist. In technischer Hinsicht führt er eine "und (&&)"-Operation auf jedem der Bits in beiden Zahlen durch. Zum Beispiel, nehmen wir an, Sie haben die Zahl "9", die im Binärsystem "1001" ist. Wenn Sie wissen möchten, ob diese Sequenz die Zahl "8" (1000) enthält, können Sie Folgendes tun:

//Dieser Ausdruck wird 8 zurückgeben, was bedeutet 8 ist tatsächlich ein Bit in 9.
(9 & 8)
//4 (00100) ist kein Bit in 16 (10000), und dies wird 0 zurückgeben.
(16 & 4)
//Der Nexte Operand ist "bitwweise oder"
//welcher eine "oder (||)" Operation auf jedem der Bits in beiden Zahlen durchführt.
//Dies wird 9 (1001) nehmen und es mit 3 (0011) abgleichen, was zu 1011 oder 11 führt.
(9 | 3)

Diese beiden Operatoren sind ebenfalls wichtig, werden jedoch nicht so oft verwendet. Es handelt sich um die bitweisen Verschiebeoperatoren, << ist ein Linksschub und >> ist ein Rechtsschub. Sie verschieben die Bits in einer Zahl in eine Richtung.

//Dies nimmt die Zahl 3 (00011) und verschiebt sie um drei Stellen nach links (11000) im Binärsystem, oder 24 im Dezimalsystem.
(3 << 3)
//Dies nimmt die Zahl 24 (11000) und verschiebt sie um drei Stellen nach rechts im Binärsystem (00011) oder 3 im Dezimalsystem.
(24 >> 3)

Der letzte Operator ist "bitweise Negation". Er gibt das genaue Gegenteil von dem zurück, was ihm gegeben wird. Wenn er auf eine Zahl angewendet wird, werden alle Bits umgekehrt (1 wird zu 0 und 0 wird zu 1).

//Gibt flase zurück
(!true)
//Gibt flase zurück
(!false)
//Dies nimmt 9 (binär 1001) und ändert es in 6 (binär 0110). Dies ist der "Bitweises Komplement"-Operator, der für jedes Bit ein "nicht" (not) durchführt.
(~(9))

Funktionen und Prozeduren[Bearbeiten]

Die Unterscheidung zwischen Funktionen und Prozeduren erfolgt oft in der Algorithmik aufgrund der Existenz einer Rückgabewert oder deren Fehlen. In C wird diese Unterscheidung durch das Schlüsselwort vor der Funktionsdefinition (void oder ein Datentyp) getroffen. Allerdings führt PAWN eine Verwirrung zwischen diesen beiden Begriffen herbei, da es keine explizite Unterscheidung zwischen ihnen ermöglicht.

Die Deklaration einer Funktion in PAWN erfolgt folgendermaßen:^[8]

main()
{
    /* Benutzereingaben */
    new a = getvalue();
    new b = getvalue();
    /* Anzeigen des Ergebnisses */
    printf("Die Multiplikation von a und b ergibt: %d", multiplie(a, b)); // Aufruf der erstellten Funktion
}

multiplie(a, b) // Multipliziert eine Ganzzahl a mit b
{
    return a * b; // Hier wird das Schlüsselwort return verwendet, um der Funktion einen Rückgabewert zuzuweisen.
}

Ebenso, wenn einen Wert eines anderen Datentyps als Ganzzahl zurückgeben werden soll, muss der Datentyp vor der Deklaration angeben werden:

bool:Gleich(a, b) // Die Funktion gibt wahr oder falsch zurück
{
    return a == b; // Gibt den Wert des Gleichheitstests zurück
}

Es ist jedoch erforderlich anzugeben, dass die Funktion einen anderen Typ als den Standardtyp (Ganzzahl) zurückgibt. Daher müssen Sie den Prototyp (auch Header genannt) Ihrer Funktion erstellen, bevor Sie sie aufrufen. Dies geschieht wie folgt:

forward bool:Gleich(a, b); // Erstellen eines Vorwärtsdeklaration unter Verwendung des Schlüsselworts forward

main()
{
   new a = 5, b = 3;
   printf("A und B gleich? %b\n", Gleich(a, b));
}
bool:Gleich(a, b)
{
   return a == b;
}

Übergabe von Parametern: Eine Funktion kann (oder auch nicht) Argumente in ihrer Deklaration haben. Die PAWN-Sprache bietet zwei Arten, Parameter an eine Funktion zu übergeben. Die erste Methode ist die Übergabe von Parametern nach Wert, bei der eine Kopie der in der Funktion übergebenen Variablen erstellt wird. Eine solche Kopie kann den Wert der ursprünglichen Variablen daher nicht ändern.

main()
{
    new a = 2;
    quadrier(a);
    printf("a ist jetzt: %d", a); // a wird 2 sein, wenn Parameter nach Wert übergeben wird.
}

quadrier(wert)
{
   wert *= wert; // Hier wird kein Ergebnis zurückgegeben. Stattdessen wird versucht, direkt auf die Variable einzuwirken.
}

Diese Methode wird bevorzugt, wenn eine Berechnungen mit dem Wert einer Variablen durchführen oder deren Wert gelesen werden soll. Wenn jedoch der Wert der übergebenen Variablen geändert werden soll, wird oft die zweite Methode verwendet: die Übergabe von Parametern per Referenz. Bei dieser Methode wird nicht der Wert der Variablen, sondern deren Speicheradresse an die Funktion übergeben, sodass auf die Variable im Speicher zugegriffen werden kann, ohne sie zu duplizieren.

main()
{
   new a = 2;
   quadrier(a);
   printf("a ist jetzt: %d", a); // a wird 4 sein, wenn Parameter per Referenz übergeben wird.
}

quadrier(&wert) // Hier wird ein "&" hinzugefügt, um die Speicheradresse der Variablen zu erhalten, nicht deren Wert.
{
   wert *= wert;
}