EN

pcosmos.ca

l'univers de Philippe Choquette

Fonctions internes

PCASTL : Fonctions internes

Liste par catégories

Fonction d'entrées et de sorties

Fonctions de contrôle du flot d'exécution

Fonctions de manipulation d'arbre

Fonctions de manipulation d'objet

Fonctions de manipulation de tableau, de liste chaînée, de liste d'énoncés et de chaîne de caractères

Fonctions d'accès pour "Dynamic-Link Libraries" et "Shared Object Libraries"

Fonctions de manipulation de mémoire

Interface au stdio.h ANSI C

Fonctions de conversion de type

Fonctions utilitaires

Liste alphabétique

abort
alloc_copy
appendnode
array
as_array
as_list
as_statements
aton
atovar
clear
clearerr
closelib
cls
codetotree
concat
copystring
copytree
createnode
detachnode
execute
exist
exit
fclose
feof
ferror
fflush
fgetc
fgetpos
fgets
fillobject
fopen
fprintf
fputc
fread
free
freestring
freetree
freopen
fscanf
fseek
fsetpos
ftell
fwrite
getfuncpt
gettype
getwd
info
insert
insertnode
length
list
memclone
memcpy
memory
memset
memtovar
mknode
names
ntoa
openlib
osfamily
popback
popfront
print
printf
prompt
pushback
pushfront
read
remove
repeat
replace
replacenode
return
rewind
rmnode
scan
scanf
setlength
setwd
source
sprintf
sscanf
strclone
strcpy
strlen
subseq
swapnodes
tmpfile
tonode
treetocode
undefine
ungetc
value
vartoa
vartomem
write


abort()

Cette fonction arrête l'exécution des énoncés soumis et replace l'interpréteur dans un état d'attente d'entrées.


alloc_copy(arg)

Cette fonction reçoit n'importe quel type d'argument, en alloue une copie et retourne un pointeur vers la copie.


appendnode(noeud_parent, noeud_fils)

Cette fonction ajoute comme fils le noeud dont un pointeur est reçu comme deuxième argument au noeud dont un pointeur est reçu comme premier argument. La valeur retournée est la valeur indéfinie.

> a = createnode("mathematical operator", "="[0])
        0x2a8110
> appendnode(a, createnode("variable", "builtfact"))
> appendnode(a, createnode("function definition"))
> appendnode(a.childset[1], createnode("list"))
> appendnode(a.childset[1], createnode("list"))
> appendnode(a.childset[1].childset[0], createnode("variable", "x"))
> appendnode(a.childset[1].childset[1], createnode("if"))
> appendnode(a.childset[1].childset[1].childset[0], codetotree("x == 1"))
> appendnode(a.childset[1].childset[1].childset[0], codetotree("return(1)")
)
> appendnode(a.childset[1].childset[1], createnode("function call"))
> appendnode(a.childset[1].childset[1].childset[1], createnode("variable",
"return"))
> appendnode(a.childset[1].childset[1].childset[1], createnode("list"))
> appendnode(a.childset[1].childset[1].childset[1].childset[1], codetotree(
"x * builtfact(x - 1)"))
> printf(concat(treetocode(a), "\n"))
builtfact = function(x)
{
   if (x == 1) return(1)
   return(x * builtfact(x - 1))
}

array([arg1[, arg2[, ...]]])

Cette fonction reçoit autant d'arguments que vous le voulez, les évalue et retourne un tableau de longueur correspondante.

> a = array(1, 2, "lettre_c")
[0]     1
[1]     2
[2]     "lettre_c"
> a[1]
        2
> a[2] = 3
        3
> a
[0]     1
[1]     2
[2]     3
> array(1,2,array(3,4))
[0]     1
[1]     2
[2][0]  3
[2][1]  4

as_array(sequence)

Cette fonction prend un paramètre, lequel peut être une liste chaînée ou un pointeur vers une liste d'énoncés. La valeur retournée est un tableau de la même longueur que la séquence fournie. Si la séquence est une liste chaînée, alors le contenu de chaque item va être le même. Si la séquence est une liste d'énoncés, alors les items de la sortie seront seulement définis pour les noeuds contenant une chaîne de caractères ou un nombre.

> a = scan()
lecture de ces mots
        0x330908
> as_array(a)
[0]     "lecture"
[1]     "de"
[2]     "ces"
[3]     "mots"
> a = `{0 1 {}}'.childset[0]
        0x332c60
> as_array(a)
[0]     0
[1]     1
[2]     undefined

as_list(sequence)

Cette fonction prend un paramètre, lequel peut être un tableau ou un pointeur vers une liste d'énoncés. La valeur retournée est une liste chaînée de la même longueur que la séquence fournie. Si la séquence est un tableau, alors le contenu de chaque item va être le même. Si la séquence est une liste d'énoncés, alors les items de la sortie seront seulement définis pour les noeuds contenant une chaîne de caractères ou un nombre.


as_statements(sequence)

Cette fonction prend un paramètre, lequel peut être un tableau ou une liste chaînée. La valeur retournée est une liste d'énoncés de la même longueur que la séquence fournie. Les items de la sortie seront seulements définis pour les items d'entrée correspondants contenant une chaîne de caractères ou un nombre. Les noeuds indéfinis reçoivent la valeur numérique zéro.

> a = list("ab", "cd")
[0]     "ab"
[1]     "cd"
> b = as_statements(a)
        0x330ba0
> value(b.childset[0])
        "ab"

aton(chaine_de_caracteres)

Cette fonction convertit la chaîne de caractères qu'elle reçoit comme paramètre en valeur numérique. Si la function rate la conversion, alors la valeur retournée est zéro.


atovar(chaine_de_caracteres)

Cette fonction crée un noeud de type "variable" dont le nom est la chaîne de caractères reçue en paramètre. La chaîne de caractères doit commencer par "_" ou par une lettre. La valeur retournée est un pointeur vers le nouveau noeud.

> a = atovar("newname")
        0x258320
> info(a)
[node_type]     "variable"
[nb_children]   0
[name]  "newname"

clear([symbole1[, symbole2[, ...]]])

Cette fonction peut ne prendre aucun argument, ou autant que vous voulez. Un appel sans argument efface tous les symboles en mémoire, variables et fonctions. Donner des symboles comme arguments cause leur effacement. La valeur retournée est la valeur indéfinie. C'est comme void en C.

> a = 1
        1
> a
        1
> clear(a)
> a
Error: Symbol "a" not found.

clearerr(stream)

Réinitialise l'indicateur d'erreur pour un stream. Le paramètre est un pointeur vers une structure FILE. La fonction clearerr réinitialise l'indicateur d'erreur et l'indicateur de fin-de-fichier pour un stream. Les indicateurs d'erreur ne sont pas automatiquement désactivés une fois que l'indicateur d'erreur pour un stream est activé, les opérations sur ce stream continuent de retourner un indicateur d'erreur jusqu'à ce que clearerr, fseek, fsetpos, ou rewind soit appelée.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


closelib(handle)

Termine l'accès à un fichier .dll sur Windows, à un fichier .so sur Linux ou à un fichier .dylib sur Mac OS. Le paramètre est une "handle" obtenue par la fonction openlib. Sur Windows, la valeur retournée est un (1) en cas de succès, tandis que sur Linux et Mac OS, la valeur retournée est zéro en cas de succès.


cls()

Efface l'écran de l'interpréteur. Cette fonction n'a pas de paramètres. La valeur retournée est la valeur indéfinie.


codetotree(chaine_de_caracteres)

Cette fonction retourne un pointeur vers le noeud racine de l'arbre syntaxique qui correspond au code (programme) dans la chaîne de caractères reçue comme argument.


concat(arg1, arg2[, arg3[, ...]])

Cette fonction prend deux arguments ou plus, qui peuvent être des tableaux, des listes chaînées, des chaînes de caractères ou des listes d'énoncés. Tous les arguments doivent être du même type. La valeur retournée est la concaténation de tous les arguments évalués.


copystring(chaine_de_caracteres)

Cette fonction alloue et retourne une copie de la chaîne de caractères reçue en argument. Noter que l'assignation d'une chaîne de caractères d'une variable à une autre pointe vers la même mémoire.


copytree(pointeur_vers_un_noeud)

Cette fonction évalue son argument et le résultat doit être un pointeur vers un noeud. Celui-ci est la racine d'un arbre. Cet arbre est copié entièrement et un pointeur vers la nouvelle racine est retournée. La nouvelle racine a NULL comme valeur de parent.


createnode(chaine_de_caracteres[, spec])

Cette fonction crée un noeud sans fils et retourne un pointeur vers celui-ci. Les valeurs du membre node_type retourné par la fonction info peuvent être utilisées comme premier argument à createnode. Toutefois, les alias suivants sont acceptés :

premier argument alias
"numerical constant" "constant"
"mathematical operator"  
"relational or logical operator" "logical operator"
"relational operator"
"variable"  
"string"  
"function definition"  
"function call" "call"
"if statement" "if"
"if else statement" "if else"
"for statement" "for"
"while statement" "while"
"list"  
"code segment"  
"parent reserved word" "parent"
"childset reserved word" "childset"
"vargenlist"  
"incrementation or decrementation" "decr"
"decrementation"
"incr"
"incrementation"
"object member access list" "access list"
"subscript"  
"stdin FILE* identifier" "stdin"
"stdout FILE* identifier" "stdout"
"stderr FILE* identifier" "stderr"
"cast"  
"structure reference operator (.)" "."
"reference"
"structure reference operator"
"structure dereference operator (->)" "->"
"dereference"
"structure dereference operator"

Le deuxième argument dépend du contenu du premier :

premier argument deuxième argument
"numerical constant" un nombre de type double
"mathematical operator" un des caractères c suivants : -, +, *, /, ^, =, & qui peut être défini ainsi : "c"[0]
"relational or logical operator" une chaîne de caractères ayant un des contenus suivants : "||", "&&", "!", ">", ">=", "<", "<=", "==", "!="
"variable" une chaîne de caractères contenant le nom de la variable
"string" une chaîne de caractères qui sera le contenu du noeud
"incrementation or decrementation" une chaîne de caractères ayant un des contenus suivants : "prefix ++", "prefix --", "postfix ++", "postfix --"
"cast" une chaîne de caractère qui contient un des types de base du C avec le nombre d'astérisques (*) voulu pour un type pointeur
"function definition" ne pas spécifier de second argument
"function call"
"if statement"
"if else statement"
"for statement"
"while statement"
"list"
"code segment"
"parent reserved word"
"childset reserved word"
"vargenlist"
"object member access list"
"subscript"
"stdin FILE* identifier"
"stdout FILE* identifier"
"stderr FILE* identifier"
"structure reference operator (.)"
"structure dereference operator (->)"

Un exemple d'utilisation est donné dans la documentation d'appendnode.


detachnode(noeud_parent, position)

Cette fonction déconnecte le fils à position reçue en deuxième paramètre du noeud parent dont un pointeur est reçu en premier paramètre. Les autres fils du noeud parent sont décalés pour combler l'espace libéré. La valeur retournée est un pointeur vers la racine du sous-arbre déconnecté.


execute(pointeur_vers_un_noeud)

Cette fonction prend un pointeur vers un noeud comme paramètre. L'arbre sous le noeud est exécuté et la valeur retournée est la valeur retourné par le code exécuté.

> execute(`print("hello")'.childset[0])
        "hello"

exist(symbole)

Cette fonction reçoit un symbole en paramètre et retourne un entier qui vaut 1 si le symbole est trouvé dans le scope actuel ou 0 si le symbole n'est pas trouvé. Noter que si un symbole existe mais n'est pas défini, il sera trouvé. Même si de messages d'erreur sont affichés en cas de non existence, le code va continuer à être exécuté.


exit()

Cette fonction ne prend aucun argument et ferme l'interpréteur.


fclose(stream)

Ferme le fichier duquel le pointeur est reçu en argument. La valeur retournée est 0 si le fichier a été fermé avec succès. Sinon, la valeur retournée est -1.


feof(stream)

Teste pour une fin-de-fichier sur un stream. Le paramètre est un pointeur vers une structure FILE. La fonction retourne une valeur non nulle après la première opération de lecture qui tente de lire dépassé la fin du fichier. Elle retourne 0 si la position courante n'est pas la fin du fichier. Il n'y a pas de retour d'erreur.

La fonction feof détermine si la fin de stream a été atteinte. Quand la fin du fichier est atteinte, les opérations de lecture retournent un indicateur fin-de-fichier jusqu'à ce que le fichier soit fermé ou jusqu'à soit appelé rewind, fsetpos, fseek, ou clearerr contre lui.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


ferror(stream)

Teste pour une erreur sur un stream. Le paramètre est un pointeur vers une structure FILE. Si aucune erreur n'est survenue sur stream, ferror retourne 0. Autrement, elle retourne une valeur différente de zéro.

La fonction ferror teste pour des erreurs en lecture ou en écriture sur le fichier associé avec stream. Si une erreur est survenue, l'indicateur d'erreur pour le stream demeure activé jusqu'à ce que le stream soit fermé ou rembobiné, ou jusqu'à ce que clearerr soit appeleé contre lui.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fflush(stream)

Flushe un stream. Le paramètre est un pointeur vers une structure FILE. fflush retourne 0 si la mémoire tampon a été flushé avec succès. La valeur 0 est aussi retournée dans les cas où le stream n'a pas de mémoire tampon ou est ouvert en lecture seule. Une valeur de retour de -1 (EOF) indique une erreur.

La fonction fflush flushe un stream. Si le fichier associé avec stream est ouvert pour l'écriture, fflush écrit dans ce fichier le contenu de la mémoire tampon associée avec le stream. Si le stream est ouvert en lecture, fflush efface le contenu de la mémoire tampon. fflush annule l'effet de tout appel précédent à ungetc contre stream. Le stream demeure ouvert après l'appel. fflush n'a pas d'effet sur les streams sans mémoire tampon.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fgetc(stream)

Lit un caractère depuis un stream. Le paramètre est un pointeur vers une structure FILE. fgetc retourne le caractère lu dans une chaîne de caractères de longueur 2 (le second caractère est nul) ou retourne "\xff" (fin-de-fichier) pour indiquer une erreur ou la fin du fichier. Utilisez feof ou ferror pour distinguer entre une condition d'erreur ou de fin-de-fichier. Si une erreur de lecture survient, l'indicateur d'erreur pour le stream est activé.

fgetc lit un caractère seul depuis la position courante du fichier associé avec stream. La fonction incrémente le pointeur de fichier (si défini) pour pointer sur le prochain caractère. Si le stream est à la fin du fichier, l'indicateur de fin-de-fichier pour le stream est activé.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fgetpos(stream, variable)

Obtient l'indicateur de position dans le fichier d'un stream. Le premier paramètre est un ponteur vers une structure FILE. Le second paramètre est une variable déjà définie qui va recevoir un pointeur vers une structure fpos_t. Si la variable n'est pas déjà un pointeur vers une structure fpos_t, elle est convertie vers ce type. En cas de réussite, fgetpos retourne 0. En cas d'échec, elle retourne une valeur différente de zéro.

La fonction fgetpos obtient la valeur courante de l'indicateur de la position dans la fichier de l'argument stream et la stocke dans l'objet pointé par variable. La fonction fsetpos peut utiliser plus tard l'information stockée dans variable pour remettre l'indicateur de la position dans le fichier de l'argument stream au temps où fgetpos a été appelée. Le type pointeur vers fpos_t est exclusivement destiné à l'usage avec fgetpos et fsetpos.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.

> a = fopen("alphabet.txt", "r")
        0x462b50
> b = "    "
        "    "
> fread(b, 1, 4, a)
        4
> c = 0
        0
> fgetpos(a, c)
        0
> fread(b, 1, 4, a)
        4
> b
        "efgh"
> fread(b, 1, 4, a)
        4
> fsetpos(a, c)
        0
> fread(b, 1, 4, a)
        4
> b
        "efgh"
> fclose(a)
        0

fillobject(object, sequence)

Cette fonction prend deux arguments. Le premier paramètre est un symbole contenant un objet. Le second paramètre peut être un tableau, une liste chaînée ou un objet. Si la séquence contient moins d'items que l'objet a de membres, alors seulement les premiers membres vont recevoir une valeur. Si la séquence a plus d'items que l'objet a de membres, alors les derniers items seront ignorés. La valeur retournée est la valeur indéfinie.

> a = names("b", "c", "d")
[b]     undefined
[c]     undefined
[d]     undefined
> fillobject(a, array(1,2))
> a
[b]     1
[c]     2
[d]     undefined

fgets(variable, compte, stream)

Le premier paramètre est une variable contenant une chaîne de caractères. Le second paramètre est le nombre maximal de caractères à lire. Le dernier paramètre est un pointeur vers une structure FILE.

Cette fonction lit une chaîne de caractères du stream et la place dans la chaîne de caractères de la variable. La lecture se fait de la position courante du stream jusqu'à, inclusivement, ce qu'un caractère de nouvelle ligne soit rencontré, jusqu'à la fin du stream ou jusqu'à ce que le nombre de caractères lus soit compte-1, le premier qui arrive. Au résultat placé dans la chaîne de caractères de la variable est ajouté un caractère nul. Le caractère de nouvelle ligne, si lu, est inclus dans la chaîne de caractère dans la variable.

La valeur retournée est la variable reçue en premier argument. S'il y a une erreur ou si la fin du stream est rencontrée, une nouvelle chaîne de caractère vide ("") est retournée.

Le texte ci-dessus a été traduit en partie de msdn.microsoft.com.


fopen(nom_fichier, mode)

Le premier paramètre est une chaîne de caractères contenant le nom du fichier à être ouvert. Le second paramètre est une chaîne de caractères contenant le type d'accès permis. La valeur retournée est un pointeur au fichier ouvert. Une valeur de pointeur nulle indique une erreur.

mode signification
"r" Ouvre en lecture. Si le fichier n'existe pas ou ne peut pas être trouvé, l'appel à fopen échoue.
"w" Ouvre un ficher vide en écriture. Si le fichier donné existe, son contenu est détruit.
"a" Ouvre pour écrire à la fin du fichier (concatène) sans enlever le marqueur EOF avant d'écrire de nouvelles données au fichier; crée d'abord le fichier s'il n'existe pas.
"r+" Ouvre pour la lecture et l'écriture. (Le fichier doit exister.)
"w+" Ouvre un fichier vide la lecture et l'écriture. Si le fichier donné existe, son contenu est détruit.
"a+" Ouvre pour la concaténation; l'opération de concaténation inclus d'enlever le marqueur EOF avant que de nouvelles données soit écrites au ficher et de restorer le marqueur EOF quand l'écriture est complétée; crée d'abord le ficher s'il n'existe pas.

Quand un fichier est ouvert avec le type d'accès "a" ou "a+", toutes les opérations d'écriture se produisent à la fin du fichier. Le pointeur vers le fichier peut être repositionné en utilisant fseek ou rewind, mais est toujours redéplacé à la fin du fichier avant que quelque opération d'écriture ne soit effectée. Donc, les données exixtantes ne peuvent pas être écrasées.

Le mode "a+" est requis pour concaténer à un stream fichier qui se termine par le marqueur CTRL+Z EOF.

Quand le type d'accès "r+", "w+", ou "a+" est spécifié, la lecture et l'écriture sont tous deux permis (le fichier est dit ouvert pour "mise à jour"). Cependant, quand vous changez entre lire et écrire, il doit y avoir une opération fflush, fsetpos, fseek, ou rewind intercalée. La position courante peut être spécifiée pour une opération fsetpos ou fseek si désiré.

En plus des valeurs ci-haut, le caractère b peut être inclus dans mode. Ça ouvre en mode binaire (non-traduit); les traductions impliquant les caractères retour de chariot et saut de ligne sont supprimées.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.

> a = fopen("test.txt", "w")
        0x462b50

fprintf(stream, string[, argument]...)

Écrit des données formattées dans un stream. Le premier paramètre est un pointeur vers une structure FILE. Vous pouvez aussi écrire stdout ou stderr. Le second paramètre est une chaîne de caractères à être écrite, laquelle peut inclure des spécifications de format pour les autre arguments, s'il y en a. Chaque autre argument est converti et sorti selon la spécification de format correspondante. La valeur retournée est la valeur indéfinie.

> a = fopen("test.txt", "w")
        0x462b50
> fprintf(a, "texte")
> fclose(a)
        0
> fprintf(stdout, "%s\n", "hello")
hello

fputc(chaine_de_caracteres, stream)

Écrit un caractère dans un stream. Le premier paramètre est une chaîne de caractères contenant le caractère à écrire à la position 0 et terminée par nul à la position 1. Le second paramètre est un pointeur vers une structure FILE. La valeur de retour est une chaîne de caractères contenant le caractère écrit. Une valeur de retour de "\xff" (EOF) indique une erreur.

fputc écrit le caractère seul chaine_de_caracteres[0] à la position indiquée par l'indicateur associcé de position dans le fichier (si défini) et avance l'indicateur en conséquence. Le fichier est associé avec stream. Si le fichier ne peut pas supporter les requêtes de positionnement ou a été ouvert en mode concaténation (append), le caractère est concaténé à la fin du stream.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fread(variable, taille, compte, stream)

Lit des données d'un stream. Le premier paramètre est une variable du type chaîne de caractères où stocker les données lues. Le second paramètre est la taille en octets des items lus. Le troisième paramètre est le nombre maximum d'items lus. Le dernier paramètre est un pointeur vers une structure FILE.

fread retourne le nombre d'éléments qui ont été lus en réalité, lequel peut être plus petit que compte si une erreur se produit ou si la fin du fichier est atteinte avant d'atteindre compte. Utilisez la fonction feof ou ferror pour distinguer une erreur de lecture d'une condition de fin-de-fichier. Si taille ou compte est 0, fread retourne 0 et le contenu de variable demeure inchangé.

La fonction fread lit jusqu'à compte items de taille octets depuis le stream d'entrée et les stocke dans variable. Le pointeur de fichier associé avec stream (s'il y en a un) est incrémenté par le nombre d'octets lus en réalité. Si le stream donné est ouvert en mode texte et si le système d'exploitation est Windows, les paires retour de chariot-saut de ligne sont remplacés par un caractère de saut de ligne unique. La substitution n'a pas d'effet sur le pointeur de fichier ou sur la valeur retournée. La position du pointeur de fichier est indéterminée si une erreur se produit. La valeur d'un item lu partiellement ne peut pas être déterminée.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.

> b = ""
        ""
> setlength(b, 10)
> a = fopen("alphabet.txt", "r")
        0x462b50
> fread(b, 2, 3, a)
        3
> b[6] = "\0"
        ""
> fclose(a)
        0
> b
        "abcdef"

free(pointeur)

Désalloue la mémoire allouée par la fonction alloc_copy. L'argument est la valeur retournée par cette fonction. La valeur retournée est la valeur indéfinie.


freestring(variable)

Cette fonction libère la mémoire allouée pour une chaîne de caractères contenue dans la variable reçue en argument. La valeur retournée est la valeur indéfinie.


freetree(pointeur_vers_un_noeud)

Désalloue un arbre syntaxique dont la racine est reçue en paramètre. La valeur reournée est la valeur indéfinie.


freopen(chemin, mode, stream)

Réassigne un pointeur de fichier. Le premier paramètre est une chaîne de caractères contenant le chemin d'accès du fichier à associer avec stream. Le second paramètre est une chaîne de caractères spécifiant le mode d'accès comme avec fopen. Le dernier paramètre est un pointeur vers une structure FILE. freopen retourne un pointeur vers le fichier nouvellement ouvert. En cas d'erreur, le fichier original est fermé et la fonction retourne un pointeur nul. La fonction freopen ferme le fichier actuellement associé avec stream et réassigne stream au fichier spécifié par chemin.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.

> a = freopen("err.txt", "w", stderr)
        0x462b30
> if (a) print(1)
        1
> fprintf(stderr, "test\n")
> a == stderr
        1
> fclose(a)
        0

fscanf(stream, format[, argument]...)

La fonction fscanf lit des données depuis la position courante de stream vers les locations données par argument (s'il y en a). Chaque argument doit être une variable déjà définie d'un type correspondant à un spécificateur de type dans format. format contrôle l'interprétation des champs d'entrée et a la même forme et fonctionnalité que l'argument format pour scanf. Si la copie prend place entre des chaînes de caractères qui se chevauchent, le comportement est indéfini. Pour plus d'information, voir les Champs de spécification de format. La valeur retournée est la valeur indéfinie.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fseek(stream, offset, origine)

Déplace le pointeur de fichier vers un endroit spécifié. Le premier paramètre est un pointeur vers une structure FILE. Le second paramètre est le nombre d'octets depuis origine. Le dernier paramètre est la position initiale. En cas de succès, fseek retourne 0. Autrement, elle retourne une valeur différente de zéro. Sur des périphériques incapable de recherche, la valeur retournée est indéfinie.

La fonction fseek déplace le pointeur de fichier (s'il y en a un) associé avec stream vers un nouvel endroit qui est à offset octets d'origine. La prochaine opération sur le stream prend place au nouvel endroit. Sur un stream ouvert pour mise à jour, la prochaine opération peut être soit une lecture ou une écriture. L'argument origine doit être une des valeurs suivantes:

valeur d'origine Signification
0 Début du fichier
1 Position courante du pointeur de fichier
2 Fin du fichier

Vous pouvez utiliser fseek pour repositionner le pointeur n'importe où dans un fichier. Le pointeur peut aussi être positionné au-delà de la fin du fichier. fseek désactive l'indicateur de fin-de-fichier et annule l'effet de toute appel antétieur à ungetc contre stream.

Quand un fichier est ouvert pour concaténer des données, la position courante dans le fichier est déterminée par la dernière opération d'E/S, pas par où la prochaine écriture aurait lieu. Si aucune opération d'E/S n'a encore eu lieu sur un fichier ouvert pour concaténation, la position dans le fichier est le début du fichier.

Pour des streams ouverts en mode texte, fseek est d'un usage limité, parce que les traductions retour de chariot-saut de ligne peuvent causer à fseek de produire des résultats inattendus. Les seules opérations garanties de fonctionner dans des streams ouverts en mode texte sont:

  • Déplacer avec un offset de 0 relatif à n'importe quelle de valeurs d'origine.
  • Déplacer depuis le début du fichier avec une valeur d'offset retournée par appel à ftell.

Aussi en mode texte, CTRL+Z est intercepté comme un caractère de fin-de-fichier dans l'entrée. Dans les fichiers ouvert pour lecture/écriture, fopen et toutes les fonctions apparentées regardent pour un CTRL+Z à la fin du fichier et l'enlèvent si possible. Ceci est fait parce qu'utiliser fseek et ftell pour déplacer à l'intérieur d'un fichier qui se termine par un CTRL+Z pourrait occasionner à fseek de se comporter incorrectement proche de la fin du fichier.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fsetpos(stream, variable)

Assigne l'indicateur de position du stream. Le premier paramètre est un pointeur vers une structure FILE. Le second paramètre est une variable du type pointeur vers une structure fpos_t. En cas de succès, fsetpos retourne 0. En cas d'échec, la fonction retourne une valeur différente de zéro.

La fonction fsetpos assigne l'indicateur de position dans le fichier pour stream à la valeur de variable, laquelle est obtenue dans un appel antérieur à fgetpos contre stream. La fonction désactive l'indicateur de fin-de-fichier et annule toute conséquence de ungetc sur stream. Aprè un appel à fsetpos, la prochaine opération pourrait être d'entrée ou de sortie.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


ftell(stream)

Donne la position courante d'un pointeur de fichier. Le paramètre est un pointeur vers une structure FILE. La valeur retournée par ftell pourrait ne pas réfléter l'offset physique en octets pour les stream ouverts en mode texte, parce que ce mode provoque une traduction retour de chariot-saut de ligne. Utilisez ftell avec fseek pour retourner à des locations dans le fichier correctement. En cas d'erreur, ftell retourne -1. Sur des périphériques incapables de déplacer (tels que des terminaux ou des imprimantes), ou quand stream ne réfère pas à un fichier ouvert, la valeur retournée est indéfinie.

La fonction ftell donne la position courante du pointeur de fichier (s'il y en a un) associé avec stream. La postion est exprimée comme un offset relatif au début du fichier.

Notez que quand un fichier est ouvert pour concaténer des données, la position courante dans le fichier est déterminée par la dernière opération d'E/S, non par l'endroit où la prochaine écriture aurait lieu. Par exemple, si un fichier est ouvert pour la concaténation et que la dernière opération était une lecture, la position dans le fichier est le point où la prochaine opération de lecture commencerait, pas où la prochaine écriture commencerait. (Quand un fichier est ouvert pour concaténation, la position dans le fichier est déplacée à la fin du fichier avant toute opération d'écriture.) Si aucune opération d'E/S n'a encore eu lieu sur un fichier ouvert pour concaténation, la position dans le fichier est le début du fichier.

Aussi en mode texte, CTRL+Z est intercepté comme un caractère de fin-de-fichier dans l'entrée. Dans les fichiers ouvert pour lecture/écriture, fopen et toutes les fonctions apparentées regardent pour un CTRL+Z à la fin du fichier et l'enlèvent si possible. Ceci est fait parce qu'utiliser fseek et ftell pour déplacer à l'intérieur d'un fichier qui se termine par un CTRL+Z pourrait occasionner à fseek de se comporter incorrectement proche de la fin du fichier.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


fwrite(chaine_de_caracteres, taille, compte, stream)

Écrit des données vers un stream. Le premier paramètre est une chaîne de caractères contenant les données à être écrites. Le second paramètre est la taille d'un item en octets. Le troisième paramètre est le nombre maximum d'items à être écrits. Le dernier paramètre est un pointeur vers une structure FILE. fwrite retourne le nombre d'items écrits en réalité, lequel pouvant être plus petit que taille si une erreur survient. Aussi, si une erreur survient, l'indicateur de position dans le fichier ne peut pas être déterminé.

La fonction fwrite écrit jusqu'à compte items, chacun de longueur taille, depuis chaine_de_caracteres vers la sortie stream. Le pointeur de fichier associé avec stream (s'il y en a un) est incrémenté par le nombre d'octets écrits en réalité. Si stream est ouvert en mode texte et si le système d'exploitation est Windows, chaque retour de chariot est remplacé avec une paire retour de chariot - saut de ligne. Le remplacement n'a pas d'effet sur la valeur retournée.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


getfuncpt(handle, chaine_de_caracteres)

Obtient un pointeur vers une fonction dans un fichier .dll sur Windows, dans un fichier .so sur Linux ou dans un fichier .dylib sur Mac OS. Le premier paramètre est la "handle" obtenue par la fonction openlib. Le second paramètre est une chaîne de caractères contenant le nom de la fonction. La valeur retournée est un pointeur vers une fonction. La variable contenant ce pointeur est utilisée comme une variable référençant un noeud de définition de fonction PCASTL.


gettype(expr)

Cette fonction prend un argument, l'évalue et retourne une chaîne de caractères contenant son type.


getwd()

Cette fonction retourne une chaîne de caractères contenant le chemin d'accès du dossier courant.


info(pointeur_vers_un_noeud)

Cette fonction retourne dans un objet de l'information à propos du pointeur vers un noeud qu'elle reçoit comme paramètre. Les deux membres qui font toujours partie de l'objet retourné se nomment node_type et nb_children.

valeur du membre node_type nom du membre optionnel
"numerical constant" value
"mathematical operator" operator
"relational or logical operator" operator
"variable" name
"string" value
"function definition" parameters
"function call" nb_args
"if statement"  
"if else statement"  
"for statement"  
"while statement"  
"list"  
"code segment"  
"parent reserved word"  
"childset reserved word"  
"vargenlist"  
"incrementation or decrementation" operator
"object member access list"  
"subscript"  
"stdin FILE* identifier"  
"stdout FILE* identifier"  
"stderr FILE* identifier"  
"cast" cast_type
"structure reference operator (.)"  
"structure dereference operator (->)"  

insert(symbole, contenu, position)

Cette fonction insère le "contenu" dans "symbole" à la position "position". Le symbole et le contenu doivent être du même type. Le type peut être tableau, liste chaînée, chaîne de caractères ou un pointeur vers une liste d'énoncés. La valeur retournée est la valeur indéfinie.

> a = "ad"
        "ad"
> insert(a, "bc", 1)
> a
        "abcd"

insertnode(noeud_parent, noeud_fils, position)

Cette fonction insère le noeud dont un pointeur est reçu comme deuxième argument comme fils au noeud dont un pointeur est reçu comme premier argument à la position "position". La valeur retournée est la valeur indéfinie.


length(sequence)

Cette fonction retourne le nombre d'éléments dans la séquence reçue comme paramètre. La séquence peut être un tableau, une liste chaînée, une chaîne de caractères, un pointeur vers une liste d'énoncés ou de la raw memory. Si la séquence est une chaîne de caractères, la longueur est la quantité de mémoire allouée, pas le nombre de caractères avant le NULL de la fin.


list([arg1[, arg2[, ...]]])

Cette fonction reçoit autant d'arguments que vous le voulez, les évalue et retourne une liste chaînée de longueur correspondante.


memclone(raw_memory)

Cette fonction retourne un clone nouvellement alloué du premier argument qui doit être de la raw memory. Les autres fonctions retournant de la raw memory sont vartomem, memclone et memory. La valeur retournée est de type raw memory.


memcpy(adresse1, adresse2, longueur)

Cette fonction copie "longueur" octets de adresse2 vers adresse1. Les deux premiers arguments peuvent être une variable de type raw memory, une chaîne de caractère, une variable de type memory address ou un pointeur vers n'importe quel autre type. La valeur retournée est adresse1 dans une variable de type memory address.


memory(longueur)

Cette fonction retourne de la raw memory initialisée à zéro de la longueur spécifiée en paramètre.


memset(adresse, valeur, longueur)

Cette fonction attribue la valeur "valeur" convertie en unsigned char aux "longueur" octets présents à l'adresse donnée en premier paramètre. Le premier argument peut être une variable de type raw memory, une chaîne de caractère, une variable de type memory address ou un pointeur vers n'importe quel autre type. La valeur retournée est "adresse" dans une variable de type memory address.


memtovar(var, memoire)

Cette fonction fait l'opération inverse de la fonction vartomem. Le premier argument doit être une variable d'un type fondamental du C, un tableau, un objet ou n'importe quelle combinaison de ces types. Le second argument doit être une variable de type raw memory de longueur suffisante pour contenir tous les membres du premier argument. Cet argument peut être la valeur retournée par la fonction vartomem, memclone ou memory. La valeur retournée est la valeur indéfinie. Pour un exemple d'utilisation, voir la fonction getfuncpt.


mknode(list, source, index)

Cette fonction ajoute un noeud à une liste de noeuds dont elle reçoit le pointeur comme premier paramètre. Le second paramètre, "source", est le code à insérer dans la liste. Ce paramètre peut être un segment de code ou un pointeur vers un noeud. Le sous-arbre inséré est copié entièrement. Le dernier paramètre est l'index de position où insérer le code dans la liste. La première place est 0 et la dernière place est la taille de la liste. La valeur retournée est la valeur indéfinie.

> a = function(x) {}
        0x3308b8
> a(2)
> mknode(a.childset[1], `x*2', 0)
> a(2)
        4
>
> a = function()
+ {
+    mknode(parent.parent.parent, `print(3)', 3)
+    print(1)
+    print(2)
+ }
        0x3334b0
> a()
        1
        2
        3
> a()
        1
        2
        3
        3

names(chaine_de_caracteres1[, chaine_de_caracteres2[, ...]])

Cette fonction prend au moins un argument chaîne de caractères. La valeur retournée est un objet avec des membres nommés selon les chaînes de caractères fournies. Si un membre d'un objet est une fonction, lorsque appelée le contexte de cette fonction va déjà contenir les variables membres de l'objet.

> a = names("b", "c")
[b]     undefined
[c]     undefined
> a.b = 0
        0
> a.c = function() { b = 1 }
        0x333028
> a.c()
        1
> a
[b]     1
[c]     0x333028

ntoa(expr)

Cette fonction évalue son argument, le convertit vers une chaîne de caractères et la retourne.


openlib(chaine_de_caracteres)

Ouvre un fichier .dll sur Windows, un fichier .so sur Linux ou un fichier .dylib sur Mac OS. Le nom de ce fichier est dans une chaîne de caractères reçue en argument. Sur Linux et Mac OS, si le fichier est dans le dossier de travail, il faut débuter son nom par "./". La valeur retournée est une "handle" vers la librairie qui devra être utilisée avec la fonction getfuncpt.


osfamily()

Si cette fonction est appelée dans l'interpréteur compilé pour Windows 32-bit, la valeur retournée sera la chaîne de caractères "win32". Pour Windows 64-bit : "win64", pour Linux 32-bit : "lin32", pour Linux 64-bit : "lin64" et pour Mac OS : "mac64".


popback(adresse_de_liste_ou_tableau)

Cette fonction retire le dernier élément de la liste chaînée ou du tableau dont l'adresse est reçue comme argument et retourne cet élément. Si le contenant est vide la valeur retournée est la valeur indéfinie.


popfront(adresse_de_liste_ou_tableau)

Cette fonction retire le premier élément de la liste chaînée ou du tableau dont l'adresse est reçue comme argument et retourne cet élément. Si le contenant est vide la valeur retournée est la valeur indéfinie.


print(expr)

Cette fonction évalue et affiche son argument. La valeur retournée est la valeur indéfinie.


printf(chaine_de_caracteres[, argument]...)

Affiche une sortie formattée dans le stream de sortie standard, stdout. L'argument chaine_de_caracteres consiste en des caractères ordinaires, des séquences échappatoires, et (si des arguments suivent la chaine_de_caracteres) des spécifications de format. Les caractères ordinaires et les séquences échappatoires sont copiées dans stdout dans l'ordre de leur apparition.

Les spécifications de format commencent toujours avec un signe de pourcentage (%) et son lues de gauche à droite. Quand printf rencontre la première spécification de format (s'il y en a), elle convertit la valeur du premier argument après la chaine_de_caracteres et la sort en conséquence. La seconde spécification de format entraîne la conversion et la sortie du second argument, et ainsi de suite. S'il y a plus d'arguments qu'il y a de spécifications de format, les arguments supplémentaires sont ignorés. Les résultats sont indéfinis s'il n'y a pas assez d'arguments pour toutes les spécifications de format. La valeur retournée est la valeur indéfinie.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.

> printf("%s %f %c\n", "abc", 2.3, (char)61)
abc 2.300000 =

prompt(chaine_de_caracteres)

Cette fonction vous permet de changer l'invite de commande vers n'importe quelle chaîne de caractères. La valeur retournée est la valeur indéfinie.

> prompt("input: ")
input: print("hello")
        "hello"
input: prompt("")
a = 1
        1
a + 2
        3
prompt("> ")
> 

pushback(adresse_de_liste_ou_tableau, element)

Cette fonction évalue son second argument et ajoute le résultat à la fin de la liste chaînée ou du tableau dont l'adresse est reçue comme premier argument. La valeur retournée est la valeur indéfinie.


pushfront(adresse_de_liste_ou_tableau, element)

Cette fonction évalue son second argument et insère le résultat au début de la liste chaînée ou du tableau dont l'adresse est reçue comme premier argument. La valeur retournée est la valeur indéfinie.


read(nom_fichier)

Cette fonction lit un fichier texte dont le nom est fourni dans une chaîne de caractères comme paramètre. La valeur retournée est un pointeur vers un noeud liste qui a un noeud chaîne de caractères pour chaque mot ou signe de ponctuation lu. Les signes de ponctuation reconnus sont ,.!?


remove(symbole, debut[, fin])

Enlève des items d'une séquence. Le premier paramètre est une variable contenant une chaîne de caractères, un tableau ou un pointeur vers une liste d'énoncés. Le second paramètre est un nombre spécifiant à quel index commencer à effacer. S'il n'y a pas de troisième argument, seulement un item est enlevé. S'il y a un troisième argument, les items effacés vont des index start à end inclusivement. La valeur retournée est la valeur indéfinie.


repeat(expr, n)

Évalue son premier argument et répète le resultat dans un tableau de longueur n. Voir la fonction getfuncpt pour un exemple d'utilisation.


replace(symbole, sequence, position)

Cette fonction remplace les items dans "symbole" à partir de la "position" par la "sequence". Le symbole pout contenir un tableau, une liste chaînée, une chaîne de caractères ou un pointeur vers une liste d'énoncés. La séquence doit être du même type. La valeur retournée est la valeur indéfinie.


replacenode(noeud_parent, noeud_remplacant, position)

Cette fonction remplace le noeud fils à la position "position" d'un noeud dont un pointeur est reçu comme premier argument à par le noeud dont un pointeur est reçu comme deuxième argument La valeur retournée est la valeur indéfinie.


return([valeur])

Cette fonction arrête l'exécution de la fonction appelée un niveau plus haut. Si vous fournissez un paramètre, il va être la valeur retournée. Si vous ne fournissez pas de paramètre, la valeur retournée est la valeur indéfinie.


rewind(stream)

Repositionne le pointeur de fichier au début du fichier. Le paramètre est un pointeur vers une structure FILE. La valeur retournée est la valeur indéfinie. La fonction rewind repositionne le pointeur de fichier associé avec stream au début du fichier. Un appel à rewind est similaire à :

fseek(stream, 0, 0)

Cependant, pas comme fseek, rewind désactive les indicateurs d'erreur pour le stream ainsi que l'indicateur de fin-de-fichier. Aussi, pas comme fseek, rewind n'indique pas si le pointeur a été déplacé avec succès dans sa valeur retournée.

Pour vider la mémoire tampon du clavier, utiliser rewind avec le stream stdin, qui est associé par défaut avec le clavier.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


rmnode(pointeur_vers_un_noeud, index)

Cette fonction enlève un noeud d'un des noeuds fils d'un noeud dont elle reçoit le pointeur comme premier paramètre. Le second paramètre est la position à laquelle supprimer le noeud. La première place est 0 et la dernière place est le nombre de noeuds fils directs - 1. La valeur retournée est la valeur indéfinie.


scan()

Cette fonction scanne les entrées au clavier jusqu'à ce qu'un caractère qui n'est pas dans l'ensemble {A-Za-z0-9,.!? } soit rencontré. La valeur retournée est un pointeur vers une liste d'énoncés qui a un noeud chaîne de caractères pour chaque mot ou signe de ponctuation rencontré.

> a = scan()
Hello World!!
        0x330908
> length(a)
        4
> value(a.childset[0])
        "Hello"
> value(a.childset[3])
        "!"

scanf(format[, argument]...)

La fonction scanf lit les données provenant du stream d'entrée standard stdin et écrit les données à l'endroit donné par argument. Chaque argument doit être une variable déjà définie d'un type correspondant à un spécificateur de type dans format. Si la copie prend place entre des chaînes de caractères qui se chevauchent, le comportement est indéfini. Pour plus d'information, voir les Champs de spécification de format. La valeur retournée est la valeur indéfinie.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.

> a = (int)0
        0
> b = 0
        0
> c = "      "
        "      "
> scanf("%i %lf %s", &a, &b, c)
100 2.4 hello
> a
        100
> b
        2.4
> c
        "hello"

setlength(symbole, longueur)

Cette fonction a deux paramètres. Le premier est un symbole qui peut contenir un tableau, une liste chaînée, une chaîne de caractères, un pointeur vers une liste d'énoncés ou de la raw memory. Le second paramètre est la nouvelle longueur du contenu du symbole. Quand le symbole contient une chaîne de caractères, la nouvelle longueur inclut l'espace pour le caractère NULL de la fin.


setwd(chemin_d_acces)

Cette fonction met le dossier courant au chemin d'accès qu'elle reçoit dans une chaîne de caractères comme paramètre. La valeur retournée est la valeur indéfinie.

> setwd("d:\\temp")
> getwd()
        "d:\temp"
> setwd("d:/temp/install")
> getwd()
        "d:\temp\install"
> setwd("..")
> getwd()
        "d:\temp"

source(nom_fichier)

Cette fonction prend un argument chaîne de caractères et exécute les énoncés dans le fichier spécifié par "nom_fichier". La valeur retournée est la valeur indéfinie.


sprintf(variable, format[, argument]...)

Écrit des données formattées vers une chaîne de caractères. Le premier paramètre est une variable déjà définie de type chaîne de caractères qui va recevoir la sortie. Le second paramètre est une chaîne de caractères à être écrite, laquelle peut inclure des spécifications de format pour les autre arguments, s'il y en a. Chaque argument est converti et sorti selon la spécification de format correspondante dans format. Un caractère nul est ajouté après le dernier caractère écrit. Si la copie a lieu entre des chaînes de caractères qui se chavauchent, le comportement est indéfini. La valeur retournée est la valeur indéfinie.

Texte traduit en partie de Microsoft Visual C++ 6.0 Docs.

> a = "                 "
        "                 "
> sprintf(a, "%s %f %i", "word", 2.01, (int)40)
> a
        "word 2.010000 40"

sscanf(chaine_de_caracteres, format[, argument]...)

Lit des données formattées depuis une chaîne de caractères. La fonction sscanf lit les données depuis chaine_de_caracteres vers l'endroit spécifié par chaque argument. Chaque argument doit être une variable déjà définie d'un type correspondant à un spécificateur de type dans format. format contrôle l'interprétation des champs d'entrée et a la même forme et fonctionnalité que l'argument format pour scanf. Si la copie prend place entre des chaînes de caractères qui se chevauchent, le comportement est indéfini. Pour plus d'information, voir les Champs de spécification de format. La valeur retournée est la valeur indéfinie.

Texte traduit en partie de Microsoft Visual C++ 6.0 Docs.


strclone(chaine_de_caracteres)

Duplique la chaîne de caractères reçue en argument. La valeur retournée est la nouvelle chaîne de caractères.


strcpy(chaine_de_caracteres_1, chaine_de_caracteres_2)

Appelle strcpy de string.h. Copie les caractères de chaine_de_caracteres_2 vers chaine_de_caracteres_1 incluant le caractère nul de fin. La longueur allouée de chaine_de_caracteres_1 doit être plus grande ou égale à la longueur de chaine_de_caracteres_2 + 1. Le comportement est indéfini si chaine_de_caracteres_1 et chaine_de_caracteres_2 se chevauchent. La valeur retournée est chaine_de_caracteres_1.


strlen(chaine_de_caracteres)

Cette fonction reçoit un argument chaîne de caractères et retourne le nombre de caractères avant le NULL de la fin.


subseq(entite, debut, fin)

Cette fonction retourne une sous séquence de l'entité reçue comme premier paramètre. L'entité peut être un tableau, une liste chaînée, une chaîne de caractères ou un pointeur vers une liste d'énoncés. Le second paramètre est l'index où les sous items de "entite" commencent à être copiés. Le dernier paramètre est l'index du dernier sous item copié de "entite".

> a = `{
+    print(1)
+    print(2)
+    print(3)
+    print(4)
+ }'.childset[0]
        0x330960
>
> b = subseq(a, 0, 1)
        0x332fa0
> c = function() {}
        0x3332d0
> c.childset[1] = b
        0x3332a8
> c()
        1
        2

swapnodes(noeud_parent1, position1, noeud_parent2, position2)

Cette fonction échange le noeud fils à la position position1 du noeud_parent1 avec le noeud à la position position2 du noeud_parent2. Les sous-arbres en dessous des noeuds fils suivent leurs parents.

> t1 = `(1 + 2) / (3 + 4)'.childset[0]
        0xbed50
> t2 = `(5 + 6) / (7 + 8)'.childset[0]
        0xbf310
> swapnodes(t1, 0, t2, 1)
> treetocode(t1)
        "(7 + 8) / (3 + 4)"
> treetocode(t2)
        "(5 + 6) / (1 + 2)"

tmpfile()

Crée un fichier temporaire. Ne prend aucun paramètre. La fonction tmpfile crée un fichier temporaire et retourne un pointeur vers ce stream. Si le fichier ne peut pas être ouvert, tmpfile retourne un pointeur nul. Ce fichier temporaire est automatiquement effacé quand il est fermé, quand le programme se termine normalement. Le fichier temporaire est ouvert en mode w+b (lecture/écriture binaire).

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


tonode(expr)

Cette fonction évalue son argument et si le résultat est un nombre ou une chaîne de caractères, alors la valeur retournée est un pointeur vers un nouveau noeud contenant le nombre ou la chaîne de caractères.


treetocode(pointeur_vers_un_noeud[, chaine_de_caracteres])

Cette fonction retourne une chaîne de caractères contenant le code (programme) correspondant à l'arbre syntaxique dont un pointeur vers la racine est reçu en premier argument. S'il est spécifié, le deuxième paramètre est une chaîne de caractères indiquant les espaces à insérer pour l'indentation. La valeur par défaut est "   " (trois espaces).

> fact = function(x)
+ {
+    if (x == 1) return(1)
+    return(x * fact(x - 1))
+ }
        0x11f2f0
> mknode(fact.childset[1], `if (x < 1) {
+    print("Parameter must be greater than zero.")
+    abort()
+ }', 0)
> printf(concat(treetocode(fact, "   "), "\n"))
function(x)
{
   if (x < 1)
   {
      print("Parameter must be greater than zero.")
      abort()
   }
   if (x == 1) return(1)
   return(x * fact(x - 1))
}

undefine(symbole)

Cette fonction met le type du symbole qu'elle reçoit comme argument à "undefined". La valeur retournée est la valeur indéfinie.


ungetc(chaine_de_caracteres, stream)

Empile un caractère de retour dans le stream. Le premier paramètre est une chaîne de caractères contenant le caractère à empiler et un caractère de fin nul. Le second paramètre est un pointeur vers une structure FILE.

La fonction ungetc empile le premier caractère de chaine_de_caracteres de retour dans stream et désactive l'indicateur fin-de-fichier. Le stream doit être ouvert pour la lecture. Une opération de lecture ultérieure sur stream commence avec chaine_de_caracteres[0]. Une tentative d'empiler "\xff" (fin-de-fichier) sur le stream en utilisant ungetc est ignorée.

Les caractères placés sur le stream par ungetc peuvent être effacés si fflush, fseek, fsetpos, ou rewind est appelé avant que le caractère soit lu du stream. L'indicateur de position dans le fichier va avoir la valeur qu'il avait avant que les caractères aient été empilés de retour. Le stockage extérieur correspondant au stream est inchangé. Dans la cas d'un appel réussi à ungetc contre un stream texte, l'indicateur de position dans le fichier est indéfini jusqu'à ce que tout les caractères empilés soient lus ou effacés. À chaque appel réussi à ungetc contre un stream binaire, l'indicateur de position dans le fichier est décrémenté ; si sa valeur était 0 avant un appel, sa valeur est indéfinie après l'appel.

Les résultats sont imprévisible si ungetc est appelé deux fois sans une opération de lecture ou de positionnement dans le fichier entre les deux appels. Après un appel à fscanf, un appel à ungetc pourrait échouer sauf si une autre opération de lecture (comme fgetc) à été exécutée. C'est parce que fscanf elle même appelle ungetc.

Texte traduit en majeure partie de Microsoft Visual C++ 6.0 Docs.


value(pointeur_vers_un_noeud)

Cette function retourne la valeur numérique ou la chaîne de caractères contenue dans un noeud dont le pointeur est reçue comme argument. Le noeud doit contenir un nombre ou une chaîne de caractères.


vartoa(pointeur_vers_un_noeud)

Cette fonction reçoit comme paramètre le pointeur vers un noeud de type "variable". La valeur retournée est une chaîne de caractères contenant le nom de la variable.

> a = `i + 1'.childset[0]
        0x3c7b30
> vartoa(a.childset[0])
        "i"

vartomem(expr)

Cette fonction peut recevoir comme argument une expression d'un des types fondamentaux du C, un tableau, un objet ou n'importe quelle combinaison de ces types. Par combinaison, nous entendons par exemple un objet contenant des tableaux, un tableau d'objets, un objet en contenant un autre, etc. Les objets reçus sont convertis en structures C avec l'alignement adéquat de chacune des variables membres. Un tableau reçu doit avoir tous les éléments du même type et est converti en tableau C. La valeur retournée est une variable de type raw memory qui peut être passée en argument à une fonction d'une dynamic-link library ou d'une shared object library. Pour un exemple d'utilisation, voir la fonction getfuncpt.


write(nom_fichier, liste, separateur)

Le premier paramètre est une chaîne de caractères contenant le nom du fichier où écrire le texte. Le second paramètre est un pointeur vers une liste où chaque sous noeud contient une chaîne de caractères. Le dernier paraparamètre est une chaîne de caractères contenant le texte à insérer entre chaque chaîne de caractères de la liste dans le fichier de sortie. La valeur retournée est la valeur indéfinie.

write("write.txt", `{"Hello" "World" "!" "!"}'.childset[0], " ")

retour au PCASTL