{\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