Types de base du C
Chaîne de caractères
Tableau
Liste
Objet
Pointeur vers un noeud
Pointeur vers une structure FILE
Pointeur vers une fpos_t
Mémoire brute
Octet
Adresse de mémoire
Pointeur vers les types ci-haut.

Pour afficher le type d'une expression, appeler gettype.

char

signed char

unsigned char

short short int signed short signed short int

unsigned short unsigned short int

int signed int

unsigned unsigned int

long long int signed long signed long int

unsigned long unsigned long int

long long long long int signed long long signed long long int

unsigned long long unsigned long long int

float

double

long double

Pour de l'infomation détaillée à propos de ces types, voir Wikipedia.

Les nombres dans un arbre syntaxique du PCASTL sont représentés comme des double du C. Lorsqu'entrés en notation hexadécimale, ils sont reçus comme des entiers signés avant d'être castés vers double. La notation hexadécimale doit commencer avec "0x". Quand "castés" et stockés dans une variable ou affichés, les nombres peuvent avoir n'importe quel des types de base du C.

> 0xA3
        163
> 0xF0000000
        -268435456
> 4.0
        4
> a = (char)64
        @
> gettype(a)
        "char"
> a = (int)3.1416
        3
> gettype(a)
        "int"

Les chaînes de caractères en PCASTL sont des tableaux de char du C alloués dynamiquement. Quand vous appelez la fonction length, vous recevez la longueur de la mémoire allouée. Pour recevoir le nombre de caractères avant le caractère nul de la fin, appeler strlen.

Pour obtenir un caractère dans une chaîne de caractères à un index donné, vous pouvez utiliser un indice. Le premier index est zéro.

> a = "hello"
        "hello"
> b = a[1]
        e
> gettype(b)
        "char"
> "hello"[3]
        l

Dans une chaîne de caractères, une séquence échappatoire indique un caractère spécial. Les séquences échappatoires commencent avec un caractère barre oblique inverse (\).

Séquence	Nom
\a	Alerte (sonnerie)
\b	Espace arrière
\f	Présentation de page suivante
\n	Nouvelle ligne
\r	Retour de chariot
\t	Tabulation horizontale
\v	Tabulation verticale
\?	Point d'interrogation littéral
\'	Apostrophe
\"	Guillemet
\\	Barre oblique inverse
\ddd	Caractère ASCII en notation octale
\xdd	Caractère ASCII en notation hexadécimale
\0	Caractère nul

Notez que pour les caractères notés en hexadécimal, l'interpréteur ignore tous les zéros en tête. Il établit la fin du caractère échappatoire spécifié en hexadécimal quand il rencontre soit le premier caractère non hexadécimal ou plus de deux caractères hexadécimaux - sans compter les zéros en tête.

Le tableau et le paragraphe suivant ont été traduits des Microsoft Visual C++ 6.0 Docs.

Les tableaux sont des tableaux alloués dynamiquement d'éléments semblables à des variables. Ils sont contigus en mémoire. Contrairement au C ou au R, chacune de ces variables peuvent avoir un type différent. Les tableaux sont créés avec la fonction array. Les données sont accessibles par des indices.

> a = array(28, "alpha")
[0]     28
[1]     "alpha"
> a[0]
        28
> gettype(a)
        "array"

Les listes sont implémentées comme des listes chaînées. Elles sont créées avec la fonction list. Les données sont accessibles par des indices.

> b = list(3, 2, 1)
[0]     3
[1]     2
[2]     1
> b[2] = 0
        0
> b
[0]     3
[1]     2
[2]     0

Les objets sont créés avec la fonction names. Un objet est un groupe de variables, accessibles avec l'opérateurs point (.). Si un membre d'un objet est une fonction, les variables accédées à l'intérieur de cette fonction sont recherchées à l'intérieur le contexte de l'objet avant d'aller voir à l'extérieur.

> id = names("nom", "age")
[nom]   undefined
[age]   undefined
> id.nom = "Philippe"
        "Philippe"
> id.age = 29
        29
> id
[nom]   "Philippe"
[age]   29
> gettype(id)
        "object"

Une définition de fonction retourne un pointeur vers un noeud, ainsi qu'une liste pointillée généalogique. Un segment de code explicite donne aussi un pointeur vers un noeud. Les noeuds sont les éléments de base de l'arbre syntaxique du code. La structure de l'arbre syntaxique est illustrée dans la page Structure de l'arbre.

> a = parent
        0x378630
> gettype(a)
        "node pointer"
> b = function() print("hello")
        0x37f110
> gettype(b)
        "node pointer"

Un pointeur vers une structure FILE est donnée par la fonction fopen. Ce type est utilisé par les fonctions de manipulation de stream. Les identificateurs de stream prédéfinis stdin, stdout et stderr sont du type pointeur vers FILE.

Le type pointeur vers une fpos_t est exclusivement utilisé par les fonctions fgetpos et fsetpos. C'est une position dans un fichier.

La mémoire brute est un buffer alloué dynamiquement et peut être obtenu par les fonctions vartomem, memclone et memory. Chacun des octets de la mémoire brute peut être lu ou écrit avec l'opérateur subscript.

> a = memory(4)
> gettype(a)
        "raw memory"
> a[0]
        0x0
> a[0] = 0xe1
        0xe1

Un octet est représenté par un unsigned char et est le type reçu en applicant l'opérateur subscript en lecture à de la mémoire brute.

> a = memory(4)
> b = a[0]
        0x0
> gettype(b)
        "byte"
> (byte) 255
        0xff

L'adresse de mémoire est le type obtenu en applicant l'opérateur de adresse-de "&" à une variable de type mémoire brute ou chaîne de caractère à laquelle on a appliqué l'opérateur subscript.

> a = memory(4)
> &a[0]
        0x335128
> b = &a[1]
        0x335129
> gettype(b)
        "memory address"
> c = "abc"
        "abc"
> gettype(&c[0])
        "memory address"

Si vous appliquez l'opérateur d'adresse-de (&) à une variable de n'importe quel type donné ci-haut, vous allez obtenir un pointeur vers son espace en mémoire. Si vous appliquez l'opérateur d'indirection (*) à une variable contenant un pointeur, vous allez obtenir la valeur de la première variable.

Si vous appliquez l'opérateur d'adresse-de à une variable contenant un pointeur, vous allez obtenir un pointeur vers un pointeur. Avec ce résultat, vous pouvez appliquer l'opérateur d'indirection deux fois.

Si vous applquez l'opérateur d'adresse-de à une variable contenant un objet, vous pouvez accéder à son contenu avec le pointeur en utilisant l'opérateur de déréférence de structure (->).

Un nombre peut aussi être "casté" vers le type pointeur vers un des types de base du C. Pour le moment, nous ne pouvons pas "caster" vers pointeur vers une chaîne de caractères, un objet, un tableau ou une liste.

> a = 42
        42
> b = &a
        0x2d0838
> gettype(b)
        "double*"
> c = &b
        0x2d08d8
> gettype(c)
        "double**"
> **c
        42
> a = names("x", "y")
[x]     undefined
[y]     undefined
> b = &a
        0x2d0838
> b->x = 5
        5
> b->y = -5
        -5
> a
[x]     5
[y]     -5

retour au PCASTL