# Pawn (langage)

Le PAWN (successeur du Small-C) est un langage de programmation open source utilisé sur différentes plates-formes.
Sa syntaxe est assez proche de celle du langage C bien que le typage soit différent. À défaut de ne pas fournir de pointeurs, les programmes implémentés dans la machine abstraite du PAWN assurent une vérification des indices de tableau ainsi qu'une protection quant au dépassement de la mémoire programme donnée.

## Utilisations

Le pawn étant un langage adapté pour des machines à ressource limitée, il a été utilisé dans quelques techniques embarquées comme c'est le cas du satellite ESTCube-1 ou plus communément pour des serveurs de jeux notamment SA-MP (San Andreas - MultiPlayer).
On citera par ailleurs Eternal Lands qui a été développé en Small-C.

## Éléments du PAWN

Comme tout langage de programmation, le PAWN a ses propres spécificités.

### Les variables

Les types de variables sont plus restreints qu'en C et leur déclaration est différente.
Effectivement, on va introduire le mot-clé « new » suivi du type (s'il y a) ainsi que le nom de la variable.
Par défaut, les variables sont déclarées comme des entiers, il n'est donc pas nécessaire de préciser un type dans ce cas-là.
Il est préférable d'initialiser chaque variable que l'on déclare afin qu'elle ne contienne pas une valeur erronée même si une valeur par défaut leur est attribuée.
| Type | Déclaration | Spécificateur |
| Entier | new a = 3; | %d, %i |
| Flottant | new Float:pi = 3.14; | %f (%.2f → 2 décimales) |
| Booléen | new bool:lightOn = false; | %b |
| Caractère | new lettreB = 'B'; | %c (%d → code ASCII) |
| Chaîne de caractères | new monEncyclopedie = "Wikipédia"; | %s |

### Les structures conditionnelles

On distinguera deux principales structures conditionnelles : « if » ainsi que le « switch ».

#### Structure « if »

Cette structure se compose du mot-clé « if » précédant une expression booléenne.
Une première forme de cette structure se définit en une simple vérification comme ci-dessous :
Néanmoins, nous pouvons tout aussi gérer la négation de la condition entrée avec le mot-clé « else ».
Un dernier mot-clé qui permet de vérifier une expression si jamais la précédente renvoyait la valeur « faux » : « else if ».
Remarque : en utilisant le « else » à la fin, je vérifie si aucune des conditions le précédant n'ont été remplies.
La structure globale débute, quoi qu'il en soit, par un « if ».

#### Structure « switch »

La structure « switch » (ou « cas..parmi » en terme algorithmique) est utilisée dans le cas où vous auriez à vérifier successivement les valeurs d'une variable. Vous pourrez utiliser une structure « if » avec un nombre considérable de « else if ».
Cependant, la structure « switch » s'adapte bien à ce genre de cas.

### Les structures itératives

Une structure itérative (ou boucle) va répéter un certain nombre de fois une ou plusieurs instructions (on parle d'itérations).
On distingue également deux principales structures itératives, chacune caractérisée par un nombre d'itérations déterminé.

#### Boucle « pour »

La boucle « pour » va conventionnellement exécuter un nombre de fois déterminé les instructions imbriquées dans celle-ci.
On parle alors de boucle déterministe.
Dans une telle boucle, on utilisera souvent un incrément. Elle est particulièrement utile quand il faut répéter une instruction plusieurs fois comme un message à afficher ou des calculs successifs.

#### Boucle «while»

La boucle «while» est, quant à elle, une boucle indéterministe.
Elle est généralement guidée par une condition qui ne vérifie pas un nombre d'itérations effectuées.
Une telle boucle ne nécessite pas forcément d'un incrément comme celle présentée ci-dessus.

#### Boucle «do..while»

La boucle «do..while» est, elle aussi, indéterministe.
Contrairement à la boucle «while», elle va exécuter les instructions qu'elles comportent avant de vérifier la condition.
Cela garantit au moins un passage dans la boucle. Elle est particulièrement sollicitée lors de contrôles de saisie utilisateur.

### Les fonctions / procédures

En algorithmique, on distingue souvent la fonction d'une procédure par l'existence ou non d'une valeur de retour. En C, la distinction s'effectue par le mot-clé mis devant la définition de la fonction (void ou un type de données). Le PAWN applique cependant une confusion entre les deux termes puisqu'il ne permet pas d'établir explicitement la différence entre ces deux notions.

#### Déclaration d'une fonction

Ainsi, la déclaration d'une fonction en PAWN se fait de la manière suivante :
De même, si l'on souhaite renvoyer une donnée d'un type différent de l'entier il suffira de préciser le type devant la déclaration :
Il sera cependant nécessaire de préciser que la fonction renvoie un type différent de celui par défaut : l'entier. De ce fait, il faudra créer le prototype (ou encore entête) de votre fonction avant de l'appeler. On aura ainsi :

#### Passage de paramètres

Une fonction peut présenter (ou non) des arguments dans la déclaration de sa fonction. Le langage Pawn propose deux types pour transmettre des paramètres à la fonction.
Le premier étant le passage de paramètres par valeur qui a la particularité de créer une copie de la variable passée en paramètre lors de l'appel de la fonction. Une telle copie ne peut donc affecter la valeur de la variable de départ.
Ce passage de paramètres est favorisé pour des traitements sur la valeur d'une variable ou sa lecture. Néanmoins, si l'on veut modifier la valeur de la variable passée en paramètre il faudra favoriser le second passage de paramètres : par référence. Un tel passage implique la transmission à la fonction non pas de la valeur de la variable mais de son adresse mémoire permettant donc d'agir sur la variable en mémoire sans passer par une duplication de celle-ci.
Ce type de passage est largement favorisé quand on est contraint de retourner plus d'une valeur (exemple : fonction qui convertit le nombre de secondes en hh-mm-ss).