mksh - En ligne dans le Cloud

PROGRAMME:

Nom

mksh, sh — Coque MirBSD Korn

SYNOPSIS

mksh [-+abCefhiklmnprUuvXx] [-T [!]tty | -] [-+o option] [-c un magnifique | -s | filet
[argument ]]
nom-intégré [argument ]

DESCRIPTION

mksh est un interpréteur de commandes destiné à la fois à une utilisation interactive et à des scripts shell. Son
Le langage de commande est un sur-ensemble du langage shell sh(C) et largement compatible avec le
coque Korn d'origine. Parfois, cette page de manuel peut donner des conseils sur les scripts ; alors qu'il
prend parfois en compte les scripts shell portables ou diverses normes
l'information est avant tout présentée avec mksh à l'esprit et doit être considéré comme tel.

je suis an Android utilisateur, so qu'est-ce que mksh ?
mksh est un interpréteur de commandes/shell UNIX, similaire à COMMAND.COM or CMD.EXE, Qui présente
été inclus avec Android Open Source Project depuis un certain temps maintenant. En gros, c'est un programme
qui s'exécute dans un terminal (fenêtre de console), prend les entrées de l'utilisateur et exécute des commandes ou des scripts,
ce qu'il peut également être demandé par d'autres programmes, même en arrière-plan. Tout privilège
les pop-ups que vous pourriez rencontrer ne sont donc pas mksh problèmes mais des questions par d'autres
programme l'utilisant.

Invocation
La plupart des fonctions intégrées peuvent être appelées directement, par exemple si un lien pointe de son nom vers le
coquille; tous n'ont pas de sens, ont été testés ou ne fonctionnent pas du tout.

Les options sont les suivantes :

-c un magnifique mksh exécutera la ou les commandes contenues dans un magnifique.

-i Coquille interactive. Un shell qui lit les commandes à partir d'une entrée standard est
« interactif » si cette option est utilisée ou si à la fois l'entrée standard et l'erreur standard
sont attachés à un tty(4). Un shell interactif a le contrôle des tâches activé, ignore
les signaux SIGINT, SIGQUIT et SIGTERM, et imprime des invites avant de lire l'entrée
(voir les paramètres PS1 et PS2). Il traite également le paramètre ENV ou le
mkshrc fichier (voir ci-dessous). Pour les shells non interactifs, le tout suivre l'option est activée
par défaut (voir le set commande ci-dessous).

-l Shell de connexion. Si le nom de base avec lequel le shell est appelé (c'est-à-dire argv[0]) commence par
'-' ou si cette option est utilisée, le shell est supposé être un shell de connexion ; voir
Démarrage fichiers ci-dessous.

-p Coquille privilégiée. Un shell est « privilégié » si l'ID utilisateur réel ou l'ID de groupe le fait
ne correspond pas à l'ID utilisateur ou à l'ID de groupe effectif (voir getuidde Géographie (2) et avec la s'énerver(2)).
Effacer l'option privilégiée oblige le shell à définir son ID utilisateur effectif
(ID de groupe) à son véritable ID d'utilisateur (ID de groupe). Pour d'autres implications, voir Démarrage
fichiers. Si le shell est privilégié et que ce drapeau n'est pas explicitement défini, le
L'option « privilégié » est automatiquement désactivée après le traitement des fichiers de démarrage.

-r Coquille restreinte. Un shell est « restreint » si cette option est utilisée. Ce qui suit
les restrictions entrent en vigueur après que le shell ait traité tout profil et ENV
fichiers:

· La cd (Et chdir) la commande est désactivée.
· Les paramètres SHELL, ENV et PATH ne peuvent pas être modifiés.
· Les noms de commande ne peuvent pas être spécifiés avec des chemins absolus ou relatifs.
· La -p option de la commande intégrée commander ne peut pas être utilisé.
· Les redirections qui créent des fichiers ne peuvent pas être utilisées (c'est-à-dire '>', '>|', '>>', '<>').

-s Le shell lit les commandes à partir de l'entrée standard ; tous les arguments non optionnels sont
paramètres de position.

-T prénom Frayer mksh sur le tty(4) appareil donné. Les chemins prénom, /dev/ttyCname ainsi que
/dev/nom_tty sont tentés dans l'ordre. Sauf si prénom commence par un point d'exclamation
('!'), cela se fait dans un sous-shell et revient immédiatement. Si prénom est un tiret
('-'), se détacher du terminal de contrôle (démoniser) à la place.

En plus de ce qui précède, les options décrites dans le set la commande intégrée peut également être utilisée
sur la ligne de commande : les deux [-+abCefhkmnuvXx] Et [-+o option] peut être utilisé pour une seule lettre
ou des options longues, respectivement.

Si ni le -c ni l' -s option est spécifiée, le premier argument non optionnel spécifie
le nom d'un fichier à partir duquel le shell lit les commandes. S'il n'y a pas d'arguments non optionnels, le
shell lit les commandes à partir de l'entrée standard. Le nom du shell (c'est-à-dire le contenu de
0 $) est déterminé comme suit : si le -c option est utilisée et il y a un argument non-optionnel,
il est utilisé comme nom ; si les commandes sont lues à partir d'un fichier, le fichier est utilisé comme
Nom; sinon, le nom de base avec lequel le shell a été appelé (c'est-à-dire argv[0]) est utilisé.

L'état de sortie du shell est 127 si le fichier de commandes spécifié sur la ligne de commande pourrait
pas ouvert, ou différent de zéro si une erreur de syntaxe fatale s'est produite lors de l'exécution d'un
scénario. En l'absence d'erreurs fatales, le statut de sortie est celui de la dernière commande
exécuté, ou zéro, si aucune commande n'est exécutée.

Démarrage fichiers
Pour connaître l'emplacement réel de ces fichiers, consultez DES DOSSIERS. Un shell de connexion traite le système
profil d'abord. Un shell privilégié traite ensuite le profil suid. Un login non privilégié
shell traite ensuite le profil utilisateur. Un shell interactif non privilégié vérifie la valeur
du paramètre ENV après l'avoir soumis au paramètre, à la commande, à l'arithmétique et au tilde ('~')
substitution; s'il n'est pas défini ou vide, le profil utilisateur mkshrc est traité ; sinon, si un fichier
dont le nom est le résultat de la substitution existe, il est traité ; la non-existence est silencieusement
ignoré. Un shell privilégié supprime alors les privilèges si ni l'un ni l'autre n'était le -p option donnée sur le
ligne de commande ni défini lors de l'exécution des fichiers de démarrage.

Command syntaxe
Le shell commence à analyser son entrée en supprimant toutes les combinaisons backslash-newline, puis
le casser en des mots. Les mots (qui sont des séquences de caractères) sont délimités par des
caractères d'espacement (espace, tabulation et nouvelle ligne) ou méta-caractères ('<', '>', '|', ';', '(',
')', et '&'). En plus de délimiter les mots, les espaces et les tabulations sont ignorés, tandis que les sauts de ligne
délimitent généralement les commandes. Les méta-caractères sont utilisés dans la construction de ce qui suit tokens:
'<', '<&', '<<', '<<<', '>', '>&', '>>', '&>', etc. sont utilisés pour spécifier les redirections (voir
D'entrée / sortie redirection au dessous de); '|' est utilisé pour créer des pipelines ; '|&' est utilisé pour créer des co-
processus (voir Co-processus au dessous de); ';' est utilisé pour séparer les commandes ; '&' est utilisé pour créer
pipelines asynchrones ; '&&' et '||' sont utilisés pour spécifier l'exécution conditionnelle ; ';;', ';&'
et ';|' sont utilisés dans maisons déclarations; '(( .. ))' est utilisé dans les expressions arithmétiques ; et
enfin, '( .. )' est utilisé pour créer des sous-shells.

Les espaces et les méta-caractères peuvent être cités individuellement à l'aide d'une barre oblique inverse ('\'), ou dans
groupes en utilisant des guillemets doubles (""') ou simples ("'"). Notez que les caractères suivants sont
également traités spécialement par le shell et doivent être cités s'ils doivent se représenter :
'\', '"', ''', '#', '$', '`', '~', '{', '}', '*', '?' et '['. les trois premiers de ces
sont les guillemets mentionnés ci-dessus (voir Citant au dessous de); '#', s'il est utilisé au
début d'un mot, introduit un commentaire - tout après le '#' jusqu'à la plus proche
le saut de ligne est ignoré ; '$' est utilisé pour introduire le paramètre, la commande et l'arithmétique
remplacements (voir Substitution au dessous de); '`' introduit une substitution de commande à l'ancienne
(voir Substitution au dessous de); '~' commence une expansion de répertoire (voir Tilde avec des données au dessous de); '{'
et '}' délimitent csh(1) alternances de style (voir Entretoise avec des données au dessous de); et enfin, '*',
'?' et '[' sont utilisés dans la génération de nom de fichier (voir Déposez votre dernière attestation prénom motifs ci-dessous).

Au fur et à mesure que les mots et les jetons sont analysés, le shell construit des commandes, dont il existe deux
les types: commandes-simples, généralement des programmes qui sont exécutés, et commandes-composées, tel
as en ainsi que if les instructions, les constructions de regroupement et les définitions de fonctions.

Une commande simple consiste en une combinaison d'affectations de paramètres (voir Paramètres
ci-dessous), les redirections d'entrée/sortie (voir D'entrée / sortie redirections ci-dessous) et les mots de commande ;
la seule restriction est que les affectations de paramètres précèdent les mots de commande. le
les mots de commande, le cas échéant, définissent la commande à exécuter et ses arguments. le
La commande peut être une commande intégrée au shell, une fonction ou une commande externe (c'est-à-dire un
fichier exécutable situé à l'aide du paramètre PATH ; voir Command exécution ci-dessous).
Notez que toutes les constructions de commande ont un état de sortie : pour les commandes externes, cela est lié
au statut renvoyé par attendez(2) (si la commande est introuvable, l'état de sortie est
127 ; s'il n'a pas pu être exécuté, le statut de sortie est 126) ; l'état de sortie d'une autre commande
les constructions (commandes intégrées, fonctions, commandes composées, pipelines, listes, etc.) sont toutes
bien définies et sont décrites là où la construction est décrite. Le statut de sortie d'un
la commande constituée uniquement de paramétrages est celle de la dernière substitution de commande
effectuée lors du paramétrage ou 0 s'il n'y a pas eu de substitutions de commandes.

Les commandes peuvent être enchaînées à l'aide du '|' jeton pour former des pipelines, dans lesquels le
sortie standard de chaque commande mais la dernière est redirigée (voir pipe(2)) à l'entrée standard de
la commande suivante. L'état de sortie d'un pipeline est celui de sa dernière commande, sauf si
le panne de canalisation l'option est définie (voir ici). Toutes les commandes d'un pipeline sont exécutées séparément
sous-shells ; ceci est autorisé par POSIX mais diffère des deux variantes d'AT&T UNIX ksh, Où
toutes sauf la dernière commande ont été exécutées dans des sous-shells ; voir le lire description intégrée pour
implications et solutions de contournement. Un pipeline peut être préfixé par le '!' mot réservé qui
provoque le complément logique de l'état de sortie du pipeline : si l'état d'origine
était 0, le statut complété sera 1 ; si le statut d'origine n'était pas 0, le complémenté
le statut sera 0.

Liste de commandes peuvent être créés en séparant les pipelines par l'un des jetons suivants :
'&&', '||', '&', '|&' et ';'. Les deux premiers sont pour l'exécution conditionnelle : "cmd1 && cmd2 »
exécute cmd2 seulement si le statut de sortie de cmd1 est zéro; '||' est le contraire - cmd2 is
exécuté uniquement si l'état de sortie de cmd1 est non nul. '&&' et '||' ont la même priorité
qui est supérieur à celui de '&', '|&' et ';', qui ont également la même priorité. Noter
que le '&&' et '||' les opérateurs sont « associatifs à gauche ». Par exemple, ces deux
les commandes n'afficheront que "bar":

$ false && echo foo || barre d'écho
$ vrai || echo foo && echo bar

Le jeton '&' provoque l'exécution asynchrone de la commande précédente ; c'est-à-dire la coquille
lance la commande mais n'attend pas qu'elle se termine (le shell garde une trace de
état des commandes asynchrones ; voir Emploi des bactéries au dessous de). Lorsqu'une commande asynchrone est
démarré lorsque le contrôle des tâches est désactivé (c'est-à-dire dans la plupart des scripts), la commande est lancée avec
signaux SIGINT et SIGQUIT ignorés et avec entrée redirigée depuis / dev / null (toutefois,
les redirections spécifiées dans la commande asynchrone sont prioritaires). L'opérateur '|&'
démarre un co-processus qui est un type particulier de processus asynchrone (voir Co-processus
au dessous de). Notez qu'une commande doit suivre le '&&' et '||' opérateurs, alors qu'il n'est pas nécessaire
suivre '&', '|&' ou ';'. L'état de sortie d'une liste est celui de la dernière commande exécutée,
à l'exception des listes asynchrones, pour lesquelles l'état de sortie est 0.

Les commandes composées sont créées à l'aide des mots réservés suivants. Ces mots ne sont que
reconnus s'ils ne sont pas guillemets et s'ils sont utilisés comme premier mot d'une commande (c'est-à-dire
ils ne peuvent pas être précédés d'affectations de paramètres ou de redirections) :

case else fonction alors ! (
faire esac si temps [[ ((
fait fi jusqu'à {
elif pour sélectionner pendant }

Dans les descriptions de commandes composées suivantes, les listes de commandes (notées liste) qui sont
suivis de mots réservés doivent se terminer par un point-virgule, une nouvelle ligne ou un (syntaxiquement
correct) mot réservé. Par exemple, les éléments suivants sont tous valides :

$ { echo foo; barre d'écho ; }
$ { echo foo; barre d'écho }
$ { { echo foo; barre d'écho ; } }

Ce n'est pas valable :

$ { echo foo; barre d'écho }

(liste)
Exécution liste dans un sous-shell. Il n'y a aucun moyen implicite de transmettre les changements d'environnement de
un sous-shell à son parent.

{ liste; }
Construction composée ; liste est exécuté, mais pas dans un sous-shell. Notez que '{' et '}'
sont des mots réservés, pas des méta-caractères.

maisons mot dans [[(] modèle [| modèle]...) liste terminateur] ... esac
La maisons l'instruction tente de correspondre mot contre un spécifié modèle; la liste
associé au premier motif mis en correspondance avec succès est exécuté. Les modèles utilisés dans
maisons sont les mêmes que celles utilisées pour les modèles de noms de fichiers, sauf que le
restrictions concernant '.' et '/' sont supprimés. Notez que tout espace sans guillemets avant
et après qu'un motif soit dépouillé ; tout espace dans un motif doit être entre guillemets. Les deux
mot et les modèles sont soumis à des paramètres, des commandes et des substitutions arithmétiques,
ainsi que la substitution de tilde.

Pour des raisons historiques, des accolades ouvertes et fermées peuvent être utilisées au lieu de in ainsi que Esac par exemple
maisons $foo { *) echo barre ;; }.

La liste terminateurS sont:

';;' Terminez après la liste.

';&' Passe à la liste suivante.

';|' Évaluez les tuples de la liste de modèles restants.

Le statut de sortie d'un maisons déclaration est celle de l'exécuté liste; sinon liste is
exécuté, l'état de sortie est zéro.

en prénom [dans mot ...] ; faire liste; terminé
Pour chaque mot dans la liste de mots spécifiée, le paramètre prénom est réglé sur le mot et
liste est exécuté. Si in n'est pas utilisé pour spécifier une liste de mots, les paramètres de position
(1 $, 2 $, etc.) sont utilisés à la place. Pour des raisons historiques, les accolades ouvertes et fermées peuvent être
utilisé à la place de do ainsi que fait par exemple en i; { echo $i ; }. Le statut de sortie d'un en
l'instruction est le dernier état de sortie de liste; si liste n'est jamais exécuté, l'état de sortie
est zéro.

if liste; puis liste; [elif liste; puis liste;] ... [autre liste;] Fi
Si l'état de sortie du premier liste est zéro, le deuxième liste est exécuté; autrement,
le liste après l' Elif, le cas échéant, est exécuté avec des conséquences similaires. Je tombe
les listes suivant le if ainsi que Elifs fail (c'est-à-dire sortie avec un statut différent de zéro), le liste
après l' d'autre est exécuté. Le statut de sortie d'un if l'énoncé est celui de non-
conditionnels. liste qui est exécuté ; si non non conditionnel liste est exécuté, la sortie
le statut est zéro.

Sélectionner prénom [dans mot ...] ; faire liste; terminé
La Sélectionner l'instruction fournit une méthode automatique pour présenter à l'utilisateur un menu
et en sélectionnant à partir de celui-ci. Une liste énumérée des spécifiés mot(s) est imprimé sur
erreur standard, suivie d'une invite (PS3 : normalement « # ? »). Un nombre correspondant à
l'un des mots énumérés est alors lu depuis l'entrée standard, prénom est réglé sur la
mot sélectionné (ou désactivé si la sélection n'est pas valide), REPLY est défini sur ce qui a été lu
(l'espace de début/de fin est supprimé), et liste est exécuté. Si une ligne vide (c'est-à-dire
zéro ou plusieurs octets IFS) est entré, le menu est réimprimé sans exécuter liste.

Quand liste se termine, la liste énumérée est imprimée si REPLY est NULL, l'invite est
imprimé, et ainsi de suite. Ce processus se poursuit jusqu'à ce qu'une fin de fichier soit lue, une interruption
est reçu, ou un pause L'instruction est exécutée à l'intérieur de la boucle. Si "en mots..." est
omis, les paramètres positionnels sont utilisés (c'est-à-dire $1, $2, etc.). Pour l'historique
raisons, des accolades ouvertes et fermées peuvent être utilisées au lieu de do ainsi que fait par exemple Sélectionner i; {
echo $i ; }. Le statut de sortie d'un Sélectionner l'instruction vaut zéro si un pause la déclaration est
utilisé pour sortir de la boucle, différent de zéro sinon.

jusqu'à liste; fais liste; terminé
Cela fonctionne comme tout en, sauf que le corps n'est exécuté que lorsque l'état de sortie de
le premier liste est non nul.

tout en liste; fais liste; terminé
A tout en est une boucle pré-vérifiée. Son corps est exécuté aussi souvent que l'état de sortie de
le premier liste est zéro. Le statut de sortie d'un tout en l'instruction est le dernier état de sortie
des liste dans le corps de la boucle ; si le corps n'est pas exécuté, le statut de sortie est
zéro.

fonction prénom { liste; }
Définit la fonction prénom (voir Les fonctions au dessous de). Notez que les redirections spécifiées
après une définition de fonction sont exécutées chaque fois que la fonction est exécutée, pas quand
la définition de la fonction est exécutée.

prénom() commander
Surtout la même chose que fonction (voir Les fonctions au dessous de). Espace (espace ou tabulation) après
prénom sera ignoré la plupart du temps.

fonction prénom() { liste; }
Le même que prénom() (bashisme). le fonction le mot-clé est ignoré.

fiable [-p] [pipeline]
La Command exécution la section décrit le fiable mot reservé.

(( expression ))
L'expression arithmétique expression est évalué ; équivalent à « let expression » (voir
Arithmétique expressions et par laisser commande, ci-dessous) dans une construction composée.

[[ expression ]]
Semblable à la tester ainsi que [ ] commandes (décrites plus loin), avec les
des exceptions:

· Le fractionnement de champ et la génération de nom de fichier ne sont pas effectués sur les arguments.

· La -a (Et et -o Les opérateurs (OR) sont remplacés par '&&' et '||', respectivement.

· Opérateurs (par exemple '-f', '=', '!') doivent être sans guillemets.

· Les substitutions de paramètres, de commandes et arithmétiques sont effectuées au fur et à mesure que les expressions sont
L'évaluation d'expression évaluée et paresseuse est utilisée pour le '&&' et '||' les opérateurs.
Cela signifie que dans l'énoncé suivant, $( est évalué si et seulement si
le fichier foo existe et est lisible :

$ [[ -r foo && $(

· Le deuxième opérande des expressions '!=' et '=' est un sous-ensemble de modèles (par exemple
La comparaison [[ Foobar = f * r ]] réussit). Cela fonctionne même indirectement :

$ bar=foobar; baz='f*r'
$ [[ $bar = $baz ]] ; écho $?
$ [[ $bar = "$baz" ]] ; écho $?

Étonnamment peut-être, la première comparaison réussit, alors que la seconde ne réussit pas.
Cela ne s'applique pas à tous les métacaractères extglob, actuellement.

Citant
Les guillemets sont utilisés pour empêcher le shell de traiter spécialement les caractères ou les mots. Il y a
trois méthodes de citation. Tout d'abord, '\' cite le caractère suivant, sauf s'il se trouve à la
fin de ligne, auquel cas le '\' et le saut de ligne sont supprimés. Deuxièmement, un seul
quote ("'") cite tout jusqu'au prochain apostrophe (cela peut s'étendre sur plusieurs lignes). Troisièmement, un
guillemets doubles ('"') cite tous les caractères, sauf '$', '`' et '\', jusqu'au prochain sans échappement
double citation. '$' et '`' entre guillemets ont leur signification habituelle (c'est-à-dire paramètre,
arithmétique ou substitution de commande) sauf qu'aucun découpage de champ n'est effectué sur les résultats
de substitutions entre guillemets doubles, et la forme à l'ancienne de substitution de commandes a
backslash-quoting pour les guillemets doubles activés. Si un '\' à l'intérieur d'une chaîne entre guillemets est
suivi de '\', '$', '`', ou '"', il est remplacé par le deuxième caractère ; s'il est suivi
par un saut de ligne, le '\' et le saut de ligne sont supprimés ; sinon, le '\' et le
les caractères suivants sont inchangés.

Si une chaîne entre guillemets simples est précédée d'un '$' sans guillemets, l'expansion de la barre oblique inverse de style C (voir
ci-dessous) est appliqué (même les guillemets simples à l'intérieur peuvent être échappés et ne se terminent pas
la chaîne alors); le résultat développé est traité comme n'importe quelle autre chaîne entre guillemets simples. Si un
La chaîne entre guillemets est précédée d'un '$' sans guillemets, le '$' est simplement ignoré.

Barre oblique inverse avec des données
Dans les endroits où les barres obliques inverses sont étendues, certains C et AT&T UNIX ksh ou GNU bash Catégorie
les évasions sont traduites. Ceux-ci incluent '\a', '\b', '\f', '\n', '\r', '\t', '\U########',
'\u####', et '\v'. Pour '\U########' et '\u####', "#" signifie un chiffre hexadécimal, de
il peut n'y en avoir aucun jusqu'à quatre ou huit ; ces échappements traduisent un point de code Unicode en UTF-8.
De plus, '\E' et '\e' se développent jusqu'au caractère d'échappement.

Dans le impression mode intégré, '\"', '\'' et '\?' sont explicitement exclus ; les séquences octales
doit avoir aucun jusqu'à trois chiffres octaux « # » précédés du chiffre zéro (« \0### » );
les séquences hexadécimales '\x##' sont limitées à aucune jusqu'à deux chiffres hexadécimaux "#" ; les deux
les séquences octales et hexadécimales sont converties en octets bruts ; '\#', où # n'est rien de ce qui précède,
se traduit par \# (les barres obliques inverses sont conservées).

L'expansion de la barre oblique inverse dans le mode de style C diffère légèrement : les séquences octales '\###' doivent avoir
aucun chiffre zéro préfixant l'un jusqu'à trois chiffres octaux « # » et donne des octets bruts ;
les séquences hexadécimales « \x#* » consomment avidement autant de chiffres hexadécimaux « # » que possible et
terminer par le premier chiffre non hexadécimal ; ceux-ci traduisent un point de code Unicode en
UTF-8. La séquence '\c#', où "#" est n'importe quel octet, se traduit par Ctrl-# (qui fondamentalement
signifie '\c?' devient DEL, tout le reste est AND au niveau du bit avec 0x1F). Enfin, '\#', où
# n'est rien de ce qui précède, se traduit par # (a la barre oblique inverse coupée), même s'il s'agit d'un
nouvelle ligne.

Alias
Il existe deux types d'alias : les alias de commande normaux et les alias suivis. Alias ​​de commande
sont normalement utilisés comme une main courte pour une commande longue ou souvent utilisée. La coquille se dilate
alias de commande (c'est-à-dire substitue le nom d'alias à sa valeur) lorsqu'elle lit le premier mot
d'une commande. Un alias étendu est à nouveau traité pour rechercher d'autres alias. Si une commande
alias se termine par un espace ou une tabulation, le mot suivant est également vérifié pour l'expansion de l'alias. le
le processus d'expansion d'alias s'arrête lorsqu'un mot qui n'est pas un alias est trouvé, lorsqu'un mot entre guillemets
est trouvé ou lorsqu'un alias en cours de développement est trouvé. Les alias sont
spécifiquement une fonctionnalité interactive : bien qu'ils fonctionnent dans les scripts et sur le
ligne de commande dans certains cas, les alias sont étendus pendant le lexing, donc leur utilisation doit être dans un
séparer l'arbre de commande de leur définition ; sinon, l'alias ne sera pas trouvé.
Notamment, les listes de commandes (séparées par un point-virgule, dans les substitutions de commandes également par une nouvelle ligne)
peut être un même arbre d'analyse.

Les alias de commandes suivants sont définis automatiquement par le shell :

autoload='\typeset -fu'
fonctions='\typeset -f'
hash='\alias intégré -t'
history='\builtin fc -l'
entier='\typeset -i'
local='\typeset'
login='\exec login'
nameref='\typeset -n'
nohup='nohup'
r='\builtin fc -e -'
type='\builtin d'où -v'

Les alias suivis permettent au shell de se souvenir où il a trouvé une commande particulière. La première
fois que le shell effectue une recherche de chemin pour une commande qui est marquée comme un alias suivi, il enregistre
le chemin complet de la commande. La prochaine fois que la commande est exécutée, le shell vérifie le
chemin enregistré pour voir qu'il est toujours valide, et si c'est le cas, évite de répéter la recherche de chemin.
Les alias suivis peuvent être répertoriés et créés à l'aide de alias -t. Notez que changer le PATH
Le paramètre efface les chemins enregistrés pour tous les alias suivis. Si la tout suivre l'option est définie
(c'est à dire set -o tout suivre or set -h), le shell suit toutes les commandes. Cette option est définie
automatiquement pour les shells non interactifs. Pour les shells interactifs, seuls les éléments suivants
les commandes sont automatiquement suivies : cat(1), cc(1), chmod(1), cp(1), données(1), ed(1),
emacs(1), grep(1), ls(1), faire(1), mv(1), pr(1), rm(1), sed(1), sh(1), vi(1), et pour qui (1).

Substitution
La première étape du shell dans l'exécution d'une commande simple consiste à effectuer des substitutions sur
les mots de la commande. Il existe trois types de substitution : paramètre, commande et
arithmétique. Les substitutions de paramètres, qui sont décrites en détail dans la section suivante,
prendre la forme $prénom ou ${ } ; les substitutions de commandes prennent la forme $(commander) ou
(obsolète) `commander` ou (exécuté dans l'environnement courant) ${ commander;} et dépouiller
les nouvelles lignes de fin ; et les substitutions arithmétiques prennent la forme $((expression)). Analyser le
la substitution de commande de l'environnement actuel nécessite un espace, une tabulation ou une nouvelle ligne après l'ouverture
accolade et que l'accolade fermante soit reconnue comme un mot-clé (c'est-à-dire qu'elle soit précédée d'un saut de ligne
ou point-virgule). Ils sont également appelés funsubs (substitutions de fonction) et se comportent comme
fonctions dans ce locales ainsi que retourner travail, et en cela sortie termine le shell parent ; coquille
les options sont partagées.

Une autre variante de substitution sont les valsubs (substitutions de valeur) ${|commander;} qui sont
également exécutés dans l'environnement actuel, comme les funsubs, mais partagent leurs E/S avec le parent ;
au lieu de cela, ils évaluent quelle que soit la variable locale d'expression, initialement vide, REPLY.
mis à l'intérieur du commanders.

Si une substitution apparaît en dehors des guillemets doubles, les résultats de la substitution sont
généralement soumis à un fractionnement de mots ou de champs en fonction de la valeur actuelle de l'IFS
paramètre. Le paramètre IFS spécifie une liste d'octets qui sont utilisés pour séparer une chaîne
en plusieurs mots ; tous les octets de l'espace défini, de la tabulation et de la nouvelle ligne qui apparaissent dans l'IFS
les octets sont appelés « espaces blancs IFS ». Séquences d'un ou plusieurs octets d'espace blanc IFS, en
combinaison avec zéro ou un octet d'espace blanc non IFS, délimite un champ. Comme cas particulier,
Les espaces blancs IFS de début et de fin sont supprimés (c'est-à-dire qu'aucun champ vide de début ou de fin n'est
créé par celui-ci); Les espaces blancs non IFS de début ou de fin créent un champ vide.

Exemple : si IFS est défini sur « :", et VAR est réglé sur
" UNE : B::D", la substitution de $VAR donne quatre champs : 'A',
'B', '' (un champ vide) et 'D'. Notez que si le paramètre IFS est défini sur la valeur vide
chaîne, aucune division de champ n'est effectuée ; s'il n'est pas défini, la valeur par défaut de l'espace, de la tabulation et
la nouvelle ligne est utilisée.

Notez également que le fractionnement des champs ne s'applique qu'au résultat immédiat de la
substitution. En utilisant l'exemple précédent, la substitution de $VAR:E entraîne le
champs : 'A', 'B', '' et 'D:E', pas 'A', 'B', '', 'D' et 'E'. Ce comportement est POSIX
conforme, mais incompatible avec d'autres implémentations shell qui effectuent le fractionnement de champ
sur le mot qui contenait la substitution ou utilisez IFS comme délimiteur général d'espaces.

Les résultats de la substitution sont, sauf indication contraire, également soumis à l'expansion de l'attelle
et l'extension du nom de fichier (voir les sections pertinentes ci-dessous).

Une substitution de commande est remplacée par la sortie générée par la commande spécifiée qui est
exécuter dans un sous-shell. Pour $(commander) et ${|commander;} et ${ commander;} substitutions, normales
les règles de citation sont utilisées lorsque commander est analysé ; cependant, pour les obsolètes `commander` forme, un
'\' suivi de l'un des '$', '`' ou '\' est supprimé (comme l'est '"' lorsque la substitution fait partie
d'une chaîne entre guillemets) ; une barre oblique inverse '\' suivie de tout autre caractère est inchangée.
Comme cas particulier dans les substitutions de commandes, une commande de la formefilet est interprété comme
signifie remplacer le contenu de filet. Noter que $( a le même effet que $(chat fou).

Notez que certains shells n'utilisent pas d'analyseur récursif pour les substitutions de commandes, ce qui conduit à
échec pour certaines constructions; pour être portable, utilisez comme solution de contournement 'x=$(cat) <<"EOF"' (ou le
extension 'x=<<"EOF"' en gardant la nouvelle ligne) au lieu de simplement avaler la chaîne. Norme IEEE 1003.1
("POSIX.1") recommande d'utiliser les instructions case de la forme 'x=$(case $foo in (bar) echo $bar
;; (*) echo $baz ;; esac)' à la place, ce qui fonctionnerait mais ne servirait pas d'exemple pour cela
problème de portabilité.

x=$(case $foo in bar) echo $bar ;; *) echo $baz ;; esac)
# ci-dessus ne parvient pas à analyser les anciens shells ; ci-dessous est la solution de contournement
x=$(eval $(cat)) <<"EOF"
case $foo dans bar) echo $bar ;; *) echo $baz ;; esac
EOF

Les substitutions arithmétiques sont remplacées par la valeur de l'expression spécifiée. Pour
exemple, la commande impression $((2+3*4)) affiche 14. Voir Arithmétique expressions pour
description d'une expression.

Paramètres
Les paramètres sont des variables shell ; on peut leur attribuer des valeurs et leurs valeurs sont accessibles
en utilisant une substitution de paramètre. Un nom de paramètre est soit l'un des
paramètres de ponctuation ou de caractère numérique décrits ci-dessous, ou une lettre suivie de zéro ou
plus de lettres ou de chiffres ('_' compte comme une lettre). Cette dernière forme peut être traitée comme des tableaux
en ajoutant un index de tableau de la forme [expr] où expr est une expression arithmétique.
Index de tableau dans mksh sont limités à la plage 0 à 4294967295, inclus. C'est-à-dire,
il s'agit d'un entier non signé de 32 bits.

Les substitutions de paramètres prennent la forme $prénom, ${prénom}, ou ${prénom[expr]} où prénom est une
le nom du paramètre. Substitution de tous les éléments du tableau par ${prénom[*]} et ${prénom[@]} travaux
équivalent à $* et $@ pour les paramètres positionnels. Si la substitution est effectuée sur un
paramètre (ou un élément de paramètre de tableau) qui n'est pas défini, une chaîne nulle est substituée
à moins que le nom Option (set -o nom or set -u) est défini, auquel cas une erreur se produit.

Les paramètres peuvent recevoir des valeurs de plusieurs manières. Premièrement, le shell définit implicitement
certains paramètres comme '#', 'PWD' et '$' ; c'est la seule façon dont le caractère unique spécial
les paramètres sont définis. Deuxièmement, les paramètres sont importés de l'environnement du shell à
Commencez. Troisièmement, les paramètres peuvent se voir attribuer des valeurs sur la ligne de commande : par exemple, FOO=barre
règle le paramètre « FOO » sur « bar » ; plusieurs affectations de paramètres peuvent être données sur un seul
ligne de commande et ils peuvent être suivis d'une simple commande, auquel cas les affectations sont
en vigueur uniquement pendant la durée de la commande (ces affectations sont également exportées ; voir
ci-dessous pour les implications de cela). Notez que le nom du paramètre et le '=" doivent être
sans guillemets pour que le shell reconnaisse une affectation de paramètre. La construction FOO+=baz est également
reconnu; les anciennes et nouvelles valeurs sont immédiatement concaténées. La quatrième façon de régler
un paramètre est avec le Exporter, de défis, lecture seulementet composer commandes ; voir leur
descriptifs dans le Command exécution section. Cinquième, en ainsi que Sélectionner les boucles définissent les paramètres
la getops, lireet set -A commandes. Enfin, des paramètres peuvent être affectés
valeurs utilisant des opérateurs d'affectation à l'intérieur d'expressions arithmétiques (voir Arithmétique expressions
ci-dessous) ou en utilisant le ${prénom=Plus-value} forme de la substitution de paramètre (voir ci-dessous).

Les paramètres avec l'attribut export (définis à l'aide de la Exporter or composer -x commandes, ou par
paramétrages suivis de commandes simples) sont mis dans l'environnement (voir
environ(7)) des commandes exécutées par le shell comme prénom=Plus-value paires. L'ordre dans lequel les paramètres
apparaître dans l'environnement d'une commande est quelconque. Lorsque le shell démarre, il
extrait les paramètres et leurs valeurs de son environnement et définit automatiquement l'export
attribut pour ces paramètres.

Des modificateurs peuvent être appliqués au ${prénom} forme de substitution de paramètre :

${prénom:-mot}
If prénom est défini et non NULL, il est substitué ; autrement, mot est remplacé.

${prénom:+mot}
If prénom est défini et non NULL, mot est substitué ; sinon, rien n'est substitué.

${prénom:=mot}
If prénom est défini et non NULL, il est substitué ; sinon, il est attribué mot ainsi que
la valeur résultante de prénom est remplacé.

${prénom:?mot}
If prénom est défini et non NULL, il est substitué ; autrement, mot est imprimé sur
erreur standard (précédée par prénom:) et une erreur se produit (provoquant normalement la résiliation
d'un script shell, d'une fonction ou d'un script obtenu à l'aide du '.' intégré). Si mot is
omis, la chaîne « paramètre nul ou non défini » est utilisée à la place. Actuellement un bug,
if mot est une variable qui se développe en chaîne nulle, le message d'erreur est également
imprimé.

Notez que, pour tout ce qui précède, mot est en fait considéré comme entre guillemets, et une analyse spéciale
les règles s'appliquent. Les règles d'analyse diffèrent également selon que l'expression est entre guillemets : mot
utilise ensuite des règles de guillemets doubles, à l'exception du guillemet double lui-même ('"') et de la fermeture
accolade, qui, si la barre oblique inverse est échappée, la suppression des guillemets est appliquée.

Dans les modificateurs ci-dessus, le ':' peut être omis, auquel cas les conditions ne dépendent que de
prénom étant défini (par opposition à défini et non NULL). Si mot est nécessaire, paramètre, commande,
l'arithmétique et la substitution de tilde y sont effectuées ; si mot n'est pas nécessaire, ce n'est pas
évalué.

Les formes suivantes de substitution de paramètres peuvent également être utilisées (si prénom est un tableau, le
élément avec la clé « 0 » sera substitué dans le contexte scalaire):

${#prénom}
Le nombre de paramètres de position si prénom est '*', '@', ou non spécifié ; autrement
la longueur (en caractères) de la valeur de chaîne du paramètre prénom.

${#prénom[*]}
${#prénom[@]}
Le nombre d'éléments dans le tableau prénom.

${%prénom}
La largeur (en colonnes d'écran) de la valeur de chaîne du paramètre prénom, ou -1 si
${prénom} contient un caractère de contrôle.

${ !prénom}
Le nom de la variable référencée par prénom. Ce sera prénom sauf quand prénom is
une référence de nom (variable liée), créée par le nomref commande (qui est un alias
en composer -n).

${ !prénom[*]}
${ !prénom[@]}
Les noms des indices (clés) dans le tableau prénom.

${prénom#modèle}
${prénom##modèle}
If modèle correspond au début de la valeur du paramètre prénom, le texte correspondant est
supprimé du résultat de la substitution. Un seul '#' donne le plus court
match, et deux d'entre eux donnent le match le plus long. Ne peut pas être appliqué à un vecteur
(${*} ou ${@} ou ${array[*]} ou ${array[@]}).

${prénom%modèle}
${prénom%%modèle}
Comme la substitution ${..#..}, mais elle supprime à partir de la fin de la valeur. C'est pas possible
appliqué à un vecteur.

${prénom/motif/chaîne}
${prénom/#motif/chaîne}
${prénom/%motif/chaîne}
${prénom//motif/chaîne}
Le match le plus long de modèle dans la valeur du paramètre prénom est remplacé par un magnifique
(supprimé si un magnifique est vide; la barre oblique ('/') peut être omise dans ce cas).
Une barre oblique suivie de '#' ou '%' provoque l'ancrage du motif à la
le début ou la fin de la valeur, respectivement ; vide sans ancrage modèles cause non
remplacement; une seule barre oblique ou l'utilisation d'un modèle qui correspond au vide
string provoque le remplacement une seule fois ; deux barres obliques provoquent tout
occurrences de correspondances dans la valeur à remplacer. Ne peut pas être appliqué à un vecteur.
Inefficacement mis en œuvre, peut être lent.

${prénom:poster:len}
La première len personnages de prénom, en commençant à la position poster, sont substitués. Les deux
poster et:len sont facultatifs. Si poster est négatif, le comptage commence à la fin du
chaîne de caractères; s'il est omis, la valeur par défaut est 0. Si len est omis ou supérieur à la
longueur de la chaîne restante, tout est substitué. Les deux poster ainsi que len
évalués comme des expressions arithmétiques. Actuellement, poster doit commencer par un espace,
parenthèse ouvrante ou chiffre à reconnaître. Ne peut pas être appliqué à un vecteur.

${prénom@#}
Le hachage (en utilisant l'algorithme BAFH) de l'expansion de prénom. Ceci est également utilisé
en interne pour les tables de hachage du shell.

${prénom@Q}
Une expression entre guillemets sûre pour la ré-entrée, dont la valeur est la valeur du prénom
paramètre, est substitué.

Notez que modèle peut nécessiter un motif de globalisation étendu (@(...)), simple ('...') ou double
("...") guillemet s'échappant à moins que -o sh est réglé.

Les paramètres spéciaux suivants sont définis implicitement par le shell et ne peuvent pas être définis directement
à l'aide des devoirs :

! ID de processus du dernier processus d'arrière-plan démarré. Si aucun processus d'arrière-plan n'a
démarré, le paramètre n'est pas défini.

# Le nombre de paramètres positionnels (1 $, 2 $, etc.).

$ Le PID du shell, ou le PID du shell d'origine s'il s'agit d'un sous-shell. Faire ne pas
utiliser ce mécanisme pour générer des noms de fichiers temporaires ; voir mktemp(1) à la place.

- La concaténation des options actuelles à une seule lettre (voir le set commande ci-dessous
pour une liste d'options).

? L'état de sortie de la dernière commande non asynchrone exécutée. Si la dernière commande
a été tué par un signal, $? est réglé sur 128 plus le numéro de signal, mais au plus 255.

0 Le nom du shell, déterminé comme suit : le premier argument de mksh si c'était
invoqué avec le -c l'option et les arguments ont été donnés ; sinon le filet argument, si
il a été fourni ; ou bien le nom de base avec lequel le shell a été invoqué (c'est-à-dire argv[0]). 0 $
est également défini sur le nom du script en cours ou le nom de la fonction en cours,
s'il était défini avec le fonction mot-clé (c'est-à-dire une fonction de style shell Korn).

1 .. 9 Les neuf premiers paramètres de position qui ont été fournis au shell, à la fonction ou
script sourcé en utilisant le '.' intégré. D'autres paramètres de position peuvent être
accédé à l'aide de ${nombre}.

* Tous les paramètres positionnels (sauf 0), c'est-à-dire $1, $2, $3, ...
S'ils sont utilisés en dehors des guillemets, les paramètres sont des mots séparés (qui sont soumis
au fractionnement de mots); s'ils sont utilisés entre guillemets, les paramètres sont séparés par le
premier caractère du paramètre IFS (ou la chaîne vide si IFS est NULL).

@ Pareil que $*, sauf s'il est utilisé entre guillemets doubles, auquel cas un mot séparé est
généré pour chaque paramètre de position. S'il n'y a pas de paramètres de position, aucun
mot est généré. $@ peut être utilisé pour accéder aux arguments, textuellement, sans perdre
Arguments NULL ou fractionnement d'arguments avec des espaces.

Les paramètres suivants sont définis et/ou utilisés par le shell :

_ (trait de soulignement) Lorsqu'une commande externe est exécutée par le shell, ce paramètre
est défini dans l'environnement du nouveau processus sur le chemin de l'exécuté
commander. En utilisation interactive, ce paramètre est également défini dans le shell parent pour
le dernier mot de la commande précédente.

BASHPID Le PID du shell ou du sous-shell.

CDPATH Comme PATH, mais utilisé pour résoudre l'argument en cd commande intégrée. Noter
que si CDPATH est défini et ne contient pas '.' ou un élément de chaîne vide, le
le répertoire actuel n'est pas recherché. Également cd la commande intégrée affichera
le répertoire résultant lorsqu'une correspondance est trouvée dans un chemin de recherche autre que le
chemin vide.

COLUMNS Définit le nombre de colonnes sur le terminal ou la fenêtre. Toujours défini, valeurs par défaut
à 80, à moins que la valeur indiquée par Sty(1) est différent de zéro et suffisamment sain d'esprit
(le minimum est de 12x3) ; similaire pour les LIGNES. Ce paramètre est utilisé par le
modes d'édition de ligne interactifs, et par le Sélectionner, set -oet tuer -l commandes
pour formater les colonnes d'informations. Importation depuis l'environnement ou désactivation
ce paramètre supprime la liaison à la taille réelle du terminal en faveur de la
valeur fournie.

ENV Si ce paramètre est défini après l'exécution de fichiers de profil, le
la valeur étendue est utilisée comme fichier de démarrage du shell. Il contient généralement la fonction
et des définitions d'alias.

ERRNO Valeur entière du shell errno variable. Il indique la raison pour laquelle le dernier
l'appel système a échoué. Pas encore implémenté.

EXECSHELL S'il est défini, ce paramètre est supposé contenir le shell qui doit être utilisé pour
exécuter des commandes qui executif(2) ne s'exécute pas et qui ne commencent pas par un
« # !coquille" séquence.

FCEDIT L'éditeur utilisé par le fc commande (voir ci-dessous).

FPATH Comme PATH, mais utilisé lorsqu'une fonction non définie est exécutée pour localiser le fichier
définir la fonction. Il est également recherché lorsqu'une commande ne peut pas être trouvée en utilisant
CHEMIN. Voir Les fonctions ci-dessous pour plus d'informations.

HISTFILE Le nom du fichier utilisé pour stocker l'historique des commandes. Lorsqu'il est affecté ou désactivé,
le fichier est ouvert, l'historique est tronqué puis chargé à partir du fichier ; subséquent
les nouvelles commandes (éventuellement constituées de plusieurs lignes) sont ajoutées une fois qu'elles
compilé avec succès. De plus, plusieurs invocations du shell partageront
history si leurs paramètres HISTFILE pointent tous vers le même fichier.

Notes: Si HISTFILE n'est pas défini ou est vide, aucun fichier d'historique n'est utilisé. C'est
différent d'AT&T UNIX ksh.

HITSIZE Le nombre de commandes normalement stockées pour l'historique. La valeur par défaut est 2047. Ne
ne définissez pas cette valeur sur des valeurs incroyablement élevées telles que 1000000000 car mksh vous
alors pas assez de mémoire pour l'historique et ne démarrera pas.

HOME Le répertoire par défaut du cd commande et la valeur substituée à un
sans réserve ~ (voir Tilde avec des données ci-dessous).

IFS Séparateur de champs interne, utilisé lors de la substitution et par le lire commande, à
diviser les valeurs en arguments distincts ; normalement défini sur espace, tabulation et saut de ligne.
See Substitution ci-dessus pour plus de détails.

Notes: Ce paramètre n'est pas importé de l'environnement lorsque le shell est
commencé.

KSHEGID L'identifiant de groupe effectif du shell.

KSHGID Le véritable identifiant de groupe du shell.

KSHUID Le véritable identifiant utilisateur du shell.

KSH_VERSION Le nom et la version du shell (lecture seule). Voir aussi les commandes de version
in Emacs édition mode ainsi que Vi édition mode sections, ci-dessous.

LINENO Le numéro de ligne de la fonction ou du script shell en cours d'exécution
réalisé.

LINES Définit le nombre de lignes sur le terminal ou la fenêtre. Toujours défini, la valeur par défaut est
24. Voir COLONNES.

EPOCHRÉALTIME
Temps depuis l'époque, tel que renvoyé par obtenir l'heure du jour(2), formaté en décimal
tv_sec suivi d'un point ('.') et tv_usec rembourré à exactement six décimales
chiffres.

OLDPWD Le répertoire de travail précédent. Désactivé si cd n'a pas été modifié avec succès
répertoires depuis le démarrage du shell, ou si le shell ne sait pas où il se trouve.

OPTARG Lors de l'utilisation getops, il contient l'argument d'une option analysée, s'il
en nécessite un.

OPTIND L'index du prochain argument à traiter lors de l'utilisation getops. Attribuer 1
à ce paramètre provoque getops traiter les arguments depuis le début
la prochaine fois qu'il est invoqué.

PATH Une liste séparée par deux points (point-virgule sur OS/2) des répertoires recherchés
lors de la recherche de commandes et de fichiers sourcés à l'aide du '.' commande (voir ci-dessous).
Une chaîne vide résultant d'un deux-points de début ou de fin, ou de deux
deux-points, est traité comme un '.' (le répertoire courant).

PGRP L'ID de processus du chef de groupe de processus du shell.

PIPESTATUS Un tableau contenant les codes de niveau d'erreur (état de sortie), un par un, du dernier
pipeline exécuté au premier plan.

PPID L'ID de processus du parent du shell.

PS1 L'invite principale pour les shells interactifs. Paramètre, commande et arithmétique
les substitutions sont effectuées, et '!' est remplacé par la commande actuelle
numéro (voir le fc commande ci-dessous). Un '!' littéral peut être mis dans l'invite par
placer '!!' sur PS1.

L'invite par défaut est '$ ' pour les utilisateurs non root, '# ' pour root. Si mksh is
invoqué par root et PS1 ne contient pas de caractère '#', la valeur par défaut
sera utilisé même si PS1 existe déjà dans l'environnement.

La mksh la distribution est livrée avec un échantillon point.mkshrc contenant un sophistiqué
exemple, mais vous pourriez aimer le suivant (notez que
${HOSTNAME:=$(hostname)} et la clause de distinction root-vs-user sont (dans
cet exemple) exécuté au moment de l'affectation PS1, tandis que $USER et $PWD sont
échappé et sera donc évalué à chaque fois qu'une invite est affichée):

PS1='${USER:=$(id -un)}'"@${HOSTNAME:=$(hostname)}:\$PWD $(
si (( USER_ID )); puis imprimez \$; sinon imprimer \#; Fi) "

Notez que puisque les éditeurs de ligne de commande essaient de déterminer combien de temps l'invite
est (pour qu'ils sachent à quelle distance il se trouve du bord de l'écran), les codes d'échappement dans le
invite ont tendance à gâcher les choses. Vous pouvez dire au shell de ne pas compter certains
séquences (telles que les codes d'échappement) en préfixant votre invite avec un caractère
(comme Ctrl-A) suivi d'un retour chariot, puis délimitant l'échappement
codes avec ce caractère. Toutes les occurrences de ce caractère dans l'invite sont
pas imprimé. Au fait, ne me blâmez pas pour ce hack ; il est dérivé du
original 88 XNUMX ksh(1), qui a imprimé le caractère délimiteur de sorte que vous étiez hors de
chance si vous n'aviez pas de caractères non imprimables.

Étant donné que les barres obliques inverses et autres caractères spéciaux peuvent être interprétés par le shell,
pour définir PS1, échappez la barre oblique inverse elle-même ou utilisez des guillemets doubles. le
ce dernier est plus pratique. Il s'agit d'un exemple plus complexe, évitant de
saisir des caractères spéciaux (par exemple avec ^V en mode édition d'emacs), qui
embarque le répertoire de travail courant, en vidéo inverse (la couleur fonctionnerait,
aussi), dans la chaîne d'invite :

x=$(imprimer \\001)
PS1="$x$(print \\r)$x$(tput so)$x\$PWD$x$(tput se)$x> "

Suite à une forte suggestion de David G. Korn, mksh prend désormais en charge également le
forme suivante :

PS1=$'\1\r\1\e[7m\1$PWD\1\e[0m\1> '

Chaîne d'invite secondaire PS2, par défaut « > », utilisée lorsqu'une entrée supplémentaire est nécessaire pour
terminer une commande.

Invite PS3 utilisée par le Sélectionner déclaration lors de la lecture d'une sélection de menu. Le défaut
est '#? '.

PS4 Utilisé pour préfixer les commandes qui sont imprimées pendant le traçage d'exécution (voir le set
-x commande ci-dessous). Les substitutions de paramètres, de commandes et arithmétiques sont
effectuée avant son impression. La valeur par défaut est '+'. Vous voudrez peut-être le définir
à '[$EPOCHREALTIME] ' à la place, pour inclure les horodatages.

PWD Le répertoire de travail actuel. Peut être non défini ou NULL si le shell ne sait pas
où est-ce que c'est.

RANDOM Chaque fois que RANDOM est référencé, un numéro entre 0 et 32767 lui est attribué
d'abord à partir d'un PRNG linéaire congruentiel.

REPLY Paramètre par défaut pour le lire commande si aucun nom n'est donné. Également utilisé dans
Sélectionner boucles pour stocker la valeur qui est lue à partir de l'entrée standard.

SECONDS Le nombre de secondes depuis le démarrage du shell ou, si le paramètre a été
affecté une valeur entière, le nombre de secondes depuis l'affectation plus le
valeur qui lui a été attribuée.

TMOUT S'il est défini sur un entier positif dans un shell interactif, il spécifie le maximum
nombre de secondes pendant lesquelles le shell attendra l'entrée après l'impression du primaire
invite (PS1). Si le temps est dépassé, le shell se ferme.

TMPDIR Le répertoire dans lequel les fichiers shell temporaires sont créés. Si ce paramètre n'est pas
défini, ou ne contient pas le chemin absolu d'un répertoire accessible en écriture, temporaire
les fichiers sont créés dans / Tmp.

USER_ID L'ID utilisateur effectif du shell.

Tilde avec des données
L'expansion du tilde qui se fait en parallèle avec la substitution de paramètres, se fait sur les mots
commençant par un '~' sans guillemets. Les caractères suivant le tilde, jusqu'au premier '/', si
any, sont supposés être un nom de connexion. Si le nom de connexion est vide, '+' ou '-', la valeur de
le paramètre HOME, PWD ou OLDPWD est respectivement substitué. Sinon, le mot de passe
le fichier est recherché pour le nom de connexion et l'expression tilde est remplacée par le nom de l'utilisateur
répertoire personnel. Si le nom de connexion n'est pas trouvé dans le fichier de mot de passe ou si des citations ou
la substitution de paramètre se produit dans le nom de connexion, aucune substitution n'est effectuée.

Dans les paramétrages (tels que ceux précédant une simple commande ou ceux apparaissant dans le
arguments de alias, Exporter, de défis, lecture seulementet composer), l'expansion du tilde se fait après
toute affectation (c'est-à-dire après le signe égal) ou après un deux-points sans guillemets (':'); noms de connexion
sont également délimités par des deux-points.

Le répertoire personnel des noms de connexion précédemment étendus est mis en cache et réutilisé. Les alias -d
La commande peut être utilisée pour lister, modifier et ajouter à ce cache (par exemple alias -d
fac=/usr/local/installations ; cd ~fac/bac).

Entretoise avec des données (alternance)
Les expressions d'accolade prennent la forme suivante :

préfixe{str1, ...,chaîne}suffixe

Les expressions sont étendues à N mots, dont chacun est la concaténation de préfixe, stri,
ainsi que suffixe (par exemple, "a{c,b{X,Y},d}e" se développe en quatre mots : "ace", "abXe", "abYe" et "ade").
Comme indiqué dans l'exemple, les expressions d'accolades peuvent être imbriquées et les mots résultants ne sont pas
trié. Les expressions d'accolade doivent contenir une virgule sans guillemets (',') pour que l'expansion se produise (par exemple
{} ainsi que {foo} ne sont pas étendus). L'expansion de l'accolade est effectuée après la substitution des paramètres
et avant la génération du nom de fichier.

Déposez votre dernière attestation prénom motifs
Un modèle de nom de fichier est un mot contenant un ou plusieurs '?', '*', '+', '@' ou '!' sans guillemets
caractères ou séquences "[..]". Une fois l'expansion de l'accolade effectuée, la coque remplace
modèles de nom de fichier avec les noms triés de tous les fichiers qui correspondent au modèle (si non
les fichiers correspondent, le mot reste inchangé). Les éléments du motif ont la signification suivante :

? Correspond à n'importe quel caractère.

* Correspond à n'importe quelle séquence d'octets.

[..] Correspond à l'un des octets entre crochets. Les plages d'octets peuvent être spécifiées par
séparant deux octets par un « - » (par exemple, « [a0-9] » correspond à la lettre « a » ou à n’importe quel chiffre).
Pour se représenter, un '-' doit être soit entre guillemets, soit le premier ou le dernier octet
dans la liste d'octets. De même, un ']' doit être entre guillemets ou le premier octet de la liste
si c'est pour se représenter lui-même au lieu de la fin de la liste. Aussi un '!' apparaissant
au début de la liste a une signification particulière (voir ci-dessous), donc se représenter
doivent être cités ou apparaître plus tard dans la liste.

[!..] Comme [..], sauf qu'il correspond à tout octet qui n'est pas entre crochets.

*(modèle|...|modèle)
Correspond à toute chaîne d'octets qui correspond à zéro ou plusieurs occurrences du spécifié
motifs. Exemple : le motif *(toto|bar) correspond aux chaînes "", "foo", "bar",
« foobarfoo », etc.

+(modèle|...|modèle)
Correspond à toute chaîne d'octets qui correspond à une ou plusieurs occurrences du spécifié
motifs. Exemple : le motif +(toto|bar) correspond aux chaînes "foo", "bar",
« foobar », etc.

?(modèle|...|modèle)
Correspond à la chaîne vide ou à une chaîne qui correspond à l'un des modèles spécifiés.
Exemple : le motif ?(foo|bar) correspond uniquement aux chaînes "", "foo" et "bar".

@(modèle|...|modèle)
Correspond à une chaîne qui correspond à l'un des modèles spécifiés. Exemple : le motif
@(toto|bar) correspond uniquement aux chaînes « foo » et « bar ».

!(modèle|...|modèle)
Correspond à toute chaîne qui ne correspond pas à l'un des modèles spécifiés. Exemples : le
modèle !(foo|bar) correspond à toutes les chaînes sauf « foo » et « bar » ; le motif !(*)
ne correspond à aucune chaîne ; le motif !(?)* correspond à toutes les chaînes (pensez-y).

Notez que la globalisation compliquée, en particulier avec les alternatives, est lente ; en utilisant séparément
les comparaisons peuvent (ou non) être plus rapides.

Notez que mksh (Et pdksh) ne correspond jamais à '.' et '..', mais AT&T UNIX ksh, Borne sh, et GNU
bash faire.

Notez qu'aucun des éléments de motif ci-dessus ne correspond à un point ('.') au début d'un
nom de fichier ou une barre oblique ('/'), même s'ils sont explicitement utilisés dans une séquence [..] ; également
noms '.' et '..' ne correspondent jamais, même par le modèle '.*'.

Si la marqueurs est définie, tous les répertoires résultant de la génération de noms de fichiers sont
marqué d'un '/' à la fin.

D'entrée / sortie redirection
Lorsqu'une commande est exécutée, son entrée standard, sa sortie standard et son erreur standard (fichier
descripteurs 0, 1 et 2, respectivement) sont normalement hérités du shell. Trois
les exceptions à cette règle sont les commandes dans les pipelines, pour lesquelles l'entrée standard et/ou standard
les sorties sont celles configurées par le pipeline, les commandes asynchrones créées lorsque le contrôle des travaux est
désactivée, pour laquelle l'entrée standard est initialement définie sur / dev / null, et des commandes pour
laquelle l'une des redirections suivantes a été spécifiée :

>filet La sortie standard est redirigée vers filet. Si filet n'existe pas, il est créé ;
s'il existe, est un fichier normal, et le nul l'option est définie, une erreur
se produit; sinon, le fichier est tronqué. Notez que cela signifie la commande cmd
<foo > foo ouvrira foo pour la lecture puis le tronquer lorsqu'il l'ouvre pour
écrit, avant cmd a la chance de lire réellement foo.

>|filet Pareil que >, sauf que le fichier est tronqué, même si le nul l'option est définie.

>>filet Pareil que >, sauf si filet existe, il est ajouté au lieu d'être tronqué.
De plus, le fichier est ouvert en mode ajout, donc les écritures vont toujours à la fin du
fichier (voir ouvert(2)).

<filet L'entrée standard est redirigée depuis filet, qui est ouvert pour la lecture.

<>filet Pareil que <, sauf que le fichier est ouvert en lecture et en écriture.

<<marqueur Après avoir lu la ligne de commande contenant ce type de redirection (appelée
« here document »), le shell copie les lignes de la source de la commande dans un
fichier temporaire jusqu'à ce qu'une ligne corresponde marqueur est lu. Lorsque la commande est
exécutée, l'entrée standard est redirigée depuis le fichier temporaire. Si marqueur
ne contient aucun caractère entre guillemets, le contenu du fichier temporaire est traité
comme s'il était entouré de guillemets doubles à chaque exécution de la commande, donc le paramètre,
commande et des substitutions arithmétiques sont effectuées, ainsi qu'une barre oblique inverse ('\')
s'échappe pour '$', '`', '\' et '\newline', mais pas pour '"'. Si plusieurs ici
les documents sont utilisés sur la même ligne de commande, ils sont enregistrés dans l'ordre.

Sinon marqueur est donné, le document ici se termine au suivant << et remplacement
sera réalisée. Si marqueur n'est qu'un ensemble de simples "''" ou de doubles '""'
guillemets sans rien entre les deux, le document ici se termine à la prochaine ligne vide
et la substitution ne sera pas effectuée.

<< -marqueur Pareil que <<, sauf que les tabulations de début sont supprimées des lignes du document ici.

<<mot Pareil que <<, excepté mot is le document ici. C'est ce qu'on appelle un ici
chaîne.

<&fd L'entrée standard est dupliquée à partir du descripteur de fichier fd. fd peut être un nombre,
indiquer le numéro d'un descripteur de fichier existant ; la lettre 'p', indiquant
le descripteur de fichier associé à la sortie du co-processus en cours ; ou la
caractère '-', indiquant que l'entrée standard doit être fermée. Noter que fd is
limité à un seul chiffre dans la plupart des implémentations shell.

>&fd Pareil que <&, sauf que l'opération est effectuée sur la sortie standard.

&>filet Pareil que >filet 2> et 1. Ceci est un GNU obsolète (ancien) bash extension prise en charge
by mksh qui prend également en charge le numéro fd explicite précédent, par exemple,
3&>filet est la même que 3>filet 2> et 3 in mksh mais une erreur de syntaxe dans GNU bash.

&>|filet, &>>filet, &>&fd
Pareil que >|filet, >>filetou >&fd, Suivie par 2> et 1, comme ci-dessus. Ceux-ci sont mksh
Extensions.

Dans l'une des redirections ci-dessus, le descripteur de fichier qui est redirigé (c'est-à-dire standard
entrée ou sortie standard) peut être explicitement donné en faisant précéder la redirection d'un nombre
(portable, un seul chiffre). Substitutions de paramètres, commandes et arithmétiques, tilde
substitutions, et (si le shell est interactif) la génération de noms de fichiers sont tous effectués sur
le filet, marqueuret fd arguments de redirection. Notez cependant que les résultats de tout
la génération de noms de fichiers n'est utilisée que si un seul fichier correspond ; si plusieurs fichiers correspondent, le
mot avec les caractères de génération de nom de fichier étendus est utilisé. Notez qu'en restreint
shells, les redirections pouvant créer des fichiers ne peuvent pas être utilisées.

Pour les commandes simples, les redirections peuvent apparaître n'importe où dans la commande ; pour les commandes composées
(if instructions, etc.), toute redirection doit apparaître à la fin. Les redirections sont traitées
après la création des pipelines et dans l'ordre dans lequel ils sont donnés, ce qui suit imprimera un
erreur avec un numéro de ligne ajouté au début :

$ cat /foo/bar 2>&1 >/dev/null | pr -n -t

Les descripteurs de fichiers créés par les redirections d'E/S sont privés du shell.

Arithmétique expressions
Les expressions arithmétiques entières peuvent être utilisées avec le laisser commande, à l'intérieur des expressions $((..)),
à l'intérieur des références de tableau (par exemple prénom[expr]), en tant qu'arguments numériques du tester commande, et comme
la valeur d'une affectation à un paramètre entier. : Cela affecte également les
conversion en nombre entier, par exemple comme le fait le laisser commander. Jamais utiliser un utilisateur non coché
entrée, par exemple de l'environnement, en arithmétique !

Les expressions sont calculées en utilisant l'arithmétique signée et le mksh_ari_t type (un 32 bits signé
entier), à moins qu'ils ne commencent par un seul caractère '#', auquel cas ils utilisent mksh_uari_t (a
entier 32 bits non signé).

Les expressions peuvent contenir des identifiants de paramètres alphanumériques, des références de tableau et des entiers
constantes et peuvent être combinés avec les opérateurs C suivants (répertoriés et regroupés dans
ordre croissant de priorité):

Opérateurs unaires :

+- ! ~ ++ --

Opérateurs binaires:

,
= += -= *= /= %= <<<= >>>= <<= >>= &= ^= |=
||
&&
|
^
&
==! =
<<=>> =
<<< >>> << >>
+ -
* /%

Opérateurs ternaires :

? : (la priorité est immédiatement supérieure à l'affectation)

Opérateurs de groupement :

()

Les constantes entières et les expressions sont calculées à l'aide d'un nombre exactement de 32 bits, signé ou
non signé, tapez avec un bouclage silencieux en cas de débordement d'entier. Les constantes entières peuvent être
spécifié avec des bases arbitraires en utilisant la notation base#nombre, Où base est un nombre décimal
entier spécifiant la base, et nombre est un nombre dans la base spécifiée. En outre,
les entiers en base 16 peuvent être spécifiés en les préfixant avec « 0x » (insensible à la casse) dans tous
formes d'expressions arithmétiques, sauf en tant qu'arguments numériques tester commande intégrée.
Préfixer des nombres avec un seul chiffre zéro ('0') ne provoque pas d'interprétation comme octale, comme
c'est dangereux à faire.

En tant que spécial mksh extension, les nombres à la base de un sont traités soit comme (8 bits
transparent) des points de code ASCII ou Unicode, selon le shell mode utf8 drapeau (actuel
réglage). L'UNIX AT&T 93 XNUMX ksh la syntaxe de "'x'" au lieu de "1#x" est également prise en charge. Noter
que les octets NUL (valeur entière de zéro) ne peuvent pas être utilisés. Un paramètre non défini ou vide
évalue à 0 dans un contexte d'entier. En mode Unicode, les octets bruts sont mappés dans la plage
EF80..EFFF comme dans OPTU-8, qui est dans le PUA et a été assigné par CSUR pour cet usage. Si
plus d'un octet en mode ASCII, ou une séquence de plus d'un octet ne formant pas un
et une séquence CESU-8 minimale est transmise, le comportement est indéfini (généralement, le shell abandonne
avec une erreur d'analyse, mais rarement, il réussit, par exemple sur la séquence C2 20). C'est pourquoi vous
devez toujours utiliser le mode ASCII à moins que vous ne sachiez que l'entrée est bien formée en UTF-8 dans le
plage de 0000..FFFD si vous utilisez cette fonctionnalité, par opposition à lire -a.

Les opérateurs sont évalués comme suit :

unaire +
Le résultat est l'argument (inclus par souci d'exhaustivité).

unaire -
Négation.

! NON logique ; le résultat est 1 si l'argument est zéro, 0 sinon.

~ Arithmétique (au niveau du bit) NON.

++ Incrément; doit être appliqué à un paramètre (pas à une expression littérale ou autre).
Le paramètre est incrémenté de 1. Lorsqu'il est utilisé comme opérateur préfixe, le résultat
est la valeur incrémentée du paramètre ; lorsqu'il est utilisé comme opérateur suffixe,
le résultat est la valeur d'origine du paramètre.

-- Semblable à ++, sauf que le paramètre est décrémenté de 1.

, sépare deux expressions arithmétiques ; le membre de gauche est évalué en premier,
puis la droite. Le résultat est la valeur de l'expression à droite
côté.

= affectation ; la variable de gauche est définie sur la valeur de droite.

+= -= *= /= %= <<<= >>>= <<= >>= &= ^= |=
Opérateurs d'affectation.var><op>=expr> est le même quevar>=var><op><expr>,
avec toute priorité d'opérateur dansexpr> préservé. Par exemple, "var1 *= 5 +
3" équivaut à spécifier "var1 = var1 * (5 + 3)".

|| OU logique ; le résultat est 1 si l'un des arguments est différent de zéro, 0 sinon. le
l'argument de droite n'est évalué que si l'argument de gauche est zéro.

&& ET logique; le résultat est 1 si les deux arguments sont différents de zéro, 0 sinon. le
l'argument de droite n'est évalué que si l'argument de gauche est différent de zéro.

| OU Arithmétique (au niveau du bit).

^ Arithmétique (bit-wise) XOR (exclusif-OR).

& Arithmétique (bit-sage) ET.

== Égal ; le résultat est 1 si les deux arguments sont égaux, 0 sinon.

!= Non égal ; le résultat est 0 si les deux arguments sont égaux, 1 sinon.

< Inférieur à; le résultat est 1 si l'argument de gauche est inférieur à celui de droite, 0 si
pas.

<= > >=
Inférieur ou égal, supérieur, supérieur ou égal. Voir <.

<<< >>>
Tournez à gauche (à droite) ; le résultat est similaire à shift (voir <<) sauf que le
les bits décalés à une extrémité sont décalés à l'autre extrémité, au lieu de zéro
ou des bits de signe.

<< >> Déplacer vers la gauche (droite) ; le résultat est l'argument gauche avec ses bits décalés vers la gauche
(à droite) par le montant indiqué dans l'argument de droite.

+ - * /
Addition, soustraction, multiplication et division.

% restant ; le résultat est le reste symétrique de la division de la gauche
argument par la droite. Pour obtenir le module mathématique de « a mod b", utilisez le
formule "(a % b + b) % b".

<argument1> ?argument2>:argument3>
Siargument1> est non nul, le résultat estargument2> ; sinon le résultat estargument3>.
L'argument de non-résultat n'est pas évalué.

Co-processus
Un co-processus (qui est un pipeline créé avec l'opérateur '|&') est un processus asynchrone
que le shell peut à la fois écrire (en utilisant impression -p) et lisez à partir de (en utilisant lire -p). L'entrée
et la sortie du co-processus peuvent également être manipulées en utilisant >&p ainsi que <&p réorientations,
respectivement. Une fois qu'un co-processus a été lancé, un autre ne peut pas être démarré tant que le co-processus n'a pas été lancé.
le processus se termine, ou jusqu'à ce que l'entrée du co-processus ait été redirigée à l'aide d'un exec n>&p
redirection. Si l'entrée d'un co-processus est redirigée de cette manière, le prochain co-processus à être
démarré partagera la sortie avec le premier co-processus, à moins que la sortie du premier
co-process a été redirigé à l'aide d'un exec n<&p réorientation.

Quelques notes concernant les co-processus :

· La seule façon de fermer l'entrée du co-processus (afin que le co-processus lise une fin de fichier) est
pour rediriger l'entrée vers un descripteur de fichier numéroté, puis fermer ce descripteur de fichier :
exec 3>&p; exec 3>&-

· Pour que les co-processus partagent une sortie commune, le shell doit conserver l'écriture
partie du tuyau de sortie ouverte. Cela signifie que la fin de fichier ne sera pas détectée avant
tous les co-processus partageant la sortie du co-processus sont sortis (lorsqu'ils sortent tous, le
shell ferme sa copie du tuyau). Cela peut être évité en redirigeant la sortie vers un
descripteur de fichier numéroté (car cela oblige également le shell à fermer sa copie). Noter que
ce comportement est légèrement différent du shell Korn d'origine qui ferme sa copie
de la partie d'écriture de la sortie du co-traitement lorsque le co-traitement démarré le plus récemment
(au lieu de quand tous les co-processus de partage) se termine.

· impression -p ignorera les signaux SIGPIPE pendant les écritures si le signal n'est pas piégé ou
ignoré; il en est de même si l'entrée co-process a été dupliquée dans un autre fichier
descripteur et impression -un est utilisé.

Les fonctions
Les fonctions sont définies à l'aide du shell Korn fonction nom-fonction la syntaxe ou le
Shell Bourne/POSIX nom-fonction() syntaxe (voir ci-dessous pour la différence entre les deux
formes). Les fonctions sont comme les .‐scripts (c'est-à-dire les scripts générés en utilisant le '.' intégré) dans ce
ils sont exécutés dans l'environnement courant. Cependant, contrairement aux .‐scripts, les arguments du shell
(c'est-à-dire les paramètres positionnels $1, $2, etc.) ne sont jamais visibles à l'intérieur. Lorsque la coquille est
déterminer l'emplacement d'une commande, les fonctions sont recherchées après des fonctions intégrées spéciales
commandes, avant les commandes intégrées et le PATH est recherché.

Une fonction existante peut être supprimée en utilisant unset -f nom-fonction. Une liste de fonctions peut
être obtenu en utilisant composer +f et les définitions de fonction peuvent être répertoriées en utilisant composer -f.
La chargement automatique commande (qui est un alias pour composer -fu) peut être utilisé pour créer undefined
fonctions : lorsqu'une fonction non définie est exécutée, le shell recherche le chemin spécifié dans
le paramètre FPATH pour un fichier portant le même nom que la fonction qui, s'il est trouvé, est lu
et exécuté. Si après l'exécution du fichier la fonction nommée est définie, le
la fonction est exécutée ; sinon, la recherche de commande normale se poursuit (c'est-à-dire le shell
recherche dans la table de commandes intégrée standard et dans PATH). Notez que si une commande n'est pas trouvée
en utilisant PATH, une tentative est faite pour charger automatiquement une fonction en utilisant FPATH (il s'agit d'un
caractéristique de la coque Korn d'origine).

Les fonctions peuvent avoir deux attributs, « trace » et « export », qui peuvent être définis avec composer -pi
ainsi que composer -fx, respectivement. Lorsqu'une fonction tracée est exécutée, le shell x trace
L'option est activée pour la durée de la fonction. L'attribut « export » des fonctions est
actuellement pas utilisé. Dans le shell Korn d'origine, les fonctions exportées sont visibles par le shell
scripts qui sont exécutés.

Étant donné que les fonctions sont exécutées dans l'environnement shell actuel, les affectations de paramètres effectuées
les fonctions internes sont visibles une fois la fonction terminée. Si ce n'est pas le désir
effet, le composer La commande peut être utilisée dans une fonction pour créer un paramètre local. Noter
qu'AT&T UNIX 93 XNUMX ksh utilise une portée statique (une portée globale, une portée locale par fonction)
et autorise les variables locales uniquement sur les fonctions de style Korn, alors que mksh utilise la portée dynamique
(étendues imbriquées de localité variable). Notez que des paramètres spéciaux (par ex. $$, $!) ne peut pas être
délimité de cette manière.

L'état de sortie d'une fonction est celui de la dernière commande exécutée dans la fonction. UNE
fonction peut être effectuée pour se terminer immédiatement en utilisant le retourner commander; cela peut aussi être utilisé
pour spécifier explicitement l'état de sortie.

Fonctions définies avec le fonction mot réservé sont traités différemment dans ce qui suit
manières à partir des fonctions définies avec le () notation:

· Le paramètre $0 est défini sur le nom de la fonction (les fonctions de style Bourne laissent $0
intact).

· Les affectations de paramètres précédant les appels de fonction ne sont pas conservées dans l'environnement shell
(l'exécution de fonctions de type Bourne conservera les affectations).

· OPTIND est enregistré/réinitialisé et restauré à l'entrée et à la sortie de la fonction afin que getops peuvent être
utilisé correctement à la fois à l'intérieur et à l'extérieur de la fonction (les fonctions de style Bourne laissent OPTIND
intact, donc en utilisant getops à l'intérieur d'une fonction interfère avec l'utilisation getops en dehors de
fonction).

· Options de coque (set -o) ont une portée locale, c'est-à-dire que les modifications à l'intérieur d'une fonction sont réinitialisées
sa sortie.

À l'avenir, les différences suivantes peuvent également être ajoutées :

· Un environnement de déroutement/signal séparé sera utilisé pendant l'exécution des fonctions. Cette
signifiera que les pièges définis dans une fonction n'affecteront pas les pièges et les signaux du shell
qui ne sont pas ignorés dans le shell (mais peuvent être piégés) auront leur effet par défaut dans
une fonction.

· Le trap EXIT, s'il est défini dans une fonction, sera exécuté après le retour de la fonction.

Command exécution
Après évaluation des arguments de ligne de commande, des redirections et des affectations de paramètres, le
le type de commande est déterminé : une commande intégrée spéciale, une fonction, une commande intégrée normale ou
le nom d'un fichier à exécuter trouvé à l'aide du paramètre PATH. Les contrôles sont effectués dans le
commande ci-dessus. Les commandes intégrées spéciales diffèrent des autres commandes en ce que le PATH
n'est pas utilisé pour les trouver, une erreur lors de leur exécution peut provoquer un non-
shell interactif à quitter et les affectations de paramètres qui sont spécifiées avant la commande
sont conservés une fois la commande terminée. Les commandes intégrées régulières ne diffèrent que par le fait
le paramètre PATH n'est pas utilisé pour les trouver.

L'ouverture a ksh et POSIX diffèrent quelque peu en ce qui concerne les commandes considérées comme spéciales ou
régulier.

Utilitaires intégrés spéciaux POSIX :

., :, pause, continuer, eval, exec, sortie, Exporter, lecture seulement, retourner, set, décalage, fois, piège,
unset

Supplémentaire mksh commandes conservant les affectations :

builtin, de défis, la source, composer, attendez

Builtins qui ne sont pas spéciaux:

[, alias, bg, lier, cat, cd, commander, echo, non, fc, fg, getops, emplois, tuer, laisser, impression,
pwd, lire, chemin réel, rebaptiser, sleep, suspendre, tester, oui, ulimit, umask, Unalias, D'où

Une fois le type de commande déterminé, toutes les affectations de paramètres de ligne de commande sont
exécutés et exportés pendant la durée de la commande.

Ce qui suit décrit les commandes intégrées spéciales et régulières et les commandes intégrées réservées
mots:

. filet [arg ]
C'est ce qu'on appelle la commande "point". Exécutez les commandes dans filet dans l'actuel
environnement. Le fichier est recherché dans les répertoires de PATH. Si les arguments sont
donnés, les paramètres de position peuvent être utilisés pour y accéder tout en filet est
réalisé. Si aucun argument n'est donné, les paramètres positionnels sont ceux du
environnement dans lequel la commande est utilisée.

: [ ]
La commande nulle. L'état de sortie est mis à zéro.

[ expression ]
See tester.

alias [-d | -t [-r] | +-x] [-p] [+] [prénom [=Plus-value] ]
Sans argument, alias répertorie tous les alias. Pour tout nom sans valeur, le
l'alias existant est répertorié. Tout nom avec une valeur définit un alias (voir Alias
au dessus de).

Lors de la liste des alias, l'un des deux formats est utilisé. Normalement, les alias sont répertoriés comme
prénom=Plus-value, Où Plus-value est cité. Si les options étaient précédées d'un '+' ou d'un seul '+'
est donné sur la ligne de commande, seulement prénom est imprimé.

La -d L'option provoque la liste des alias de répertoire qui sont utilisés dans l'expansion tilde
ou définir (voir Tilde avec des données au dessus de).

Si la -p est utilisée, chaque alias est préfixé par la chaîne « alias ».

La -t L'option indique que les alias suivis doivent être répertoriés/définis (valeurs spécifiées
sur la ligne de commande sont ignorés pour les alias suivis). le -r option indique que
tous les alias suivis doivent être réinitialisés.

La -x jeux d'options (+x efface) l'attribut d'exportation d'un alias, ou, si aucun nom n'est
donné, répertorie les alias avec l'attribut export (exporter un alias n'a pas
effet).

bg [JOB ]
Reprendre le ou les travaux arrêtés spécifiés en arrière-plan. Si aucun travail n'est spécifié, %+
est assumé. Voir Emploi des bactéries ci-dessous pour plus d'informations.

lier [-l]
Les liaisons actuelles sont répertoriées. Si la -l le drapeau est donné, lier énumère à la place les
les noms des fonctions auxquelles les touches peuvent être liées. Voir Emacs édition mode pour plus d'
</br>L’Information.

lier [-m] un magnifique=[remplacer]
lier un magnifique=[commande-édition]
La commande d'édition spécifiée est liée à la donnée un magnifique, qui devrait consister en un
caractère de contrôle éventuellement précédé de l'un des deux caractères préfixes et
éventuellement suivi d'un caractère tilde. L'apport futur de la un magnifique provoque l'
commande d'édition à appeler immédiatement. Si la -m flag est donné, le spécifié
contribution un magnifique sera ensuite immédiatement remplacé par le donné remplacer un magnifique
qui peut contenir des commandes d'édition mais pas d'autres macros. Si un suffixe tilde est
donné, un tilde à la fin du ou des deux préfixes et le caractère de contrôle est ignoré,
tout autre caractère de fin sera traité par la suite.

Les caractères de contrôle peuvent être écrits en utilisant la notation caret, c'est-à-dire que ^X représente Ctrl-X.
Notez que bien que seuls deux caractères de préfixe (généralement ESC et ^X) soient pris en charge,
certaines séquences de plusieurs caractères peuvent être prises en charge.

Les liaisons par défaut suivantes montrent comment les touches fléchées, les touches d'accueil, de fin et de suppression
sur un terminal d'écran BSD wsvt25, xterm-xfree86 ou GNU sont liés (bien sûr certains
les séquences d'échappement ne fonctionneront pas aussi bien):

lier '^X'=préfixe-2
lier '^[['=préfixe-2
lier '^XA'=up-history
bind '^XB'=down-history
bind '^XC'=forward-char
bind '^XD'=backward-char
bind '^X1~'=début de ligne
bind '^X7~'=début de ligne
bind '^XH'=début de ligne
lier '^X4~'=fin de ligne
lier '^X8~'=fin de ligne
lier '^XF'=fin de ligne
lier '^X3~'=delete-char-forward

pause [niveau]
Quittez le niveaule plus à l'intérieur en, Sélectionner, jusqu'àou tout en boucle. niveau la valeur par défaut est 1.

builtin [--] commander [arg ]
Exécuter la commande intégrée commander.

cat [-u] [filet ]
Lisez les fichiers séquentiellement, dans l'ordre de la ligne de commande, et écrivez-les sur la sortie standard.
Si un filet est un seul tiret ("-") ou absent, lu à partir de l'entrée standard. Pour direct
appels intégrés, le POSIX -u L'option est prise en charge en tant que no-op. Pour les appels depuis le shell, si
toutes les options sont données, un externe cat(1) l'utilitaire est préféré à l'utilitaire intégré.

cd [-L] [dir]
cd -P [-e] [dir]
chdir [-eLP] [dir]
Définissez le répertoire de travail sur dir. Si le paramètre CDPATH est défini, il répertorie les
chemin de recherche du répertoire contenant dir. Un chemin NULL signifie le
annuaire. Si dir se trouve dans n'importe quel composant du chemin de recherche CDPATH autre que le
Chemin NULL, le nom du nouveau répertoire de travail sera écrit sur la sortie standard.
If dir est manquant, le répertoire personnel HOME est utilisé. Si dir est '-', le précédent
répertoire de travail est utilisé (voir le paramètre OLDPWD).

Si la -L (chemin logique) est utilisé ou si l'option Physique l'option n'est pas définie (voir le
set commande ci-dessous), les références à '..' dans dir sont relatifs au chemin utilisé pour se rendre à
le répertoire. Si la -P (chemin physique) est utilisé ou si l'option Physique option est
set, '..' est relatif à l'arborescence des répertoires du système de fichiers. Les PWD et OLDPWD
les paramètres sont mis à jour pour refléter le répertoire de travail actuel et ancien,
respectivement. Si la -e l'option est définie pour la traversée du système de fichiers physique et PWD
n'a pas pu être défini, le code de sortie est 1 ; supérieur à 1 si une erreur s'est produite, 0
autrement.

cd [-eLP] et les sites anciens neufs
chdir [-eLP] et les sites anciens neufs
La corde neufs est substitué à et les sites anciens dans le répertoire courant, et le shell
tente de passer au nouveau répertoire.

commander [-pVv] cmd [arg ]
Si ni le -v ni -V l'option est donnée, cmd est exécuté exactement comme si commander ait eu
pas été précisé, à deux exceptions près : d'une part, cmd ne peut pas être une fonction shell ; et
deuxièmement, les commandes intégrées spéciales perdent leur spécificité (c'est-à-dire la redirection et
les erreurs d'utilitaire ne provoquent pas la sortie du shell, et les affectations de commande ne sont pas
permanent).

Si la -p est donnée, un chemin de recherche par défaut est utilisé à la place de la valeur actuelle
de PATH, dont la valeur réelle dépend du système.

Si la -v option est donnée, au lieu d'exécuter cmd, des informations sur ce qui serait
exécuté est donné (et il en est de même pour arg ). Pour les commandes intégrées, les fonctions et
mots-clés, leurs noms sont simplement imprimés ; pour les alias, une commande qui les définit est
imprimé; pour les utilitaires trouvés en recherchant le paramètre PATH, le chemin complet du
la commande est imprimée. Si aucune commande n'est trouvée (c'est-à-dire que la recherche de chemin échoue), rien n'est
imprimé et commander sort avec un statut différent de zéro. le -V l'option est comme la -v
option, sauf qu'elle est plus verbeuse.

continuer [niveau]
Saute au début du niveaule plus à l'intérieur en, Sélectionner, jusqu'àou tout en boucle.
niveau la valeur par défaut est 1.

echo [-Une] [arg ]
Mise en garde: cet utilitaire n'est pas portable ; utiliser le shell Korn intégré impression à la place.

Affiche ses arguments (séparés par des espaces) suivis d'un saut de ligne, au standard
sortir. La nouvelle ligne est supprimée si l'un des arguments contient la barre oblique inverse
séquence '\c'. Voir le impression commande ci-dessous pour une liste d'autres séquences de barres obliques inverses
qui sont reconnus.

Les options sont fournies pour la compatibilité avec les scripts shell BSD. le -n option
supprime le retour à la ligne de fin, -e permet l'interprétation de la barre oblique inverse (un no-op, puisque
cela se fait normalement), et -E supprime l'interprétation de la barre oblique inverse.

Si la posix or sh est définie ou il s'agit d'un appel intégré direct, seul le premier
l'argument est traité comme une option, et seulement s'il est exactement "-n”. barre oblique inverse
l'interprétation est désactivée.

eval commander
Les arguments sont concaténés (avec des espaces entre eux) pour former une seule chaîne
que le shell analyse et exécute ensuite dans l'environnement actuel.

exec [-a argv0] [-c] [commander [arg ]]
La commande est exécutée sans fork, remplaçant le processus shell. C'est
actuellement absolu, c'est-à-dire exec ne revient jamais, même si le commander n'est pas trouvé. Les
-a L'option permet de définir une valeur argv[0] différente, et -c nettoie l'environnement
avant d'exécuter le processus fils, à l'exception de la variable _ et des affectations directes.

Si aucune commande n'est donnée à l'exception de la redirection des E/S, la redirection des E/S est permanente
et la coque n'est pas remplacée. Tout descripteur de fichier supérieur à 2 qui est ouvert
or dup(2)'d de cette manière ne sont pas disponibles pour d'autres commandes exécutées (c'est-à-dire
commandes qui ne sont pas intégrées au shell). Notez que le shell Bourne diffère
ici; il transmet ces descripteurs de fichiers.

sortie [statuts]
Le shell se termine avec l'état de sortie spécifié. Si statuts n'est pas spécifié, la sortie
status est la valeur actuelle du $? paramètre.

Exporter [-p] [paramètre[=Plus-value]]
Définit l'attribut d'exportation des paramètres nommés. Les paramètres exportés sont transmis
l'environnement aux commandes exécutées. Si des valeurs sont spécifiées, les paramètres nommés
sont également attribués.

Si aucun paramètre n'est spécifié, tous les paramètres avec l'attribut d'exportation défini sont
imprimé un par ligne ; soit leurs noms, soit, si un '-' sans lettre d'option est
spécifié, paires nom=valeur, ou, avec -p, Exporter commandes adaptées à la ré-entrée.

non Une commande qui se termine avec un état différent de zéro.

fc [-e éditeur | -l [-n]] [-r] [premier [dernier]]
premier ainsi que dernier sélectionnez les commandes de l'historique. Les commandes peuvent être sélectionnées par historique
nombre (les nombres négatifs remontent à partir de la ligne actuelle, la plus récente) ou un
chaîne spécifiant la commande la plus récente commençant par cette chaîne. le -l option
répertorie la commande sur la sortie standard, et -n inhibe les numéros de commande par défaut.
La -r L'option inverse l'ordre de la liste. Sans -l, les commandes sélectionnées sont
édité par l'éditeur spécifié avec le -e option, ou si non -e est spécifié, le
éditeur spécifié par le paramètre FCEDIT (si ce paramètre n'est pas défini, /bin/ed is
utilisé), puis exécuté par le shell.

fc -e - | -s [-g] [et les sites anciens=neufs] [préfixe]
Réexécutez la commande sélectionnée (la commande précédente par défaut) après avoir exécuté
la substitution facultative de et les sites anciens avec neufs. Si -g est spécifié, toutes les occurrences de
et les sites anciens sont remplacés par neufs. Le sens de -e - ainsi que -s est identique : réexécutez le
commande sélectionnée sans appeler un éditeur. Cette commande est généralement accessible avec
le prédéfini : alias r='fc -e -'

fg [JOB ]
Reprendre le ou les travaux spécifiés au premier plan. Si aucun travail n'est spécifié, %+ is
assumé. Voir Emploi des bactéries ci-dessous pour plus d'informations.

getops chaîne d'options prénom [arg ]
Utilisé par les procédures shell pour analyser les arguments spécifiés (ou les paramètres positionnels,
si aucun argument n'est donné) et de vérifier les options légales. chaîne d'options contient l'
lettres d'option qui getops est de reconnaître. Si une lettre est suivie de deux points, le
option devrait avoir un argument. Les options qui ne prennent pas d'arguments peuvent être
regroupés en un seul argument. Si une option prend un argument et que l'option
n'est pas le dernier caractère de l'argument dans lequel il se trouve, le reste de
l'argument est considéré comme l'argument de l'option ; sinon, l'argument suivant est
l'argument de l'option.

Chaque fois getops est invoqué, il place l'option suivante dans le paramètre shell prénom
et l'index de l'argument à traiter par le prochain appel à getops dans l'
paramètre shell OPTIND. Si l'option a été introduite avec un '+', l'option placée
in prénom est précédé d'un '+'. Lorsqu'une option nécessite un argument, getops endroits
dans le paramètre shell OPTARG.

Lorsqu'une option illégale ou un argument d'option manquant est rencontré, un point d'interrogation
ou un deux-points est placé dans prénom (indiquant une option illégale ou un argument manquant,
respectivement) et OPTARG est défini sur le caractère d'option qui a causé le problème.
En outre, si chaîne d'options ne commence pas par deux points, un point d'interrogation est placé dans
prénom, OPTARG n'est pas défini et un message d'erreur est imprimé en erreur standard.

Lorsque la fin des options est rencontrée, getops sorties avec une sortie non nulle
statut. Les options se terminent au premier argument (argument non optionnel) qui ne commence pas
avec un '-', ou lorsqu'un argument '--' est rencontré.

L'analyse des options peut être réinitialisée en définissant OPTIND sur 1 (cela se fait automatiquement
chaque fois que le shell ou une procédure shell est invoqué).

Avertissement : changer la valeur du paramètre shell OPTIND en une valeur différente de 1, ou
l'analyse de différents ensembles d'arguments sans réinitialiser OPTIND, peut conduire à des
résultats.

de défis
See composer.

hachage [-r] [prénom ]
Sans arguments, tous les chemins de commandes exécutables hachés sont répertoriés. le -r option
entraîne la suppression de toutes les commandes hachées de la table de hachage. Chaque prénom est recherché
comme s'il s'agissait d'un nom de commande et ajouté à la table de hachage s'il s'agit d'un exécutable
commander.

emplois [-lnp] [JOB ]
Afficher des informations sur le(s) travail(s) spécifié(s) ; si aucun travail n'est spécifié, tous les travaux
sont affichés. le -n l'option provoque l'affichage des informations uniquement pour les travaux qui
ont changé d'état depuis la dernière notification. Si la -l l'option est utilisée, le
L'ID de processus de chaque processus dans un travail est également répertorié. le -p l'option provoque uniquement le
groupe de processus de chaque travail à imprimer. Voir Emploi des bactéries ci-dessous pour le format de JOB
et le travail affiché.

tuer [-s nom | -signe | -nom] { JOB | Pid | pgrp }
Envoyez le signal spécifié aux travaux, ID de processus ou groupes de processus spécifiés. Si
aucun signal n'est spécifié, le signal TERM est envoyé. Si un travail est spécifié, le signal
est envoyé au groupe de processus du travail. Voir Emploi des bactéries ci-dessous pour le format de JOB.

tuer -l [état-de-sortie ]
Imprimer le nom du signal correspondant à état-de-sortie. Si aucun argument n'est spécifié, un
une liste de tous les signaux, leurs numéros et une brève description de ceux-ci sont imprimés.

laisser [expression ]
Chaque expression est évaluée (voir Arithmétique expressions au dessus). Si toutes les expressions
sont évalués avec succès, le statut de sortie est 0 (1) si la dernière expression évaluée
à non nul (zéro). Si une erreur se produit lors de l'analyse ou de l'évaluation d'un
expression, l'état de sortie est supérieur à 1. Étant donné que les expressions peuvent avoir besoin d'être
cité, (( expr )) est le sucre syntaxique pour { let 'expr'; }.

laisser] Alias ​​utilisé en interne pour laisser.

mknod [-m mode] prénom b|c majeur mineur
mknod [-m mode] prénom p
Créez un fichier spécial de périphérique. Le type de fichier peut être b (appareil de type bloc), c
(appareil de type caractère), ou p (tube nommé, FIFO). Le fichier créé peut être modifié
selon son mode (Par l'intermédiaire de l' -m option), majeur (numéro d'appareil principal), et mineur
(numéro d'appareil mineur). Cela ne fait normalement pas partie de mksh; cependant, les distributeurs peuvent
ont ajouté ceci en tant que hack de vitesse.

impression [-nprsu[n] | -R [-En]] [argument ]
impression imprime ses arguments sur la sortie standard, séparés par des espaces et terminés
avec une nouvelle ligne. le -n L'option supprime le saut de ligne. Par défaut, certains C échappe
sont traduits. Il s'agit notamment de ceux mentionnés dans Barre oblique inverse avec des données ci-dessus aussi
comme '\c', ce qui équivaut à utiliser le -n option. L'expansion de la barre oblique inverse peut être
inhibé avec le -r option. La -s l'option imprime dans le fichier historique au lieu de
sortie standard; la -u l'option imprime dans le descripteur de fichier n (n par défaut à 1 si
omis); et le -p l'option s'imprime dans le co-processus (voir Co-processus au dessus de).

La -R L'option est utilisée pour émuler, dans une certaine mesure, le BSD echo(1) commande qui fait
ne pas traiter les séquences '\' à moins que le -e option est donnée. Comme ci-dessus, le -n option
supprime le saut de ligne de fin.

printf le format [arguments ]
Sortie formatée. A peu près le même que le printf(1), utilitaire, sauf qu'il utilise
le même Barre oblique inverse avec des données et le code d'E/S et ne gère pas la virgule flottante comme le
reste de mksh. Un utilitaire externe est préférable à l'utilitaire intégré. Ce n'est pas
normalement partie de mksh; cependant, les distributeurs peuvent avoir ajouté ceci comme intégré en tant que
hack de vitesse. Ne pas utiliser dans le nouveau code.

pwd [-PL]
Imprimer le répertoire de travail actuel. Si la -L l'option est utilisée ou si l'option Physique
l'option n'est pas définie (voir le set commande ci-dessous), le chemin logique est affiché (c'est-à-dire le
chemin utilisé pour cd dans le répertoire courant). Si la -P l'option (chemin physique) est utilisée
ou si le Physique est définie, le chemin déterminé à partir du système de fichiers (par
répertoires '..' suivants dans le répertoire racine) est imprimé.

lire [-A | -a] [-d x] [-N z | -n z] [-p | -u[n]] [-t n] [-rs] [p ]
Lit une ligne d'entrée, sépare l'entrée en champs à l'aide du paramètre IFS (voir
Substitution ci-dessus) et affecte chaque champ aux paramètres spécifiés p. Sinon
sont spécifiés, le paramètre REPLY est utilisé pour stocker le résultat. Avec le
-A ainsi que -a options, seul aucun ou un paramètre est accepté. S'il y a plus
paramètres que les champs, les paramètres supplémentaires sont définis sur la chaîne vide ou 0 ; si
il y a plus de champs que de paramètres, le dernier paramètre se voit attribuer le reste
champs (y compris les séparateurs de mots).

Les options sont les suivantes :

-A Stocker le résultat dans le paramètre p (ou REPLY) sous forme de tableau de mots.

-a Stocker le résultat sans fractionnement de mot dans le paramètre p (ou REPONDRE) comme
tableau de caractères (caractères larges si le mode utf8 l'option est adoptée,
octets sinon); les points de code sont codés sous forme de nombres décimaux par défaut.

-d x Utilisez le premier octet de x, NUL si vide, au lieu du caractère de nouvelle ligne ASCII
comme délimiteur de ligne d'entrée.

-N z Au lieu de lire jusqu'à la fin de la ligne, lisez exactement z octets. Si EOF ou un
timeout se produit, une lecture partielle est renvoyée avec l'état de sortie 1.

-n z Au lieu de lire jusqu'à la fin de la ligne, lisez jusqu'à z octets mais revient dès que
tous les octets sont lus, par exemple à partir d'un terminal lent, ou si EOF ou un délai d'attente
se produit.

-p Lire à partir du co-processus actuellement actif, voir Co-processus ci-dessus pour plus de détails
sur ce.

-u[n] Lire à partir du descripteur de fichier n (la valeur par défaut est 0, c'est-à-dire l'entrée standard). le
L'argument doit suivre immédiatement le caractère d'option.

-t n Interrompre la lecture après n secondes (spécifiée comme valeur décimale positive avec un
partie fractionnaire facultative). Le statut de sortie de lire est 1 si le délai d'attente
s'est produite, mais des lectures partielles peuvent toujours être renvoyées.

-r Normalement, la barre oblique inverse ASCII échappe à la signification spéciale du
caractère suivant et est supprimé de l'entrée ; lire ne s'arrête pas quand
rencontre une séquence backslash-newline et ne stocke pas cette nouvelle ligne dans
le résultat. Cette option active le mode brut, dans lequel les barres obliques inverses ne sont pas
traité.

-s La ligne de saisie est enregistrée dans l'historique.

Si l'entrée est une borne, les deux -N ainsi que -n les options le mettent en mode brut ; elles ou ils
lire un fichier entier si -1 est passé comme z argument.

Le premier paramètre peut être accompagné d'un point d'interrogation et d'une chaîne, dans laquelle
dans le cas où la chaîne est utilisée comme invite (imprimée à l'erreur standard avant qu'une entrée ne soit
read) si l'entrée est un tty(4) (par exemple lire nfoo?'numéro of trucs : ').

Si aucune entrée n'est lue ou qu'un délai d'attente s'est produit, lire sort avec un statut différent de zéro.

Une autre série d'astuces pratiques : si lire est exécuté dans une boucle telle que tout en lire fou ; do ...;
fait alors les espaces blancs seront supprimés (IFS) et les barres obliques inverses traitées. Vous
pourrait vouloir utiliser tout en IFS= lire -r fou ; do ...; fait pour des E/S impeccables. De la même manière,
lors de l'utilisation du -a option, utilisation de la -r l'option pourrait être prudente; la même chose s'applique
pour:

trouver . -type f -print0 |& \
tandis que IFS= read -d '' -pr nom de fichier ; faire
print -r -- "trouvé <${filename#./}>"
fait

La boucle interne sera exécutée dans un sous-shell et les modifications de variables ne peuvent pas être
propagé si exécuté dans un pipeline :

barre | baz | tout en lisant foo; faire ...; Fini

Utilisez plutôt des co-processus :

barre | baz |&
pendant la lecture -p foo; faire ...; Fini
exec 3>&p; exécutable 3>&-

lecture seulement [-p] [paramètre [=Plus-value] ]
Définit l'attribut en lecture seule des paramètres nommés. Si des valeurs sont données,
les paramètres leur sont définis avant de définir l'attribut. Une fois qu'un paramètre est fait
en lecture seule, il ne peut pas être désactivé et sa valeur ne peut pas être modifiée.

Si aucun paramètre n'est spécifié, les noms de tous les paramètres avec la valeur en lecture seule
attribut sont imprimés un par ligne, à moins que le -p l'option est utilisée, auquel cas
lecture seulement les commandes définissant tous les paramètres en lecture seule, y compris leurs valeurs, sont
imprimé.

chemin réel [--] prénom
Imprime le chemin d'accès absolu résolu correspondant à prénom. Si prénom se termine par un
barre oblique ('/'), son existence est également vérifiée et s'il s'agit d'un répertoire ;
autrement, chemin réel renvoie 0 si le chemin existe ou peut être créé
immédiatement, c'est-à-dire que tous les composants sauf le dernier existent et sont des répertoires.

rebaptiser [--] de à
Renomme le fichier de à à. Les deux doivent être des chemins d'accès complets et sur le même périphérique.
Cette fonction intégrée est destinée aux situations d'urgence où /bin/mv devient inutilisable et
appelle directement rebaptiser (2).

retourner [statuts]
Retours d'une fonction ou . script, avec état de sortie statuts. Sinon statuts est donné,
l'état de sortie de la dernière commande exécutée est utilisé. Si utilisé en dehors d'une fonction
or . script, il a le même effet que sortie. Noter que mksh traite à la fois le profil et
ENV en tant que . scripts, tandis que le shell Korn d'origine ne traite les profils que comme .
scripts.

set [+-abCefhiklmnprsUuvXx] [+-o option] [+-A prénom] [--] [arg ]
La set La commande peut être utilisée pour définir (-) ou effacer (+) options du shell, définissez la position
paramètres ou définissez un paramètre de tableau. Les options peuvent être modifiées à l'aide de la +-o option
syntaxe, où option est le nom long d'une option, ou en utilisant le +-lettre syntaxe,
De lettre est le nom d'une seule lettre de l'option (toutes les options n'ont pas une seule lettre
Nom). Le tableau suivant répertorie à la fois les lettres d'option (si elles existent) et les noms longs
avec une description de ce que fait l'option :

-A prénom
Définit les éléments du paramètre de tableau prénom à arg If -A Est utilisé, le
le tableau est réinitialisé (c'est-à-dire vidé) en premier ; si +A est utilisé, les N premiers éléments sont définis
(où N est le nombre d'arguments) ; le reste est laissé intact.

Une syntaxe alternative pour la commande set -A foo -- a b c qui est compatible avec
GNU bash et également pris en charge par AT&T UNIX 93 XNUMX ksh est: foo=(un b c); foo+=(d e)

-a | -o toutexporter
Tous les nouveaux paramètres sont créés avec l'attribut export.

-b | -o notifier
Imprimez les messages de notification de tâche de manière asynchrone, au lieu de juste avant le
rapide. Utilisé uniquement si le contrôle des tâches est activé (-m).

-C | -o nul
Empêcher > la redirection d'écraser les fichiers existants. Au lieu de cela, >| doit être utilisé
pour forcer un écrasement. Notez que ce n'est pas sûr à utiliser pour la création de
fichiers temporaires ou lockfiles dus à un TOCTOU dans un chèque permettant de rediriger
sortie vers / dev / null ou d'autres fichiers de périphérique, même dans nul mode.

-e | -o erresort
Quitter (après avoir exécuté le trap ERR) dès qu'une erreur se produit ou qu'une commande
échoue (c'est-à-dire se termine avec un statut différent de zéro). Cela ne s'applique pas aux commandes
dont l'état de sortie est explicitement testé par une construction shell telle que if, jusqu'à,
tout enou ! déclarations. Pour && ou ||, seul le statut de la dernière commande est
testé.

-f | -o noglob
Ne développez pas les modèles de nom de fichier.

-h | -o tout suivre
Créez des alias suivis pour toutes les commandes exécutées (voir Alias au dessus). Activée
par défaut pour les shells non interactifs.

-i | -o Interactif
Le shell est un shell interactif. Cette option ne peut être utilisée que lorsque le shell
est invoqué. Voir ci-dessus pour une description de ce que cela signifie.

-k | -o mot-clé
Les affectations de paramètres sont reconnues n'importe où dans une commande.

-l | -o vous connecter
Le shell est un shell de connexion. Cette option ne peut être utilisée que lorsque le shell est
invoqué. Voir ci-dessus pour une description de ce que cela signifie.

-m | -o moniteur
Activer le contrôle des tâches (par défaut pour les shells interactifs).

-n | -o noexec
N'exécutez aucune commande. Utile pour vérifier la syntaxe des scripts (ignoré
si interactif).

-p | -o privilégié
Le shell est un shell privilégié. Il est défini automatiquement si, lorsque le shell
démarre, l'UID ou le GID réel ne correspond pas à l'UID effectif (EUID) ou au GID
(EGID), respectivement. Voir ci-dessus pour une description de ce que cela signifie.

-r | -o limité
Le shell est un shell restreint. Cette option ne peut être utilisée que lorsque le shell est
invoqué. Voir ci-dessus pour une description de ce que cela signifie.

-s | -o Stdin
Si elles sont utilisées lorsque le shell est invoqué, les commandes sont lues à partir de l'entrée standard. Ensemble
automatiquement si le shell est invoqué sans argument.

Quand -s est utilisé avec le set commande, les arguments spécifiés sont
triés avant de les affecter aux paramètres positionnels (ou au tableau prénom, Si
-A est utilisé).

-U | -o mode utf8
Activer la prise en charge UTF-8 dans le Emacs édition mode et gestion interne des chaînes
les fonctions. Ce drapeau est désactivé par défaut, mais peut être activé en le définissant
sur la ligne de commande du shell ; est activé automatiquement pour les shells interactifs si
demandé au moment de la compilation, votre système prend en charge définirlocale(LC_CTYPE, "") et
facultativement nl_langinfo(JEU DE CODES), ou l'environnement LC_ALL, LC_CTYPE ou LANG
variables, et au moins l'une d'entre elles renvoie quelque chose qui correspond à "UTF-8" ou
« utf8 » sans tenir compte de la casse ; pour les appels intégrés directs selon le
les variables d'environnement susmentionnées ; ou pour stdin ou scripts, si l'entrée
commence par une marque d'ordre d'octet UTF-8.

Dans un avenir proche, le suivi des paramètres régionaux sera mis en œuvre, ce qui signifie que set -+U is
changé chaque fois que l'une des variables d'environnement liées aux paramètres régionaux POSIX change.

-u | -o nom
Le référencement d'un paramètre non défini, autre que « $@ » ou « $* », est traité comme un
erreur, sauf si l'un des modificateurs '-', '+' ou '=' est utilisé.

-v | -o verbeux
Écrire l'entrée du shell sur l'erreur standard au fur et à mesure qu'elle est lue.

-X | -o marqueurs
Marquez les répertoires avec un '/' à la fin lors de la génération du nom de fichier.

-x | -o x trace
Affiche les arborescences de commandes lorsqu'elles sont exécutées, précédées de la valeur de PS4.

-o merci
Les tâches en arrière-plan sont exécutées avec une priorité inférieure.

-o accolade développer
Activer l'extension de l'accolade (alias alternance). C'est activé par défault. Si
désactivé, l'expansion du tilde après un signe égal est désactivée comme effet secondaire.

-o emacs
Activer l'édition en ligne de commande de type BRL emacs (shells interactifs uniquement) ; voir Emacs
édition mode.

-o gmacs
Activez l'édition en ligne de commande de type gmacs (shells interactifs uniquement). Actuellement
identique à l'édition emacs sauf que transpose-chars (^T) agit légèrement
différemment.

-o ignorer
Le shell ne se fermera pas (facilement) lors de la lecture de la fin du fichier ; sortie doit être utilisé.
Pour éviter les boucles infinies, le shell se fermera si EOF est lu 13 fois de suite.

-o hériter-xtrace
Ne pas réinitialiser -o x trace lors de la saisie des fonctions. C'est activé par défault.

-o nohup
Ne tuez pas les tâches en cours d'exécution avec un signal SIGHUP lorsqu'un shell de connexion se termine.
Actuellement défini par défaut, mais cela peut changer à l'avenir pour être compatible
avec AT&T UNIX ksh, qui n'a pas cette option, mais envoie le SIGHUP
signal.

-o nolog
Aucun effet. Dans le shell Korn d'origine, cela empêche les définitions de fonction de
étant stocké dans le fichier historique.

-o Physique
Provoque le cd ainsi que pwd commandes pour utiliser « physique » (c'est-à-dire le système de fichiers) « .. »
répertoires au lieu de répertoires « logiques » (c'est-à-dire que le shell gère « .. », qui
permet à l'utilisateur d'ignorer les liens symboliques vers les répertoires). Effacer par
défaut. Notez que la définition de cette option n'affecte pas la valeur actuelle du
paramètre PWD ; seulement le cd la commande change PWD. Voir le cd ainsi que pwd commandes
ci-dessus pour plus de détails.

-o panne de canalisation
Faire de l'état de sortie d'un pipeline (avant de le compléter logiquement) le
errorlevel non nul le plus à droite, ou zéro si toutes les commandes se terminent par zéro.

-o posix
Se comporter au plus près des normes (voir POSIX mode pour les détails). Automatiquement
activé si le nom de base de l'invocation du shell commence par "sh" et ceci
la fonction de détection automatique est compilée (pas dans MirBSD). Comme effet secondaire, le réglage
ce drapeau s'éteint accolade développer mode, qui peut être réactivé manuellement, et
sh mode (sauf si les deux sont activés en même temps).

-o sh
Activer / Bin / sh mode (kludge) (voir SH mode). Activé automatiquement si le
le nom de base de l'invocation du shell commence par "sh" et cette fonction de détection automatique
est compilé dans (pas dans MirBSD). Comme effet secondaire, la définition de ce drapeau se désactive
accolade développer mode, qui peut être réactivé manuellement, et posix mode (à moins que
les deux sont activés en même temps).

-o vi
Activer viÉdition en ligne de commande de type (1) (shells interactifs uniquement). Voir Vi
édition mode pour la documentation et les limitations.

-o vi-esccomplet
Dans l'édition de la ligne de commande vi, complétez la commande et le nom de fichier lors de l'échappement (^[)
est entré en mode commande.

-o vi-tabcomplet
Dans l'édition de la ligne de commande vi, complétez la commande et le nom de fichier lorsque l'onglet (^I) est
entré en mode insertion. C'est la valeur par défaut.

-o viraw
Aucun effet. Dans le shell Korn d'origine, à moins que viraw a été défini, la commande vi-
le mode ligne laisserait le tty(4) le conducteur effectue le travail jusqu'à ce que ESC (^[) soit entré.
mksh est toujours en mode viraw.

Ces options peuvent également être utilisées lors de l'invocation du shell. L'ensemble actuel de
Les options (avec des noms à une seule lettre) peuvent être trouvées dans le paramètre '$-'. set -o avec
aucun nom d'option ne listera toutes les options et si chacune est activée ou désactivée ; set +o sera
imprimer les noms longs de toutes les options actuellement activées. Dans une future version, set
+o se comportera conformément à POSIX et imprimera des commandes pour restaurer les options actuelles
à la place.

Les arguments restants, le cas échéant, sont des paramètres positionnels et sont affectés, dans l'ordre, à
les paramètres de position (c'est-à-dire $1, $2, etc.). Si les options se terminent par '--' et là
n'y a pas d'arguments restants, tous les paramètres de position sont effacés. Si aucune option ou
les arguments sont donnés, les valeurs de tous les noms sont affichées. Pour historique inconnu
raisons, une seule option '-' est traitée spécialement - elle efface à la fois le -v ainsi que -x
options.

décalage [nombre]
Les paramètres de position nombre+ 1, nombre+2, etc. sont renommés en '1', '2', etc.
nombre la valeur par défaut est 1.

sleep secondes
Suspend l'exécution pendant au moins secondes spécifié comme valeur décimale positive
avec une partie fractionnaire optionnelle. La livraison du signal peut continuer l'exécution plus tôt.

la source filet [arg ]
Comme . ("dot"), sauf que le répertoire de travail courant est ajouté à la recherche
chemin (GNU bash extension).

suspendre
Arrête le shell comme s'il avait reçu le caractère de suspension du terminal. Il est
impossible de suspendre un shell de connexion à moins que le processus parent ne soit membre du
même session de terminal mais est membre d'un groupe de processus différent. En général
règle, si le shell a été lancé par un autre shell ou via su(1), il peut être suspendu.

tester expression
[ expression ]
tester évalue le expression et renvoie l'état zéro si vrai, 1 si faux ou supérieur
que 1 en cas d'erreur. Il est normalement utilisé comme commande de condition de if ainsi que
tout en déclarations. Les liens symboliques sont suivis pour tous filet expressions sauf -h ainsi que
-L.

Les expressions de base suivantes sont disponibles :

-a filet filet existe.

-b filet filet est un dispositif spécial de bloc.

-c filet filet est un dispositif spécial de caractère.

-d filet filet est un directeur.

-e filet filet existe.

-f filet filet est un fichier normal.

-G filet filetLe groupe de est l'ID de groupe effectif du shell.

-g filet filetLe mode de a le bit setgid défini.

-H filet filet est un répertoire dépendant du contexte (utile uniquement sur HP-UX).

-h filet filet est un lien symbolique.

-k filet filetle mode de a le gluant(8) bits réglés.

-L filet filet est un lien symbolique.

-O filet filetLe propriétaire de est l'ID utilisateur effectif du shell.

-o option coquillage option est réglé (voir le set commande ci-dessus pour une liste de
option). En tant qu'extension non standard, si l'option commence par
un '!', le test est annulé ; le test échoue toujours si option
n'existe pas (donc [ -o foo -o -o !foo ] renvoie vrai si et seulement
si option foo existe). La même chose peut être obtenue avec [ -o ?foo ]
comme dans AT&T UNIX 93 XNUMX ksh. option peut aussi être le drapeau court mené par
soit '-' ou '+' (pas de négation logique), par exemple '-x' ou '+x'
au lieu de « xtrace ».

-p filet filet est un tube nommé (FIFO).

-r filet filet existe et est lisible.

-S filet filet est une unix(4) socket de domaine.

-s filet filet n'est pas vide.

-t fd Descripteur de fichier fd est une tty(4) appareil.

-u filet filetLe mode de a le bit setuid défini.

-w filet filet existe et est accessible en écriture.

-x filet filet existe et est exécutable.

file1 -NT file2 file1 est plus récent que file2 or file1 existe et file2 ne fait pas.

file1 -pas file2 file1 est plus vieux que file2 or file2 existe et file1 ne fait pas.

file1 -si file2 file1 est le même fichier que file2.

un magnifique un magnifique a une longueur non nulle.

-n un magnifique un magnifique n'est pas vide.

-z un magnifique un magnifique est vide.

un magnifique = un magnifique Les cordes sont égales.

un magnifique == un magnifique Les cordes sont égales.

un magnifique > un magnifique Le premier opérande de chaîne est supérieur au deuxième opérande de chaîne.

un magnifique < un magnifique Le premier opérande de chaîne est inférieur au deuxième opérande de chaîne.

un magnifique != un magnifique Les chaînes ne sont pas égales.

nombre -eq nombre Les nombres se comparent égaux.

nombre -Ne nombre Les nombres ne sont pas égaux.

nombre -donner nombre Les nombres se comparent supérieurs ou égaux.

nombre -Gt nombre Les nombres se comparent supérieurs à.

nombre -Le nombre Les nombres se comparent inférieurs ou égaux.

nombre -lt nombre Les nombres se comparent moins que.

Les expressions de base ci-dessus, dans lesquelles les opérateurs unaires ont la priorité sur les binaires
opérateurs, peuvent être combinés avec les opérateurs suivants (listés par ordre croissant
de préséance):

expr -o expr OU logique.
expr -a expr ET logique.
! expr NON logique.
( expr ) Regroupement.

Notez qu'un nombre peut en fait être une expression arithmétique, telle qu'une expression mathématique
terme ou le nom d'une variable entière :

x=1 ; [ "x" -eq 1 ] est évalué à vrai

Notez que certaines règles spéciales sont appliquées (avec l'aimable autorisation de POSIX) si le nombre de
arguments à tester ou à l'intérieur des parenthèses [ ] est inférieur à cinq : si '!'
les arguments peuvent être supprimés de telle sorte qu'il ne reste qu'un à trois arguments, alors le
la comparaison abaissée est exécutée ; (merci à XSI) parenthèses \( \) inférieur quatre et
des formes à trois arguments aux formes à deux et à un argument, respectivement ; trois arguments
les formes préfèrent finalement les opérations binaires, suivies de la négation et de la parenthèse
abaissement; les formes à deux et quatre arguments préfèrent la négation suivie de parenthèses ; la
la forme à un argument implique toujours -n.

Notes: Une erreur courante consiste à utiliser « if [ $foo = bar ] » qui échoue si le paramètre « foo »
est NULL ou non défini, s'il contient des espaces intégrés (c'est-à-dire des octets IFS), ou s'il s'agit d'un unaire
opérateur comme '!' ou '-n'. Utilisez des tests comme "if [ x"$foo" = x"bar" ]" à la place, ou le
opérateur double crochet "if [[ $foo = bar ]]" ou, pour éviter la correspondance de modèle (voir [[
ci-dessus) : "si [[ $foo = "$bar" ]]"

La [[ ]] construct est non seulement plus sûr à utiliser, mais aussi souvent plus rapide.

fiable [-p] [pipeline]
Si un pipeline est donné, les temps utilisés pour exécuter le pipeline sont indiqués. Sinon
pipeline est donné, puis l'utilisateur et l'heure système utilisés par le shell lui-même, et tout
les commandes qu'il a exécutées depuis son démarrage sont signalées. Les temps indiqués sont
le temps réel (temps écoulé du début à la fin), le temps CPU utilisateur (temps passé
s'exécutant en mode utilisateur) et le temps CPU système (temps passé à s'exécuter en mode noyau).
Les temps sont rapportés à l'erreur standard ; le format de la sortie est :

0m0.00s réel 0m0.00s utilisateur 0m0.00s système

Si la -p l'option est donnée, la sortie est légèrement plus longue :

vrai 0.00
utilisateur 0.00
système 0.00

C'est une erreur de spécifier le -p option à moins que pipeline est une commande simple.

Les redirections simples d'erreur standard n'affectent pas la sortie du fiable commander:

$ time sleep 1 2>un fichier
$ { temps de sommeil 1 ; } 2>un fichier

Les temps de la première commande ne vont pas à « un fichier », mais ceux de la deuxième commande oui.

fois Imprimer les temps utilisateur et système accumulés utilisés à la fois par le shell et par les processus
que le shell a commencé qui sont sortis. Le format de la sortie est :

0m0.00s 0m0.00s
0m0.00s 0m0.00s

piège n [signal ]
Si le premier opérande est un entier décimal non signé, cela réinitialise tous les signaux spécifiés
à l'action par défaut, c'est-à-dire la même chose que d'appeler piège avec un signe moins ('-') comme
maître, suivi des arguments (n [signal ]), qui sont tous traités comme
signaux.

piège [maître signal ]
Définit un gestionnaire d'interruptions qui doit être exécuté lorsque l'un des signals sont
reçu. maître est soit une chaîne vide, indiquant que les signaux doivent être
ignoré, un signe moins ('-'), indiquant que l'action par défaut doit être prise pour
les signaux (voir signal(3)), ou une chaîne contenant des commandes shell à exécuter à
la première opportunité (c'est-à-dire lorsque la commande en cours se termine, ou avant l'impression
la prochaine invite PS1) après réception de l'un des signaux. signal est le nom d'un
signal (par ex. PIPE ou ALRM) ou le numéro du signal (voir le tuer -l commander
au dessus de).

Il existe deux signaux spéciaux : EXIT (également appelé 0), qui est exécuté lorsque le
shell est sur le point de se terminer et ERR, qui est exécuté après qu'une erreur se soit produite ; une erreur est
quelque chose qui ferait sortir le shell si le set -e or set -o erresort option
ont été fixés. Les gestionnaires EXIT sont exécutés dans l'environnement du dernier exécuté
commander.

Notez que, pour les shells non interactifs, le gestionnaire d'interruptions ne peut pas être modifié pour les signaux
qui ont été ignorés au démarrage du shell.

Sans arguments, l'état actuel des pièges qui ont été définis depuis le shell
commencé est affiché comme une série de piège commandes. Notez que la sortie de piège ne peut pas
être utilement redirigé vers un autre processus (un artefact du fait que les pièges sont supprimés
lors de la création des sous-processus).

Le piège DEBUG du shell Korn d'origine et la gestion des pièges ERR et EXIT dans
les fonctions ne sont pas encore implémentées.

oui Une commande qui se termine avec une valeur zéro.

de défis [[+-alpnrtUux] [-L[n]] [-R[n]] [-Z[n]] [-i[n]] | -f [-smoking]] [prénom [=Plus-value] ]
composer [[+-alpnrtUux] [-LRZ[n]] [-i[n]] | -f [-smoking]] [prénom [=Plus-value] ]
Afficher ou définir les attributs des paramètres. Sans prénom arguments, attributs de paramètre
sont affichés; si aucune option n'est utilisée, les attributs actuels de tous les paramètres sont
imprimé comme composer commandes ; si une option est donnée (ou '-' sans lettre d'option),
tous les paramètres et leurs valeurs avec les attributs spécifiés sont imprimés ; si option
sont introduits avec '+', les valeurs des paramètres ne sont pas imprimées.

If prénom les arguments sont donnés, les attributs des paramètres nommés sont définis (-) ou
effacé (+). Les valeurs des paramètres peuvent éventuellement être spécifiées. Pour prénom[*], la
le changement affecte l'ensemble du tableau et aucune valeur ne peut être spécifiée.

If composer est utilisé dans une fonction, tous les paramètres spécifiés sont localisés. Cette
n'est pas fait par le par ailleurs identique de défis. Notes: Cela signifie que mksh 's de défis
la commande est ne sauraient équivalent à d'autres langages de programmation car il ne permet pas un
fonction appelée depuis une autre fonction pour accéder à un paramètre à portée vraiment globale,
mais empêche seulement de mettre un accès dans la portée locale.

Quand -f est utilisé, composer opère sur les attributs des fonctions. Comme avec
paramètres, si non prénom les arguments sont donnés, les fonctions sont listées avec leurs valeurs
(c'est-à-dire des définitions) à moins que les options ne soient introduites avec '+', auquel cas seul le
les noms de fonction sont signalés.

-a Attribut de tableau indexé.

-f Mode de fonction. Afficher ou définir des fonctions et leurs attributs, au lieu de
paramètres.

-i[n] Attribut entier. n spécifie la base à utiliser lors de l'affichage de l'entier
(si non spécifié, la base donnée dans le premier devoir est utilisée).
Les paramètres avec cet attribut peuvent se voir attribuer des valeurs contenant de l'arithmétique
expressions.

-L[n] Attribut justifié à gauche. n spécifie la largeur du champ. Si n n'est pas spécifié,
la largeur actuelle d'un paramètre (ou la largeur de sa première valeur attribuée)
est utilisé. Les espaces de début (et les zéros, s'ils sont utilisés avec le -Z option) est
dépouillé. Si nécessaire, les valeurs sont soit tronquées, soit remplies d'espace pour s'adapter
la largeur du champ.

-l Attribut en minuscule. Tous les caractères majuscules dans les valeurs sont convertis en
minuscule. (Dans le shell Korn d'origine, ce paramètre signifiait « entier long »
lorsqu'il est utilisé avec le -i option.)

-n Créer une variable liée (référence de nom) : tout accès à la variable prénom
accédera à la variable Plus-value dans le périmètre actuel (cela est différent de
AT&T UNIX 93 XNUMX ksh!) plutôt. Également différent d'AT&T UNIX 93 XNUMX ksh que
Plus-value est évalué paresseusement au moment prénom est accessible. Cela peut être utilisé par
fonctions pour accéder aux variables dont les noms sont passés en paramètres, à la place
d'utilisation eval.

-p Impression terminée composer commandes qui peuvent être utilisées pour recréer les attributs
et les valeurs des paramètres.

-R[n] Attribut de justification à droite. n spécifie la largeur du champ. Si n n'est pas
spécifié, la largeur actuelle d'un paramètre (ou la largeur de son premier
valeur assignée) est utilisé. Les espaces de fin sont supprimés. Si nécessaire,
les valeurs sont soit dépouillées des caractères de début, soit remplies d'espace pour les rendre
adapter la largeur du champ.

-r Attribut en lecture seule. Les paramètres avec cet attribut ne peuvent pas être affectés à
ou non réglé. Une fois cet attribut défini, il ne peut pas être désactivé.

-t Attribut de balise. N'a aucune signification pour le shell ; fourni pour l'utilisation de l'application.

Pour les fonctions, -t est l'attribut trace. Quand fonctionne avec la trace
attribut sont exécutés, le x trace (-x) l'option shell est temporairement activée
sur.

-U Attribut entier non signé. Les entiers sont imprimés sous forme de valeurs non signées (combinez
les -i option). Cette option n'est pas dans le shell Korn d'origine.

-u Attribut majuscule. Tous les caractères minuscules dans les valeurs sont convertis en
haut de casse. (Dans le shell Korn d'origine, ce paramètre signifiait « non signé
entier" lorsqu'il est utilisé avec le -i option qui signifiait que les lettres majuscules seraient
ne jamais être utilisé pour des bases supérieures à 10. Voir le -U option.)

Pour les fonctions, -u est l'attribut indéfini. Voir Les fonctions ci-dessus pour le
implications de cela.

-x Attribut d'exportation. Les paramètres (ou fonctions) sont placés dans l'environnement de
toutes les commandes exécutées. Les fonctions exportées ne sont pas encore implémentées.

-Z[n] Attribut de remplissage nul. S'il n'est pas combiné avec -L, c'est la même chose que -R, sauf
le remplissage zéro est utilisé au lieu du remplissage d'espace. Pour les entiers, le nombre
au lieu de la base est rembourrée.

Si l'un des -i, -L, -l, -R, -U, -uou -Z les options sont modifiées, toutes les autres de cette
set sont effacés, à moins qu'ils ne soient également donnés sur la même ligne de commande.

ulimit [-aBCcdefHilMmnOPpqrSsTtVvw] [Plus-value]
Afficher ou définir les limites de processus. Si aucune option n'est utilisée, la limite de taille de fichier (-f) est
assumé. Plus-value, s'il est spécifié, peut être soit une expression arithmétique, soit le mot
"illimité". Les limites affectent le shell et tous les processus créés par le shell
après l'imposition d'une limite. Notez que certains systèmes peuvent ne pas autoriser les limites
augmenté une fois qu'ils sont définis. Notez également que les types de limites disponibles sont le système
dépendant - certains systèmes n'ont que le -f limite.

-a Afficher toutes les limites ; sauf si -H est utilisé, les limites logicielles sont affichées.

-B n Définissez la taille du tampon de socket sur n kibioctets.

-C n Définissez le nombre de threads mis en cache sur n.

-c n Imposer une taille limite de n blocs sur la taille des vidages de mémoire.

-d n Imposer une taille limite de n kibioctets sur la taille de la zone de données.

-e n Réglez la gentillesse maximale sur n.

-f n Imposer une taille limite de n blocs sur les fichiers écrits par le shell et son enfant
processus (les fichiers de toute taille peuvent être lus).

-H Définissez uniquement la limite stricte (la valeur par défaut consiste à définir à la fois les limites strictes et souples).

-i n Réglez le nombre de signaux en attente sur n.

-l n Imposer une limite de n kibioctets sur la quantité de mémoire physique verrouillée (câblée).

-M n Réglez la mémoire verrouillée AIO sur n kibioctets.

-m n Imposer une limite de n kibioctets sur la quantité de mémoire physique utilisée.

-n n Imposer une limite de n descripteurs de fichiers pouvant être ouverts à la fois.

-O n Réglez le nombre d'opérations AIO sur n.

-P n Limitez le nombre de threads par processus à n.

-p n Imposer une limite de n processus qui peuvent être exécutés par l'utilisateur à tout moment.

-q n Limitez la taille des files d'attente de messages POSIX à n octets.

-r n Définissez la priorité maximale en temps réel sur n.

-S Définissez uniquement la limite logicielle (la valeur par défaut consiste à définir à la fois les limites matérielles et logicielles).

-s n Imposer une taille limite de n kibioctets sur la taille de la zone de pile.

-T n Imposer un délai de n secondes réelles à utiliser par chaque processus.

-t n Imposer un délai de n Secondes CPU passées en mode utilisateur à utiliser par chacun
processus.

-V n Définissez le nombre de moniteurs vnode sur Haiku sur n.

-v n Imposer une limite de n kibioctets sur la quantité de mémoire virtuelle (espace d'adressage)
utilisé.

-w n Imposer une limite de n kibioctets sur la quantité d'espace de swap utilisé.

Autant que ulimit est concerné, un bloc fait 512 octets.

umask [-S] [masque]
Affichez ou définissez le masque de création d'autorisation de fichier, ou umask (voir umask(2)). Si la -S
est utilisée, le masque affiché ou défini est symbolique ; sinon c'est un octal
.

Les masques symboliques sont comme ceux utilisés par chmod(1). Lorsqu'ils sont utilisés, ils décrivent ce que
des autorisations peuvent être rendues disponibles (par opposition aux masques octaux dans lesquels un bit défini signifie
le bit correspondant est à effacer). Par exemple, "ug=rwx,o=" définit le masque de manière
les fichiers ne seront pas lisibles, inscriptibles ou exécutables par « d'autres », et est équivalent
(sur la plupart des systèmes) au masque octal « 007 ».

Unalias [-adt] [prénom ]
Les alias des noms donnés sont supprimés. Si la -a l'option est utilisée, tous les alias
sont enlevés. Si la -t or -d les options sont utilisées, les opérations indiquées sont effectuées
sur des alias suivis ou de répertoire, respectivement.

unset [-fv] paramètre
Désactivez les paramètres nommés (-v, la valeur par défaut) ou des fonctions (-f). Avec paramètre[*],
les attributs sont conservés, seules les valeurs ne sont pas définies.

L'état de sortie est différent de zéro si l'un des paramètres a l'attribut en lecture seule
mis, zéro sinon.

attendez [JOB ]
Attendez la fin des travaux spécifiés. Le statut de sortie de attendez est celui du dernier
travail spécifié ; si le dernier job est tué par un signal, l'état de sortie est 128 + le
numéro du signal (voir tuer -l état-de-sortie au dessus); si le dernier travail spécifié ne peut pas
être trouvé (parce qu'il n'a jamais existé, ou qu'il était déjà terminé), l'état de sortie de attendez
est de 127. Voir Emploi des bactéries ci-dessous pour le format de JOB. attendez reviendra si un signal
pour lequel un trap a été défini est reçu, ou si un signal SIGHUP, SIGINT ou SIGQUIT
est reçu.

Si aucun travail n'est spécifié, attendez attend que tous les travaux en cours (le cas échéant)
termine et sort avec un statut zéro. Si la surveillance des travaux est activée, l'achèvement
l'état des travaux est imprimé (ce n'est pas le cas lorsque les travaux sont explicitement spécifiés).

D'où [-pv] [prénom ]
Sans le -v option, c'est la même chose que commander -v, sauf que les alias ne sont pas imprimés
comme commande d'alias. Avec le -v option, c'est exactement la même chose que commander -V. En
dans les deux cas, le -p l'option diffère : le chemin de recherche n'est pas affecté dans D'où, mais
la recherche est limitée au chemin.

Emploi des bactéries
Le contrôle des tâches fait référence à la capacité du shell à surveiller et à contrôler les tâches qui sont des processus ou
groupes de processus créés pour les commandes ou les pipelines. Au minimum, la coque garde la trace
de l'état des travaux d'arrière-plan (c'est-à-dire asynchrones) qui existent actuellement ; cette
les informations peuvent être affichées à l'aide de la emplois commandes. Si le contrôle des tâches est entièrement activé
(À L'Aide De set -m or set -o moniteur), comme pour les shells interactifs, les processus d'un travail
sont placés dans leur propre groupe de processus. Les travaux de premier plan peuvent être arrêtés en tapant la commande suspend
caractère du terminal (normalement ^Z), les travaux peuvent être redémarrés au premier plan ou
arrière-plan en utilisant le fg ainsi que bg commandes, et l'état du terminal est enregistré ou restauré
lorsqu'un travail de premier plan est arrêté ou redémarré, respectivement.

Notez que seules les commandes qui créent des processus (par exemple, commandes asynchrones, sous-shell
commandes et commandes non intégrées et non fonctionnelles) peuvent être arrêtés ; des commandes comme lire ne peut pas
être.

Lorsqu'un travail est créé, un numéro de travail lui est attribué. Pour les shells interactifs, ce nombre est
imprimé à l'intérieur de « [..] », suivi des ID de processus des processus du travail lorsqu'un
la commande asynchrone est exécutée. Un emploi peut être mentionné dans le bg, fg, emplois, tueret attendez
commandes soit par l'ID de processus du dernier processus dans le pipeline de commandes (tel qu'il est stocké dans
le $! paramètre) ou en préfixant le numéro de la tâche d'un signe de pourcentage ('%'). Autre pourcentage
les séquences peuvent également être utilisées pour faire référence à des tâches :

%+ | %% | % Le travail arrêté le plus récemment ou, s'il n'y a pas de travail arrêté, le plus ancien
travail en cours d'exécution.

%- Le travail qui serait le %+ travail si celui-ci n'existait pas.

%n Le travail avec le numéro de travail n.

%?un magnifique Le travail avec sa commande contenant la chaîne un magnifique (une erreur se produit si
plusieurs emplois sont appariés).

%un magnifique Le travail avec sa commande commençant par la chaîne un magnifique (une erreur se produit si
plusieurs emplois sont appariés).

Lorsqu'un travail change d'état (par exemple, un travail d'arrière-plan se termine ou un travail de premier plan est arrêté), le
shell imprime les informations d'état suivantes :

[nombre] drapeau statuts commander

où ...

nombre est le numéro de travail du travail ;

drapeau est le caractère '+' ou '-' si le travail est le %+ or %- travail, respectivement, ou espace
si ce n'est ni l'un ni l'autre ;

statuts indique l'état actuel du travail et peut être :

Fait [nombre]
Le travail est terminé. nombre est l'état de sortie du travail qui est omis
si le statut est zéro.

Exécution La tâche ne s'est ni arrêtée ni terminée (notez que l'exécution ne
signifie nécessairement consommer du temps CPU - le processus pourrait être bloqué
en attendant un événement).

Arrêté [signal]
Le travail a été arrêté par le signal (si aucun signal n'est donné, le
travail a été arrêté par SIGTSTP).

description-signal [« noyau sous-évalué »]
Le travail a été tué par un signal (par ex. défaut de mémoire, raccrochage) ; utiliser tuer -l
pour une liste de descriptions de signaux. Le message « core dumped » indique
le processus a créé un fichier de base.

commander est la commande qui a créé le processus. S'il y a plusieurs processus dans le
tâche, chaque processus aura une ligne indiquant son commander et peut-être son statuts, Si
il est différent du statut du processus précédent.

Lorsqu'une tentative est faite pour quitter le shell alors qu'il y a des travaux à l'état arrêté, le
shell avertit l'utilisateur qu'il y a des travaux arrêtés et ne se ferme pas. Si une autre tentative est
immédiatement fait pour quitter le shell, les travaux arrêtés reçoivent un signal SIGHUP et le shell
sorties. De même, si le nohup l'option n'est pas définie et des tâches sont en cours lors d'une tentative
est fait pour quitter un shell de connexion, le shell avertit l'utilisateur et ne quitte pas. Si un autre
une tentative est immédiatement effectuée pour quitter le shell, les travaux en cours reçoivent un signal SIGHUP et
la coquille sort.

POSIX mode
Saisie set -o posix le mode provoquera mksh se comporter encore plus conforme POSIX par endroits
où les valeurs par défaut ou les opinions diffèrent. Noter que mksh fonctionnera toujours avec non signé
arithmétique 32 bits ; utiliser lksh si l'arithmétique sur l'hôte Long type de données, complet avec ISO C
Comportement non défini, sont requis ; se référer au lksh(1) page de manuel pour plus de détails. La plupart des autres
historique, AT&T UNIX ksh-les différences compatibles ou opiniâtres peuvent être désactivées en utilisant ceci
mode; ceux-ci sont:

· Le GNU bash Redirection I / O &>filet n'est plus supporté.

· Les descripteurs de fichiers créés par les redirections d'E/S sont hérités par les processus enfants.

· Les nombres avec un premier chiffre zéro sont interprétés comme octaux.

· La echo Builtin n'interprète pas les barres obliques inverses et ne prend en charge que l'option exacte "-n ».

· ... (la liste est incomplète et peut changer pour R53)

SH mode
Le mode de compatibilité; destiné à être utilisé avec des scripts hérités qui ne peuvent pas être facilement corrigés ; la
les changements sont les suivants :

· Le GNU bash Redirection I / O &>filet n'est plus supporté.

· Les descripteurs de fichiers créés par les redirections d'E/S sont hérités par les processus enfants.

· La echo Builtin n'interprète pas les barres obliques inverses et ne prend en charge que l'option exacte "-n ».

· ... (la liste est incomplète et peut changer pour R53)

interactif contribution en ligne édition
Le shell prend en charge trois modes de lecture des lignes de commande à partir d'un tty(4) de manière interactive
session, contrôlée par le emacs, gmacset vi options (au plus une d'entre elles peut être définie à
une fois). La valeur par défaut est emacs. Les modes d'édition peuvent être définis explicitement à l'aide de la set intégré.
Si aucune de ces options n'est activée, le shell lit simplement les lignes en utilisant la tty(4)
chauffeur. Si la emacs or gmacs est définie, le shell permet une édition similaire à Emacs du
commander; de même, si le vi est définie, le shell permet une édition de type vi du
commander. Ces modes sont décrits en détail dans les sections suivantes.

Dans ces modes d'édition, si une ligne est plus longue que la largeur de l'écran (voir les COLONNES
paramètre), un caractère '>', '+' ou '<' est affiché dans la dernière colonne indiquant que
il y a plus de caractères après, avant et après, ou avant la position actuelle,
respectivement. La ligne défile horizontalement si nécessaire.

Les lignes complétées sont poussées dans l'historique, sauf si elles commencent par un octet IFS ou IFS
espace blanc, ou sont les mêmes que la ligne précédente.

Emacs édition mode
When the emacs est définie, l'édition interactive de la ligne d'entrée est activée. Attention : ce mode
est légèrement différent du mode emacs du shell Korn d'origine. Dans ce mode, divers
les commandes d'édition (généralement liées à un ou plusieurs caractères de contrôle) provoquent des actions immédiates
sans attendre une nouvelle ligne. Plusieurs commandes d'édition sont liées à un contrôle particulier
caractères lorsque le shell est invoqué ; ces fixations peuvent être modifiées à l'aide du lier commander.

Ce qui suit est une liste des commandes d'édition disponibles. Chaque description commence par le
nom de la commande, suffixé par deux points ; une [n] (si la commande peut être préfixée par un
compter); et toutes les touches auxquelles la commande est liée par défaut, écrites en utilisant la notation caret, par exemple
le caractère ASCII ESC est écrit sous la forme ^[. Ces séquences de contrôle ne sont pas sensibles à la casse.
Un préfixe de comptage pour une commande est entré à l'aide de la séquence ^[n, Où n est une suite de 1
ou plusieurs chiffres. Sauf indication contraire, si un nombre est omis, sa valeur par défaut est 1.

Notez que les noms de commande d'édition ne sont utilisés qu'avec le lier commander. En outre, de nombreux
les commandes d'édition ne sont utiles que sur les terminaux avec un curseur visible. Les liaisons par défaut
ont été choisis pour ressembler aux raccourcis clavier Emacs correspondants. Les utilisateurs tty(4) personnages
(par exemple ERASE) sont liés à des substituts raisonnables et remplacent les liaisons par défaut.

annuler : ^C, ^G
Abandonnez la commande en cours, videz le tampon de ligne et définissez l'état de sortie sur
interrompu.

insertion automatique : [n]
Fait simplement apparaître le caractère comme entrée littérale. Les personnages les plus ordinaires
sont liés à cela.

caractère arrière : [n] ^B, ^XD, ANSI-CourtGauche, PC-CourtGauche
Déplace le curseur vers l'arrière n caractères.

mot-arrière: [n] ^[b, ANSI-Ctrl-CurLeft, ANSI-Alt-CurLeft
Déplace le curseur vers le début du mot ; les mots consistent en
caractères alphanumériques, traits de soulignement ('_') et signe dollar ('$').

début-de-l'histoire : ^[
Passe au début de l'historique.

début de ligne : ^A, ANSI-Home, PC-Home
Déplace le curseur au début de la ligne de saisie modifiée.

mot-majuscule : [n] ^[C, ^[c
Le premier caractère du suivant en majuscule n mots, en laissant le curseur après la fin
du dernier mot.

écran clair : ^[^L
Imprime une séquence configurable au moment de la compilation pour effacer l'écran et positionner le curseur,
redessine l'intégralité de l'invite et la ligne de saisie actuellement modifiée. La séquence par défaut
fonctionne pour presque tous les terminaux standard.

commentaire : ^[#
Si la ligne courante ne commence pas par un caractère de commentaire, un est ajouté à la
début de la ligne et la ligne est entrée (comme si retour avait été pressé) ;
sinon, les caractères de commentaire existants sont supprimés et le curseur est placé sur
le début de la ligne.

complet : ^[^[
Complète automatiquement autant qu'il est unique du nom de la commande ou du nom du fichier
contenant le curseur. Si l'intégralité du nom de la commande ou du fichier restant est unique, un
l'espace est imprimé après son achèvement, sauf s'il s'agit d'un nom de répertoire auquel cas
'/' est ajouté. S'il n'y a pas de commande ou de nom de fichier avec le mot partiel courant
comme préfixe, un caractère de cloche est émis (généralement, un bip retentit).

commande-complète : ^X^[
Complète automatiquement autant qu'il est unique du nom de la commande ayant le partiel
mot jusqu'au curseur comme préfixe, comme dans le complet commande ci-dessus.

fichier-complet : ^[^X
Complète automatiquement autant qu'il est unique du nom de fichier ayant la partie
mot jusqu'au curseur comme préfixe, comme dans le complet commande décrite ci-dessus.

liste-complète : ^I, ^[=
Complétez autant que possible le mot courant et listez les possibles
achèvements pour cela. Si une seule complétion est possible, faites correspondre comme dans le complet
commande ci-dessus. Notez que ^I est généralement généré par la touche TAB (tabulation).

delete-char-backward : [n] EFFACER, ^?, ^H
Les suppressions n caractères avant le curseur.

delete-char-forward : [n] ANSI-Suppr, PC-Suppr
Les suppressions n caractères après le curseur.

supprimer-mot-arrière : [n] EFFACER, ^[^?, ^[^H, ^[h
Les suppressions n mots avant le curseur.

delete-word-forward : [n] ^[d
Supprime les caractères après le curseur jusqu'à la fin de n mots.

bas-historique : [n] ^N, ^XB, ANSI-CurDown, PC-CurDown
Fait défiler le tampon d'historique vers l'avant n lignes (plus tard). Chaque ligne d'entrée à l'origine
commence juste après la dernière entrée dans le tampon d'historique, donc bas-histoire n'est pas
utile jusqu'à ce que soit historique des recherches, recherche-historique-up or historique a été
effectué.

mot-downcase : [n] ^[L, ^[l
Le suivant en minuscules n mots.

ligne d'édition : [n] ^Xe
Modifier la ligne n ou la ligne courante, si non spécifiée, interactivement. L'actuel
la commande exécutée est fc -e ${VISUEL :-${EDITEUR :-vi}} n.

fin de l'histoire : ^[>
Passe à la fin de l'historique.

fin de ligne : ^E, ANSI-End, PC-End
Déplace le curseur à la fin de la ligne de saisie.

eot : ^_
Agit comme une fin de dossier; c'est utile car l'entrée en mode édition désactive la normale
canonisation de l'entrée du terminal.

eot-ou-supprimer : [n] ^D
Agit comme EOT si seul sur une ligne; agit autrement comme supprimer-char-forward.

erreur : (non lié)
Erreur (sonnez la cloche).

échange-point-and-mark: ^X^X
Place le curseur là où se trouve la marque et place la marque là où se trouvait le curseur.

fichier-développer : ^[*
Ajoute un '*' au mot courant et remplace le mot par le résultat de
effectuer un regroupement de fichiers sur le mot. Si aucun fichier ne correspond au modèle, la cloche est
échelon.

caractère avant : [n] ^F, ^XC, ANSI-CurRight, PC-CurRight
Déplace le curseur vers l'avant n caractères.

mot avant : [n] ^[f, ANSI-Ctrl-CurRight, ANSI-Alt-CurRight
Avance le curseur jusqu'à la fin du ne mot.

aller à l'historique : [n] ^[g
Va au numéro d'historique n.

ligne de mise à mort : KILL
Supprime toute la ligne d'entrée.

kill-région : ^W
Supprime l'entrée entre le curseur et la marque.

kill-to-eol : [n] ^K
Supprime l'entrée du curseur à la fin de la ligne si n n'est pas spécifié ;
sinon supprime les caractères entre le curseur et la colonne n.

liste : ^[?
Imprime une liste triée et en colonnes de noms de commandes ou de noms de fichiers (le cas échéant) qui peuvent
compléter le mot partiel contenant le curseur. Les noms de répertoire ont '/' ajouté
pour eux.

commande-liste : ^X ?
Imprime une liste triée et en colonnes des noms de commandes (le cas échéant) qui peuvent compléter le
mot partiel contenant le curseur.

fichier-liste : ^X^Y
Imprime une liste triée et en colonnes des noms de fichiers (le cas échéant) qui peuvent compléter le
mot partiel contenant le curseur. Les indicateurs de type de fichier sont ajoutés comme décrit
sous liste au dessus.

nouvelle ligne : ^J, ^M
Provoque le traitement de la ligne d'entrée actuelle par le shell. Le curseur actuel
position peut être n'importe où sur la ligne.

saut de ligne et suivant : ^O
Provoque le traitement de la ligne d'entrée actuelle par le shell, et la ligne suivante de
l'histoire devient la ligne courante. Ceci n'est utile qu'après un historique,
historique des recherches or recherche-historique-up.

no-op: QUITTER
Cela ne fait rien.

préfixe-1 : ^[
Introduit une séquence de commandes à 2 caractères.

préfixe-2 : ^X, ^[[, ^[O
Introduit une séquence de commandes à 2 caractères.

préc-hist-mot : [n] ^[., ^[_
Le dernier mot ou, s'il est donné, le nème mot (base zéro) du précédent (sur répétition
exécution, avant-dernier, troisième-dernier, etc.) est insérée au niveau du curseur. Utilisation de
cette commande d'édition supprime la marque.

citation : ^^, ^V
Le caractère suivant est pris littéralement plutôt que comme une commande d'édition.

redessiner : ^L
Réimprime la dernière ligne de la chaîne d'invite et la ligne d'entrée actuelle sur un nouveau
ligne.

recherche-caractère-en arrière : [n] ^[^]
Recherche en arrière dans la ligne courante pour le nème occurrence du caractère suivant
tapé.

recherche-caractère-en avant : [n] ^]
Rechercher vers l'avant dans la ligne actuelle pour le nème occurrence du caractère suivant
tapé.

historique de la recherche : ^R
Entrez en mode de recherche incrémentielle. La liste d'historique interne est recherchée en arrière pour
commandes correspondant à l'entrée. Un '^' initial dans la chaîne de recherche ancre le
chercher. La touche d'échappement quittera le mode de recherche. Autres commandes, y compris les séquences
d'évasion comme préfixe-1 suivie d'une préfixe-1 or préfixe-2 clé sera exécutée après
quitter le mode de recherche. le avortement (^G) la commande restaurera la ligne d'entrée avant
la recherche a commencé. Successif historique des recherches les commandes continuent la recherche en arrière jusqu'à
la prochaine occurrence précédente du motif. Le tampon d'historique ne conserve qu'un
nombre fini de lignes; les plus anciennes sont écartées si nécessaire.

recherche-historique-up : ANSI-PgUp, PC-PgUp
Recherche en arrière dans le tampon d'historique pour les commandes dont le début correspond au
partie de la ligne de saisie avant le curseur. Lorsqu'il est utilisé sur une ligne vide, cela a
le même effet que historique.

recherche-historique-down : ANSI-PgDn, PC-PgDn
Recherche vers l'avant dans le tampon d'historique pour les commandes dont le début correspond au
partie de la ligne de saisie avant le curseur. Lorsqu'il est utilisé sur une ligne vide, cela a
le même effet que bas-histoire. Ceci n'est utile qu'après un historique,
historique des recherches or recherche-historique-up.

set-mark-commande: ^[
Placez la marque à la position du curseur.

transpose-chars : ^T
Si en fin de ligne, ou si le gmacs l'option est définie, cela échange les deux
caractères précédents ; sinon, il échange les caractères précédents et actuels et
déplace le curseur d'un caractère vers la droite.

historique : [n] ^P, ^XA, ANSI-CurUp, PC-CurUp
Fait défiler le tampon d'historique vers l'arrière n lignes (antérieures).

mot-majuscule : [n] ^[U, ^[u
Le suivant en majuscule n mots.

version : ^[^V
Afficher la version de mksh. Le tampon d'édition actuel est restauré dès qu'une touche
est pressé. La touche de restauration est traitée, sauf s'il s'agit d'un espace.

tirer : ^Y
Insère la dernière chaîne de texte supprimée à la position actuelle du curseur.

Yank-pop : ^[y
Immédiatement après une coup sec, remplace la chaîne de texte insérée par la suivante précédemment
chaîne de texte tuée.

Vi édition mode
Remarque: Le mode d'édition en ligne de commande vi est orphelin, mais toujours fonctionnel. C'est 8 bits propre
mais ne prend spécifiquement pas en charge UTF-8 ou MBCS.

L'éditeur de ligne de commande vi dans mksh a fondamentalement les mêmes commandes que le vi(1) éditeur avec
les exceptions suivantes:

· Vous commencez en mode insertion.

· Il existe des commandes de nom de fichier et d'achèvement de commande : =, \, *, ^X, ^E, ^F et,
en option, et .

· La _ la commande est différente (dans mksh, c'est le dernier argument de la commande ; dans vi(1) ça va
au début de la ligne courante).

· La / ainsi que G les commandes se déplacent dans la direction opposée à la j commander.

· Les commandes qui n'ont pas de sens dans un éditeur à une seule ligne ne sont pas disponibles (par exemple screen
commandes de mouvement et ex(1)-style deux-points (:) commandes).

Comme vi(1), il existe deux modes : le mode « insertion » et le mode « commande ». En mode insertion, la plupart
les caractères sont simplement placés dans le tampon à la position actuelle du curseur au fur et à mesure qu'ils sont tapés ;
cependant, certains caractères sont traités spécialement. En particulier, les caractères suivants sont
tiré du courant tty(4) paramètres (voir Sty(1)) et ont leur sens habituel (valeurs normales
sont entre parenthèses) : kill (^U), effacer (^?), werase (^W), eof (^D), intr (^C) et quitter (^\).
En plus de ce qui précède, les caractères suivants sont également traités spécialement dans l'insert
mode:

^E Énumération des commandes et des noms de fichiers (voir ci-dessous).

^F Complétion des commandes et des noms de fichiers (voir ci-dessous). Si elle est utilisée deux fois de suite, la liste des
les complétions possibles sont affichées ; s'il est utilisé une troisième fois, l'achèvement est annulé.

^H Efface le caractère précédent.

^J | ^M Fin de ligne. La ligne actuelle est lue, analysée et exécutée par le shell.

^V Littéral ensuite. Le prochain caractère tapé n'est pas traité spécialement (peut être utilisé pour
insérer les caractères décrits ici).

^X Extension de la commande et du nom de fichier (voir ci-dessous).

Met l'éditeur en mode commande (voir ci-dessous).

Nom de fichier facultatif et achèvement de la commande (voir ^F ci-dessus), activé avec set -o
vi-tabcomplet.

En mode commande, chaque caractère est interprété comme une commande. Des personnages qui ne
correspondent à des commandes, sont des combinaisons illégales de commandes ou sont des commandes qui ne peuvent pas être
effectué, toutes causent des bips. Dans les descriptions de commandes suivantes, un [n] indique le
commande peut être précédée d'un numéro (par exemple 10l se déplace vers la droite de 10 caractères); si pas de numéro
le préfixe est utilisé, n est supposé être égal à 1, sauf indication contraire. Le terme « actuel
position” fait référence à la position entre le curseur et le caractère précédant le curseur.
Un « mot » est une séquence de lettres, de chiffres et de caractères de soulignement ou une séquence de non-
des lettres, des caractères non numériques, non soulignés et non blancs (par exemple, « ab2*&^ » contient deux
mots) et un « gros mot » est une séquence de caractères autres que des espaces.

# mksh commandes vi :

Les commandes suivantes ne font pas partie de l'éditeur de fichiers vi normal ou en sont différentes :

[n]_ Insérez un espace suivi du ne grand mot de la dernière commande de l'histoire
à la position actuelle et entrez en mode insertion ; si n n'est pas spécifié, le dernier
mot est inséré.

# Insérez le caractère de commentaire ('#') au début de la ligne courante et retournez
la ligne à la coque (équivalent à Je#^J).

[n]g J'aime G, sauf si n n'est pas spécifié, il va au plus récent mémorisé
ligne.

[n]v Modifier la ligne n utilisant l' vi(1) éditeur ; si n n'est pas spécifié, la ligne courante est
édité. La commande réelle exécutée est fc -e ${VISUEL :-${EDITEUR :-vi}} n.

* et ^X L'extension de la commande ou du nom de fichier est appliquée au gros mot courant (avec un
'*' ajouté si le mot ne contient aucun caractère de globalisation de fichier) - le grand mot est
remplacé par les mots résultants. Si le grand mot actuel est le premier sur le
ligne ou suit l'un des caractères ';', '|', '&', '(' ou ')', et ne
contenir une barre oblique ('/'), puis l'expansion de la commande est effectuée ; sinon nom de fichier
l'agrandissement est fait. L'expansion des commandes correspondra au grand mot contre tous
alias, fonctions et commandes intégrées ainsi que tous les fichiers exécutables trouvés
en recherchant les répertoires dans le paramètre PATH. L'extension du nom de fichier correspond
le grand mot contre les fichiers dans le répertoire courant. Après expansion, le
le curseur est placé juste après le dernier mot et l'éditeur est en mode insertion.

[n]\, [n]^F, [n] , et [n]
Complétion du nom de la commande/fichier. Remplacez le grand mot actuel par le plus long
correspondance unique obtenue après l'exécution de la commande et de l'extension du nom de fichier.
n'est reconnu que si le vi-tabcomplet l'option est définie, tandis que est seulement
reconnu si le vi-esccomplet l'option est définie (voir set -o). Si n est spécifié,
le nla complétion possible est sélectionnée (comme indiqué par la commande/le nom du fichier
commande d'énumération).

= et ^E Énumération des noms de commandes/fichiers. Répertoriez toutes les commandes ou fichiers qui correspondent au
grand mot actuel.

^V Affiche la version de mksh. Le tampon d'édition actuel est restauré dès qu'un
la touche est enfoncée. La touche de restauration est ignorée.

@c Extension de macros. Exécuter les commandes trouvées dans l'alias c.

Commandes de mouvement intra-ligne :

[n]main [n]^H
Se déplacer à gauche n caractères.

[n]terre [n]
Déplacer vers la droite n caractères.

0 Passer à la colonne 0.

^ Déplacez-vous vers le premier caractère non blanc.

[n]| Déplacer vers la colonne n.

$ Se déplacer jusqu'au dernier caractère.

[n]b Revenir en arrière n mots.

[n]B Revenir en arrière n grands mots.

[n]e Avancer jusqu'à la fin du mot, n fois.

[n]E Avancez jusqu'à la fin du grand mot, n fois.

[n]w Avancer n mots.

[n]W Avancer n grands mots.

% Trouver la correspondance. L'éditeur attend avec impatience la parenthèse, la parenthèse ou l'accolade la plus proche
puis déplace le curseur sur la parenthèse, le crochet ou l'accolade correspondants.

[n]fc Avancez vers le nème occurrence du caractère c.

[n]Fc Revenir en arrière vers le nème occurrence du caractère c.

[n]tc Avancez juste avant le nème occurrence du caractère c.

[n]Tc Revenir juste avant le nème occurrence du caractère c.

[n] ; répète le dernier f, F, tou T commander.

[n], répète le dernier f, F, tou T commande, mais se déplace dans la direction opposée.

Commandes de déplacement inter-lignes :

[n]j, [n]+, et [n]^N
Aller à la nème ligne suivante dans l'histoire.

[n]k, [n]-, et [n]^P
Aller à la nème ligne précédente de l'historique.

[n]G Déplacer vers la ligne n dans l'histoire; si n n'est pas spécifié, le numéro du premier
la ligne mémorisée est utilisée.

[n]g J'aime G, sauf si n n'est pas spécifié, il va à la ligne mémorisée la plus récente.

[n]/un magnifique
Rechercher en arrière dans l'historique pour le nème ligne contenant un magnifique; si un magnifique
commence par '^', le reste de la chaîne doit apparaître au début de l'historique
ligne pour qu'il corresponde.

[n]?un magnifique
Pareil que /, sauf qu'il recherche vers l'avant dans l'historique.

[n]n Recherchez le nème occurrence de la dernière chaîne de recherche ; le sens de la recherche
est le même que la dernière recherche.

[n]N Rechercher le nème occurrence de la dernière chaîne de recherche ; le sens de la recherche
est le contraire de la dernière recherche.

ANSI-CurUp, PC-Page Up
Prendre les caractères du début de la ligne à la position actuelle du curseur comme
chaîne de recherche et effectuez une recherche historique en arrière pour les lignes commençant par ceci
chaîne de caractères; garder la position du curseur. Cela ne fonctionne qu'en mode insertion et le conserve
activée.

Modifier les commandes

[n]a Ajouter du texte n fois; passe en mode insertion juste après la position actuelle. le
append n'est répliqué que si le mode de commande est à nouveau entré, c'est-à-dire est utilisé.

[n]A Identique à a, sauf qu'il s'ajoute à la fin de la ligne.

[n]i Insérer du texte n fois; passe en mode insertion à la position actuelle. L'insertion
n'est répliqué que si le mode de commande est à nouveau entré, c'est-à-dire est utilisé.

[n] I Identique à i, sauf que l'insertion se fait juste avant le premier caractère non vide.

[n]s Remplacer le suivant n caractères (c'est-à-dire supprimer les caractères et entrer dans insérer
mode).

S Remplacez la ligne entière. Tous les caractères du premier caractère non vide à la fin
de la ligne sont supprimés et le mode insertion est activé.

[n]cdéplacer-cmd
Passage de la position actuelle à la position résultant de n déplacer-cmds (c'est-à-dire
supprimer la région indiquée et passer en mode insertion); si déplacer-cmd is c, La ligne
à partir du premier caractère non vide est modifié.

C Passer de la position actuelle à la fin de la ligne (c'est-à-dire supprimer à la fin de
la ligne et passer en mode insertion).

[n]x Supprimer le suivant n caractères.

[n]X Supprimer le précédent n caractères.

D Supprimer jusqu'à la fin de la ligne.

[n]ddéplacer-cmd
Supprimer de la position actuelle à la position résultant de n déplacer-cmds;
déplacer-cmd est une commande de mouvement (voir ci-dessus) ou d, auquel cas la ligne courante est
supprimée.

[n]rc Remplacer le suivant n personnages avec le personnage c.

[n]R Remplacer. Entrez en mode insertion mais écrasez les caractères existants au lieu d'insérer
avant les caractères existants. Le remplacement est répété n fois.

[n]~ Changer la casse du prochain n caractères.

[n]ydéplacer-cmd
Tirez de la position actuelle à la position résultant de n déplacer-cmds dans le
arracher le tampon ; si déplacer-cmd is y, toute la ligne est arrachée.

Y Tirez de la position actuelle à la fin de la ligne.

[n]p Colle le contenu du tampon Yank juste après la position actuelle, n fois.

[n]P Identique à p, sauf que le tampon est collé à la position actuelle.

Diverses commandes vi

^J et ^M
La ligne courante est lue, analysée et exécutée par le shell.

^L et ^R
Redessine la ligne courante.

[n]. Refaire la dernière commande d'édition n fois.

u Annuler la dernière commande d'édition.

U Annuler toutes les modifications apportées à la ligne actuelle.

Touches PC Accueil, Fin, Suppr et curseur
Ils se déplacent comme prévu, à la fois en mode insertion et en mode commande.

intr ainsi que quitter
Les caractères terminaux d'interruption et de sortie entraînent la suppression de la ligne en cours et
une nouvelle invite à imprimer.

Utiliser mksh en ligne à l'aide des services onworks.net