resumepostscript.tex

{\bf Nota~:} Les commandes ci-dessous sont recopiées du {\sl Manuel de
référence du langage PostScript}, d'Adobe Systems Incorporation, chez
Addison-Wesley, 1992, conformément à l'autorisation Adobe publiée à la
page 11 de cet ouvrage.
 
\sparagraphe {Opérateurs de manipulation de la pile d'opérandes}%
 
\syntaxe
\longref 
   {$any$}
   {pop}
   {$-$}
   {enlève l'élément supérieur}
 
\longref 
   {$any_1$ $any_2$}
   {exch}
   {$any_2$ $any_1$}
   {intervertit les deux éléments en haut de la pile}
 
\longref 
   {$any$}
   {dup}
   {$any$ $any$}
   {duplique l'élément au sommet}
 
\longref 
   {$any_1$ $\dots$ $any_n$ $n$}
   {copy}
   {$any_1$ $\dots$ $any_n$ $any_1$ $\dots$ $any_n$}
   {duplique $n$ éléments au sommet}
 
\longref 
   {$any_n$ $\dots$ $any_0$ $n$}
   {index}
   {$any_n$ $\dots$ $any_0$ $any_n$}
   {duplique un élément déterminé}
 
\longref 
   {$a_{n-1}$ $\dots$ $a_0$ $n$ $j$}
   {roll}
   {$a_{(j-1)\mod n}$ $\dots$ $a_0$ $a_{n-1}$ $a_{j\mod n}$}
   {permute $n$ éléments $j$ fois}
 
\longref 
   {$\vdash $ $any_1$ $\dots$ $any_n$}
   {clear}
   {$\vdash $}
   {enlève tous les éléments}
 
\longref 
   {$\vdash $ $any_1$ $\dots$ $any_n$}
   {count}
   {$\vdash $ $any_1$ $\dots$ $any_n$ $n$}
   {compte les éléments dans la pile}
 
\longref 
   {$-$}
   {mark}
   {$mark$}
   {place une marque sur la pile}
 
\longref 
   {$marks$ $obj_1$ $\dots $ $obj_n$}
   {cleartomark}
   {$-$}
   {enlève les éléments jusqu'à $mark$}
 
\longref 
   {$marks$ $obj_1$ $\dots $ $obj_n$}
   {counttomark}
   {$marks$ $obj_1$ $\dots $ $obj_n$ $n$}
   {compte les élémens jusqu'à $mark$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs arihmétiques et mathématiques}
 
\syntaxe
\longref 
   {$num_1$ $num_2$}
   {add}
   {$sum$}
   {$num_1$ plus $num_2$}
 
\longref 
   {$num_1$ $num_2$}
   {div}
   {$quotient$}
   {$num_1$ divisé par $num_2$}
 
\longref 
   {$int_1$ $int_2$}
   {idiv}
   {$quotient$}
   {division entière}
 
\longref 
   {$int_1$ $int_2$}
   {mod}
   {$remainder$}
   {$int_1 \mod int_2$}
 
\longref 
   {$num_1$ $num_2$}
   {mul}
   {$product$}
   {$num_1$ multiplié par $num_2$}
 
\longref 
   {$num_1$ $num_2$}
   {sub}
   {$difference$}
   {$num_1$ moins $num_2$}
 
\longref 
   {$num_1$}
   {abs}
   {$num_2$}
   {valeur absolue de $num_1$}
 
\longref 
   {$num_1$}
   {neg}
   {$num_2$}
   {opposé de $num_1$}
 
\longref 
   {$num_1$}
   {ceiling}
   {$num_2$}
   {plafond de $num_1$}
 
\longref 
   {$num_1$}
   {floor}
   {$num_2$}
   {plafond de $num_1$}
 
\longref 
   {$num_1$}
   {round}
   {$num_2$}
   {arrondit $num_1$ à l'entier le plus proche}
 
\longref 
   {$num_1$}
   {truncate}
   {$num_2$}
   {enlève la partie fractionnaire de $num_1$}
 
\longref 
   {$num$}
   {sqrt}
   {$real$}
   {racine carrée de $num$}
 
\longref 
   {$num$ $den$}
   {atan}
   {$angle$}
   {arc tangente de $num/den$ en degrés}
 
\longref 
   {$angle$}
   {cos}
   {$real$}
   {cosinus de $angle$ (en degrés)}
 
\longref 
   {$angle$}
   {sin}
   {$real$}
   {sinus de $angle$ (en degrés)}
 
\longref 
   {$base$ $exponent$}
   {exp}
   {$real$}
   {élève $base$ à la puissance $exponent$}
 
\longref 
   {$num$}
   {ln}
   {$real$}
   {logarithme naturel (base $e$)}
 
\longref 
   {$num$}
   {log}
   {$real$}
   {logarithme décimal (base 10)}
 
\longref 
   {$-$}
   {rand}
   {$int$}
   {génère un entier au hasard}
 
\longref 
   {$int$}
   {srand}
   {$-$}
   {paramètre le nombre d'origine du générateur aléatoire}
 
\longref 
   {$-$}
   {rrand}
   {$int$}
   {renvoie le nombre d'origine du générateur aléatoire}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de tableau}
 
\syntaxe
\longref 
   {$int$}
   {array}
   {$array$}
   {crée un tableau de longueur $int$}
 
\longref 
   {$-$}
   {[}
   {$mark$}
   {commence la construction de tableau}
 
\longref 
   {$mark$ $obj_0$ $\dots$ $obj_{n-1}$}
   {]}
   {$array$}
   {termine la construction de tableau}
 
\longref 
   {$array$}
   {length}
   {$int$}
   {nombre d'éléments dans $array$}
 
\longref 
   {$array$ $index$}
   {get}
   {$any$}
   {obtient l'élément du tableau indexé par $index$}
 
\longref 
   {$array$ $index$ $any$}
   {put}
   {$-$}
   {met $any$ dans $array$ à $index$}
 
\longref 
   {$array$ $index$ $count$}
   {getinterval}
   {$subarray$}
   {sous-tableau de $array$ commençant à $index$ et long de $count$ éléments}
 
\longref 
   {$array_1$ $index$ $array_2$}
   {putinterval}
   {$-$}
   {remplace le sous-tableau $array_1$ commençant à $index$ par $array_2$}
 
\longref 
   {$any_0$ $\dots $ $any_{n-1}$ $array$}
   {astore}
   {$array$}
   {pousse l'élément depuis la pile vers array}
 
\longref 
   {$array$}
   {aload}
   {$a_0$ $\dots $ $a_{n-1}$ $array$}
   {pousse tous les éléments de $array$ dans la pile}
 
\longref 
   {$array_1$ $array_2$}
   {copy}
   {$subarray_2$}
   {copie les éléments de $array_1$ dans le sous-tableau initial de $array_2$}
 
\longref 
   {$array$ $proc$}
   {forall}
   {$-$}
   {éxécute $proc$ pour chaque élément dans $array$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de dictionnaire}
 
\syntaxe
\longref 
   {$int$}
   {dict}
   {$dict$}
   {crée un dictionnaire ayant une contenance de $int$ éléments}
 
\longref 
   {$-$}
   {<<}
   {$mark$}
   {commence la construction de dictionnaire}
 
\longref 
   {$mark$ $key_1$ $value_1$ $\dots $ $key_n$ $value_n$}
   {>>}
   {$dict$}
   {termine la construction de dictionnaire}
 
\longref 
   {$dict$}
   {length}
   {$int$}
   {nombre de couples clé-valeur dans $dict$}
 
\longref 
   {$dict$}
   {maxlength}
   {$int$}
   {capacité courante de $dict$}
 
\longref 
   {$dict$}
   {begin}
   {$-$}
   {pousse $dict$ dans la pile des dictionnaires}
 
\longref 
   {$-$}
   {end}
   {$-$}
   {expulse la pile des dictionnaires}
 
\longref 
   {$key$ $value$}
   {def}
   {$-$}
   {associe $key$ et $value$ dans le dictionnaire courant}
 
\longref 
   {$key$}
   {load}
   {$value$}
   {recherche $key$ dans la pile des dictionnaires et renvoie le
   $vlue$ qui y est associé}
 
\longref 
   {$key$ $value$}
   {store}
   {$-$}
   {remplace la définition la plus haute de $key$}
 
\longref 
   {$dict$ $key$ $value$}
   {put}
   {$-$}
   {associe $key$ à $value$ dans $dict$}
 
\longref 
   {$dict$ $key$}
   {undef}
   {$-$}
   {enlève $key$ et $value$ dans $dict$}
 
\longref 
   {$dict$ $key$}
   {known}
   {$bool$}
   {test si $key$ est dans $dict$}
 
\longref 
   {key}
   {where}
   {$dict$ $true$ ou bien $false$}
   {trouve le dictionnaire dans lequel $key$ est défini}
 
\longref 
   {$dict$ $proc$}
   {forall}
   {$-$}
   {exécute $proc$ pour chaque élément de $dict$}
 
\longref 
   {$-$}
   {currentdict}
   {$dict$}
   {pousse le dictionnaire courant dans la pile des opérandes}
 
\longref 
   {$-$}
   {errordict}
   {$dict$}
   {dictionnaire des gestions d'erreur}
 
\longref 
   {$-$}
   {\$error}
   {$dict$}
   {dictionnaire de contrôle des erreurs et de statut}
 
\longref 
   {$-$}
   {systemdict}
   {$dict$}
   {dictionnaire système}
 
\longref 
   {$-$}
   {userdict}
   {$dict$}
   {dictionnaire en écriture en VM locale}
 
\longref 
   {$-$}
   {globaldict}
   {$dict$}
   {dictionnaire en écriture en VM globale}
 
\longref 
   {$-$}
   {statusdict}
   {$dict$}
   {dictionnaire dépendant du produit}
 
\longref 
   {$-$}
   {countdictstack}
   {$int$}
   {compte les éléments dans la pile des dictionnaires}
 
\longref 
   {$array$}
   {dictstack}
   {$subarray$}
   {copie la pile des dictionnaires dans $array$}
 
\longref 
   {$-$}
   {cleardictstack}
   {$-$}
   {enlève tous les dictionnaires non permanents de la pile des dictionnaires}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de chaînes}
 
\syntaxe
\longref 
   {$int$}
   {string}
   {$string$}
   {crée une chaîne de longueur $int$}
 
\longref 
   {$string$}
   {length}
   {$int$}
   {nombre d'éléments dans $string$}
 
\longref 
   {$string$ $index$}
   {get}
   {$int$}
   {obtinet l'élement de $string$ indexé par $index$}
 
\longref 
   {$string$ $index$ $int$}
   {put}
   {$-$}
   {place $int$ dans $string$ à $index$}
 
\longref 
   {$string$ $index$ $count$}
   {getinterval}
   {$substring$}
   {sous-chaîne de $string$ commençant à $index$ pour $count$ éléments}
 
\longref 
   {$string_1$ $index$ $string_2$}
   {putinterval}
   {$-$}
   {remplace la sous-chaîne de $string_1$ commençant à $index$ par $string_2$}
 
\longref 
   {$string_1$ $string_2$}
   {copy}
   {$substring_2$}
   {copie les élément de $string_1$ dans la sousè-chaîne initiale de $string_2$} 
 
\longref 
   {$string$ $proc$}
   {forall}
   {$-$}
   {exécute $proc$ pour chaque élément de $string$}
 
\longref 
   {$string$ $seek$}
   {anchorsearch}
   {$post$ $match$ $true$ ou bien $string$ $false$}
   {détermine si $seek$ est une sous-chaîne de $string$}
 
\longref 
   {$string$ $seek$}
   {search}
   {$post$ $match$ $pre$ $true$ ou bien $string$ $false$}
   {cherche $seek$ dans $string$}
 
\longref 
   {$string$}
   {token}
   {$post$ $token$ $true$ ou bien $string$ $false$}
   {lit le léxème à partir du début de $string$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs relationnels, booléens et bit à bit}
 
\syntaxe
\longref 
   {$any_1$ $any_2$}
   {eq}
   {$bool$}
   {test l'égalité}
 
\longref 
   {$any_1$ $any_2$}
   {ne}
   {$bool$}
   {test l'inégalité}
 
\longref 
   {$num_1/str_1$ $num_2/str_2$}
   {ge}
   {$bool$}
   {teste si supérieur ou égal}
 
\longref 
   {$num_1/str_1$ $num_2/str_2$}
   {gt}
   {$bool$}
   {teste si supérieur}
 
\longref 
   {$num_1/str_1$ $num_2/str_2$}
   {le}
   {$bool$}
   {test si inférieur}
 
\longref 
   {$num_1/str_1$ $num_2/str_2$}
   {lt}
   {$bool$}
   {teste si inférieur ou égal}
 
\longref 
   {$bool_1/int_1$ $bool_2/int_2$}
   {and}
   {$bool_3/int_3$}
   {et logique bit à bit}
 
\longref 
   {$bool_1/int_1$}
   {not}
   {$bool_2/int_2$}
   {non logique bit à bit}
 
\longref 
   {$num_1/string_1$ $num_2/string_2$}
   {or}
   {$bool_3/int_3$}
   {ou inclusif logique bit à bit}
 
\longref 
   {$num_1/string_1$ $num_2/string_2$}
   {xor}
   {$bool_3/int_3$}
   {ou exclusif logique bit à b it}
 
\longref 
   {$-$}
   {true}
   {$true$}
   {pousse la valeur booléenne $true$ (vrai)}
 
\longref 
   {$-$}
   {false}
   {$false$}
   {pousse la valeur booléenne $false$ (faux)}
 
\longref 
   {$int_1$ $shift$}
   {bitshift}
   {$int_2$}
   {décalement bit à bit de $int_1$ (positif à gauche)}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de contrôle}
 
\syntaxe
\longref 
   {$any$}
   {exec}
   {$-$}
   {exécute un objet arbitraire}
 
\longref 
   {$bool$ $proc$}
   {if}
   {$-$}
   {exécute $proc$ si $bool$ est $true$}
 
\longref 
   {$bool$ $proc_1$ $proc_2$}
   {ifelse}
   {$-$}
   {exécute $proc_1$ si $bool$ est $true$, $proc_2$ sinon}
 
\longref 
   {$init$ $incr$ $limit$ $proc$}
   {for}
   {$-$}
   {exécute $proc$ avec les valeurs à partie de $init$ par pas de
   $inc$ jusqu'à $limit$}
 
\longref 
   {$int$ $proc$}
   {repeat}
   {$-$}
   {exécute $int$ fois $proc$}
 
\longref 
   {$proc$}
   {loop}
   {$-$}
   {exécute $proc$ un nombre indéfini de fois}
 
\longref 
   {$-$}
   {exit}
   {$-$}
   {quitte la boucle active la plus interne}
 
\longref 
   {$-$}
   {stop}
   {$-$}
   {termine le contexte {\bf stopped}}
 
\longref 
   {$any$}
   {stopped}
   {$bool$}
   {établit le contexte pour attraper {\bf stop}}
 
\longref 
   {$-$}
   {countexecstack}
   {$int$}
   {compte les éléments dans la pile d'éxécution}
 
\longref 
   {$array$}
   {execstack}
   {$subaray$}
   {copie la pile d'exécution dans $array$}
 
\longref 
   {$-$}
   {quit}
   {$-$}
   {quitte l'interpréteur}
 
\longref 
   {$-$}
   {start}
   {$-$}
   {exécuté au lancement de l'interpréteur}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de type, attribut et conversion}
 
\syntaxe
\longref 
   {$any$}
   {type}
   {$name$}
   {renvoie le nom identifiant le type de $any$}
 
\longref 
   {$any$}
   {cvlit}
   {$any$}
   {convertit l'objet en littéral}
 
\longref 
   {$any$}
   {cvx}
   {$any$}
   {convertit l'objet en exécutable}
 
\longref 
   {$any$}
   {xcheck}
   {$bool$}
   {teste l'attribut d'exécutable}
 
\longref 
   {$array/packedarray/file/string$}
   {executeonly}
   {$-$ $array/packedarray/file/string$}
   {réduit l'accès à e\-xé\-cu\-ta\-ble seulement}
 
\longref 
   {$array/packedarray/dict/file/string$}
   {noaccess}
   {$-$ $array/packedarray/dict/file/string$}
   {interdit tout accès}
 
\longref 
   {$array/packedarray/dict/file/string$}
   {readonly}
   {$-$ $array/packedarray/dict/file/string$}
   {réduit l'ac\-cès à lecture seule}
 
\longref 
   {$array/packedarray/dict/file/string$}
   {rcheck}
   {$bool$}
   {teste l'accès en lecture}
 
\longref 
   {$array/packedarray/dict/file/string$}
   {wcheck}
   {$bool$}
   {teste l'accès en écriture}
 
\longref 
   {$num/string$}
   {cvi}
   {$int$}
   {convertit en entier}
 
\longref 
   {$string$}
   {cvn}
   {$name$}
   {convertit en nom}
 
\longref 
   {$num/string$}
   {cvr}
   {$real$}
   {convertit en réel}
 
\longref 
   {$num$ $radix$ $string$}
   {cvrs}
   {$substring$}
   {convertit en chaîne avec racine}
 
\longref 
   {$any$ $string$}
   {cvs}
   {$substring$}
   {convertit en chaîne}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de fichier}
 
\syntaxe
\longref 
   {$string_1$ $string_2$}
   {file}
   {$file$}
   {ouvre le fichier idéntifié par $string_1$ avec l'accès $string_2$}
 
\longref 
   {$src/tgt/param_1 \dots param_n$ $name$}
   {filter}
   {$file$}
   {établit le fichier filtré}
 
\longref 
   {$file$}
   {closefile}
   {$-$}
   {ferme $file$}
 
\longref 
   {$file$}
   {read}
   {$int$ $true$ ou bien $false$}
   {lit un caractère dans $file$}
 
\longref 
   {$file$ $int$}
   {write}
   {$-$}
   {écrit un caractère dans $file$}
 
\longref 
   {$file$ $string$}
   {readhexstring}
   {$substring$ $bool$}
   {lit une chaîne hexadécimale depuis $file$ vers $string$}
 
\longref 
   {$file$ $string$}
   {writehexstring}
   {$-$}
   {écrit $string$ dans $file$ en chaîne hexadécimale}
 
\longref 
   {$file$ $string$}
   {readstring}
   {$substring$ $bool$}
   {lit une ligne depuis $file$ dans $string$}
 
\longref 
   {$file$ $string$}
   {writestring}
   {$-$}
   {écrit $string$ dans $file$}
 
\longref 
   {$file$ $string$}
   {readline}
   {$substring$ $bool$}
   {lit une ligne depuis $file$ dans $string$}
 
\longref 
   {$file$}
   {token}
   {$token$ $true$ ou bien $false$}
   {lit un léxème depuis $file$}
 
\longref 
   {$file$}
   {bytesavailable}
   {$int$}
   {nombre d'octets pouvant être lus}
 
\longref 
   {$-$}
   {flush}
   {$-$}
   {renvoie les données du tampon dans le fichier de sortie standard}
 
\longref 
   {$file$}
   {flushfile}
   {$-$}
   {renvoie les données du tampon ou les lit jusqu'à EOF}
 
\longref 
   {$file$}
   {resetfile}
   {$-$}
   {ignore les caractères dans le tampon}
 
\longref 
   {$file$}
   {status}
   {$bool$}
   {renvoie le statut de $file$}
 
\longref 
   {$string$}
   {status}
   {$pages$ $bytes$ $referenced$ $created$ $true$ ou bien $false$}
   {renvoie l'information à propos du fichier nommé}
 
\longref 
   {$string$}
   {run}
   {$-$}
   {exécute le contenu du fichier nommé}
 
\longref 
   {$-$}
   {currentfile}
   {$file$}
   {renvoie le fichier en cours d'exécution}
 
\longref 
   {$any_1$ $\dots $ $any_n$ $string$}
   {deletefile}
   {$-$}
   {détruit le fichier nommé}
 
\longref 
   {$string_1$ $string_2$}
   {renamefile}
   {$-$}
   {renomme le fichier appelé $string_1$ en $string_2$}
 
\longref 
   {$template$ $proc$ $scratch$}
   {filenameforall}
   {$-$}
   {exécute $proc$ pour chaque nom de fichier correspondant à $template$}
 
\longref 
   {$file$ $int$}
   {setfileposition}
   {$-$}
   {met $file$ à la position indiquée}
 
\longref 
   {$file$}
   {fileposition}
   {$int$}
   {renvoie la position courant dans $file$}
 
\longref 
   {$string$}
   {print}
   {$-$}
   {écrit $string$ dans le fichier de sortie standard}
 
\longref 
   {$any$}
   {=}
   {$-$}
   {écrit la représentation textuelle de $any$ dans le fichier de
   sortie standard}
 
\longref 
   {$any$}
   {==}
   {$-$}
   {écrit la représentation syntaxique de $any$ dans le fichier de
   sortie standard}
 
\longref 
   {$\vdash $ $any_1$ $\dots $ $any_n$}
   {stack}
   {$-$ $\vdash $ $any_1$ $\dots $ $any_n$}
   {imprime la pile de façon non destructive en utilisant |=|}
 
\longref 
   {$\vdash $ $any_1$ $\dots $ $any_n$}
   {pstack}
   {$-$ $\vdash $ $any_1$ $\dots $ $any_n$}
   {imprime la pile de façon non destructive en utilisant |==|}
 
\longref 
   {$obj$ $int$}
   {printobject}
   {$-$}
   {écrit un objet binaire dans le fichier de sortie standard, en
   utilisant $int$ en tant que drapeau}
 
\longref 
   {$file$ $obj$ $int$}
   {writeobject}
   {$-$}
   {écrit un objet binaire dans $file$ en
   utilisant $int$ en tant que drapeau}
 
\longref 
   {$int$}
   {setobjectformat}
   {$-$}
   {définit le format d'objet binaire ($0 = $~désactivé, $1 = $~IEEE
   haut, $2 =$~bas, $3 =$~haut natif, $4 =$~bas)}
 
\longref 
   {$-$}
   {currentobjectformat}
   {$int$}
   {renvoie le format d'objet binaire}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de ressource}
 
\syntaxe
\longref 
   {$key$ $instance$ $category$}
   {defineresource}
   {$instance$}
   {enregistre la ressource nommée $instance$ dans $category$}
 
\longref 
   {$key$ $category$}
   {undefinedresource}
   {$-$}
   {enlève l'enregistrement de ressource}
 
\longref 
   {$key$ $category$}
   {findresource}
   {$instance$}
   {renvoie la ressource $instance$ identifiée par $key$ dans $category$}
 
\longref 
   {$key$ $category$}
   {resourcestatus}
   {$status$ $size$ $true$ ou bien $false$}
   {renvoie le $status$ des instances de ressource}
 
\longref 
   {$template$ $proc$ $scratch$ $category$}
   {resourceforall}
   {$-$}
   {énumère les instances de ressources dans $category$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de mémoire virtuelle}
 
\syntaxe
\longref 
   {$-$}
   {save}
   {$save$}
   {crée une photo de la VM}
 
\longref 
   {$save$}
   {restore}
   {$-$}
   {réinstalle la photo de la VM}
 
\longref 
   {$bool$}
   {setglobal}
   {$-$}
   {définit le mode d'allocation en VM ($fale =$~local, $true =$~global)}
 
\longref 
   {$-$}
   {currentglobal}
   {$bool$}
   {renvoie le mode courant d'allocation en VM}
 
\longref 
   {$any$}
   {gcheck}
   {$bool$}
   {$true$ si $any$ est simple ou en VM globale, $false$ si en VM locale}
 
\longref 
   {$bool_1$ $password$}
   {startjob}
   {$bool_2$}
   {commence une nouvelle tâche qui modifiera la VM initiale si $bool$
   est vrai}
 
\longref 
   {$index$ $any$}
   {defineuserobject}
   {$-$}
   {définit l'objet utilisateur associé à $index$}
 
\longref 
   {$index$}
   {execuserobject}
   {$-$}
   {exécute l'objet utilisateur associé à $index$}
 
\longref 
   {$index$}
   {undefineduserobject}
   {$-$}
   {enlève l'objet utilisateur associé à $index$}
 
\longref 
   {$-$}
   {UserObject}
   {$array$}
   {tableau |UserObjects| courant défini dans |userdict|}
 
\endsyntaxe
 
\sparagraphe {Opérateurs divers}
 
\syntaxe
\longref 
   {$proc$}
   {bind}
   {$proc$}
   {remplace les noms d'opérateurs dans $proc$ par les opérateurs}
 
\longref 
   {$-$}
   {null}
   {$null$}
   {pousse $null$ dans la pile d'opérandes}
 
\longref 
   {$-$}
   {version}
   {$string$}
   {version de l'interpréteur}
 
\longref 
   {$-$}
   {realtime}
   {$int$}
   {renvoie le temps réel en millisecondes}
 
\longref 
   {$-$}
   {usertime}
   {$int$}
   {renvoie le temps d'exécution en millisecondes}
 
\longref 
   {$-$}
   {languagelevel}
   {$int$}
   {niveau de fonction du langage}
 
\longref 
   {$-$}
   {product}
   {$string$}
   {nom du produit}
 
\longref 
   {$-$}
   {revision}
   {$int$}
   {numéro de révision du produit}
 
\longref 
   {$-$}
   {serialnumber}
   {$int$}
   {numéro de série de la machine}
 
\longref 
   {$-$}
   {executive}
   {$-$}
   {appelle l'exécuteur intéractif}
 
\longref 
   {$bool$}
   {echo}
   {$-$}
   {alterne l'écho actif et inactif}
 
\longref 
   {$-$}
   {prompt}
   {$-$}
   {exécuté quand prêt pour l'entrée intéractive}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de de l'état graphique - Indépendants du périphérique}
 
\syntaxe
\longref 
   {$-$}
   {save}
   {$-$}
   {pousse l'état graphique}
 
\longref 
   {$-$}
   {grestore}
   {$-$}
   {remet l'état graphique en place}
 
\longref 
   {$-$}
   {grestorealll}
   {$-$}
   {remet l'état graphique le plus ancien en place}
 
\longref 
   {$-$}
   {initgraphics}
   {$-$}
   {réinitialise les paramètres de l'état graphique}
 
\longref 
   {$-$}
   {gstate}
   {$gstate$}
   {crée un objet état graphique}
 
\longref 
   {$gstate$}
   {setgstate}
   {$-$}
   {établit l'état graphique à partir de $gstate$}
 
\longref 
   {$gstate$}
   {currentgstate}
   {$gstate$}
   {copie l'état graphique courant dans $gstate$}
 
\longref 
   {$num$}
   {setlinewidth}
   {$-$}
   {ajuste la largeur de ligne}
 
\longref 
   {$-$}
   {currentlinewidth}
   {$num$}
   {renvoie la largeur de ligne courante}
 
\longref 
   {$int$}
   {setlinecap}
   {$-$}
   {définit la forme des fins de ligne lors des tracés ($0 =$~en
   ogive, $1 =$~rond, $2 =$~en biais)}
 
\longref 
   {$-$}
   {currentlinecap}
   {$int$}
   {renvoie le recouvrement courant de la ligne}
 
\longref 
   {$int$}
   {setlinejoin}
   {$-$}
   {définit la forme des coins lors du tracé ($0=$~en ogive,
   $1=$~rond, $2=$~en biais)}
 
\longref 
   {$-$}
   {currentlinejoin}
   {$num$}
   {renvoie le type de jointure courant des lignes}
 
\longref 
   {$num$}
   {setmiterlimit}
   {$-$}
   {définit la limite de longueur d'intersection}
 
\longref 
   {$-$}
   {currentmiterlimit}
   {$num$}
   {renvoie la valeur courante du paramètre de limite d'extrémité de ligne}
 
\longref 
   {$bool$}
   {setstrokeadjust}
   {$-$}
   {définit l'ajustement du tracé ($false =$~désactivé, $true =$~activé)}
 
\longref 
   {$-$}
   {currentstrokeadjust}
   {$bool$}
   {renvoie l'ajustement de tracé courant}
 
\longref 
   {$array$ $offset$}
   {setdash}
   {$-$}
   {définit le pointillé pour le tracé}
 
\longref 
   {$-$}
   {currentdash}
   {$array$ $offset$}
   {renvoie le pointillé de tracé courant}
 
\longref 
   {$array$}
   {setcolorspace}
   {$-$}
   {définit l'espace de couleur}
 
\longref 
   {$-$}
   {currentcolorspace}
   {$array$}
   {renvoie l'espace de couleur courant}
 
\longref 
   {$comp_1$ $\dots $ $comp_n$}
   {setcolor}
   {$-$}
   {définit les composantes de couleur}
 
\longref 
   {$-$}
   {currentcolor}
   {$comp_1$ $\dots $ $comp_n$}
   {renvoie les composantes courantes de couleur}
 
\longref 
   {$num$}
   {setgray}
   {$-$}
   {définit l'espace de couleur pour |DeviceGray| et la couleur de la
   valeur de gris spécifiée ($0=$~noir, $1=$~blanc)}
 
\longref 
   {$-$}
   {currentgray}
   {$num$}
   {renvoie la valeur courante en tant que valeur de gris}
 
\longref 
   {$hue$ $sat$ $brt$}
   {sethsbcolor}
   {$-$}
   {définit |DeviceRGB| comme espace de couleur et la couleur à la
   teinte, saturation et luminosité indiquée}
 
\longref 
   {$-$}
   {currenthsbcolor}
   {$hue$ $sat$ $brt$}
   {retourne la couleur courant en teinte, saturation et luminosité}
 
\longref 
   {$red$ $green$ $blue$}
   {setrgbcolor}
   {$-$}
   {définit |DeviceRGB| comme espace de couleur et la couleur aux
   rouge, vert et bleu indiqués}
 
\longref 
   {$-$}
   {currentrgbcolor}
   {$red$ $green$ $blue$}
   {renvoie la couleur courante selon ses composantes rouge, vert, bleu}
 
\longref 
   {$cyan$ $magenta$ $yellow$ $black$}
   {setcmykcolor}
   {$-$}
   {définit |DeviceCYMK| comme espace de couleur et la couleur selon
   le cyan, jaune, magenta et noir indiqués}
 
\longref 
   {$-$}
   {currentcmykcolor}
   {$cyan$ $magenta$ $yellow$ $black$}
   {renvoie la couleur courane selon les cyan, jaune, magenta et noir}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de de l'état graphique - Dépendants du périphérique}
 
\syntaxe
\longref 
   {$dict$}
   {sethalftone}
   {$-$}
   {définit le dictionnaire de simili}
 
\longref 
   {$-$}
   {currenthalftone}
   {$dict$}
   {renvoie le dictionnaire de simili courant}
 
\longref 
   {$frequency$ $angle$ $proc$}
   {setscreen}
   {$-$}
   {définit l'écran de simili de gris}
 
\longref 
   {$-$}
   {currentscreen}
   {$frequency$ $angle$ $proc$}
   {renvoie l'écran de simili de gris courant}
 
\longref 
   {$redfreq$ $redang$ $redproc$ 
   $greenfreq$ $greenang$ $greenproc$ 
   $bluefreq$ $blueang$ $blueproc$ 
   $grayfreq$ $grayang$ $grayproc$ }
   {setcolorscreen}
   {$-$}
   {définit les quatres écrans de simili}
 
\longref 
   {$-$}
   {currentcolorscreen}
   {$redfreq$ $redang$ $redproc$ 
   $greenfreq$ $greenang$ $greenproc$ 
   $bluefreq$ $blueang$ $blueproc$ 
   $grayfreq$ $grayang$ $grayproc$ }
   {renvoie les quatres écrans de simili}
 
\longref 
   {$proc$}
   {settransfer}
   {$-$}
   {définit la fonction de transfert de gris}
 
\longref 
   {$-$}
   {currenttransfer}
   {$proc$}
   {renvoie la fonction de transfert de gris}
 
\longref 
   {$redproc$ $greenproc$ $blueproc$ $grayproc$}
   {setcolortransfer}
   {$-$}
   {définit les quatre fonctions de transfert}
 
\longref 
   {$-$}
   {currentcolortransfer}
   {$redproc$ $greenproc$ $blueproc$ $grayproc$}
   {renvoie les fonctions de transfert courantes}
 
\longref 
   {$proc$}
   {setblackgeneration}
   {$-$}
   {définit la fonction de génération de noir courante}
 
\longref 
   {$-$}
   {currentblackgeneration}
   {$proc$}
   {renvoie la fonction de génération de noir courante}
 
\longref 
   {$proc$}
   {setundercolorremoval}
   {$-$}
   {définit la fonction d'enlèvement de couleur sous-jacente}
 
\longref 
   {$-$}
   {currentundercolorremoval}
   {$proc$}
   {renvoie la fonction d'enlèvement de couleur sous-jacente courante}
 
\longref 
   {$dict$}
   {setcolorrenderring}
   {$-$}
   {définit le dictionnaire de rendu des couleurs basées sur le CIE}
 
\longref 
   {$-$}
   {currentcolorrenderring}
   {$dict$}
   {renvoie le dictionnaire courant de rendu des couleurs basées sur le CIE}
 
\longref 
   {$num$}
   {setflat}
   {$-$}
   {définit la tolérance de l'arrondi des courbes}
 
\longref 
   {$-$}
   {currentflat}
   {$num$}
   {renvoie la tolérance de l'arrondi des courbes}
 
\longref 
   {$bool$}
   {setoverprint}
   {$-$}
   {définit le paramètre de sur-impression}
 
\longref 
   {$-$}
   {currentoverprint}
   {$bool$}
   {renvoie le paramètre de sur-impression courant}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de système de coordonnées et de matrice}
 
\syntaxe
\longref 
   {$-$}
   {matrix}
   {$matrix$}
   {crée une matrice identité}
 
\longref 
   {$-$}
   {initmatrix}
   {$-$}
   {définit la CTM pour le périphérique par défaut}
 
\longref 
   {$matrix$}
   {identmatrix}
   {$matrix$}
   {remplit $matrix$ avec la transformation identité}
 
\longref 
   {$matrix$}
   {defaultmatrix}
   {$matrix$}
   {remplit $matrix$ avec la matrice par défaut du périphérique}
 
\longref 
   {$matrix$}
   {currentmatrix}
   {$matrix$}
   {remplit $matrix$ avec la CTM}
 
\longref 
   {$matrix$}
   {setmatrix}
   {$-$}
   {remplace la CTM ar $matrix$}
 
\longref 
   {$t_x$ $t_y$}
   {translate}
   {$-$}
   {déplace l'espace utilisateur par $(t_x, t_y)$}
 
\longref 
   {$t_x$ $t_y$ $matrix$}
   {translate}
   {$matrix$}
   {définit le déplacement par $(t_x, t_y)$}
 
\longref 
   {$S_x$ $S_y$}
   {scale}
   {$-$}
   {met à l'échelle l'espace utilisateur par $s_x$ et $s_y$}
 
\longref 
   {$S_x$ $S_y$ $matrix$}
   {scale}
   {$matrix$}
   {définit la mise à l'échelle par $s_x$ et $s_y$}
 
\longref 
   {$angle$}
   {rotate}
   {$-$}
   {effectue une rotation de l'espace utilisateur de $angle$ degrés}
 
\longref 
   {$angle$ $matrix$}
   {rotate}
   {$matrix$}
   {définit la rotation par $angle$ degrés}
   {}
 
\longref 
   {$matrix$}
   {concat}
   {$-$}
   {remplace la CTM par le produit $matrix \times \rm CTM$}
 
\longref 
   {$matrix_1$ $matrix_2$ $matrix_3$}
   {concatmatrix}
   {$matrix_3$}
   {remplit $matrix_3$ avec le produit $matrix_1 \times matrix_2$}
 
\longref 
   {$x$ $y$}
   {transform}
   {$x'$ $y'$}
   {transforme $(x, y) par CTM$}
 
\longref 
   {$x$ $y$ $matrix$}
   {transform}
   {$x'$ $y'$}
   {transform $(x, y)$ par $matrix$}
 
\longref 
   {$dx$ $dy$}
   {dtransform}
   {$dx'$ $dy'$}
   {transforme la distance $(dx, dy)$ par CTM}
 
\longref 
   {$dx$ $dy$ $matrix$}
   {dtransform}
   {$dx'$ $dy'$}
   {transforme la distance $(dx, dy)$ par $matrix$}
 
\longref 
   {$x'$ $y'$}
   {itransform}
   {$x$ $y$}
   {inverse la transformation $(x', y')$ par CTM}
 
\longref 
   {$x'$ $y'$ $matrix$}
   {itransform}
   {$x$ $y$}
   {inverse la transformation $(x', y')$ par $matrix$}
 
\longref 
   {$dx'$ $dy'$}
   {idtransform}
   {$dx$ $dy$}
   {inverse la transformation de la distance $(dx', dy')$ par CTM}
 
\longref 
   {$dx'$ $dy'$ $matrix$}
   {idtransform}
   {$dx$ $dy$}
   {inverse la transformation de la distance $(dx', dy')$ par $matrix$}
 
\longref 
   {$matrix_1$ $matrix_2$}
   {invertmatrix}
   {$matrix_2$}
   {remplit $matrix_2$ avec l'inverse de $matrix_1$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de construction de chemin}
 
\syntaxe
\longref 
   {$-$}
   {newpath}
   {$-$}
   {initialise et vide le chemin courant}
 
\longref 
   {$-$}
   {currentpoint}
   {$x$ $y$}
   {renvoie les coordonnées du point courant}
 
\longref 
   {$x$ $y$}
   {moveto}
   {$-$}
   {définit le point courant à $(x, y)$}
 
\longref 
   {$dx$ $dy$}
   {rmoveto}
   {$-$}
   {|moveto| relatif}
 
\longref 
   {$x$ $y$}
   {lineto}
   {$-$}
   {ajoute une ligne droite jusqu'en $(x, y)$}
 
\longref 
   {$dx$ $dy$}
   {rlineto}
   {$-$}
   {|lineto| relatif}
 
\longref 
   {$x$ $y$ $r$ $ang_1$ $ang_2$}
   {arc}
   {$-$}
   {ajoute un arc dans le sens contraire des aiguilles d'une montre}
 
\longref 
   {$x$ $y$ $r$ $ang_1$ $ang_2$}
   {arcn}
   {$-$}
   {ajoute un arc dans le sens des aiguilles d'une montre}
 
\longref 
   {$x_1$ $y_1$ $x_2$ $y_2$ $r$}
   {arct}
   {$r$}
   {ajoute un arc tangent}
 
\longref 
   {$x_1$ $y_1$ $x_2$ $y_2$ $r$}
   {arcto}
   {$xt_1$ $yt_1$ $xt_2$ $yt_2$}
   {ajoute un arc tangent}
 
\longref 
   {$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$}
   {curveto}
   {$-$}
   {ajoute une section cubique de Bézier}
 
\longref 
   {$dx_1$ $dy_1$ $dx_2$ $dy_2$ $dx_3$ $dy_3$}
   {rcurveto}
   {$-$}
   {|curveto| relatif}
 
\longref 
   {$-$}
   {closepath}
   {$-$}
   {connecte le sous-chemin à son point de départ}
 
\longref 
   {$-$}
   {flattenpath}
   {$-$}
   {convertit les courbes en suites de segments de droites}
 
\longref 
   {$-$}
   {reversepath}
   {$-$}
   {renverse la direction du chemin courant}
 
\longref 
   {$-$}
   {strokepath}
   {$-$}
   {calcul le contour du chemin tracé}
 
\longref 
   {$userpath$}
   {ustrokepath}
   {$-$}
   {calcul le contour du $userpath$ tracé}
 
\longref 
   {$userpath$ $matrix$}
   {ustrokepath}
   {$-$}
   {calcul le contour du $userpath$ tracé}
 
\longref 
   {$string$ $bool$}
   {charpath}
   {$-$}
   {ajoute un contour de caractère au chemin courant}
 
\longref 
   {$userpath$}
   {uappend}
   {$-$}
   {interprète $userpath$ et l'ajoute au chemin courant}
 
\longref 
   {$-$}
   {clippath}
   {$-$}
   {définit le chemin d'incrustation en tant que chemin courant}
 
\longref 
   {$ll_x$ $ll_y$ $ur_x$ $ur_y$}
   {setbbox}
   {$-$}
   {définit le cadre de limite pour le chemin courant}
 
\longref 
   {$-$}
   {pathbbox}
   {$ll_x$ $ll_y$ $ur_x$ $ur_y$}
   {renvoie le cadre de limite pour le chemin courant}
 
\longref 
   {$move$ $line$ $curve$ $close$}
   {pathforall}
   {$-$}
   {détaille le chemion courant}
 
\longref 
   {$bool$}
   {upath}
   {$userpath$}
   {crée $userpath$ pour le chemin courant~; inclut |ucache| si $bool$
   est $true$}
 
\longref 
   {$-$}
   {initclip}
   {$-$}
   {définit le chemin d'incrustation au périphérique par défaut}
 
\longref 
   {$-$}
   {clip}
   {$-$}
   {incruste en utilisant la règle du nombre sinueux différent de zéro}
 
\longref 
   {$-$}
   {eoclip}
   {$-$}
   {incruste en utilisant la règle du pair-impair}
 
\longref 
   {$x$ $y$ $width$ $height$}
   {rectclip}
   {$-$}
   {incruste avec un chemin rectangulaire}
 
\longref 
   {$numarray/numstring$}
   {rectclip}
   {$-$}
   {incruste avec des chemins rectangulaires}
 
\longref 
   {$-$}
   {ucache}
   {$-$}
   {déclare que le chemin utilisateur doît être mis en cache}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de dessin}
 
\syntaxe
\longref 
   {$-$}
   {erasepage}
   {$-$}
   {dessine la page courante en blanc}
 
\longref 
   {$-$}
   {fill}
   {$-$}
   {remplit le chemin courant avec la couleur courante}
 
\longref 
   {$-$}
   {eofill}
   {$-$}
   {remplit en utilisant la règle pair-impair}
 
\longref 
   {$-$}
   {stroke}
   {$-$}
   {dessine la ligne le long du chemin courant}
 
\longref 
   {$userpath$}
   {ufill}
   {$-$}
   {interprète et remplit $userpath$}
 
\longref 
   {$userpath$}
   {ueofill}
   {$-$}
   {remplit $userpath$ en utilisant la règle pair-impir}
 
\longref 
   {$userpath$}
   {ustroke}
   {$-$}
   {interprète et trace $userpath$}
 
\longref 
   {$userpath$ $matrix$}
   {ustroke}
   {$-$}
   {interprète $userpath$, concatène $matrix$ et trace}
 
\longref 
   {$x$ $y$ $width$ $height$}
   {rectfill}
   {$-$}
   {remplit le chemin rectangulaire}
 
\longref 
   {$numarray/numstring$}
   {rectfill}
   {$-$}
   {remplit les chemins rectangulaires}
 
\longref 
   {$x$ $y$ $width$ $height$}
   {rectstroke}
   {$-$}
   {trace le chemin rectangulaire}
 
\longref 
   {$numarray/numstring$}
   {rectstroke}
   {$-$}
   {trace les chemins rectangulaires}
 
\longref 
   {$dict$}
   {image}
   {$-$}
   {dessine une image numérisée}
 
\longref 
   {$width height bits/samp matrix datasrc$}
   {image}
   {$-$}
   {dessine une image numérisée monochrome}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de test de position à l'intérieur du chemin}
 
\syntaxe
\longref 
   {$x$ $y$}
   {infill}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |fill|}
 
\longref 
   {$userpath$}
   {infill}
   {$bool$}
   {teste si les pixels dans $userpath$ sont dessinés par |fill|}
 
\longref 
   {$x$ $y$}
   {ineofill}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |eofill|}
 
\longref 
   {$userpath$}
   {ineofill}
   {$bool$}
   {teste si les pixels dans $userpath$ sont dessinés par |eofill|}
 
\longref 
   {$x$ $y$ $userpath$}
   {inufill}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |ufill| de $userpath$}
 
\longref 
   {$userpath_1$ $userpath_2$}
   {inufill}
   {$bool$}
   {teste si les pixels dans $userpath_1$ sont dessinés par |ufill|
   dans $userpath_2$}
 
\longref 
   {$x$ $y$ $userpath$}
   {inueofill}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |eofill| de $userpath$}
 
\longref 
   {$userpath_1$ $userpath_2$}
   {inueofill}
   {$bool$}
   {teste si les pixels dans $userpath_1$ sont dessinés par |ueofill|
   dans $userpath_2$}
 
\longref 
   {$x$ $y$}
   {instroke}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |stroke|}
 
\longref 
   {$x$ $y$ $userpath$}
   {instroke}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |ustroke| de $userpath$}
 
\longref 
   {$x$ $y$ $userpath$ $matrix$}
   {inustroke}
   {$bool$}
   {teste si le point $(x, y)$ est dessiné par |ustroke| de $userpath$}
 
\longref 
   {$userpath_1$ $userpath_2$}
   {inustroke}
   {$bool$}
   {teste si les pixels dans $userpath_1$ sont dessinés par |ustroke|
   de $userpath_2$}
 
\longref 
   {$userpath_1$ $userpath_2$ $matrix$}
   {inustroke}
   {$bool$}
   {teste si les pixels dans $userpath_1$ sont dessinés par |ustroke|
   de $userpath_2$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de formes et de motifs}
 
\syntaxe
\longref 
   {$pattern$ $matrix$}
   {makepattern}
   {$pattern$}
   {crée une instance d'un motif à partir d'un prototype}
 
\longref 
   {$comp_1$ $\dots $ $comp_n$ $pattern$}
   {setpattern}
   {$-$}
   {installe $pattern$ en tant que couleur courante}
 
\longref 
   {$form$}
   {execform}
   {$-$}
   {dessin $form$}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de configuration et de sortie du périphérique}
 
\syntaxe
\longref 
   {$-$}
   {showpage}
   {$-$}
   {transmet et réinitialise la page courante}
 
\longref 
   {$-$}
   {copypage}
   {$-$}
   {transmet la page courante}
 
\longref 
   {$dict$}
   {setpagedevice}
   {$-$}
   {installe le périphérique de sortie orienté page}
 
\longref 
   {$-$}
   {currentpagedevice}
   {$dict$}
   {renvoie les paramètres du périphérique courant de sortie de page}
 
\longref 
   {$-$}
   {nulldevice}
   {$-$}
   {installe un périphérique sans sortie}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de caractères et de polices}
 
\syntaxe
 
\longref 
   {$key$ $font$}
   {definefont}
   {$font$}
   {enregistre $font$ comme dictionnaire de police}
 
\longref 
   {$key$}
   {undefinedfont}
   {$-$}
   {supprime l'identification de police}
 
\longref 
   {$key$}
   {findfont}
   {$font$}
   {renvoie le dictionnaire de police identifié par $key$}
 
\longref 
   {$font$ $scale$}
   {scalefont}
   {$font'$}
   {met à l'échelle $font$ par $sclae$ pour produire la nouvelle $font'$}
 
\longref 
   {$font$ $matrix$}
   {makefont}
   {$font'$}
   {transforme $font$ par $matrix$ pour produire la nouvelle $font'$}
 
\longref 
   {$font$}
   {setfont}
   {$-$}
   {définit le dictionnaire de police dans l'état graphique}
 
\longref 
   {$-$}
   {currentfont}
   {$font$}
   {renvoie le dictionnaire de police courant}
 
\longref 
   {$-$}
   {rootfont}
   {$font$}
   {renvoie le dictionnaire racine d'une police composite}
 
\longref 
   {$key$ $scale/matrix$}
   {selectfont}
   {$-$}
   {définit le dictionnaire de police par son nom et le transforme}
 
\longref 
   {$string$}
   {show}
   {$-$}
   {déssine les caractères de $string$ sur la page}
 
\longref 
   {$a_x$ $a_y$ $string$}
   {ashow}
   {$-$}
   {ajoute $(a_x, a_y)$ à la largeur de tout caractère tout en
   montrant $string$}
 
\longref 
   {$c_x$ $c_y$ $char$ $string$}
   {widthshow}
   {$-$}
   {ajoute $(c_x, c_y)$ à la largeur de $char$ tout en montrant $string$}
 
\longref 
   {$c_x$ $c_y$ $char$ $a_x$ $a_y$ $string$}
   {awidthshow}
   {$-$}
   {combine les effets de |ashow| et de |widthshow|}
 
\longref 
   {$string$ $numarray/numstring$}
   {xshow}
   {$-$}
   {dessine les caractères de $string$ en utilisant les largeurs $x$
   dans $numarray/numstring$}
 
\longref 
   {$string$ $numarray/numstring$}
   {xyshow}
   {$-$}
   {dessine les caractères de $string$ en utilisant les largeurs $x$
   et $y$ dans $numarray/numstring$}
 
\longref 
   {$string$ $numarray/numstring$}
   {yshow}
   {$-$}
   {dessine les caractères de $string$ en utilisant les largeurs $y$
   dans $numarray/numstring$} 
 
\longref 
   {$name$}
   {glypshow}
   {$-$}
   {dessine les caractères identifiés par $name$}
 
\longref 
   {$string$}
   {stringwidth}
   {$w_x$ $w_y$}
   {largeur de $string$ dans la police courante}
 
\longref 
   {$proc$ $string$}
   {cshow}
   {$-$}
   {appelle l'algorithme d'affichage et appelle $proc$}
 
\longref 
   {$proc$ $string$}
   {kshow}
   {$-$}
   {exécute $proc$ entre les caractères montrés depuis $string$}
 
\longref 
   {$-$}
   {FontDirectory}
   {$dict$}
   {dictionnaire des dictionnaires de police}
 
\longref 
   {$-$}
   {GlobalFontDirectory}
   {$dict$}
   {dictionnaire des dictionnaires de police dans la VM globale}
 
\longref 
   {$-$}
   {StandardEncoding}
   {$array$}
   {vecteur d'encodage standard des polices Adobe}
 
\longref 
   {$-$}
   {ISOLatin1Encoding}
   {$array$}
   {vecteur d'encodage international ISO Latin-1 des polices}
 
\longref 
   {$key$}
   {findencoding}
   {$array$}
   {trouve le tableau d'encodage}
 
\longref 
   {$w_x$ $w_y$ $ll_x$ $ll_y$ $ur_x$ $ur_y$}
   {setcachedevice}
   {$-$}
   {déclare les mesures des caractères en cache}
 
\longref 
   {$w0_x$ $w0_y$ $ll_x$ $ll_y$ $ur_x$ $ur_y$ 
   $w1_x$ $w1_y$ $ll_x$ $ll_y$ $v_x$ $v_y$}
   {setcachedevice2}
   {$-$}
   {déclare les mesures des caractères en cache}
 
\longref 
   {$w_x$ $w_y$}
   {setcharwidth}
   {$-$}
   {déclare les mesures des caractères non mis en cache}
 
\endsyntaxe
 
\sparagraphe {Opérateurs de paramétrage de l'interpréteur}
 
\syntaxe
\longref 
   {$dict$}
   {setsystemparams}
   {$-$}
   {définit les paramètres de système pour l'interpréteur}
 
\longref 
   {$-$}
   {currentsystemparams}
   {$dict$}
   {renvoie les paramètres de système pour l'interpréteur}
 
\longref 
   {$dict$}
   {setusersparams}
   {$-$}
   {établit les paramètres de l'interpréteur par contexte}
 
\longref 
   {$-$}
   {currentusersparams}
   {$dict$}
   {renvoie les paramètres de l'interpréteur par contexte}
 
\longref 
   {$string$ $dict$}
   {setdevparams}
   {$-$}
   {définit les paramètres pour le périphérique d'entrée-sortie}
 
\longref 
   {$string$}
   {currentdevarams}
   {$dict$}
   {renvoie les paramètres du périphérique}
 
\longref 
   {$int$}
   {vmreclaim}
   {$-$}
   {contrôle le ramassage des poubelles}
 
\longref 
   {$int$}
   {setvmhreshold}
   {$-$}
   {contrôle le ramassage des poubelles}
 
\longref 
   {$-$}
   {vmstatus}
   {$level$ $used$ $maximum$}
   {rapport sur le statut de la VM}
 
\longref 
   {$-$}
   {cachestatus}
   {$bsize$ $bmax$ $msize$ $mmax$ $csize$ $cmax$ $blimit$}
   {renvoie le statut du cache de police et ses paramètres}
 
\longref 
   {$num$}
   {setcachelimit}
   {$-$}
   {définit le nombre maximum d'octets pour les caractères mis en cache}
 
\longref 
   {$mark$ $size$ $lower$ $upper$}
   {setcacheparams}
   {$-$}
   {modofie les paramètres du cache de police}
 
\longref 
   {$-$}
   {currentcacheparams}
   {$mark$ $size$ $lower$ $upper$}
   {renvoie les paramètres courant du cache de police}
 
\longref 
   {$mark$ $blimit$}
   {setucacheparams}
   {$-$}
   {définit les paramètres du cache de chemin utilisateur}
 
\longref 
   {$-$}
   {ucachestatus}
   {$mark$ $bsize$ $bmax$ $rsize$ $rmax$ $blimit$}
   {renvoie le statut du cache de chemin utilisateur et les paramètres}
 
\endsyntaxe
 
\sparagraphe {Opérateurs Display PostScript}
 
\syntaxe
\longref 
   {$-$}
   {currentcontext}
   {$context$}
   {renvoie l'identificateur du contexte courant}
 
\longref 
   {$mark$ $obj_1$ $\dots $ $obj_n$ $proc$}
   {fork}
   {$context$}
   {crée un contexte exécutant $proc$ avec $obj_1$ $\dots $ $obj_n$
   comme opérandes}
 
\longref 
   {$context$}
   {join}
   {$mark$ $obj_1$ $\dots $ $obj_n$}
   {attend la fin d'un contexte et renvoie son résultat}
 
\longref 
   {$context$}
   {detach}
   {$-$}
   {permet à un contexte de se terminer immédiatement lorsqu'il est fini}
 
\longref 
   {$-$}
   {lock}
   {$lock$}
   {crée un objet verrou}
 
\longref 
   {$lock$ $proc$}
   {monitor}
   {$-$}
   {exécute $proc$ tout en gardant $lock$}
 
\longref 
   {$-$}
   {condition}
   {$condition$}
   {crée un objet condition}
 
\longref 
   {$lock$ $condition$}
   {wait}
   {$-$}
   {relâche $lock$, attend $condition$, reprend $lock$}
 
\longref 
   {$condition$}
   {notify}
   {$-$}
   {reprend le contexte en attendant $condition$}
 
\longref 
   {$-$}
   {yield}
   {$-$}
   {met momentanément en attente dans le contexte courant}
 
\longref 
   {$index$ $name$}
   {defineusername}
   {$-$}
   {définit un index de nom encodé}
 
\longref 
   {$-$}
   {viewclip}
   {$-$}
   {définit la vue d'incrustation depuis le chemin courant}
 
\longref 
   {$-$}
   {eoviewclip}
   {$-$}
   {définit la vue d'incrustation en utilisant la règle pair-impair}
 
\longref 
   {$x$ $y$ $width$ $height$}
   {rectviewclip}
   {$-$}
   {définit un chemin rectangulaire de vue d'incrustation}
 
\longref 
   {numarray/numstring}
   {rectviewclip}
   {$-$}
   {définit des chemins rectangulaires de vue d'incrustation}
 
\longref 
   {$-$}
   {initviewclip}
   {$-$}
   {réinitialise la vue d'incrustation}
 
\longref 
   {$-$}
   {viewclippath}
   {$-$}
   {définit le chemin courant à partir de la vue d'incrustation}
 
\longref 
   {$-$}
   {deviceinfo}
   {$dict$}
   {renvoie le dictionnaire contenant les informations à propos du
   périphérique courant}
 
\longref 
   {$-$}
   {wtranslation}
   {$x$ $y$}
   {renvoie la traduction à partir de l'origine de la fenêtre vers
   l'origine de l'espace du périphérique}
 
\longref 
   {$x$ $y$}
   {sethalftonephase}
   {$-$}
   {définit la phase de simili}
 
\longref 
   {$-$}
   {currenthalftonephase}
   {$x$ $y$}
   {renvoie la phase de simili courante}
 
\endsyntaxe
 
\sparagraphe {Erreurs}
 
\syntaxe
\longref 
   {}
   {configurationerror}
   {}
   {une demande |setpagedevice| ne peut être satisfaite}
 
\longref 
   {}
   {dictfull}
   {}
   {plus de place dans le dictionnaire}
 
\longref 
   {}
   {dictstackoverflow}
   {}
   {trop de |begin|}
 
\longref 
   {}
   {dictstackunderflow}
   {}
   {trop de |end|}
 
\longref 
   {}
   {execstackoverflow}
   {}
   {imbrication trop nombreuse d'|exec|}
 
\longref 
   {}
   {handleerror}
   {}
   {appelé pour donner un rapport sur les erreurs}
 
\longref 
   {}
   {interrupt}
   {}
   {demande extérieure d'interruption}
 
\longref 
   {}
   {invalidaccess}
   {}
   {essai de violation des attributs d'accès}
 
\longref 
   {}
   {invalidcontext}
   {}
   {utilisation impropre de l'opération concernant le contexte}
 
\longref 
   {}
   {invalidexit}
   {}
   {|exit| n'est pas dans la boucle}
 
\longref 
   {}
   {invalidfileaccess}
   {}
   {chaîne d'accès onn correcte}
 
\longref 
   {}
   {invalidfont}
   {}
   {nom de police ou de dictionnaire incorrect}
 
\longref 
   {}
   {invalid}
   {}
   {identificateur invalide pour un objet externe}
 
\longref 
   {}
   {invalidrestore}
   {}
   {|restore| incorrect}
 
\longref 
   {}
   {ioerror}
   {}
   {erreur d'entrée$/$sortie}
 
\longref 
   {}
   {limitcheck}
   {}
   {dépassement des limites de l'implémentation}
 
\longref 
   {}
   {nocurrentpoint}
   {}
   {le point courant n'est pas défini}
 
\longref 
   {}
   {rangecheck}
   {}
   {opérande en dehors des limites}
 
\longref 
   {}
   {stackoverflow}
   {}
   {dépassement de capacité de la pile d'opérandes}
 
\longref 
   {}
   {stackunderflow}
   {}
   {pas assez d'opérandes dans la pile}
 
\longref 
   {}
   {syntaxerror}
   {}
   {erreur de syntaxe en PostScript}
 
\longref 
   {}
   {timeout}
   {}
   {dépassement de la limite de temps}
 
\longref 
   {}
   {typecheck}
   {}
   {opérande de mauvais type}
 
\longref 
   {}
   {undefined}
   {}
   {nom inconnu}
 
\longref 
   {}
   {undefinedfilename}
   {}
   {fichier non trouvé}
 
\longref 
   {}
   {undefinedsource}
   {}
   {instance de resssource non trouvée}
 
\longref 
   {}
   {undefinedresult}
   {}
   {résultat insuffisant, dépassant ou sans signification}
 
\longref 
   {}
   {undefinedmark}
   {}
   {marque attendue absente de la pile}
 
\longref 
   {}
   {unregistered}
   {}
   {erreur interne}
 
\longref 
   {}
   {VMerror}
   {}
   {VM épuisée}
 
\endsyntaxe