????

Your IP : 3.20.224.152

Current Path : C:/opt/msys64/usr/share/locale/ro/LC_MESSAGES/

Current File : C:/opt/msys64/usr/share/locale/ro/LC_MESSAGES/bash.mo

��V�|%�1*�12</2$l2
�2�2�2�2�2�233 33=3O3f3}3�3�3�3�3 �34404H4(d4/�4;�4$�4:5Y5l5�5(�5'�5"�56#6@63^6�6 �6&�6&�6/7/C7s7�7.�7�7"�78+'8S8e8/~8�8�8�8"�8939D9b9~9"�9/�9�9�9:-&:T:j:�:�:�:�:�:�:;);)F;p;�;�;�;�;�;< <!?<a<w<,�<�< �<�<
=0=.H=w=0�=�=�=�=>>.>E>]>w>�>
�>�>�>&�>?4?/R?�?�?)�?�?�?&@3-@a@~@�@�@&�@�@�@�@
AA9+A#eA�A�A�A��AH�E�H�H
IFI`JoJJ�J �J �J��J�P�
�Pw[1�[m�[ ]�0]�^]a�fbT?f�h��lX_p+�uL�w�1y�y?�|�$�-�t=�����������O�w��f��^��X�g@����u�������v��
�|�����i�
���8�O�j���?���ذ����Ա ���$� 4�>�G�[� o�y�N���ϲJQ����,r�=��f��D�DS������$�P�x\������������2��������<��@�F��F�L`����Xt�����>���'�,�s9��Z�`3D���� �b�:"B"S"g"|"O�"*�#
$$,$E$5^$O�$B�%�'&B�+E@,�,
�,�,}�,4/XH/�/*�/
�/
�/�0��4J6�Y6�C7�;<
<$<5<G<%f<$�<'�<�<%�<=,=.F=u=�=!�=�=�=
>>'.>0V>�>9�>�>�>�>$?@?T?
e?s?&|?'�?3�?9�?9@6K@6�@��@.MA:|A3�A �A�A!B
0B3>BrB=�B-�B�B'C&EC*lC*�C)�C)�C%D%<D bD1�D#�D1�D&E&2E&YE5�E.�E�E�E!F!3F:UF�F�F �F0�F1G�LG��G#�H(�H$�H�H$I#*I'NIvIS~I.�IJ J6JLJ)cJ
�J�J�J�J�J,�J%*K,PK%}K�K.�K?�K+!LMLVLcL,xL�L#�L@�L
M,MIM-dM,�M'�M�M.N,1N&^N*�N0�N6�NPO(iO �O)�O�O�O"P?+PTkP�P�P
�P8�PV.Q&�Q'�Q4�Q R)RAR(NRwR�R�R�R�R"�RS5
SOCS�S�S�S �S�S5�ST6T
>T
IT+TT9�T;�T$�TUd9U$�U�U�U�U�UV 1VRVmV�VH�V�V�V WW")W+LWxW�W�W4�W
�WD�W?5X,uX�X�X2�X!Y""Y"EY0hY�Y�Y �Yo�Y@ZfSZ1�Z/�Z)[-F[3t[�[&�[2�[5\,R\
\
�\1�\I�\4].F]>u](�],�],
^07^)h^N�^ �^�^ �^"_;_W_q_~_&�_=�_�_#`/`'F`n`�`�`,�`)�`a$6a[aqa}a�a"�a6�a�abQ7b*�b�b�b%�b.c-=c7kc6�c2�c1
d*?d,jd,�d;�d#e$e,eBe#be�e6�e�e�e*f"-fPf6pf �f�f-�f-�f#gAg'Qg'yg�g�g(�g=�i5j=Kj'�j�j�j�j%�jk%k?kXkmkyk$�k�k.�k!l#l#Alel1l�l�l�l'�l:mFSmZ�m&�m=nZn&on�n@�n5�n1&oXo so�o6�o�o:p8>p+wpH�p;�p(qBq8^q'�q+�q�q;rCr"[r;~r#�r/�rs-+sYsts8�s"�s�sAt4Ft{t�t�tP�t!u!@ubuzu�u/�u�u�uv"'v4Jv"v!�v"�v�v�vw#0w%Tw2zw�w�w8�w x(5x^x}x?�xK�x*y:Cy%~y�y%�y�y
z!z?z _z�z�z�z�z#�z,{?{W{@w{"�{$�{2|!3|U|6h|@�|�|�|}4}=D}�}�}�}�}�}M�}2'~Z~s~�~o�~�
���̆ކf�,U�������"ƈ�������
ߜ8��#���)՞������1E��w��l�ZE�����%�������x�w-� ��
�������_��f��-��������
����������������O����
�����w�����'�E�Zw�R���)�#"9)\!�'����2?YG5�D�� K��yp#����#
�%�
�%j�071D8vZ8��;��?K�@\�B�0F8(I>aK��LaWNf�Nn O�P��R
GTRT�gTxPX��[S�d��gw�j{ ~��~�)�Ԇ� �O�b�h�w��� �����0������&؏��9��Y�]%�R��Y֙^0�������0̚��k�0��7�������
�����
���
�&�5�$S�*x�*��6ή*�L0�}�*��?ů,�(2�=[�'��%���"��1�7Q� ��G�����-�,B�o�������9��4��H-�Qv�ȳ8ܳ8��N�;��E5�B{� ��0ȵ+��
%�_3�&��M��A�MJ�:��1ӷ@�CF�C��Bθ@�AR�*��?��J��;J�-��9��-�4�BQ���.��3ػH�5U���'��!м?�[2�����5�0�*�'G�o�(|�6��-ܿ
�V�7h�-�����,"�O�+a�������1�1�;:�3v���A��@��-<�j�s���/����-��B�U�,e�'��,��-��6�&L�.s�,��I��<�OV�5��U��22�$e�*������1��Y�[u�,�����B+�Pn�(��)��A�T�t���+����&����2�1K�}�:��]��%�:�L�
T�#_�Q��#����

�
�3#�GW�X��(��!!�eC�4�������*�%I�)o�*������u�!w�5������)��.!�8P�����D����Q�QW�7������J�(\�"��"��<���� 8�qB���q��4?�/t�G��?��R,�+�B��3��<"�,_���
��:��W��T9�/��@��<��@<�@}�D��<�V@� ����&��$���'%�M�Z�.m�K����,�15�1g�(�� ��'��2�.>�*m�4������(��!� 7�YX�����T��,E�r���H��\��UK�B��A��9&�8`�7��=��=�KM�.��
������!�5�?T�����6��9��&1�KX�����\��\!�!~���*��-��0�
@�Q+����|F���%&C<Y��_#��5��{o�b0n��lx�$/?O� ="�� !�H>���f��1�Pg�*�
vh�0;�LP���u'N�6M��rT?�`�\�:��>�7N�k�X<���*���BWmYb6�R"��T6�&>EC~
�%�B�`'�}�9�K��(�IfS.@m3���@ ����$FM�:
5��n��x�����?�[z �4
�����@�G�!QQ����S!���� ���L#J�B��^�WKP���;U%(����^/�H�y��Tu��0�Z��2�t��p�����#,RH�Z.4�,dU�1V{A��i\�FI���l$�-�8��k��Ipc+y���V�G���3:�e���J���������g��A��D�G"v�5<h8qt���,�NOj;r��_��1�7���s�9�J��ww�)�V���
�D���c]���.U)�Cs/�����2��i}��4*��+A�e] �zd��=j����q-�a[8�K���'&��7���3�����X��L�9�Eo
(E�D���a~��O����S-�|���M=����)�R2timed out waiting for input: auto-logout
-%s or -o option
-ilrsD or -c command or -O shopt_option (invocation only)

malloc: %s:%d: assertion botched
(wd: %s) (core dumped) line $%s: cannot assign in this way%c%c: invalid option%d: invalid file descriptor: %s%s can be invoked via %s has null exportstr%s is %s
%s is a function
%s is a shell builtin
%s is a shell keyword
%s is a special shell builtin
%s is aliased to `%s'
%s is hashed (%s)
%s is not bound to any keys.
%s out of range%s%s%s: %s (error token is "%s")%s: %s%s: %s out of range%s: %s: bad interpreter%s: %s: cannot open as FILE%s: %s: compatibility value out of range%s: %s: invalid value for trace file descriptor%s: %s: must use subscript when assigning associative array%s: %s:%d: cannot allocate %lu bytes%s: %s:%d: cannot allocate %lu bytes (%lu bytes allocated)%s: Is a directory%s: ambiguous job spec%s: ambiguous redirect%s: arguments must be process or job IDs%s: assigning integer to name reference%s: bad network path specification%s: bad substitution%s: binary operator expected%s: cannot allocate %lu bytes%s: cannot allocate %lu bytes (%lu bytes allocated)%s: cannot assign%s: cannot assign fd to variable%s: cannot assign list to array member%s: cannot assign to non-numeric index%s: cannot convert associative to indexed array%s: cannot convert indexed to associative array%s: cannot create: %s%s: cannot delete: %s%s: cannot destroy array variables in this way%s: cannot execute binary file%s: cannot execute binary file: %s%s: cannot execute: %s%s: cannot execute: required file not found%s: cannot export%s: cannot get limit: %s%s: cannot inherit value from incompatible type%s: cannot modify limit: %s%s: cannot open temp file: %s%s: cannot open: %s%s: cannot overwrite existing file%s: cannot read: %s%s: cannot unset%s: cannot unset: readonly %s%s: circular name reference%s: command not found%s: dynamic builtin already loaded%s: error retrieving current directory: %s: %s
%s: expression error
%s: file is too large%s: file not found%s: first non-whitespace character is not `"'%s: hash table empty
%s: history expansion failed%s: host unknown%s: illegal option -- %c
%s: inlib failed%s: integer expression expected%s: invalid action name%s: invalid argument%s: invalid array origin%s: invalid callback quantum%s: invalid file descriptor specification%s: invalid indirect expansion%s: invalid limit argument%s: invalid line count%s: invalid option%s: invalid option name%s: invalid service%s: invalid shell option name%s: invalid signal specification%s: invalid timeout specification%s: invalid timestamp%s: invalid variable name%s: invalid variable name for name reference%s: is a directory%s: job %d already in background%s: job has terminated%s: line %d: %s: maximum function nesting level exceeded (%d)%s: maximum source nesting level exceeded (%d)%s: missing colon separator%s: nameref variable self references not allowed%s: no completion specification%s: no current jobs%s: no job control%s: no such job%s: not a function%s: not a regular file%s: not a shell builtin%s: not an array variable%s: not an indexed array%s: not dynamically loaded%s: not found%s: numeric argument required%s: option requires an argument%s: option requires an argument -- %c
%s: parameter not set%s: parameter null or not set%s: quoted compound array assignment deprecated%s: readonly function%s: readonly variable%s: reference variable cannot be an array%s: removing nameref attribute%s: restricted%s: restricted: cannot redirect output%s: restricted: cannot specify `/' in command names%s: substring expression < 0%s: unary operator expected%s: unbound variable%s: usage: %s: variable may not be assigned value'

(( expression ))(core dumped) (wd now: %s)
. filename [arguments]/dev/(tcp|udp)/host/port not supported without networking/tmp must be a valid directory name<no current directory>ABORT instructionAborting...Add directories to stack.

Adds a directory to the top of the directory stack, or rotates
the stack, making the new top of the stack the current working
directory. With no arguments, exchanges the top two directories.

Options:
-n Suppresses the normal change of directory when adding
directories to the stack, so only the stack is manipulated.

Arguments:
+N Rotates the stack so that the Nth directory (counting
from the left of the list shown by `dirs', starting with
zero) is at the top.

-N Rotates the stack so that the Nth directory (counting
from the right of the list shown by `dirs', starting with
zero) is at the top.

dir Adds DIR to the directory stack at the top, making it the
new current working directory.

The `dirs' builtin displays the directory stack.

Exit Status:
Returns success unless an invalid argument is supplied or the directory
change fails.Adds a directory to the top of the directory stack, or rotates
the stack, making the new top of the stack the current working
directory. With no arguments, exchanges the top two directories.

Options:
-n Suppresses the normal change of directory when adding
directories to the stack, so only the stack is manipulated.

Arguments:
+N Rotates the stack so that the Nth directory (counting
from the left of the list shown by `dirs', starting with
zero) is at the top.

-N Rotates the stack so that the Nth directory (counting
from the right of the list shown by `dirs', starting with
zero) is at the top.

dir Adds DIR to the directory stack at the top, making it the
new current working directory.

The `dirs' builtin displays the directory stack.Alarm (profile)Alarm (virtual)Alarm clockArithmetic for loop.

Equivalent to
(( EXP1 ))
while (( EXP2 )); do
COMMANDS
(( EXP3 ))
done
EXP1, EXP2, and EXP3 are arithmetic expressions. If any expression is
omitted, it behaves as if it evaluates to 1.

Exit Status:
Returns the status of the last command executed.BPT trace/trapBad system callBogus signalBroken pipeBus errorCPU limitChange the shell working directory.

Change the current directory to DIR. The default DIR is the value of the
HOME shell variable.

The variable CDPATH defines the search path for the directory containing
DIR. Alternative directory names in CDPATH are separated by a colon (:).
A null directory name is the same as the current directory. If DIR begins
with a slash (/), then CDPATH is not used.

If the directory is not found, and the shell option `cdable_vars' is set,
the word is assumed to be a variable name. If that variable has a value,
its value is used for DIR.

Options:
-L force symbolic links to be followed: resolve symbolic
links in DIR after processing instances of `..'
-P use the physical directory structure without following
symbolic links: resolve symbolic links in DIR before
processing instances of `..'
-e if the -P option is supplied, and the current working
directory cannot be determined successfully, exit with
a non-zero status
-@ on systems that support it, present a file with extended
attributes as a directory containing the file attributes

The default is to follow symbolic links, as if `-L' were specified.
`..' is processed by removing the immediately previous pathname component
back to a slash or the beginning of DIR.

Exit Status:
Returns 0 if the directory is changed, and if $PWD is set successfully when
-P is used; non-zero otherwise.Child death or stopCommon shell variable names and usage.

BASH_VERSION Version information for this Bash.
CDPATH A colon-separated list of directories to search
for directories given as arguments to `cd'.
GLOBIGNORE A colon-separated list of patterns describing filenames to
be ignored by pathname expansion.
HISTFILE The name of the file where your command history is stored.
HISTFILESIZE The maximum number of lines this file can contain.
HISTSIZE The maximum number of history lines that a running
shell can access.
HOME The complete pathname to your login directory.
HOSTNAME The name of the current host.
HOSTTYPE The type of CPU this version of Bash is running under.
IGNOREEOF Controls the action of the shell on receipt of an EOF
character as the sole input. If set, then the value
of it is the number of EOF characters that can be seen
in a row on an empty line before the shell will exit
(default 10). When unset, EOF signifies the end of input.
MACHTYPE A string describing the current system Bash is running on.
MAILCHECK How often, in seconds, Bash checks for new mail.
MAILPATH A colon-separated list of filenames which Bash checks
for new mail.
OSTYPE The version of Unix this version of Bash is running on.
PATH A colon-separated list of directories to search when
looking for commands.
PROMPT_COMMAND A command to be executed before the printing of each
primary prompt.
PS1 The primary prompt string.
PS2 The secondary prompt string.
PWD The full pathname of the current directory.
SHELLOPTS A colon-separated list of enabled shell options.
TERM The name of the current terminal type.
TIMEFORMAT The output format for timing statistics displayed by the
`time' reserved word.
auto_resume Non-null means a command word appearing on a line by
itself is first looked for in the list of currently
stopped jobs. If found there, that job is foregrounded.
A value of `exact' means that the command word must
exactly match a command in the list of stopped jobs. A
value of `substring' means that the command word must
match a substring of the job. Any other value means that
the command must be a prefix of a stopped job.
histchars Characters controlling history expansion and quick
substitution. The first character is the history
substitution character, usually `!'. The second is
the `quick substitution' character, usually `^'. The
third is the `history comment' character, usually `#'.
HISTIGNORE A colon-separated list of patterns used to decide which
commands should be saved on the history list.
ContinueCopyright (C) 2022 Free Software Foundation, Inc.Create a coprocess named NAME.

Execute COMMAND asynchronously, with the standard output and standard
input of the command connected via a pipe to file descriptors assigned
to indices 0 and 1 of an array variable NAME in the executing shell.
The default NAME is "COPROC".

Exit Status:
The coproc command returns an exit status of 0.DEBUG warning: Define local variables.

Create a local variable called NAME, and give it VALUE. OPTION can
be any option accepted by `declare'.

Local variables can only be used within a function; they are visible
only to the function where they are defined and its children.

Exit Status:
Returns success unless an invalid option is supplied, a variable
assignment error occurs, or the shell is not executing a function.Define or display aliases.

Without arguments, `alias' prints the list of aliases in the reusable
form `alias NAME=VALUE' on standard output.

Otherwise, an alias is defined for each NAME whose VALUE is given.
A trailing space in VALUE causes the next word to be checked for
alias substitution when the alias is expanded.

Options:
-p print all defined aliases in a reusable format

Exit Status:
alias returns true unless a NAME is supplied for which no alias has been
defined.Define shell function.

Create a shell function named NAME. When invoked as a simple command,
NAME runs COMMANDs in the calling shell's context. When NAME is invoked,
the arguments are passed to the function as $1...$n, and the function's
name is in $FUNCNAME.

Exit Status:
Returns success unless NAME is readonly.Display directory stack.

Display the list of currently remembered directories. Directories
find their way onto the list with the `pushd' command; you can get
back up through the list with the `popd' command.

Options:
-c clear the directory stack by deleting all of the elements
-l do not print tilde-prefixed versions of directories relative
to your home directory
-p print the directory stack with one entry per line
-v print the directory stack with one entry per line prefixed
with its position in the stack

Arguments:
+N Displays the Nth entry counting from the left of the list
shown by dirs when invoked without options, starting with
zero.

-N Displays the Nth entry counting from the right of the list
shown by dirs when invoked without options, starting with
zero.

Exit Status:
Returns success unless an invalid option is supplied or an error occurs.Display information about builtin commands.

Displays brief summaries of builtin commands. If PATTERN is
specified, gives detailed help on all commands matching PATTERN,
otherwise the list of help topics is printed.

Options:
-d output short description for each topic
-m display usage in pseudo-manpage format
-s output only a short usage synopsis for each topic matching
PATTERN

Arguments:
PATTERN Pattern specifying a help topic

Exit Status:
Returns success unless PATTERN is not found or an invalid option is given.Display information about command type.

For each NAME, indicate how it would be interpreted if used as a
command name.

Options:
-a display all locations containing an executable named NAME;
includes aliases, builtins, and functions, if and only if
the `-p' option is not also used
-f suppress shell function lookup
-P force a PATH search for each NAME, even if it is an alias,
builtin, or function, and returns the name of the disk file
that would be executed
-p returns either the name of the disk file that would be executed,
or nothing if `type -t NAME' would not return `file'
-t output a single word which is one of `alias', `keyword',
`function', `builtin', `file' or `', if NAME is an alias,
shell reserved word, shell function, shell builtin, disk file,
or not found, respectively

Arguments:
NAME Command name to be interpreted.

Exit Status:
Returns success if all of the NAMEs are found; fails if any are not found.Display or execute commands from the history list.

fc is used to list or edit and re-execute commands from the history list.
FIRST and LAST can be numbers specifying the range, or FIRST can be a
string, which means the most recent command beginning with that
string.

Options:
-e ENAME select which editor to use. Default is FCEDIT, then EDITOR,
then vi
-l list lines instead of editing
-n omit line numbers when listing
-r reverse the order of the lines (newest listed first)

With the `fc -s [pat=rep ...] [command]' format, COMMAND is
re-executed after the substitution OLD=NEW is performed.

A useful alias to use with this is r='fc -s', so that typing `r cc'
runs the last command beginning with `cc' and typing `r' re-executes
the last command.

Exit Status:
Returns success or status of executed command; non-zero if an error occurs.Display or manipulate the history list.

Display the history list with line numbers, prefixing each modified
entry with a `*'. An argument of N lists only the last N entries.

Options:
-c clear the history list by deleting all of the entries
-d offset delete the history entry at position OFFSET. Negative
offsets count back from the end of the history list

-a append history lines from this session to the history file
-n read all history lines not already read from the history file
and append them to the history list
-r read the history file and append the contents to the history
list
-w write the current history to the history file

-p perform history expansion on each ARG and display the result
without storing it in the history list
-s append the ARGs to the history list as a single entry

If FILENAME is given, it is used as the history file. Otherwise,
if HISTFILE has a value, that is used, else ~/.bash_history.

If the HISTTIMEFORMAT variable is set and not null, its value is used
as a format string for strftime(3) to print the time stamp associated
with each displayed history entry. No time stamps are printed otherwise.

Exit Status:
Returns success unless an invalid option is given or an error occurs.Display or set file mode mask.

Sets the user file-creation mask to MODE. If MODE is omitted, prints
the current value of the mask.

If MODE begins with a digit, it is interpreted as an octal number;
otherwise it is a symbolic mode string like that accepted by chmod(1).

Options:
-p if MODE is omitted, output in a form that may be reused as input
-S makes the output symbolic; otherwise an octal number is output

Exit Status:
Returns success unless MODE is invalid or an invalid option is given.Display possible completions depending on the options.

Intended to be used from within a shell function generating possible
completions. If the optional WORD argument is supplied, matches against
WORD are generated.

Exit Status:
Returns success unless an invalid option is supplied or an error occurs.Display process times.

Prints the accumulated user and system times for the shell and all of its
child processes.

Exit Status:
Always succeeds.Display status of jobs.

Lists the active jobs. JOBSPEC restricts output to that job.
Without options, the status of all active jobs is displayed.

Options:
-l lists process IDs in addition to the normal information
-n lists only processes that have changed status since the last
notification
-p lists process IDs only
-r restrict output to running jobs
-s restrict output to stopped jobs

If -x is supplied, COMMAND is run after all job specifications that
appear in ARGS have been replaced with the process ID of that job's
process group leader.

Exit Status:
Returns success unless an invalid option is given or an error occurs.
If -x is used, returns the exit status of COMMAND.Display the list of currently remembered directories. Directories
find their way onto the list with the `pushd' command; you can get
back up through the list with the `popd' command.

Arguments:
+N Displays the Nth entry counting from the left of the list shown by
dirs when invoked without options, starting with zero.

-N Displays the Nth entry counting from the right of the list shown by
dirs when invoked without options, starting with zero.DoneDone(%d)EMT instructionEnable and disable shell builtins.

Enables and disables builtin shell commands. Disabling allows you to
execute a disk command which has the same name as a shell builtin
without using a full pathname.

Options:
-a print a list of builtins showing whether or not each is enabled
-n disable each NAME or display a list of disabled builtins
-p print the list of builtins in a reusable format
-s print only the names of Posix `special' builtins

Options controlling dynamic loading:
-f Load builtin NAME from shared object FILENAME
-d Remove a builtin loaded with -f

Without options, each NAME is enabled.

To use the `test' found in $PATH instead of the shell builtin
version, type `enable -n test'.

Exit Status:
Returns success unless NAME is not a shell builtin or an error occurs.Evaluate arithmetic expression.

The EXPRESSION is evaluated according to the rules for arithmetic
evaluation. Equivalent to `let "EXPRESSION"'.

Exit Status:
Returns 1 if EXPRESSION evaluates to 0; returns 0 otherwise.Evaluate arithmetic expressions.

Evaluate each ARG as an arithmetic expression. Evaluation is done in
fixed-width integers with no check for overflow, though division by 0
is trapped and flagged as an error. The following list of operators is
grouped into levels of equal-precedence operators. The levels are listed
in order of decreasing precedence.

id++, id-- variable post-increment, post-decrement
++id, --id variable pre-increment, pre-decrement
-, + unary minus, plus
!, ~ logical and bitwise negation
** exponentiation
*, /, % multiplication, division, remainder
+, - addition, subtraction
<<, >> left and right bitwise shifts
<=, >=, <, > comparison
==, != equality, inequality
& bitwise AND
^ bitwise XOR
| bitwise OR
&& logical AND
|| logical OR
expr ? expr : expr
conditional operator
=, *=, /=, %=,
+=, -=, <<=, >>=,
&=, ^=, |= assignment

Shell variables are allowed as operands. The name of the variable
is replaced by its value (coerced to a fixed-width integer) within
an expression. The variable need not have its integer attribute
turned on to be used in an expression.

Operators are evaluated in order of precedence. Sub-expressions in
parentheses are evaluated first and may override the precedence
rules above.

Exit Status:
If the last ARG evaluates to 0, let returns 1; let returns 0 otherwise.Evaluate conditional expression.

Exits with a status of 0 (true) or 1 (false) depending on
the evaluation of EXPR. Expressions may be unary or binary. Unary
expressions are often used to examine the status of a file. There
are string operators and numeric comparison operators as well.

The behavior of test depends on the number of arguments. Read the
bash manual page for the complete specification.

File operators:

-a FILE True if file exists.
-b FILE True if file is block special.
-c FILE True if file is character special.
-d FILE True if file is a directory.
-e FILE True if file exists.
-f FILE True if file exists and is a regular file.
-g FILE True if file is set-group-id.
-h FILE True if file is a symbolic link.
-L FILE True if file is a symbolic link.
-k FILE True if file has its `sticky' bit set.
-p FILE True if file is a named pipe.
-r FILE True if file is readable by you.
-s FILE True if file exists and is not empty.
-S FILE True if file is a socket.
-t FD True if FD is opened on a terminal.
-u FILE True if the file is set-user-id.
-w FILE True if the file is writable by you.
-x FILE True if the file is executable by you.
-O FILE True if the file is effectively owned by you.
-G FILE True if the file is effectively owned by your group.
-N FILE True if the file has been modified since it was last read.

FILE1 -nt FILE2 True if file1 is newer than file2 (according to
modification date).

FILE1 -ot FILE2 True if file1 is older than file2.

FILE1 -ef FILE2 True if file1 is a hard link to file2.

String operators:

-z STRING True if string is empty.

-n STRING
STRING True if string is not empty.

STRING1 = STRING2
True if the strings are equal.
STRING1 != STRING2
True if the strings are not equal.
STRING1 < STRING2
True if STRING1 sorts before STRING2 lexicographically.
STRING1 > STRING2
True if STRING1 sorts after STRING2 lexicographically.

Other operators:

-o OPTION True if the shell option OPTION is enabled.
-v VAR True if the shell variable VAR is set.
-R VAR True if the shell variable VAR is set and is a name
reference.
! EXPR True if expr is false.
EXPR1 -a EXPR2 True if both expr1 AND expr2 are true.
EXPR1 -o EXPR2 True if either expr1 OR expr2 is true.

arg1 OP arg2 Arithmetic tests. OP is one of -eq, -ne,
-lt, -le, -gt, or -ge.

Arithmetic binary operators return true if ARG1 is equal, not-equal,
less-than, less-than-or-equal, greater-than, or greater-than-or-equal
than ARG2.

Exit Status:
Returns success if EXPR evaluates to true; fails if EXPR evaluates to
false or an invalid argument is given.Evaluate conditional expression.

This is a synonym for the "test" builtin, but the last argument must
be a literal `]', to match the opening `['.Execute a simple command or display information about commands.

Runs COMMAND with ARGS suppressing shell function lookup, or display
information about the specified COMMANDs. Can be used to invoke commands
on disk when a function with the same name exists.

Options:
-p use a default value for PATH that is guaranteed to find all of
the standard utilities
-v print a description of COMMAND similar to the `type' builtin
-V print a more verbose description of each COMMAND

Exit Status:
Returns exit status of COMMAND, or failure if COMMAND is not found.Execute arguments as a shell command.

Combine ARGs into a single string, use the result as input to the shell,
and execute the resulting commands.

Exit Status:
Returns exit status of command or success if command is null.Execute commands as long as a test does not succeed.

Expand and execute COMMANDS-2 as long as the final command in COMMANDS has
an exit status which is not zero.

Exit Status:
Returns the status of the last command executed.Execute commands as long as a test succeeds.

Expand and execute COMMANDS-2 as long as the final command in COMMANDS has
an exit status of zero.

Exit Status:
Returns the status of the last command executed.Execute commands based on conditional.

The `if COMMANDS' list is executed. If its exit status is zero, then the
`then COMMANDS' list is executed. Otherwise, each `elif COMMANDS' list is
executed in turn, and if its exit status is zero, the corresponding
`then COMMANDS' list is executed and the if command completes. Otherwise,
the `else COMMANDS' list is executed, if present. The exit status of the
entire construct is the exit status of the last command executed, or zero
if no condition tested true.

Exit Status:
Returns the status of the last command executed.Execute commands based on pattern matching.

Selectively execute COMMANDS based upon WORD matching PATTERN. The
`|' is used to separate multiple patterns.

Exit Status:
Returns the status of the last command executed.Execute commands for each member in a list.

The `for' loop executes a sequence of commands for each member in a
list of items. If `in WORDS ...;' is not present, then `in "$@"' is
assumed. For each element in WORDS, NAME is set to that element, and
the COMMANDS are executed.

Exit Status:
Returns the status of the last command executed.Execute commands from a file in the current shell.

Read and execute commands from FILENAME in the current shell. The
entries in $PATH are used to find the directory containing FILENAME.
If any ARGUMENTS are supplied, they become the positional parameters
when FILENAME is executed.

Exit Status:
Returns the status of the last command executed in FILENAME; fails if
FILENAME cannot be read.Execute conditional command.

Returns a status of 0 or 1 depending on the evaluation of the conditional
expression EXPRESSION. Expressions are composed of the same primaries used
by the `test' builtin, and may be combined using the following operators:

( EXPRESSION ) Returns the value of EXPRESSION
! EXPRESSION True if EXPRESSION is false; else false
EXPR1 && EXPR2 True if both EXPR1 and EXPR2 are true; else false
EXPR1 || EXPR2 True if either EXPR1 or EXPR2 is true; else false

When the `==' and `!=' operators are used, the string to the right of
the operator is used as a pattern and pattern matching is performed.
When the `=~' operator is used, the string to the right of the operator
is matched as a regular expression.

The && and || operators do not evaluate EXPR2 if EXPR1 is sufficient to
determine the expression's value.

Exit Status:
0 or 1 depending on value of EXPRESSION.Execute shell builtins.

Execute SHELL-BUILTIN with arguments ARGs without performing command
lookup. This is useful when you wish to reimplement a shell builtin
as a shell function, but need to execute the builtin within the function.

Exit Status:
Returns the exit status of SHELL-BUILTIN, or false if SHELL-BUILTIN is
not a shell builtin.Exit %dExit a login shell.

Exits a login shell with exit status N. Returns an error if not executed
in a login shell.Exit for, while, or until loops.

Exit a FOR, WHILE or UNTIL loop. If N is specified, break N enclosing
loops.

Exit Status:
The exit status is 0 unless N is not greater than or equal to 1.Exit the shell.

Exits the shell with a status of N. If N is omitted, the exit status
is that of the last command executed.File limitFloating point exceptionFormats and prints ARGUMENTS under control of the FORMAT.

Options:
-v var assign the output to shell variable VAR rather than
display it on the standard output

FORMAT is a character string which contains three types of objects: plain
characters, which are simply copied to standard output; character escape
sequences, which are converted and copied to the standard output; and
format specifications, each of which causes printing of the next successive
argument.

In addition to the standard format specifications described in printf(1),
printf interprets:

%b expand backslash escape sequences in the corresponding argument
%q quote the argument in a way that can be reused as shell input
%Q like %q, but apply any precision to the unquoted argument before
quoting
%(fmt)T output the date-time string resulting from using FMT as a format
string for strftime(3)

The format is re-used as necessary to consume all of the arguments. If
there are fewer arguments than the format requires, extra format
specifications behave as if a zero value or null string, as appropriate,
had been supplied.

Exit Status:
Returns success unless an invalid option is given or a write or assignment
error occurs.GNU bash, version %s (%s)
GNU bash, version %s-(%s)
GNU long options:
General help using GNU software: <http://www.gnu.org/gethelp/>
Group commands as a unit.

Run a set of commands in a group. This is one way to redirect an
entire set of commands.

Exit Status:
Returns the status of the last command executed.HFT input data pendingHFT monitor mode grantedHFT monitor mode retractedHFT sound sequence has completedHOME not setHangupI have no name!I/O readyINFORM: Illegal instructionInformation requestInterruptKilledLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
Mark shell variables as unchangeable.

Mark each NAME as read-only; the values of these NAMEs may not be
changed by subsequent assignment. If VALUE is supplied, assign VALUE
before marking as read-only.

Options:
-a refer to indexed array variables
-A refer to associative array variables
-f refer to shell functions
-p display a list of all readonly variables or functions,
depending on whether or not the -f option is given

An argument of `--' disables further option processing.

Exit Status:
Returns success unless an invalid option is given or NAME is invalid.Modify or display completion options.

Modify the completion options for each NAME, or, if no NAMEs are supplied,
the completion currently being executed. If no OPTIONs are given, print
the completion options for each NAME or the current completion specification.

Options:
-o option Set completion option OPTION for each NAME
-D Change options for the "default" command completion
-E Change options for the "empty" command completion
-I Change options for completion on the initial word

Using `+o' instead of `-o' turns off the specified option.

Arguments:

Each NAME refers to a command for which a completion specification must
have previously been defined using the `complete' builtin. If no NAMEs
are supplied, compopt must be called by a function currently generating
completions, and the options for that currently-executing completion
generator are modified.

Exit Status:
Returns success unless an invalid option is supplied or NAME does not
have a completion specification defined.Modify shell resource limits.

Provides control over the resources available to the shell and processes
it creates, on systems that allow such control.

Options:
-S use the `soft' resource limit
-H use the `hard' resource limit
-a all current limits are reported
-b the socket buffer size
-c the maximum size of core files created
-d the maximum size of a process's data segment
-e the maximum scheduling priority (`nice')
-f the maximum size of files written by the shell and its children
-i the maximum number of pending signals
-k the maximum number of kqueues allocated for this process
-l the maximum size a process may lock into memory
-m the maximum resident set size
-n the maximum number of open file descriptors
-p the pipe buffer size
-q the maximum number of bytes in POSIX message queues
-r the maximum real-time scheduling priority
-s the maximum stack size
-t the maximum amount of cpu time in seconds
-u the maximum number of user processes
-v the size of virtual memory
-x the maximum number of file locks
-P the maximum number of pseudoterminals
-R the maximum time a real-time process can run before blocking
-T the maximum number of threads

Not all options are available on all platforms.

If LIMIT is given, it is the new value of the specified resource; the
special LIMIT values `soft', `hard', and `unlimited' stand for the
current soft limit, the current hard limit, and no limit, respectively.
Otherwise, the current value of the specified resource is printed. If
no option is given, then -f is assumed.

Values are in 1024-byte increments, except for -t, which is in seconds,
-p, which is in increments of 512 bytes, and -u, which is an unscaled
number of processes.

Exit Status:
Returns success unless an invalid option is supplied or an error occurs.Move job to the foreground.

Place the job identified by JOB_SPEC in the foreground, making it the
current job. If JOB_SPEC is not present, the shell's notion of the
current job is used.

Exit Status:
Status of command placed in foreground, or failure if an error occurs.Move jobs to the background.

Place the jobs identified by each JOB_SPEC in the background, as if they
had been started with `&'. If JOB_SPEC is not present, the shell's notion
of the current job is used.

Exit Status:
Returns success unless job control is not enabled or an error occurs.Null command.

No effect; the command does nothing.

Exit Status:
Always succeeds.OLDPWD not setParse option arguments.

Getopts is used by shell procedures to parse positional parameters
as options.

OPTSTRING contains the option letters to be recognized; if a letter
is followed by a colon, the option is expected to have an argument,
which should be separated from it by white space.

Each time it is invoked, getopts will place the next option in the
shell variable $name, initializing name if it does not exist, and
the index of the next argument to be processed into the shell
variable OPTIND. OPTIND is initialized to 1 each time the shell or
a shell script is invoked. When an option requires an argument,
getopts places that argument into the shell variable OPTARG.

getopts reports errors in one of two ways. If the first character
of OPTSTRING is a colon, getopts uses silent error reporting. In
this mode, no error messages are printed. If an invalid option is
seen, getopts places the option character found into OPTARG. If a
required argument is not found, getopts places a ':' into NAME and
sets OPTARG to the option character found. If getopts is not in
silent mode, and an invalid option is seen, getopts places '?' into
NAME and unsets OPTARG. If a required argument is not found, a '?'
is placed in NAME, OPTARG is unset, and a diagnostic message is
printed.

If the shell variable OPTERR has the value 0, getopts disables the
printing of error messages, even if the first character of
OPTSTRING is not a colon. OPTERR has the value 1 by default.

Getopts normally parses the positional parameters, but if arguments
are supplied as ARG values, they are parsed instead.

Exit Status:
Returns success if an option is found; fails if the end of options is
encountered or an error occurs.Print the name of the current working directory.

Options:
-L print the value of $PWD if it names the current working
directory
-P print the physical directory, without any symbolic links

By default, `pwd' behaves as if `-L' were specified.

Exit Status:
Returns 0 unless an invalid option is given or the current directory
cannot be read.QuitRead a line from the standard input and split it into fields.

Reads a single line from the standard input, or from file descriptor FD
if the -u option is supplied. The line is split into fields as with word
splitting, and the first word is assigned to the first NAME, the second
word to the second NAME, and so on, with any leftover words assigned to
the last NAME. Only the characters found in $IFS are recognized as word
delimiters. By default, the backslash character escapes delimiter characters
and newline.

If no NAMEs are supplied, the line read is stored in the REPLY variable.

Options:
-a array assign the words read to sequential indices of the array
variable ARRAY, starting at zero
-d delim continue until the first character of DELIM is read, rather
than newline
-e use Readline to obtain the line
-i text use TEXT as the initial text for Readline
-n nchars return after reading NCHARS characters rather than waiting
for a newline, but honor a delimiter if fewer than
NCHARS characters are read before the delimiter
-N nchars return only after reading exactly NCHARS characters, unless
EOF is encountered or read times out, ignoring any
delimiter
-p prompt output the string PROMPT without a trailing newline before
attempting to read
-r do not allow backslashes to escape any characters
-s do not echo input coming from a terminal
-t timeout time out and return failure if a complete line of
input is not read within TIMEOUT seconds. The value of the
TMOUT variable is the default timeout. TIMEOUT may be a
fractional number. If TIMEOUT is 0, read returns
immediately, without trying to read any data, returning
success only if input is available on the specified
file descriptor. The exit status is greater than 128
if the timeout is exceeded
-u fd read from file descriptor FD instead of the standard input

Exit Status:
The return code is zero, unless end-of-file is encountered, read times out
(in which case it's greater than 128), a variable assignment error occurs,
or an invalid file descriptor is supplied as the argument to -u.Read lines from a file into an array variable.

A synonym for `mapfile'.Read lines from the standard input into an indexed array variable.

Read lines from the standard input into the indexed array variable ARRAY, or
from file descriptor FD if the -u option is supplied. The variable MAPFILE
is the default ARRAY.

Options:
-d delim Use DELIM to terminate lines, instead of newline
-n count Copy at most COUNT lines. If COUNT is 0, all lines are copied
-O origin Begin assigning to ARRAY at index ORIGIN. The default index is 0
-s count Discard the first COUNT lines read
-t Remove a trailing DELIM from each line read (default newline)
-u fd Read lines from file descriptor FD instead of the standard input
-C callback Evaluate CALLBACK each time QUANTUM lines are read
-c quantum Specify the number of lines read between each call to
CALLBACK

Arguments:
ARRAY Array variable name to use for file data

If -C is supplied without -c, the default quantum is 5000. When
CALLBACK is evaluated, it is supplied the index of the next array
element to be assigned and the line to be assigned to that element
as additional arguments.

If not supplied with an explicit origin, mapfile will clear ARRAY before
assigning to it.

Exit Status:
Returns success unless an invalid option is given or ARRAY is readonly or
not an indexed array.Record lockRemember or display program locations.

Determine and remember the full pathname of each command NAME. If
no arguments are given, information about remembered commands is displayed.

Options:
-d forget the remembered location of each NAME
-l display in a format that may be reused as input
-p pathname use PATHNAME as the full pathname of NAME
-r forget all remembered locations
-t print the remembered location of each NAME, preceding
each location with the corresponding NAME if multiple
NAMEs are given
Arguments:
NAME Each NAME is searched for in $PATH and added to the list
of remembered commands.

Exit Status:
Returns success unless NAME is not found or an invalid option is given.Remove directories from stack.

Removes entries from the directory stack. With no arguments, removes
the top directory from the stack, and changes to the new top directory.

Options:
-n Suppresses the normal change of directory when removing
directories from the stack, so only the stack is manipulated.

Arguments:
+N Removes the Nth entry counting from the left of the list
shown by `dirs', starting with zero. For example: `popd +0'
removes the first directory, `popd +1' the second.

-N Removes the Nth entry counting from the right of the list
shown by `dirs', starting with zero. For example: `popd -0'
removes the last directory, `popd -1' the next to last.

The `dirs' builtin displays the directory stack.

Exit Status:
Returns success unless an invalid argument is supplied or the directory
change fails.Remove each NAME from the list of defined aliases.

Options:
-a remove all alias definitions

Return success unless a NAME is not an existing alias.Remove jobs from current shell.

Removes each JOBSPEC argument from the table of active jobs. Without
any JOBSPECs, the shell uses its notion of the current job.

Options:
-a remove all jobs if JOBSPEC is not supplied
-h mark each JOBSPEC so that SIGHUP is not sent to the job if the
shell receives a SIGHUP
-r remove only running jobs

Exit Status:
Returns success unless an invalid option or JOBSPEC is given.Removes entries from the directory stack. With no arguments, removes
the top directory from the stack, and changes to the new top directory.

Options:
-n Suppresses the normal change of directory when removing
directories from the stack, so only the stack is manipulated.

Arguments:
+N Removes the Nth entry counting from the left of the list
shown by `dirs', starting with zero. For example: `popd +0'
removes the first directory, `popd +1' the second.

-N Removes the Nth entry counting from the right of the list
shown by `dirs', starting with zero. For example: `popd -0'
removes the last directory, `popd -1' the next to last.

The `dirs' builtin displays the directory stack.Replace the shell with the given command.

Execute COMMAND, replacing this shell with the specified program.
ARGUMENTS become the arguments to COMMAND. If COMMAND is not specified,
any redirections take effect in the current shell.

Options:
-a name pass NAME as the zeroth argument to COMMAND
-c execute COMMAND with an empty environment
-l place a dash in the zeroth argument to COMMAND

If the command cannot be executed, a non-interactive shell exits, unless
the shell option `execfail' is set.

Exit Status:
Returns success unless COMMAND is not found or a redirection error occurs.Report time consumed by pipeline's execution.

Execute PIPELINE and print a summary of the real time, user CPU time,
and system CPU time spent executing PIPELINE when it terminates.

Options:
-p print the timing summary in the portable Posix format

The value of the TIMEFORMAT variable is used as the output format.

Exit Status:
The return status is the return status of PIPELINE.Resume for, while, or until loops.

Resumes the next iteration of the enclosing FOR, WHILE or UNTIL loop.
If N is specified, resumes the Nth enclosing loop.

Exit Status:
The exit status is 0 unless N is not greater than or equal to 1.Resume job in foreground.

Equivalent to the JOB_SPEC argument to the `fg' command. Resume a
stopped or background job. JOB_SPEC can specify either a job name
or a job number. Following JOB_SPEC with a `&' places the job in
the background, as if the job specification had been supplied as an
argument to `bg'.

Exit Status:
Returns the status of the resumed job.Return a successful result.

Exit Status:
Always succeeds.Return an unsuccessful result.

Exit Status:
Always fails.Return from a shell function.

Causes a function or sourced script to exit with the return value
specified by N. If N is omitted, the return status is that of the
last command executed within the function or script.

Exit Status:
Returns N, or failure if the shell is not executing a function or script.Return the context of the current subroutine call.

Without EXPR, returns "$line $filename". With EXPR, returns
"$line $subroutine $filename"; this extra information can be used to
provide a stack trace.

The value of EXPR indicates how many call frames to go back before the
current one; the top frame is frame 0.

Exit Status:
Returns 0 unless the shell is not executing a shell function or EXPR
is invalid.Returns the context of the current subroutine call.

Without EXPR, returns "$line $filename". With EXPR, returns
"$line $subroutine $filename"; this extra information can be used to
provide a stack trace.

The value of EXPR indicates how many call frames to go back before the
current one; the top frame is frame 0.RunningSegmentation faultSelect words from a list and execute commands.

The WORDS are expanded, generating a list of words. The
set of expanded words is printed on the standard error, each
preceded by a number. If `in WORDS' is not present, `in "$@"'
is assumed. The PS3 prompt is then displayed and a line read
from the standard input. If the line consists of the number
corresponding to one of the displayed words, then NAME is set
to that word. If the line is empty, WORDS and the prompt are
redisplayed. If EOF is read, the command completes. Any other
value read causes NAME to be set to null. The line read is saved
in the variable REPLY. COMMANDS are executed after each selection
until a break command is executed.

Exit Status:
Returns the status of the last command executed.Send a signal to a job.

Send the processes identified by PID or JOBSPEC the signal named by
SIGSPEC or SIGNUM. If neither SIGSPEC nor SIGNUM is present, then
SIGTERM is assumed.

Options:
-s sig SIG is a signal name
-n sig SIG is a signal number
-l list the signal names; if arguments follow `-l' they are
assumed to be signal numbers for which names should be listed
-L synonym for -l

Kill is a shell builtin for two reasons: it allows job IDs to be used
instead of process IDs, and allows processes to be killed if the limit
on processes that you can create is reached.

Exit Status:
Returns success unless an invalid option is given or an error occurs.Set Readline key bindings and variables.

Bind a key sequence to a Readline function or a macro, or set a
Readline variable. The non-option argument syntax is equivalent to
that found in ~/.inputrc, but must be passed as a single argument:
e.g., bind '"\C-x\C-r": re-read-init-file'.

Options:
-m keymap Use KEYMAP as the keymap for the duration of this
command. Acceptable keymap names are emacs,
emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
vi-command, and vi-insert.
-l List names of functions.
-P List function names and bindings.
-p List functions and bindings in a form that can be
reused as input.
-S List key sequences that invoke macros and their values
-s List key sequences that invoke macros and their values
in a form that can be reused as input.
-V List variable names and values
-v List variable names and values in a form that can
be reused as input.
-q function-name Query about which keys invoke the named function.
-u function-name Unbind all keys which are bound to the named function.
-r keyseq Remove the binding for KEYSEQ.
-f filename Read key bindings from FILENAME.
-x keyseq:shell-command Cause SHELL-COMMAND to be executed when
KEYSEQ is entered.
-X List key sequences bound with -x and associated commands
in a form that can be reused as input.

Exit Status:
bind returns 0 unless an unrecognized option is given or an error occurs.Set and unset shell options.

Change the setting of each shell option OPTNAME. Without any option
arguments, list each supplied OPTNAME, or all shell options if no
OPTNAMEs are given, with an indication of whether or not each is set.

Options:
-o restrict OPTNAMEs to those defined for use with `set -o'
-p print each shell option with an indication of its status
-q suppress output
-s enable (set) each OPTNAME
-u disable (unset) each OPTNAME

Exit Status:
Returns success if OPTNAME is enabled; fails if an invalid option is
given or OPTNAME is disabled.Set export attribute for shell variables.

Marks each NAME for automatic export to the environment of subsequently
executed commands. If VALUE is supplied, assign VALUE before exporting.

Options:
-f refer to shell functions
-n remove the export property from each NAME
-p display a list of all exported variables and functions

An argument of `--' disables further option processing.

Exit Status:
Returns success unless an invalid option is given or NAME is invalid.Set or unset values of shell options and positional parameters.

Change the value of shell attributes and positional parameters, or
display the names and values of shell variables.

Options:
-a Mark variables which are modified or created for export.
-b Notify of job termination immediately.
-e Exit immediately if a command exits with a non-zero status.
-f Disable file name generation (globbing).
-h Remember the location of commands as they are looked up.
-k All assignment arguments are placed in the environment for a
command, not just those that precede the command name.
-m Job control is enabled.
-n Read commands but do not execute them.
-o option-name
Set the variable corresponding to option-name:
allexport same as -a
braceexpand same as -B
emacs use an emacs-style line editing interface
errexit same as -e
errtrace same as -E
functrace same as -T
hashall same as -h
histexpand same as -H
history enable command history
ignoreeof the shell will not exit upon reading EOF
interactive-comments
allow comments to appear in interactive commands
keyword same as -k
monitor same as -m
noclobber same as -C
noexec same as -n
noglob same as -f
nolog currently accepted but ignored
notify same as -b
nounset same as -u
onecmd same as -t
physical same as -P
pipefail the return value of a pipeline is the status of
the last command to exit with a non-zero status,
or zero if no command exited with a non-zero status
posix change the behavior of bash where the default
operation differs from the Posix standard to
match the standard
privileged same as -p
verbose same as -v
vi use a vi-style line editing interface
xtrace same as -x
-p Turned on whenever the real and effective user ids do not match.
Disables processing of the $ENV file and importing of shell
functions. Turning this option off causes the effective uid and
gid to be set to the real uid and gid.
-t Exit after reading and executing one command.
-u Treat unset variables as an error when substituting.
-v Print shell input lines as they are read.
-x Print commands and their arguments as they are executed.
-B the shell will perform brace expansion
-C If set, disallow existing regular files to be overwritten
by redirection of output.
-E If set, the ERR trap is inherited by shell functions.
-H Enable ! style history substitution. This flag is on
by default when the shell is interactive.
-P If set, do not resolve symbolic links when executing commands
such as cd which change the current directory.
-T If set, the DEBUG and RETURN traps are inherited by shell functions.
-- Assign any remaining arguments to the positional parameters.
If there are no remaining arguments, the positional parameters
are unset.
- Assign any remaining arguments to the positional parameters.
The -x and -v options are turned off.

Using + rather than - causes these flags to be turned off. The
flags can also be used upon invocation of the shell. The current
set of flags may be found in $-. The remaining n ARGs are positional
parameters and are assigned, in order, to $1, $2, .. $n. If no
ARGs are given, all shell variables are printed.

Exit Status:
Returns success unless an invalid option is given.Set variable values and attributes.

A synonym for `declare'. See `help declare'.Set variable values and attributes.

Declare variables and give them attributes. If no NAMEs are given,
display the attributes and values of all variables.

Options:
-f restrict action or display to function names and definitions
-F restrict display to function names only (plus line number and
source file when debugging)
-g create global variables when used in a shell function; otherwise
ignored
-I if creating a local variable, inherit the attributes and value
of a variable with the same name at a previous scope
-p display the attributes and value of each NAME

Options which set attributes:
-a to make NAMEs indexed arrays (if supported)
-A to make NAMEs associative arrays (if supported)
-i to make NAMEs have the `integer' attribute
-l to convert the value of each NAME to lower case on assignment
-n make NAME a reference to the variable named by its value
-r to make NAMEs readonly
-t to make NAMEs have the `trace' attribute
-u to convert the value of each NAME to upper case on assignment
-x to make NAMEs export

Using `+' instead of `-' turns off the given attribute.

Variables with the integer attribute have arithmetic evaluation (see
the `let' command) performed when the variable is assigned a value.

When used in a function, `declare' makes NAMEs local, as with the `local'
command. The `-g' option suppresses this behavior.

Exit Status:
Returns success unless an invalid option is supplied or a variable
assignment error occurs.Shell commands matching keyword `Shell commands matching keywords `Shell options:
Shift positional parameters.

Rename the positional parameters $N+1,$N+2 ... to $1,$2 ... If N is
not given, it is assumed to be 1.

Exit Status:
Returns success unless N is negative or greater than $#.Signal %dSpecify how arguments are to be completed by Readline.

For each NAME, specify how arguments are to be completed. If no options
are supplied, existing completion specifications are printed in a way that
allows them to be reused as input.

Options:
-p print existing completion specifications in a reusable format
-r remove a completion specification for each NAME, or, if no
NAMEs are supplied, all completion specifications
-D apply the completions and actions as the default for commands
without any specific completion defined
-E apply the completions and actions to "empty" commands --
completion attempted on a blank line
-I apply the completions and actions to the initial (usually the
command) word

When completion is attempted, the actions are applied in the order the
uppercase-letter options are listed above. If multiple options are supplied,
the -D option takes precedence over -E, and both take precedence over -I.

Exit Status:
Returns success unless an invalid option is supplied or an error occurs.StoppedStopped (signal)Stopped (tty input)Stopped (tty output)Stopped(%s)Suspend shell execution.

Suspend the execution of this shell until it receives a SIGCONT signal.
Unless forced, login shells cannot be suspended.

Options:
-f force the suspend, even if the shell is a login shell

Exit Status:
Returns success unless job control is not enabled or an error occurs.TIMEFORMAT: `%c': invalid format characterTerminatedThe mail in %s has been read
There are running jobs.
There are stopped jobs.
There is NO WARRANTY, to the extent permitted by law.These shell commands are defined internally. Type `help' to see this list.
Type `help name' to find out more about the function `name'.
Use `info bash' to find out more about the shell in general.
Use `man -k' or `info' to find out more about commands not in this list.

A star (*) next to a name means that the command is disabled.

This is free software; you are free to change and redistribute it.Trap signals and other events.

Defines and activates handlers to be run when the shell receives signals
or other conditions.

ARG is a command to be read and executed when the shell receives the
signal(s) SIGNAL_SPEC. If ARG is absent (and a single SIGNAL_SPEC
is supplied) or `-', each specified signal is reset to its original
value. If ARG is the null string each SIGNAL_SPEC is ignored by the
shell and by the commands it invokes.

If a SIGNAL_SPEC is EXIT (0) ARG is executed on exit from the shell. If
a SIGNAL_SPEC is DEBUG, ARG is executed before every simple command. If
a SIGNAL_SPEC is RETURN, ARG is executed each time a shell function or a
script run by the . or source builtins finishes executing. A SIGNAL_SPEC
of ERR means to execute ARG each time a command's failure would cause the
shell to exit when the -e option is enabled.

If no arguments are supplied, trap prints the list of commands associated
with each signal.

Options:
-l print a list of signal names and their corresponding numbers
-p display the trap commands associated with each SIGNAL_SPEC

Each SIGNAL_SPEC is either a signal name in <signal.h> or a signal number.
Signal names are case insensitive and the SIG prefix is optional. A
signal may be sent to the shell with "kill -signal $$".

Exit Status:
Returns success unless a SIGSPEC is invalid or an invalid option is given.Type `%s -c "help set"' for more information about shell options.
Type `%s -c help' for more information about shell builtin commands.
Unknown Signal #%dUnknown errorUnknown statusUnset values and attributes of shell variables and functions.

For each NAME, remove the corresponding variable or function.

Options:
-f treat each NAME as a shell function
-v treat each NAME as a shell variable
-n treat each NAME as a name reference and unset the variable itself
rather than the variable it references

Without options, unset first tries to unset a variable, and if that fails,
tries to unset a function.

Some variables cannot be unset; also see `readonly'.

Exit Status:
Returns success unless an invalid option is given or a NAME is read-only.Urgent IO conditionUsage: %s [GNU long option] [option] ...
%s [GNU long option] [option] script-file ...
Use "%s" to leave the shell.
Use the `bashbug' command to report bugs.
User signal 1User signal 2Wait for job completion and return exit status.

Waits for each process identified by an ID, which may be a process ID or a
job specification, and reports its termination status. If ID is not
given, waits for all currently active child processes, and the return
status is zero. If ID is a job specification, waits for all processes
in that job's pipeline.

If the -n option is supplied, waits for a single job from the list of IDs,
or, if no IDs are supplied, for the next job to complete and returns its
exit status.

If the -p option is supplied, the process or job identifier of the job
for which the exit status is returned is assigned to the variable VAR
named by the option argument. The variable will be unset initially, before
any assignment. This is useful only when the -n option is supplied.

If the -f option is supplied, and job control is enabled, waits for the
specified ID to terminate, instead of waiting for it to change status.

Exit Status:
Returns the status of the last ID; fails if ID is invalid or an invalid
option is given, or if -n is supplied and the shell has no unwaited-for
children.Wait for process completion and return exit status.

Waits for each process specified by a PID and reports its termination status.
If PID is not given, waits for all currently active child processes,
and the return status is zero. PID must be a process ID.

Exit Status:
Returns the status of the last PID; fails if PID is invalid or an invalid
option is given.Window changedWrite arguments to the standard output.

Display the ARGs on the standard output followed by a newline.

Options:
-n do not append a newline

Exit Status:
Returns success unless a write error occurs.Write arguments to the standard output.

Display the ARGs, separated by a single space character and followed by a
newline, on the standard output.

Options:
-n do not append a newline
-e enable interpretation of the following backslash escapes
-E explicitly suppress interpretation of backslash escapes

`echo' interprets the following backslash-escaped characters:
\a alert (bell)
\b backspace
\c suppress further output
\e escape character
\E escape character
\f form feed
\n new line
\r carriage return
\t horizontal tab
\v vertical tab
\\ backslash
\0nnn the character whose ASCII code is NNN (octal). NNN can be
0 to 3 octal digits
\xHH the eight-bit character whose value is HH (hexadecimal). HH
can be one or two hex digits
\uHHHH the Unicode character whose value is the hexadecimal value HHHH.
HHHH can be one to four hex digits.
\UHHHHHHHH the Unicode character whose value is the hexadecimal value
HHHHHHHH. HHHHHHHH can be one to eight hex digits.

Exit Status:
Returns success unless a write error occurs.You have mail in $_You have new mail in $_[ arg... ][[ expression ]]`%c': bad command`%c': invalid format character`%c': invalid symbolic mode character`%c': invalid symbolic mode operator`%c': invalid time format specification`%s': cannot unbind`%s': cannot unbind in command keymap`%s': invalid alias name`%s': invalid keymap name`%s': invalid variable name for name reference`%s': is a special builtin`%s': missing format character`%s': not a pid or valid job spec`%s': not a valid identifier`%s': unknown function name`)' expected`)' expected, found %s`:' expected for conditional expressionadd_process: pid %5ld (%s) marked as still alivealias [-p] [name[=value] ... ]all_local_variables: no function context at current scopeargumentargument expectedarray variable support requiredattempted assignment to non-variablebad array subscriptbad command typebad connectorbad jumpbad substitution: no closing "`" in %sbad substitution: no closing `%s' in %sbash home page: <http://www.gnu.org/software/bash>
bash_execute_unix_command: cannot find keymap for commandbg [job_spec ...]bgp_delete: LOOP: psi (%d) == storage[psi].bucket_nextbgp_search: LOOP: psi (%d) == storage[psi].bucket_nextbind [-lpsvPSVX] [-m keymap] [-f filename] [-q name] [-u name] [-r keyseq] [-x keyseq:shell-command] [keyseq:readline-function or readline-command]brace expansion: cannot allocate memory for %sbrace expansion: failed to allocate memory for %u elementsbrace expansion: failed to allocate memory for `%s'break [n]bug: bad expassign tokenbuiltin [shell-builtin [arg ...]]caller [expr]can only `return' from a function or sourced scriptcan only be used in a functioncannot allocate new file descriptor for bash input from fd %dcannot create temp file for here-document: %scannot duplicate fd %d to fd %dcannot duplicate named pipe %s as fd %dcannot find %s in shared object %s: %scannot make child for command substitutioncannot make child for process substitutioncannot make pipe for command substitutioncannot make pipe for process substitutioncannot open named pipe %s for readingcannot open named pipe %s for writingcannot open shared object %s: %scannot redirect standard input from /dev/null: %scannot reset nodelay mode for fd %dcannot set and unset shell options simultaneouslycannot set gid to %d: effective gid %dcannot set terminal process group (%d)cannot set uid to %d: effective uid %dcannot simultaneously unset a function and a variablecannot start debugger; debugging mode disabledcannot suspendcannot suspend a login shellcannot use `-f' to make functionscannot use more than one of -anrwcase WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esaccd [-L|[-P [-e]] [-@]] [dir]child setpgid (%ld to %ld)command [-pVv] command [arg ...]command substitution: ignored null byte in inputcommand_substitute: cannot duplicate pipe as fd 1compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]complete [-abcdefgjksuv] [-pr] [-DEI] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [name ...]completion: function `%s' not foundcompopt [-o|+o option] [-DEI] [name ...]conditional binary operator expectedcontinue [n]coproc [NAME] command [redirections]could not find /tmp, please create!cprintf: `%c': invalid format charactercurrentdeclare [-aAfFgiIlnrtux] [name[=value] ...] or declare -p [-aAfFilnrtux] [name ...]deleting stopped job %d with process group %lddescribe_pid: %ld: no such piddirectory stack emptydirectory stack indexdirs [-clpv] [+N] [-N]disown [-h] [-ar] [jobspec ... | pid ...]division by 0dynamic loading not availableecho [-n] [arg ...]echo [-neE] [arg ...]empty array variable nameenable [-a] [-dnps] [-f filename] [name ...]error getting terminal attributes: %serror importing function definition for `%s'error setting terminal attributes: %seval [arg ...]eval: maximum eval nesting level exceeded (%d)exec [-cl] [-a name] [command [argument ...]] [redirection ...]execute_coproc: coproc [%d:%s] still existsexit [n]expected `)'exponent less than 0export [-fn] [name[=value] ...] or export -pexpression expectedexpression recursion level exceededfc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]fg [job_spec]file descriptor out of rangefilename argument requiredfor (( exp1; exp2; exp3 )); do COMMANDS; donefor NAME [in WORDS ... ] ; do COMMANDS; doneforked pid %d appears in running job %dformat parsing problem: %sfree: called with already freed block argumentfree: called with unallocated block argumentfree: start and end chunk sizes differfree: underflow detected; magic8 corruptedfree: underflow detected; mh_nbytes out of rangefunction name { COMMANDS ; } or name () { COMMANDS ; }future versions of the shell will force evaluation as an arithmetic substitutiongetcwd: cannot access parent directoriesgetopts optstring name [arg ...]hash [-lr] [-p pathname] [-dt] [name ...]hashing disabledhelp [-dms] [pattern ...]help not available in this versionhere-document at line %d delimited by end-of-file (wanted `%s')history [-c] [-d offset] [n] or history -anrw [filename] or history -ps arg [arg...]history positionhistory specificationhits command
identifier expected after pre-increment or pre-decrementif COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else COMMANDS; ] fiinitialize_job_control: getpgrp failedinitialize_job_control: line disciplineinitialize_job_control: no job control in backgroundinitialize_job_control: setpgidinvalid arithmetic baseinvalid baseinvalid character %d in exportstr for %sinvalid hex numberinvalid integer constantinvalid numberinvalid octal numberinvalid signal numberjob %d started without job controljob_spec [&]jobs [-lnprs] [jobspec ...] or jobs -x command [args]kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]last command: %s
let arg [arg ...]limitline %d: line editing not enabledload function for %s returns failure (%d): not loadedlocal [option] name[=value] ...logout
logout [n]loop countmake_here_document: bad instruction type %dmake_local_variable: no function context at current scopemake_redirection: redirection instruction `%d' out of rangemalloc: block on free list clobberedmalloc: failed assertion: %s
mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]maximum here-document count exceededmigrate process to another CPUmissing `)'missing `]'missing hex digit for \xmissing unicode digit for \%cnetwork operations not supportedno `=' in exportstr for %sno closing `%c' in %sno command foundno help topics match `%s'. Try `help help' or `man -k %s' or `info %s'.no job controlno job control in this shellno match: %sno other directoryno other options allowed with `-x'not currently executing completion functionnot login shell: use `exit'null directoryoctal numberonly meaningful in a `for', `while', or `until' looppipe errorpop_scope: head of shell_variables not a temporary environment scopepop_var_context: head of shell_variables not a function contextpop_var_context: no global_variables contextpopd [-n] [+N | -N]power failure imminentpretty-printing mode ignored in interactive shellsprint_command: bad connector `%d'printf [-v var] format [arguments]progcomp_insert: %s: NULL COMPSPECprogrammable_completion: %s: possible retry loopprogramming errorpushd [-n] [+N | -N | dir]pwd [-LP]read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]read error: %d: %sreadarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]readonly [-aAf] [name[=value] ...] or readonly -prealloc: called with unallocated block argumentrealloc: start and end chunk sizes differrealloc: underflow detected; magic8 corruptedrealloc: underflow detected; mh_nbytes out of rangerecursion stack underflowredirection error: cannot duplicate fdregister_alloc: %p already in table as allocated?
register_alloc: alloc table is full with FIND_ALLOC?
register_free: %p already in table as free?
restrictedreturn [n]run_pending_traps: bad value in trap_list[%d]: %prun_pending_traps: signal handler is SIG_DFL, resending %d (%s) to myselfsave_bash_input: buffer already exists for new fd %dselect NAME [in WORDS ... ;] do COMMANDS; doneset [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [-] [arg ...]setlocale: %s: cannot change locale (%s)setlocale: %s: cannot change locale (%s): %ssetlocale: LC_ALL: cannot change locale (%s)setlocale: LC_ALL: cannot change locale (%s): %sshell level (%d) too high, resetting to 1shell_getc: shell_input_line_size (%zu) exceeds SIZE_MAX (%lu): line truncatedshift [n]shift countshopt [-pqsu] [-o] [optname ...]sigprocmask: %d: invalid operationsource filename [arguments]start_pipeline: pgrp pipesuspend [-f]syntax errorsyntax error in conditional expressionsyntax error in conditional expression: unexpected token `%s'syntax error in expressionsyntax error in variable assignmentsyntax error near `%s'syntax error near unexpected token `%s'syntax error: `%s' unexpectedsyntax error: `((%s))'syntax error: `;' unexpectedsyntax error: arithmetic expression requiredsyntax error: invalid arithmetic operatorsyntax error: operand expectedsyntax error: unexpected end of filesystem crash imminenttest [expr]time [-p] pipelinetoo many argumentstrap [-lp] [[arg] signal_spec ...]trap handler: maximum trap handler level exceeded (%d)trap_handler: bad signal %dtype [-afptP] name [name ...]typeset [-aAfFgiIlnrtux] name[=value] ... or typeset -p [-aAfFilnrtux] [name ...]ulimit [-SHabcdefiklmnpqrstuvxPRT] [limit]umask [-p] [-S] [mode]unalias [-a] name [name ...]unexpected EOF while looking for `]]'unexpected EOF while looking for matching `%c'unexpected EOF while looking for matching `)'unexpected argument `%s' to conditional binary operatorunexpected argument `%s' to conditional unary operatorunexpected argument to conditional binary operatorunexpected argument to conditional unary operatorunexpected token %d in conditional commandunexpected token `%c' in conditional commandunexpected token `%s' in conditional commandunexpected token `%s', conditional binary operator expectedunexpected token `%s', expected `)'unknownunknown command errorunset [-f] [-v] [-n] [name ...]until COMMANDS; do COMMANDS-2; donevalue too great for basevariables - Names and meanings of some shell variableswait [-fn] [-p var] [id ...]wait [pid ...]wait: pid %ld is not a child of this shellwait_for: No record of process %ldwait_for_job: job %d is stoppedwaitchld: turning on WNOHANG to avoid indefinite blockwarning: warning: %s: %swarning: -C option may not work as you expectwarning: -F option may not work as you expectwhile COMMANDS; do COMMANDS-2; donewrite error: %sxtrace fd (%d) != fileno xtrace fp (%d)xtrace_set: %d: invalid file descriptorxtrace_set: NULL file pointer{ COMMANDS ; }Project-Id-Version: bash 5.2-rc1
Report-Msgid-Bugs-To:
PO-Revision-Date: 2022-06-18 01:02+0200
Last-Translator: Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>
Language-Team: Romanian <translation-team-ro@lists.sourceforge.net>
Language: ro
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=3; plural=(n==1 ? 0 : (n==0 || ((n%100) > 0 && (n%100) < 20)) ? 1 : 2);
X-Bugs: Report translation errors to the Language-Team address.
X-Generator: Poedit 2.3.1
X-Poedit-SourceCharset: UTF-8
timed expirat așteptând introducerea datelor: auto-logout
-%s sau -o opțiune
-ilrsD sau -c comandă sau -O shopt_option (doar invocare)

malloc: %s:%d: aserțiune greșită
(dir.lucru: %s) (core dumped) linie $%s: nu se poate asigna în acest mod%c%c: opțiune nevalidă%d: descriptor de fișier nevalid: %s%s poate fi invocat via %s are exportstr nul%s este %s
%s este o funcție
%s este o comandă internă a shell
%s este un cuvânt cheie shell
%s este o comandă internă specială a shell
%s este un alias pentru „%s”
%s este asociat(hashed) (%s)
%s nu este asociat niciunei taste.
%s în afara intervalului%s%s%s: %s (identificatorul erorii este „%s”)%s: %s%s: %s în afara intervalului%s: %s: interpret greșit%s: %s: nu se poate deschide ca FIȘIER%s: %s: valoarea de compatibilitate în afara intervalului%s: %s: valoare nevalidă pentru descriptorul fișierului de urmărire%s: %s: trebuie să fie folosit un indice atunci când se atribuie unei matrice asociative%s: %s:%d: nu se pot aloca %lu octeți%s: %s:%d: nu se pot aloca %lu octeți (%lu octeți alocați)%s: Este un director%s: specificație de lucrare, ambiguă%s: redirectare ambiguă%s: argumentele trebuie să fie ID-uri de proces sau de lucrări%s: se atribuie un număr întreg referinței de nume%s: specificație incorectă pentru ruta rețelei%s: substituție nevalidă%s: se așteaptă operator binar%s: nu se pot aloca %lu octeți%s: nu se pot aloca %lu octeți (%lu octeți alocați)%s: nu se poate atribui%s: nu se poate atribui descriptorul de fișier variabilei%s: nu se poate atribui o listă unui membru al matricei%s: nu se poate atribui la index ne-numeric%s: nu se poate converti o matrice asociativă într-o matrice indexată%s: nu se poate converti matricea indexată în asociativă%s: nu s-a putut crea: %s%s: nu se poate șterge: %s%s: nu se pot distruge variabilele matrice în acest fel%s: nu se poate executa fișierul binar%s: nu se poate executa fișierul binar: %s%s: nu se poate executa: %s%s: nu se poate executa: fișierul necesar nu a fost găsit%s: nu se poate exporta%s: nu se poate obține limita: %s%s: nu se poate moșteni valoarea de la un tip incompatibil%s: nu se poate modifica limita: %s%s: nu se poate deschide fișierul temporal: %s%s: nu se poate deschide: %s%s: nu se poate suprascrie fișierul existent%s: nu s-a putut citii: %s%s: nu se poate deconfigura%s: nu se poate deconfigura: %s este protejat la scriere%s: referință de nume circulară%s: comandă negăsită%s: comanda internă dinamică a «bash», este deja încărcată%s: eroare la preluarea directorului curent: %s: %s
%s: eroare în expresie
%s: fișierul este prea mare%s: nu s-a găsit fișierul%s: primul caracter care nu este spațiu în alb nu este «"» (ghilimele duble)%s: tabelul de asociere este gol
%s: a eșuat expansiunea istoriei%s: gazdă necunoscută%s: opțiune ilegală -- %c
%s: a eșuat inlib%s: se aștepta o expresie întreagă (integer)%s: nume de acțiune nevalid%s argument nevalid%s: origine matrice nevalid%s: cuantum de apel invers nevalid%s: specificație de descriptor de fișier nevalidă%s: extindere indirectă nevalidă%s: limită de argument nevalidă%s: contorizare de linii nevalidă%s: opțiune nevalidă%s: nume de opțiune nevalid%s: serviciu nevalid%s: nume nevalid al opțiunii shell%s: specificație de semnal nevalidă%s: specificație a timpului de expirare nevalidă%s: marcaj de timp nevalid%s: nume de variabilă nevalid%s: nume de variabilă nevalid pentru referința numelui%s: este un director%s: lucrarea %d se află deja în fundal%s: lucrarea a fost terminată%s: linie %d: %s: s-a depășit nivelul maxim de suprapunere de funcții (%d)%s: s-a depășit nivelul maxim de suprapunere de citiri cu «source» (%d)%s: lipsește separatorul două puncte (:)%s: nu sunt permise auto-referințele la variabile nameref%s: nicio specificație de completare%s: nu există lucrări actuale%s: nu există un control de lucrări%s: nu există această lucrare%s: nu este o funcție%s: nu este un fișier normal%s: nu este o comandă internă%s: nu este o variabilă matrice%s: nu este o matrice indexată%s: nu este încărcat dinamic%s: nu s-a găsit%s: argument numeric necesar%s: opțiunea necesită un argument%s: opțiunea necesită un parametru: -- %c
%s: parametru nedefinit%s: parametru nul sau nedefinit%s: alocarea de matrice compusă între ghilimele este perimată%s: funcție protejată la scriere%s: variabilă protejată la scriere%s: variabila de referință nu poate fi o matrice%s: se elimină atributul nameref%s: restricționat%s: restricționat: nu se poate redirecționa ieșirea%s: limitat: nu se poate specifica „/” în numele comenzilor%s: expresie subșir < 0%s: se așteaptă operator unar%s: variabilă neasociată%s: utilizare: %s: nu este posibil ca variabilei să i se atribuie o valoare”

(( expresie ))(core dumped) (dir.lucru actual: %s)
. nume_fișier [argumente]nu se admite «/dev/(tcp|udp)/host/port» fără a avea o conexiune la rețea«/tmp» trebuie să fie un nume de director valid<niciun director curent>Instrucțiune ABORTSe abandonează...Adaugă directoare la stivă.

Adaugă un director în partea de sus a stivei de directoare sau
rotește stiva, făcând din partea de sus a stivei directorul de lucru
curent. Fără argumente, interschimbă primele două directoare.

Opțiuni:
-n Suprimă schimbarea normală a directorului atunci când se adaugă
directoare la stivă, astfel încât numai stiva este manipulată.

Argumente:
+N Rotește stiva astfel încât al N-lea director (numărând
din stânga listei afișate de «dirs», începând cu zero) să fie
în partea de sus.

-N Rotește stiva astfel încât al N-lea director (numărând
din dreapta listei afișate de «dirs», începând cu zero) să fie
în partea de sus.

dir Adaugă DIR la stiva de directoare din partea de sus, făcându-l
noul director de lucru curent.

Comanda internă «dirs» afișează stiva de directoare.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizat un argument
nevalid sau dacă schimbarea directorului eșuează.Adaugă un director în partea de sus a stivei de directoare sau rotește
stiva, făcând din noul director din partea de sus a stivei, directorul de
lucru curent. Fără argumente, interschimbă primele două directoare.

Opțiuni:
-n Suprimă schimbarea normală a directorului atunci când se
adaugă directoare la stivă, astfel încât numai stiva este manipulată.

Argumente:
+N Rotește stiva astfel încât al N-lea director (numărând din
stânga listei afișate de «dirs», începând cu zero) să fie în
partea de sus.

-N Rotește stiva astfel încât al N-lea director (numărând din
dreapta listei afișate de «dirs», începând cu zero) să fie în
partea de sus.

dir Adaugă DIR la stiva de directoare din partea de sus,
făcându-l noul director de lucru curent.

Comanda internă «dirs» arată stiva curentă de directoare.Alarmă (profil)Alarmă (virtual)Ceas cu alarmăBuclă aritmetică „for”.

Echivalentă cu:
(( EXP1 ))
while (( EXP2 )); do
COMENZI
(( EXP3 ))
done
EXP1, EXP2, și EXP3 sunt expresii aritmetice. Dacă orice expresie este
omisă, se comportă ca și cum aceasta ar avea valoarea 1.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Punct de întrerupere de urmărire/capturareApel de sistem incorectSemnal falsLinie de conectare întreruptăEroare de magistrală de date(bus)Limită CPUSchimbă directorul de lucru al shell-ului.

Schimbă directorul actual cu DIR. DIR implicit este valoarea variabilei de
shell HOME.

Variabila CDPATH definește calea de căutare pentru directorul care conține
DIR. Numele alternative ale directoarelor din CDPATH sunt separate prin
două puncte (:). Numele unui director nul este același cu directorul curent.
Dacă DIR începe cu o bară oblică (/), atunci CDPATH nu este utilizat.

Dacă directorul nu este găsit și opțiunea de shell „cdable_vars” este setată,
cuvântul se presupune a fi un nume de variabilă. Dacă acea variabilă are o
valoare, valoarea ei este utilizată pentru DIR.

Opțiuni:
-L forțează ca legăturile simbolice să fie urmate: rezolvă
legăturile simbolice din DIR după procesarea instanțelor de „..”
-P utilizează structura fizică a directorului fără a urma legăturile
simbolice: rezolvă legăturile simbolice din DIR înainte de a
procesa instanțe de „..”
-e dacă este furnizată opțiunea „-P” și directorul de lucru curent
nu poate fi determinat cu succes, iese cu o stare diferită de
zero
-@ pe sistemele care acceptă acest lucru, prezintă un fișier cu
atribute extinse, ca un director care conține atributele fișierului

Modul implicit este să urmeze legături simbolice, ca și cum ar fi fost specificat „-L”.
„..” este procesat prin eliminarea componentei de cale imediat anterioară până
la o bară oblică sau la începutul DIR.

Starea de ieșire:
Returnează 0 dacă directorul este schimbat și dacă $PWD este stabilit cu succes atunci
când este utilizat „-P”; diferit de zero, în caz contrar.Proces-copil mort sau opritNumele și utilizarea variabilelor shell comune.

BASH_VERSION
Informații despre versiunea acestui Bash.
CDPATH O listă de directoare separate prin două puncte
pentru a căuta directoare date ca argumente pentru «cd».
GLOBIGNORE O listă de modele, separate prin două puncte, care descriu nume
de fișiere care trebuie ignorate de extinderea numelui de cale.
HISTFILE Numele fișierului în care este stocat istoricul comenzilor.
HISTFILESIZE
Numărul maxim de linii pe care acest fișier le poate conține.
HISTSIZE Numărul maxim de linii de istoric pe care le poate accesa un
shell care rulează.
HOME Calea completă către directorul dumneavoastră de conectare.
HOSTNAME Numele gazdei curente.
HOSTTYPE Tipul de CPU pe care rulează această versiune de Bash.
IGNOREEOF Controlează acțiunea shell-ului la primirea unui caracter „EOF”
ca unică intrare. Dacă este definită, atunci valoarea acesteia
este numărul de caractere „EOF” care pot fi văzute într-un rând
pe o linie goală înainte ca shell-ul să iasă (implicit 10).
Când nu este definită, „EOF” înseamnă sfârșitul intrării.
MACHTYPE Un șir care descrie sistemul curent pe care rulează Bash.
MAILCHECK Cât de des, în secunde, verifică Bash dacă există e-mailuri noi.
MAILPATH O listă de nume de fișiere, separate prin două puncte, pe care
Bash le verifică pentru e-mailuri noi.
OSTYPE Versiunea de Unix pe care rulează această versiune de Bash.
PATH O listă de directoare separate prin două puncte în care se caută,
atunci când se caută comenzi.
PROMPT_COMMAND
O comandă care trebuie executată înainte de afișarea
fiecărui prompt primar.
PS1 Șirul de prompt primar.
PS2 Șirul de prompt secundar.
PWD Calea completă a directorului curent.
SHELLOPTS O listă separată de două puncte, de opțiuni de shell activate.
TERM Numele tipului actual de terminal.
TIMEFORMAT Formatul de ieșire pentru statisticile de timp afișat de
cuvântul rezervat „time”.
auto_resume Non-null înseamnă că un cuvânt de comandă care apare singur pe o
linie este căutat mai întâi în lista de lucrări opriteîn prezent.
Dacă se găsește acolo, lucrarea este în prim plan. O valoare
„exact” înseamnă că cuvântul de comandă trebuie să se potrivească
exact cu o comandă din lista de lucrări oprite. O valoare „sub-
string” înseamnă că cuvântul de comandă trebuie să se potrivească
cu un subșir al lucrării. Orice altă valoare înseamnă că
comanda trebuie să fie un prefix al unei lucrări oprite.
histchars Caractere care controlează extinderea istoricului și
înlocuirea rapidă. Primul caracter este caracterul
de înlocuire a istoricului, de obicei „!”. Al doilea este
caracterul „înlocuire rapidă”, de obicei „^”. Al treilea
este caracterul „comentare istoric”, de obicei „#”.
HISTIGNORE O listă de modele separate prin două puncte, utilizată pentru a
decide ce comenzi ar trebui salvate în lista istoricului.
ContinuareDrepturi de autor © 2022 Free Software Foundation, Inc.Creează un coproces numit NUME.

Execută COMANDA în mod asincron, cu ieșirea standard și intrarea standard a
comenzii conectate printr-o conductă la descriptorii de fișiere alocați
indicilor 0 și 1 ai unei variabile matrice NUME din shell-ul de execuție.
NUMELE implicit este „COPROC”.

Starea de ieșire:
Comanda «coproc» returnează o stare de ieșire de 0.Avertisment de DEPANARE: Definește variabilele locale.

Creează o variabilă locală numită NUME și îi dă această VALOARE.
OPȚIUNE poate fi orice opțiune acceptată de «declare».

Variabilele locale pot fi utilizate numai în cadrul unei funcții; sunt
vizibile numai pentru funcția în care sunt definite și pentru copiii
acesteia.

Starea de ieșire:
Returnează succes cu excepția cazului în care este furnizată o opțiune
nevalidă, apare o eroare de atribuire a variabilei sau shell-ul nu execută
o funcție.Definește sau afișează alias.

Fără argumente, «alias» imprimă lista de alias în forma reutilizabilă
„alias NUME=VALOARE” la ieșirea standard (pe ecran).

În caz contrar, un alias este definit pentru fiecare NUME a cărui VALOARE
este dată. Un spațiu final în VALOARE, face ca următorul cuvânt să fie
verificat pentru înlocuirea aliasului atunci când aliasul este extins.

Opțiuni:
-p imprimă toate alias definite într-un format reutilizabil

Starea de ieșire:
«alias» returnează adevărat, cu excepția cazului în care este furnizat
un NUME pentru care nu a fost definit niciun alias.Definește funcția shell.

Creează o funcție de shell numită NUME. Când se invocă ca o comandă simplă,
NUME rulează COMENZI în contextul shell-ului apelant. Când NUME este
invocat, argumentele sunt transmise funcției ca $1...$n, iar numele
funcției este în $FUNCNAME.

Starea de ieșire:
Returnează succes, cu excepția cazului în care NUME este protejat la scriereAfișează stiva de directoare.

Afișează lista directoarelor memorate în prezent. Directoarele
sunt adăugate la această listă cu comanda «pushd» și eliminate
cu comanda «popd».

Opțiuni:
-c curăță stiva de directoare ștergând toate elementele
-l nu afișează versiuni de directoare cu prefix „~” în raport
cu directorul dumneavoastră «acasă»
-p afișează stiva de directoare cu o intrare pe linie
-v afișează stiva de directoare cu o intrare pe linie, prefixată
cu poziția sa în stivă

Argumente:
+N Afișează a N-a intrare numărând din stânga listei afișate
de «dirs» atunci când este invocată fără opțiuni, începând
cu zero.

-N Afișează a N-a intrare numărând din dreapta listei afișate
de «dirs» atunci când este invocată fără opțiuni, începând
cu zero.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizată o opțiune
nevalidă sau apare o eroare.Afișează informații despre comenzile interne.

Afișează scurte rezumate ale comenzilor interne. Dacă TIPAR, este
specificat, oferă ajutor detaliat pentru toate comenzile care se potrivesc
cu TIPARul, în caz contrar, este afișată lista temelor de ajutor.

Opțiuni:
-d afișează o scurtă descriere pentru fiecare temă
-m afișează utilizarea în format pseudo-pagină de manual
-s afișează doar un scurt rezumat de utilizare pentru
fiecare temă care se potrivește cu TIPAR

Argumente:
TIPAR TIPAR care specifică o temă de ajutor

Starea de ieșire:
Returnează succes, cu excepția cazului în care TIPAR nu este găsit sau este
dată o opțiune nevalidă.Afișează informații despre comanda «type».

Pentru fiecare NUME, indică cum ar fi interpretat dacă ar fi folosit ca
nume de comandă.

Opțiuni:
-a afișează toate locațiile care conțin un executabil numit NUME;
include alias, componente integrate și funcții, dacă și numai
dacă opțiunea „-p” nu este, de asemenea, utilizată
-f suprimă căutarea funcției de shell
-P forțează o căutare PATH pentru fiecare NUME, chiar dacă este un
alias, o comandă internă sau o funcție, și returnează numele
fișierului din disc care va fi executat
-p returnează fie numele fișierului de pe disc care va fi executat,
fie nimic dacă «type -t NUME» nu va returna „file”
-t afișează un singur cuvânt care este unul dintre „alias”, „keyword”,
„function”, „builtin”, „file” sau „”, dacă NUME este un alias,
cuvânt rezervat shell, funcție shell, comandă internă shell,
fișier pe disc, sau, respectiv, negăsit

Argumente:
NUME Numele comenzii de interpretat.

Starea de ieșire:
Returnează succes dacă toate NUMEle sunt găsite; eșuează dacă nu sunt găsite.Afișează sau execută comenzi din lista istoricului.

«fc» se utilizează pentru a lista sau edita și re-executa comenzi din lista
istoricului.
PRIMA și ULTIMA pot fi numere care specifică intervalul sau PRIMA poate fi
un șir, ceea ce înseamnă cea mai recentă comandă care începe cu acel șir.

Opțiuni:
-e NUME_EDIT
selectează ce editor să utilizat. Implicit este FCEDIT, apoi
EDITOR, apoi vi
-l listează linii în loc să editeze
-n omite numerele de rând la listare
-r inversează ordinea liniilor (cele mai noi sunt listate primele)

Cu formatul «fc -s [tipar=înloc ...] [comanda]», COMANDA este re-executată
după ce este efectuată înlocuirea VECHE=NOUĂ.

Un alias util de folosit cu aceasta, este «r='fc -s'», astfel încât tastând
«r cc» se execută ultima comandă ce începe cu „cc” și tastând «r» se execută
din nou ultima comandă folosită.

Starea de ieșire:
Returnează succesul sau starea comenzii executate; diferit de zero dacă
apare o eroare.Afișează sau manipulează lista istoricului.

Afișează lista istoricului cu numere de linie, prefixând fiecare intrare
modificată cu un „*”. Un argument de N, listează numai ultimele N intrări.

Opțiuni:
-c șterge lista istoricului ștergând toate intrările
-d poziție
șterge intrarea din istoric de la poziția POZIȚIE. Pozițiile
negative se numără înapoi de la sfârșitul listei istoricului

-a adaugă linii istorice din această sesiune la fișierul istoricului
-n citește toate liniile istorice care nu sunt deja citite din
fișierul istoricului și le adaugă la lista istoricului
-r citește fișierul istoricului și îi adaugă conținutul la lista
istoricului
-w scrie istoricul curent în fișierul istoricului

-p efectuează extinderea istoricului pentru fiecare ARG și afișează
rezultatul fără a-l stoca în lista istoricului
-s adaugă ARGumentele la lista istoricului ca o singură intrare

Dacă NUME_FIȘIER este dat, acesta este utilizat ca fișierul istoricului.
Altfel, dacă HISTFILE are o valoare, aceasta este folosită, dacă nu are,
se folosește ~/.bash_history.

Dacă variabila HISTTIMEFORMAT este definită și nu este nulă, valoarea ei este
utilizată ca șir de format pentru strftime(3) pentru a imprima marcajul de
timp asociat cu fiecare intrare din istoric afișată. În caz contrar, nu se
imprimă marcajele de timp.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau apare o eroare.Afișează sau modifică masca pentru accesarea fișierelor nou create.

Stabilește masca de creare a fișierelor de utilizator la MOD. Dacă MOD
este omis, afișează valoarea curentă a măștii.

Dacă MOD începe cu o cifră, acesta este interpretat ca un număr octal;
altminteri este interpretat ca un șir în format simbolic ca cel acceptat
de chmod(1).

Opșiuni
-p dacă MOD este omis, arată ieșirea într-o formă care poate fi
reutilizată ca intrare
-S afișează MODul în formatul simbolic; altminteri în formatul octal

Starea de ieșire:
Returnează succes, cu excepția cazului în care MOD este nevalid sau
este dată o opțiune nevalidă.Afișează posibilele completări în funcție de opțiuni.

Aceasta este destinată să fie utilizată dintr-o funcție shell care generează
posibile completări. Dacă este furnizat argumentul opțional CUVÂNT, se
generează potriviri cu CUVÂNT.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizată o opțiune
nevalidă sau apare o eroare.Afișează timpii procesului.

Afișează timpii acumulați de utilizator și sistem pentru shell și pentru toate
procesele sale secundare.

Starea de ieșire:
Întotdeauna reușește(0).Afișează starea proceselor.

Listează procesele active. ID_PROC, restrânge afișarea la acel proces.
Fără opțiuni, se afișează starea tuturor proceselor active.

Opțiuni:
-l listează ID-urile proceselor, pe lângă informațiile normale
-n listează numai procesele care s-au schimbat de la ultima notificare
-p listează numai ID-urile proceselor
-r restrânge afișarea, la procesele în execuție
-s restrânge afișarea, la procesele oprite

Dacă este furnizată -x, COMANDA este rulată după ce toate specificațiile
procesului care apar în ARGumente au fost înlocuite cu ID-ul de proces al
liderului grupului de procese, al procesului respectiv.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau apare o eroare.
Dacă se utilizează „-x”, returnează starea de ieșire a COMENZII.Afișează lista curentă a directoarelor memorate. Directoarele
sunt adăugate la această listă cu comanda «pushd» și sunt eliminate din
ea, cu comanda «popd».

Opțiuni:
-c golește stiva de directoare prin ștergerea tuturor elementelor
-l nu afișează versiuni scurtate (cu ~) ale directoarelor în raport cu
directorul dumneavoastră «acasă»
-p imprimă stiva de directoare cu o intrare pe linie
-v imprimă stiva de directoare cu o intrare pe linie, prefixată cu poziția
sa în stivă

Argumente:
+N Afișează a N-a intrare numărând din stânga listei afișate de «dirs»,
atunci când este invocată fără opțiuni, începând cu zero.

-N Afișează a N-a intrare numărând din dreapta listei afișate de «dirs»,
atunci când este invocată fără opțiuni, începând cu zero.FinalizatFinalizat(%d)Instrucțiune EMTActivează și dezactivează comenzile interne ale shell-ului.

Activează și dezactivează comenzile interne ale shell-ului. Dezactivarea
vă permite să executați o comandă de pe disc care are același nume ca
și comanda internă a shell-ului, fără a utiliza calea completă.

Opțiuni:
-a afișează lista comenzilor interne indicând dacă sunt activate sau nu
-n dezactivează fiecare NUME sau afișează o listă de comenzi interne
dezactivate
-p afișează lista comenzilor interne într-un format reutilizabil
-s afișează numai numele comenzilor interne „speciale” Posix

Opțiuni care controlează încărcarea dinamică:
-f Încarcă comanda internă NUME de la obiectul partajat NUME_FIȘIER
-d Elimină o comandă internă încărcată cu -f

Fără opțiuni, fiecare NUME este activat.

Pentru a utiliza comanda «test» găsită în $PATH în loc de comanda internă
de shell, tastați «enable -n test».

Starea de ieșire:
Returnează succes, cu excepția cazului în care NUME nu este o comandă shell internă sau apare o eroare.Evaluează expresia aritmetică.

EXPRESIA este evaluată conform regulilor de evaluare aritmetică.
Echivalent cu „let "EXPRESIA"”.

Starea de ieșire:
Returnează 1 dacă EXPRESIA este evaluată la 0; în caz contrar, returnează 0.Evaluează expresii aritmetice.

Evaluează fiecare ARGument ca o expresie aritmetică. Evaluarea se face
în numere întregi cu lățime fixă, fără verificarea depășirii, dar împărțirea
la 0 este detectată și semnalată ca o eroare. Următoarea listă de operatori
este grupată în grupuri de operatori cu prioritate egală. Nivelurile sunt
listate în ordinea descrescătoare a priorității.

id++, id-- post-incrementare, post-decrementare a variabilei
++id, --id pre-incrementare, pre-decrementare a variabilei
-, + minus unar, plus unar
!, ~ negații logice și binare
** exponențial
*, /, % înmulțire, împărțire, rest
+, - adunare, scădere
<<, >> deplasare binară la stânga și la dreapta
<=, >=, <, > comparare
==, != egalitate, inegalitate
& și (AND) binar
^ sau exclusiv (XOR) binar
| sau (OR) binar
&& lși (AND) logic
|| sau (OR) logic
expr ? expr : expr
operator condițional
=, *=, /=, %=,
+=, -=, <<=, >>=,
&=, ^=, |= asignare

Variabilele shell sunt permise ca operanzi. Numele variabilei este
înlocuit cu valoarea acesteia (constrânsă la un număr întreg cu
lățime fixă) în cadrul unei expresii. Nu este necesar ca variabila să
aibă atributul întreg activat pentru a fi utilizată într-o expresie.

Operatorii sunt evaluați în ordinea de prioritate. Subexpresiile din
paranteze sunt evaluate mai întâi și pot suprascrie regulile de
precedență de mai sus.

Starea de ieșire:
Dacă ultimul ARGument este evaluat la 0, «let» returnează 1; în caz contrar,
«let» returnează 0.Evaluează expresia condițională.

Termină cu starea 0 (adevărat) sau 1 (fals) în funcție de evaluarea EXPR.
Expresiile pot fi unare sau binare. Expresiile unare sunt adesea folosite
pentru a examina starea unui fișier. Există de-asemeni operatori de șir și
operatori de comparație numerică.

Comportamentul testului depinde de numărul de argumente. Citiți pagina
de manual, «bash», pentru specificația completă.

Operatori de fișiere:

-a FIȘIER Adevărat dacă fișierul există.
-b FIȘIER Adevărat dacă fișierul este un dispozitiv de blocuri.
-c FIȘIER Adevărat dacă fișierul este un dispozitiv de caractere.
-d FIȘIER Adevărat dacă fișierul este un director.
-e FIȘIER Adevărat dacă fișierul există.
-f FIȘIER Adevărat dacă fișierul există și este un fișier normal.
-g FIȘIER Adevărat dacă fișierul are activat bitul „set-group-id”.
-h FIȘIER Adevărat dacă fișierul este o legătură simbolică.
-L FIȘIER Adevărat dacă fișierul este o legătură simbolică..
-k FIȘIER Adevărat dacă fișierul are activat bitul „sticky” (lipicios).
-p FIȘIER Adevărat dacă fișierul este o linie de conectare numită.
-r FIȘIER Adevărat dacă fișierul poate fi citit de dumneavoastră.
-s FIȘIER Adevărat dacă fișierul există și nu este gol.
-S FIȘIER Adevărat dacă fișierul este un soclu.
-t DF Adevărat dacă DF(descriptorul de fișier) este deschis pe un terminal.
-u FIȘIER Adevărat dacă fișierul are activat bitul „set-user-id”.
-w FIȘIER Adevărat dacă fișierul poate fi scris de dumneavoastră.
-x FIȘIER Adevărat dacă fișierul poate fi executat de dumneavoastră.
-O FIȘIER Adevărat dacă fișierul este deținut efectiv de dumneavoastră.
-G FIȘIER Adevărat dacă fișierul este deținut efectiv de grupul dumneavoastră.
-N FIȘIER Adevărat dacă fișierul a fost modificat de la ultima citire.

FIȘI1 -nt FIȘI2 Adevărat dacă fișierul 1 este mai nou decât fișierul 2 (conform
datei modificării).

FIȘI1 -ot FIȘI2 Adevărat dacă fișierul1 este mai vechi decât fișierul2.

FIȘI1 -ef FIȘI2 Adevărat dacă fișierul1 este o legătură dură către fișierul2.

Operatori de șir:

-z ȘIR Adevărat dacă șirul este gol.

-n ȘIR Adevărat dacă șirul nu este gol.
ȘIR Adevărat dacă șirul nu este gol.

ȘIR1 = ȘIR2 Adevărat dacă șirurile sunt egale.
ȘIR1 != ȘIR2 Adevărat dacă șirurile nu sunt egale.
ȘIR1 < ȘIR2 Adevărat dacă ȘIR1 se ordonează lexicografic înainte de ȘIR2.
ȘIR1 > ȘIR2 Adevărat dacă ȘIR1 se ordonează lexicografic după ȘIR2.n

Alți operatori:

-o OPȚIUNE Adevărat dacă opțiunea shell OPȚIUNE este activată.
-v VAR Adevărat dacă este definită variabila shell VAR.
-R VAR Adevărat dacă variabila shell VAR este definită și este o referință
de nume.
! EXPR Adevărat dacă expresia EXPR este falsă.
EXPR1 -a EXPR2 Adevărat dacă amândouă expresiile EXPR1 și EXPR2 sunt adevărate.
EXPR1 -o EXPR2 Adevărat dacă fie expresia EXPR1, fie expresia EXPR2 este adevărată.

ARG1 OP ARG2 Teste aritmetice. OP este unul dintre -eq, -ne, -lt, -le, -gt, sau -ge.

Operatorii binari aritmetici returnează adevărat dacă ARG1 este egal, inegal, mai mic
decât, mai mic decât sau egal, mai mare decât, sau mai mare decât sau egal cu ARG2.

Starea de ieșire:
Returnează succes dacă EXPR este evaluată ca adevărată; eșuează dacă EXPR este
evaluată ca fiind falsă sau este dat un argument nevalid.Evaluează expresia condițională.

Acesta este un sinonim pentru comanda internă «test», dar ultimul argument
trebuie să fie un „]” literal, pentru a se potrivi cu „[” de deschidere.Execută o comandă simplă sau afișează informații despre comenzi.

Rulează COMANDA cu ARGumente care suprimă căutarea funcției shell sau afișează
informații despre COMENZILE specificate. Se poate utiliza pentru a invoca comenzi
de pe disc atunci când există o funcție cu același nume.

Opțiuni:
-p utilizează o valoare implicită pentru PATH ce garantează că se
vor găsi toate utilitățile standard
-v imprimă o descriere a COMENZII, similară cu cea a comenzii
interne «type».
-V imprimă o descriere mai detaliată pentru fiecare COMANDĂ

Starea de ieșire:
Returnează starea de ieșire a COMENZII sau eșuează dacă COMANDA nu este găsită.Execută argumente ca o comandă de shell.

Combină ARGumentele într-un singur șir, folosește rezultatul ca intrare în
shell și execută comenzile rezultate.

Starea de ieșire:
Returnează starea de ieșire a comenzii, sau succes dacă comanda este nulă.Execută comenzi atâta timp cât un test nu reușește.

Expandează și execută COMENZI-2 atâta timp cât comanda finală din
COMENZI are o stare de ieșire diferită de zero.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Execută comenzi atâta timp cât un test reușește.

Expandează și execută COMENZI-2 atâta timp cât comanda finală din
COMENZI are o stare de ieșire zero.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Execută comenzi bazate pe condițional.

Lista „if COMENZI” este executată. Dacă starea sa de ieșire este zero,
atunci este executată lista „then COMENZI”. În caz contrar, fiecare listă
„elif COMENZI” este executată pe rând, iar dacă starea sa de ieșire este
zero, lista corespunzătoare „then COMENZI” este executată și comanda
«if» se completează. În caz contrar, lista „else COMENZI” este executată,
dacă este prezentă. Starea de ieșire a întregii construcții este starea de
ieșire a ultimei comenzi executate sau zero dacă nicio condiție nu a fost
evaluată ca adevărată.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Execută comenzi bazate pe potrivirea modelelor.

Execută COMENZI selectiv, pe baza potrivirilor dintre CUVÂNT și MODEL.
„|” este folosit pentru a separa mai multe modele.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Execută comenzi pentru fiecare membru dintr-o listă.

Bucla „for” execută o secvență de comenzi pentru fiecare membru dintr-o
listă de elemente. Dacă „in CUVINTE ...;” nu este prezent, atunci se
presupune „in "$@"”. Pentru fiecare element din CUVINTE, se definește
NUME ca acel element, și se execută COMENZILE.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Execută comenzi dintr-un fișier în shell-ul curent.

Citește și execută comenzi din NUME_FIȘIER în shell-ul curent. Intrările
din $PATH sunt utilizate pentru a găsi directorul care conține NUME_FIȘIER.
Dacă sunt furnizate ARGUMENTE, acestea devin parametrii de poziție atunci
când este executat NUME_FIȘIER.

Starea de ieșire:
Returnează starea ultimei comenzi executate în NUME_FIȘIER; eșuează dacă
NUME_FIȘIER nu poate fi citit.Execută comanda condițională.

Returnează o stare de 0 sau 1, în funcție de evaluarea expresiei condiționale
EXPRESIA. Expresiile sunt compuse din aceleași elemente primare folosite de
comanda INTERNĂ «test» și pot fi combinate folosind următorii operatori:

( EXPRESIA ) Returnează valoarea EXPRESIEI
! EXPRESIA Adevărat dacă EXPRESIA este falsă; altfel fals
EXPR1 && EXPR2 Adevărat dacă atât EXPR1 cât și EXPR2 sunt adevărate;
altfel fals
EXPR1 || EXPR2 Adevărat dacă fie EXPR1, fie EXPR2 este adevărată;
altfel fals

Când se utilizează operatorii „==” și „!=”, șirul din dreapta operatorului
este utilizat ca model și se realizează potrivirea modelului.
Când se utilizează operatorul „=~”, șirul din dreapta operatorului se
potrivește ca expresie regulată.

Operatorii „&&” și „||” nu evaluează EXPR2 dacă EXPR1 este suficientă pentru
a determina valoarea expresiei.

Starea de ieșire:
0 sau 1, în funcție de valoarea EXPRESIEI.Execută comenzile interne de shell.

Execută SHELL-BUILTIN cu argumentele ARG fără a efectua căutarea comenzilor.
Acest lucru este util atunci când doriți să reimplementați o comandă internă de shell
ca o funcție shell, dar trebuie să executați comanda internă în cadrul funcției.

Starea de ieșire:
Returnează starea de ieșire a lui SHELL-BUILTIN sau false dacă SHELL-BUILTIN nu
este o comandă internă de shell.Ieșire %dIese din shell-ul de autentificare.

Iese din shell-ul de autentificare cu starea de ieșire N. Returnează o eroare
dacă nu este executată într-un shell de autentificare.Termină buclele for, while, sau until.

Termină o buclă FOR, WHILE sau UNTIL. Dacă se specifică N, termină
numărul de bucle specificat.

Starea de ieșire:
Starea de ieșire este 0, cu excepția cazului în care N nu este mai mare sau egal cu 1.Iese din shell.

Iese din shell cu starea lui N. Dacă N este omis, starea de ieșire
este starea ultimei comenzi executate.Limită fișierExcepție de virgulă mobilăFormatează și imprimă ARGUMENTELE sub controlul FORMATului.

Opțiuni:
-v var asignează ieșirea variabilei shell VAR, în loc să o
afișeze la ieșirea standard

FORMAT este un șir de caractere care conține trei tipuri de obiecte:
caractere simple, care sunt pur și simplu copiate la ieșirea standard;
secvențe de eludare de caractere, care sunt convertite și copiate la
ieșirea standard; și specificații de format, fiecare dintre acestea
determinând imprimarea următorului argument succesiv.

În plus față de specificațiile de format standard descrise în printf(1),
«printf» interpretează:

%b expandează secvențele de eludare de bară inversată,
în argumentul corespunzător
%q citează argumentul într-un mod care poate fi reutilizat
ca intrare shell
%Q precum %q, dar aplică orice precizie argumentului necitat
înainte de al cita
%(fmt)T afișează șirul dată-oră rezultat din utilizarea FMT,
ca șir de format pentru strftime(3)

Formatul este reutilizat după cum este necesar pentru a consuma toate
argumentele. Dacă există mai puține argumente decât necesită formatul,
specificațiile de format suplimentare se comportă ca și cum ar fi fost
furnizată o valoare zero sau un șir nul, după caz.

Starea de ieșire:
Returnează succes cu excepția cazului în care este dată o opțiune nevalidă
sau apare o eroare de scriere sau de atribuire.GNU bash, versiunea %s (%s)
GNU bash, versiunea %s-(%s)
Opțiuni lungi GNU:
Ajutor general pentru utilizarea software-ului GNU: <http://www.gnu.org/gethelp/>
Grupează comenzile ca o unitate.

Rulează un set de comenzi dintr-un grup. Aceasta este o modalitate
de a redirecționa un întreg set de comenzi.

Starea de ieșire:
Returnează starea ultimei comenzi executate.Date de intrare HFT în curs de rezolvareModul de monitor HFT a fost acordatModul de monitor HFT a fost retrasSecvența de sunet HFT a fost completatăvariabila $HOME nu este definităDeconectare/Terminare anormală(Hangup)Nu am nici un nume!In/Ieș pregătităRAPORT: Instrucțiune ilegalăSolicitare de informațieÎntrerupereOmorâtLicență GPLv3+: GNU GPL versiunea 3 sau ulterioară <http://gnu.org/licenses/gpl.html>
Marchează variabilele shell ca neschimbabile.

Marchează fiecare NUME ca fiind doar pentru citire; valorile acestor NUME
nu pot fi modificate prin atribuirea ulterioară. Dacă este furnizată VALOARE,
atribuie VALOARE înainte de a marca ca doar pentru citire.

Opțiuni:
-a se referă la variabilele matrice indexate
-A se referă la variabile matrice asociative
-f se referă la funcțiile shell
-p afișează o listă cu toate variabilele sau funcțiile protejate
la scriere, în funcție de dacă este dată sau nu opțiunea „-f”

Un argument de „--” dezactivează procesarea ulterioară a opțiunilor.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau NUME nu este valid.Modifică sau afișează opțiunile de completare.

Modifică opțiunile de completare pentru fiecare NUME sau, dacă nu sunt
furnizate NUME, completarea aflată în curs de executare. Dacă nu sunt
date OPȚIUNI, afișează opțiunile de completare pentru fiecare NUME sau
specificația de completare curentă.

Opțiuni:
-o opțiune
Stabilește opțiunea de completare OPȚIUNE pentru fiecare NUME
-D Schimbă opțiunile pentru completarea comenzii „implicite”.
-E Schimbă opțiunile pentru completarea comenzii „goale”.
-I Schimbă opțiunile de completare a cuvântului inițial

Utilizarea lui „+o” în loc de „-o” dezactivează opțiunea specificată.

Argumente:

Fiecare NUME se referă la o comandă pentru care o specificație de completare
trebuie să fi fost definită anterior folosind comanda internă «complete».
Dacă nu sunt furnizate NUME, «compopt» trebuie să fie apelată de o funcție
care generează completări în acest moment și opțiunile pentru acest
generator de completare care se execută acum, sunt modificate.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizată o opțiune
nevalidă sau NUME nu are o specificație de completare definită.Modifică limitele resurselor shell.

Oferă control asupra resurselor disponibile shell-ului și proceselor pe care
acesta le creează, pe sisteme care permit un astfel de control.

Opțiuni:
-S utilizează limita de resurse „soft”
-H utilizează limita de resurse „hard”
-a sunt raportate toate limitele curente
-b dimensiunea memoriei tampon a soclului
-c dimensiunea maximă a fișierelor create cu conținutul memoriei (core)
-d dimensiunea maximă a segmentului de date al unui proces
-e prioritatea maximă de planificare („nice”)
-f dimensiunea maximă a fișierelor scrise de shell și subprocesele sale
-i numărul maxim de semnale în așteptare
-k numărul maxim de Kcozi alocate pentru acest proces
-l dimensiunea maximă pe care un proces o poate bloca în memorie
-m cantitatea maximă de memorie fizică a unui proces
-n numărul maxim de descriptori de fișier deschise
-p dimensiunea memoriei tampon a liniei de conectare
-q numărul maxim de octeți din cozile de mesaje POSIX
-r prioritatea maximă a procesului în timp real
-s dimensiunea maximă a stivei
-t cantitatea maximă de timp a CPU-ului în secunde
-u numărul maxim de procese ale utilizatorului
-v dimensiunea memoriei virtuale
-x numărul maxim de blocări ale fișierelor
-P numărul maxim de pseudoterminale
-R timpul maxim pe care îl poate rula un proces în timp real înainte
de blocare
-T numărul maxim de fire(threads)

Nu toate opțiunile sunt disponibile pe toate platformele.

Dacă se dă LIMITA, aceasta este noua valoare a resursei specificate;
valorile speciale de LIMITĂ: „soft”, „hard” și „unlimited” reprezintă
limita curentă maleabilă, limita curentă dură și, respectiv, fără limită.
Altminteri, este afișată valoarea curentă a resursei specificate. Dacă
nu este dată nicio opțiune, atunci se presupune „-f”.

Valorile sunt în incremente de 1024 de octeți, cu excepția lui „-t”, care
este în secunde, a lui „-p”, care este în incremente de 512 octeți și a lui
„-u”, care este un număr nescalat de procese.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizată o opțiune
nevalidă sau apare o eroare.Mută procesul în primul plan.

Plasează procesul identificat de ID_PROC în primul plan, făcându-l procesul
curent. Dacă ID_PROC nu este prezent, este utilizată noțiunea shell-ului
despre procesul curent

Starea de ieșire:
Starea comenzii plasată în prim-plan sau eșec dacă apare o eroare.Mută procesul în fundal.

Plasează procesele identificate de fiecare ID_PROC în fundal, ca și cum ar fi
fost pornite cu „&”. Dacă ID_PROC nu este prezent, se folosește noțiunea
shell-ului despre procesul curent.

Starea de ieșire:
Returnează succes, cu excepția cazului în care controlul procesului nu este
activat sau apare o eroare.Comandă nulă.

Fără efect; comanda nu face nimic.

Starea de ieșire:
Întotdeauna reușește(0).variabila $OLDPWD nu este definităAnalizează argumentele opțiunii.

«getopts» este folosit de procedurile shell pentru a analiza parametrii
poziționali ca opțiuni.

ȘIR_OPȚIUNI conține literele de opțiune care trebuie recunoscute; dacă
o literă este urmată de două puncte, se așteaptă ca opțiunea să aibă un
argument, care ar trebui să fie separat de aceasta prin spațiu alb.

De fiecare dată când este invocată, «getopts» va plasa următoarea opțiune
în variabila shell $nume, inițializând nume dacă nu există, iar indexul
următorului argument va fi procesat în variabila shell OPTIND. OPTIND este
inițializată la 1 de fiecare dată când shell-ul sau un script shell este
invocat. Când o opțiune necesită un argument, «getopts» plasează acel
argument în variabila shell OPTARG.

«getopts» raportează erorile într-unul dintre următoarele două moduri. Dacă
primul caracter al lui ȘIR_OPȚIUNI este două puncte, «getopts» utilizează
raportarea silențioasă a erorilor. În acest mod, nu este afișat niciun mesaj
de eroare. Dacă se găsește o opțiune nevalidă, «getopts» plasează caracterul
de opțiune găsit în OPTARG. Dacă nu este găsit un argument necesar, «getopts»
plasează un „:” în NUME și pune în OPTARG caracterul de opțiune găsit. Dacă
«getopts» nu este în modul silențios și se găsește o opțiune nevalidă, «getopts»
plasează „?” în NUME și dezactivează OPTARG. Dacă nu este găsit un argument
necesar, un „?” este plasat în NUME, OPTARG este dezactivată și este afișat un
mesaj de diagnosticare.

Dacă variabila shell OPTERR are valoarea 0, «getopts» dezactivează afișarea
mesajelor de eroare, chiar dacă primul caracter al lui ȘIR_OPȚIUNI nu este
două puncte „:”. OPTERR are valoarea 1 implicit.

«getopts» analizează în mod normal parametrii de poziție, dar dacă argumentele
sunt furnizate ca valori ARG, acestea sunt analizate în schimb.

Starea de ieșire:
Returnează succes dacă este găsită o opțiune; eșuează dacă se întâlnește
sfârșitul opțiunilor sau apare o eroare.Imprimă numele directorului de lucru curent.

Opțiuni:
-L imprimă valoarea lui $PWD dacă aceasta numește directorul de
lucru curent
-P imprimă directorul fizic, fără nicio legătură simbolică

În mod implicit, „pwd” se comportă ca și cum „-L” ar fi fost specificat.

Starea de ieșire:
Returnează 0, cu excepția cazului în care este dată o opțiune nevalidă
sau directorul curent nu poate fi citit.PărăsireCitește o linie din intrarea standard și o împarte în câmpuri.

Citește o singură linie din intrarea standard sau din descriptorul de fișier
FD dacă este furnizată opțiunea -u. Linia este împărțită în câmpuri ca în
cazul împărțirii cuvintelor, iar primul cuvânt este atribuit primului NUME,
al doilea cuvânt celui de-al doilea NUME și așa mai departe, ultimul NUME
preluând lista cuvintelor rămase. Doar caracterele găsite în $IFS sunt
recunoscute ca delimitatori de cuvinte. În mod implicit, caracterul bară oblică
inversă eludează caracterele delimitatoare și linia nouă.

Dacă nu sunt furnizate NUME, linia citită este stocată în variabila REPLY.

Opțiuni:
-a matrice
atribuie cuvintele citite indicilor secvențiali ai variabilei
matrice MATRICE, începând de la zero
-d delim continuă până când este citit primul caracter din DELIM, în loc
de linia nouă
-e utilizează Readline pentru a obține linia
-i text utilizează TEXT ca text inițial pentru Readline
-n ncarac returnează după citirea a NCARAC caractere în loc să aștepte
o nouă linie, dar respectă delimitatorul dacă sunt citite mai
puțin de NCARAC caractere înainte de delimitator
-N ncarac returnează numai după citirea exactă a NCARAC caractere, cu
excepția cazului în care se întâlnește sfârșitul fișierului sau
dacă timpul de citire expiră, eliminând orice delimitatori
-p prompt afișează șirul PROMPT fără un caracter de linie nouă la final,
înainte de a încerca să citească
-r nu permite barelor oblice inverse să eludeze niciun caracter
-s nu afișează ieșirea ce vine de la un terminal
-t timeout
expiră și returnează un cod de eroare dacă o linie completă de
intrare nu este citită în TIMEOUT secunde. Valoarea variabilei
TIMEOUT este timpul de expirare implicit. TIMEOUT poate fi un
număr fracțional. Dacă TIMEOUT este zero, citirea se termină
imediat fără a încerca să citească date, și returnează un cod de
succes numai dacă intrarea este disponibilă pe descriptorul de
fișier specificat. Starea de ieșire este mai mare de 128 dacă
timpul de expirare este depășit
-u fd citește din descriptorul de fișier FD în loc de intrarea standard

Starea de ieșire:
Codul de returnare este zero, cu excepția cazului în care se întâlnește
sfârșitul fișierului, expirarea timpului de citire (caz în care este mai mare
de 128), apare o eroare de atribuire a variabilei sau este furnizat un
descriptor de fișier nevalid ca argument pentru opțiunea „-u”.Citește linii dintr-un fișier într-o variabilă de tip matrice.

Un sinonim pentru «mapfile».Citește linii de la intrarea standard într-o variabilă matrice indexată.

Citește linii de la intrarea standard în variabila matrice indexată MATRICE,
sau din descriptorul de fișier „FD” dacă este furnizată opțiunea „-u”.
Variabila MAPFILE este MATRICEA implicită.

Opțiuni:
-d delim Utilizează DELIM pentru a termina liniile, în loc de linie nouă
-n număr Copiază cel mult NUMĂRul de rânduri. Dacă NUMĂR este 0,
toate liniile sunt copiate
-O origin Începe alocarea către MATRICE la indexul ORIGIN. Indicele
implicit este 0
-s count Renunță la primele COUNT rânduri citite
-t Elimină un DELIM final din fiecare linie citită (implicit,
linie nouă)
-u fd Citește linii din descriptorul de fișier „FD” în loc de la
intrarea standard
-C apelare
Evaluează APELARE de fiecare dată când sunt citite linii CANTITATE
-c cantitate
Specifică numărul de linii citite între fiecare apel către APELARE

Argumente:
MATRICE Nume variabilă matrice de utilizat pentru datele fișierului

Dacă „-C” este furnizată fără „-c”, cantitatea implicită este 5000. Când se
evaluează APELARE, i se furnizează indexul următorului element din matrice
care urmează să fie atribuit și linia care urmează să fie atribuită
acelui element ca argumente suplimentare.

Dacă nu este furnizat cu o origine explicită, «mapfile» va șterge MATRICE
înainte de a-o utiliza pentru asignare.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau MATRICE este protejată la scriere sau nu este o matrice indexată.Blocare înregistrareMemorizează sau afișează locațiile programelor.

Determină și memorizează calea completă a fiecărei comenzi NUME. Dacă nu
sunt date argumente, sunt afișate informații despre comenzile memorate.

Opțiuni:
-d uită locația reținută pentru fiecare NUME
-l afișează într-un format care poate fi reutilizat ca intrare
-p calenume
utilizează CALENUME drept calea completă a NUME
-r uită toate locațiile memorizate
-t afișează locația reținută a fiecărui NUME, precedând fiecare
locație cu NUMELE corespunzător dacă sunt date mai multe NUME
Argumente:
NUME Fiecare NUME este căutat în $PATH și adăugat la lista comenzilor
memorate.

Starea de ieșire:
Returnează succes, cu excepția cazului în care NUME nu este găsit sau
este dată o opțiune nevalidă.Elimină directoare din stivă.

Elimină intrările din stiva de directoare. Fără argumente, elimină
directorul de sus din stivă, și trece la noul director de sus.

Opțiuni:
-n Suprimă schimbarea normală a directorului atunci când se elimină
directoare la stivă, astfel încât numai stiva este manipulată.

Argumente:
+N Elimină intrarea a N-a numărând din stânga listei afișate
de «dirs», începând cu zero. De exemplu: «popd +0»
elimină primul director, «popd +1» al doilea.

-N Elimină intrarea a N-a numărând din dreapta listei afișate
de «dirs», începând cu zero. De exemplu: «popd -0»
elimină ultimul director, «popd -1» penultimul.

Comanda internă «dirs» afișează stiva de directoare.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizat un argument
nevalid sau dacă schimbarea directorului eșuează.Elimină fiecare NUME din lista de aliasuri definite.

Opțiuni:
-a elimină toate definițiile de alias

Returnează succes, cu excepția cazului în care un NUME nu este un alias existent.Elimină procese din shell-ul actual.

Elimină fiecare argument ID_PROC din tabelul de procese active. Fără
niciun ID_PROC, shell-ul folosește noțiunea sa de proces curent.

Opțiuni:
-a elimină toate procesele dacă ID_PROC nu este furnizat
-h marchează fiecare ID_PROC astfel încât SIGHUP să nu fie trimis
la proces dacă shell-ul primește un semnal SIGHUP
-r elimină numai procesele care rulează

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau ID_PROC.Elimină intrările din stiva de directoare. Fără argumente, elimină directorul
din partea de sus a stivei, și trece la cel cea devenit noul director de sus
a stivei.

Opțiuni:
-n Suprimă schimbarea normală a directorului atunci când se elimină
directoare din stivă, astfel încât numai stiva este manipulată.

Argumente:
+N Elimină intrarea a N-a numărând din stânga listei afișate de «dirs»,
începând cu zero. De exemplu: «popd +0» elimină primul director,
«popd +1» al doilea director, șamd.

-N Elimină intrarea a N-a numărând din dreapta listei afișate de «dirs»,
începând cu zero. De exemplu: «popd -0» elimină ultimul director,
„popd -1” penultimul director, șamd.

Comanda internă «dirs» arată stiva curentă de directoare.Înlocuiește shell-ul cu comanda dată.

Execută COMANDA, înlocuind acest shell cu programul specificat.
ARGUMENTELE devin argumente pentru COMANDA. Dacă COMANDA nu este
specificată, orice redirecționare va avea efect în shell-ul curent.

Opțiuni:
-a nume pasează NUME ca argument zero la COMANDA
-c execută COMANDA într-un mediu gol
-l plasează o liniuță în argumentul zero la COMANDA

Dacă comanda nu poate fi executată, un shell non-interactiv se va închide,
cu excepția cazului în care opțiunea shell „execfail” este setată.

Starea de ieșire
Returnează succes, cu excepția cazului în care COMANDA nu este găsită sau
apare o eroare de redirecționare.Raportează timpul consumat de execuția secvenței de comenzi.

Execută SECVENȚA_DE_COMENZI și imprimă un rezumat al timpului real,
al timpului CPU al utilizatorului și al timpului CPU al sistemului
petrecut executând SECVENȚA_DE_COMENZI atunci când aceasta termină.

Opțiuni:
-p afișează rezumatul cronometrajului în formatul Posix portabil

Valoarea variabilei TIMEFORMAT este utilizată drept format de ieșire.

Starea de ieșire:
Starea de returnare este starea de returnare a SECVENȚEI_DE_COMENZI.Reia buclele for, while, sau until.

Reia următoarea iterație a buclei curente FOR, WHILE sau UNTIL.
Dacă se specifică N, reia bucla și continuă pentru N niveluri în continuare.

Starea de ieșire:
Starea de ieșire este 0, cu excepția cazului în care N nu este mai mare sau egal cu 1.Reia lucrarea în prim-plan.

Echivalent cu argumentul JOB_SPEC al comenzii «fg». Reia o lucrare
oprită sau în fundal. JOB_SPEC poate specifica fie un nume de lucrare,
fie un număr de lucrare. JOB_SPEC urmat de un „&” plasează lucrarea
în fundal, ca și cum specificația lucrării ar fi fost furnizată ca argument
pentru «bg».

Starea de ieșire:
Returnează starea lucrării reluate.Returnează un rezultat de succes(0).

Starea de ieșire:
Întotdeauna reușește(0).Returnează un rezultat nereușit(≠0).

Starea de ieșire:
Întotdeauna eșuează(≠0).Returnează dintr-o funcție shell.

Determină ieșirea unei funcții sau a unui script sursă cu valoarea de
returnare specificată de N. Dacă N este omis, starea de returnare
este cea a ultimei comenzi executate în funcție sau script.

Starea de ieșire:
Returnează N sau eșec dacă shell-ul nu execută o funcție sau un script.Returnează contextul apelului subrutinei curente.

Fără EXPR, returnează „$line $filename”. Cu EXPR, returnează
„$line $subroutine $filename”; aceste informații suplimentare pot fi
utilizate pentru a furniza o urmărire a stivei.

Valoarea EXPR indică câte cadre de apel trebuie să se întoarcă înaintea
celui curent; cadrul superior este cadrul 0.

Starea de ieșire:
Returnează 0, cu excepția cazului în care shell-ul nu execută o funcție shell
sau EXPR nu este validă.Returnează contextul apelului subrutinei curente.

Fără EXPR, returnează „$linie $nume_fișier”. Cu EXPR, returnează
„$linie $subrutină $nume_fișier”; aceste informații suplimentare pot să fie
folosite pentru a furniza o urmărire a stivei.

Valoarea EXPR indică cîte cadre de apel trebuie să se întoarcă înaintea celui
curent; cadrul superior este cadrul 0.În rulareEroare de segmentareSelectează cuvinte dintr-o listă și execută comenzi.

CUVINTELE sunt expandate, generând o listă de cuvinte. Setul
de cuvinte expandate este afișat la ieșirea de eroare standard,
fiecare precedat de un număr. Dacă „în CUVINTE” nu este prezent,
se presupune „in "$@"”. Se afișează apoi promptul PS3 și se citește
o linie de la intrarea standard. Dacă linia constă din numărul
corespunzător unuia dintre cuvintele afișate, atunci se definește NUME
ca acest cuvânt. Dacă linia este goală, CUVINTE și promptul sunt
reafișate. Dacă este citit sfârșitul fișierului(EOF), comanda se
finalizează. Orice altă valoare citită face ca NUME să fie definit ca
null. Linia citită este salvată în variabila „REPLY”. COMENZILE sunt
executate după fiecare selecție până când este executată o comandă
de întrerupere(break).

Starea de ieșire:
Returnează starea ultimei comenzi executate.Trimite un semnal către un proces.

Trimite proceselor identificate prin PID sau JOBSPEC semnalul numit de
SIGSPEC sau de SIGNUM. Dacă nici SIGSPEC, nici SIGNUM nu sunt
prezente, atunci se presupune SIGTERM.

Opțiuni:
-s sig SIG este un nume de semnal
-n sig SIG este un număr de semnal
-l listează numele semnalelor; dacă după „-l” urmează argumente, se
presupune că sunt numere de semnal pentru care ar trebui listate
nume
-L sinonim cu -l

Kill este o comandă internă de shell din două motive: permite utilizarea
ID-urilor de job în locul ID-urilor de proces și permite omorârea proceselor
dacă este atinsă limita de procese pe care le puteți crea.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau apare o eroare.Configurează legăturile de taste și variabilele Readline.

Asociază o secvență de taste cu o funcție Readline sau cu o macrocomandă
sau configurează o variabilă Readline. Sintaxa argumentului fără opțiune
este echivalentă cu cea găsită în ~/.inputrc, dar trebuie transmisă ca un
singur argument; de exp.: bind '"\C-x\C-r": re-read-init-file'.

Opțiuni:
-m keymap Utilizează KEYMAP ca hartă de taste pe durata acestei
comenzi. Numele valabile pentru hărți de taste sunt emacs,
emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
vi-command, și vi-insert.
-l Enumeră numele funcțiilor.
-P Enumeră numele și asocierile funcțiilor.
-p Enumeră funcțiile și asocierile într-o formă care poate fi
reutilizată ca intrare.
-S Enumeră secvențele de chei care invocă macrocomenzi și
valorile acestora
-s Enumeră secvențele de chei care invocă macrocomenzi și
valorile acestora într-o formă care poate fi reutilizată ca intrare.
-V Enumeră numele și valorile variabilelor
-v Enumeră numele și valorile variabilelor într-o formă care
poate fi reutilizată ca intrare.
-q nume-funcție Se utilizează pentru a afla care taste invocă funcția numită.
-u nume-funcție Dezasociază toate tastele care sunt asociate cu funcția numită.
-r sec-taste Elimină asocierea pentru sec-taste numită.
-f nume-fișier Citește asocierile de taste din fișierul al cărui nume a fost dat.
-x sec-taste:comandă-shell Determină executarea comandă-shell când este
introdusă sec-taste.
-X Enumeră secvențele de taste asociate cu -x și comenzile asociate într-o
formă care poate fi reutilizată ca intrare.

Starea de ieșire:
«bind» returnează 0, cu excepția cazului în care este dată o opțiune nerecunoscută, sau apare o eroare.Activează sau dezactivează opțiunile de shell.

Schimbă configurarea fiecărei opțiuni de shell NUME_OPȚIUNE. Fără
niciun argument de opțiune, listează fiecare NUME_OPȚIUNE furnizat,
sau toate opțiunile de shell dacă nu sunt date NUME_OPȚIUNE, cu o
indicație dacă fiecare este sau nu definită.

Opțiuni:
-o restricționează NUME_OPȚIUNE la cele definite pentru a fi
utilizate cu «set -o»
-p afișează fiecare opțiune de shell cu o indicație a stării acesteia
-q suprimă ieșirea
-s activează (definește) fiecare NUME_OPȚIUNE
-u dezactivează (șterge) fiecare NUME_OPȚIUNE

Starea de ieșire:
Returnează succes dacă NUME_OPȚIUNE este activată; eșuează dacă
este dată o opțiune nevalidă sau NUME_OPȚIUNE este dezactivată.Stabilește atributul de export pentru variabilele shell.

Marchează fiecare NUME pentru export automat în mediul(environment)
comenzilor executate ulterior. Dacă este furnizată VALOAREa, atribuie
VALOAREa înainte de a exporta.

Opțiuni:
-f se referă la funcțiile shell
-n elimină proprietatea de export din fiecare NUME
-p afișează o listă cu toate variabilele și funcțiile exportate

Un argument de „--” dezactivează procesarea ulterioară a opțiunilor.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau NUME nu este valid.Stabilește sau anulează valorile opțiunilor de shell și ale parametrilor
poziționali.

Modifică valoarea atributelor shell și a parametrilor poziționali sau
afișează numele și valorile variabilelor shell.

Opțiuni:
-a Marchează variabilele care sunt modificate sau create, pentru export.
-b Notifică imediat când o sarcină este finalizată.
-e Termină imediat dacă o comandă termină cu o stare diferită de zero.
-f Dezactivează folosirea metacaracterelor pentru completarea numelor
fișierelor (fără „globbing”).
-h Memorizează locația comenzilor pe măsură ce sunt căutate.
-k Toate argumentele de atribuire sunt plasate în mediul(environment)
unei comenzi, nu doar cele care preced numele comenzii.
-m Activează controlul sarcinii.
-n Citește comenzile, dar nu le execută.
-o nume-opțiune
Stabilește variabila corespunzătoare → nume-opțiune:
allexport la fel ca -a
braceexpand la fel ca -B
emacs utilizează o interfață de editare a liniilor în
stilul «emacs»
errexit la fel ca -e
errtrace la fel ca -E
functrace la fel ca -T
hashall la fel ca -h
histexpand la fel ca -H
history activează istoricul comenzilor
ignoreeof shell-ul nu va termina după citirea „EOF”
interactive-comments
permite comentariilor să apară în comenzile interactive
keyword la fel ca -k
monitor la fel ca -m
noclobber la fel ca -C
noexec la fel ca -n
noglob la fel ca -f
nolog acceptat în prezent, dar ignorat
notify la fel ca -b
nounset la fel ca -u
onecmd la fel ca -t
physical la fel ca -P
pipefail valoarea returnată a unei linii de conectare este
starea ultimei comenzi care a ieșit cu o stare diferită
de zero sau zero dacă nicio comandă nu a ieșit cu o
stare diferită de zero
posix modifică comportamentul lui «bash» în cazul în care
operația implicită diferă de standardul Posix, pentru
a se potrivi cu standardul Posix
privileged la fel ca -p
verbose la fel ca -v
vi utilizează o interfață de editare a liniilor în
stilul «vi»
xtrace la fel ca -x
-p Modul cu privilegii: Activat ori de câte ori ID-urile de utilizator
reale și efective nu se potrivesc. Dezactivează procesarea
fișierului $ENV și importul funcțiilor shell. Dezactivarea acestei
opțiuni face ca uid-ul și gid-ul efectiv să fie stabilite la uid-ul și
gid-ul real
-t Termină după citirea și executarea unei comenzi.
-u Tratează variabilele nedefinite ca pe o eroare la substituire.
-v Afișează liniile de intrare ale shell-ului pe măsură ce sunt citite.
-x Afișează comenzile și argumentele lor pe măsură ce sunt executate.
-B Shell-ul va efectua înlocuirea acoladelor (de exp.: a{b,c} → ab ac)
-C Dacă este specificată, nu permite ca fișierele obișnuite existente să
fie suprascrise prin redirecționarea ieșirii.
-E Dacă este specificată, capturarea ERR este moștenită de funcțiile shell.
-H Permite înlocuirea istoricului cu un „!”. Această opțiune este activată
în mod implicit atunci când shell-ul este interactiv.
-P Dacă este specificată, legăturile simbolice nu sunt urmate la executarea
comenzilor precum «cd» care schimbă directorul curent.
-T Dacă este specificată, capturile DEBUG și RETURN sunt moștenite de
funcțiile shell.
-- Atribuie toate argumentele rămase parametrilor de poziție.
Dacă nu există argumente rămase, parametrii de poziție sunt eliminați.
- Atribuie toate argumentele rămase parametrilor de poziție.
Opțiunile -x și -v sunt dezactivate.

Utilizarea lui „+” în loc de „-”, face ca aceste opțiuni să fie dezactivate.
Opțiunile pot fi folosite și la invocarea shell-ului. Setul actual de
opțiuni poate fi găsit în $-. Restul de n ARG sunt parametri poziționali și
sunt alocați, în ordine, la $1, $2, .. $n. Dacă nu sunt date ARG, toate
variabilele shell sunt afișate.

Starea de ieșire:
Returnează succes cu excepția cazului în care este dată o opțiune nevalidă.Stabilește valorile și atributele variabilelor.

Un sinonim pentru „declare”. A se vedea „help declare”.Stabilește valorile și atributele variabilelor.

Declară variabilele și-le atribuie atribute. Dacă nu sunt date NUME,
afișează atributele și valorile tuturor variabilelor.

Opțiuni:
-f restricționează acțiunea sau afișarea, la numele și definițiile funcțiilor
-F restricționează afișarea numai la numele funcțiilor (plus numărul de
linie și fișierul sursă, la depanare)
-g creează variabile globale atunci când sunt utilizate într-o funcție shell;
altfel sunt ignorate
-I dacă se creează o variabilă locală, moștenește atributele și valoarea
unei variabile cu același nume dintr-un scop anterior
-p afișează atributele și valoarea fiecărui NUME

Opțiuni care stabilesc atributele:
-a stabilește NUME ca matrice indexată (dacă este acceptat)
-A stabilește NUME ca matrice asociativă (dacă este acceptat)
-i stabilește ca NUME să aibă atributul „integer”
-l pentru a converti valoarea fiecărui NUME în minuscule, la atribuire
-n face din NUME o referință la variabila numită după valoarea acesteia
-r creează NUME ca numai-citire
-t stabilește ca NUME să aibă atributul „trace”
-u pentru a converti valoarea fiecărui NUME în majuscule, la atribuire
-x pentru a exporta NUME

Utilizarea a „+” în loc de „-”, dezactivează atributul dat.

Variabilele cu atributul întreg au o evaluare aritmetică (vezi comanda
«let») efectuată atunci când variabilei i se atribuie o valoare.

Când este folosită într-o funcție, «declare» face ca NUME să fie local, ca
și în cazul comenzii «local». Opțiunea „-g” suprimă acest comportament.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizată o opțiune
nevalidă sau apare o eroare de atribuire a variabilelor.Comenzile Shell care se potrivesc cu cuvântul cheie „Comenzile Shell care se potrivesc cu cuvintele cheie „Comenzile Shell care se potrivesc cu cuvintele cheie „Opțiuni ale shell-ului:
Schimbă parametrii poziționali.

Redenumește parametrii de poziție $N+1,$N+2 ... la $1,$2 ... Dacă N
nu este dat, se presupune că este 1.

Starea de ieșire:
Returnează succes, cu excepția cazului în care N este negativ sau mai
mare decât $#.Semnal %dSpecifică modul în care argumentele vor fi completate de Readline.

Pentru fiecare NUME, specifică cum vor fi completate argumentele. Dacă
nu sunt furnizate opțiuni, specificațiile de completare existente sunt
imprimate într-un mod care să permită reutilizarea lor ca intrare

Opțiuni:
-p afișează specificațiile de completare existente într-un format
reutilizabil
-r elimină o specificație de completare pentru fiecare NUME sau,
dacă nu sunt furnizate NUME, toate specificațiile de completare
-D aplicați completările și acțiunile ca implicite pentru comenzi
fără nicio completare specifică definită
-E aplică completările și acțiunile pentru comenzile „goale” --
când se încearcă completarea într-o linie goală
-I aplică completările și acțiunile la cuvântul inițial (de obicei
comanda).

Când se încearcă completarea, acțiunile sunt aplicate în ordinea în care
opțiunile cu litere mari sunt listate mai sus. Dacă sunt furnizate mai multe
opțiuni, opțiunea „-D” are prioritate față de „-E” și ambele au prioritate
față de opțiunea „-I”.

Starea de ieșire:
Returnează succes, cu excepția cazului în care este furnizată o opțiune
nevalidă sau apare o eroare.OpritOprit (semnal)Oprit (tty input)Oprit (tty output)Oprit(%s)Suspendă execuția shell-ului.

Suspendă execuția acestui shell până când primește un semnal SIGCONT.
Cu excepția cazului în care sunt forțate, shell-urile de autentificare nu pot
fi suspendate.

Opțiuni:
-f forțează suspendarea, chiar dacă shell-ul este un shell de
autentificare

Starea de ieșire:
Returnează succes, cu excepția cazului în care controlul sarcinii nu este
activat sau apare o eroare.TIMEFORMAT: „%c”: caracter de format nevalidTerminatMailul din %s a fost citit
Sunt(există) lucrări în execuție.
Sunt(există) lucrări oprite.
NU EXISTĂ NICIO GARANȚIE, în măsura permisă de lege.Aceste comenzi shell, sunt definite intern. Tastează «help», pentru a vedea
această listă.
Tastează «help nume_funcție» pentru a afla mai multe despre funcția „nume_funcție”.
Utilizați «info bash» pentru a afla mai multe despre shell în general.
Utilizați «man -k» sau «info» pentru a afla mai multe despre comenzile care nu
sunt în această listă.

O stea (*) în dreptul unui nume înseamnă că acea comandă este dezactivată.

Acesta este un software liber; sunteți liber să îl modificați și să îl redistribuiți.Capturează semnale și alte evenimente.

Definește și activează operatorii care urmează să fie rulați atunci când
shell-ul primește semnale sau apar alte evenimente.

ARG este o comandă care trebuie citită și executată atunci când shell-ul
primește semnalul(ele) SIGNAL_SPEC. Dacă ARG este absentă (și este
furnizat un singur SIGNAL_SPEC) sau „-”, fiecare semnal specificat este
restabilit la valoarea sa originală. Dacă ARG este un șir nul, fiecare
SIGNAL_SPEC este ignorat de către shell și de comenzile pe care le invocă.

Dacă un SIGNAL_SPEC este EXIT (0), ARG este executat la ieșirea din shell.
Dacă un SIGNAL_SPEC este DEBUG, ARG este executat înainte de fiecare comandă
simplă. Dacă un SIGNAL_SPEC este RETURN, ARG este executat de fiecare dată
când o funcție shell sau un script rulat din . sau comanda internă «source»
se termină de executat. Un SIGNAL_SPEC de ERR face ca ARG să fie executat
de fiecare dată când eșecul unei comenzi ar determina terminarea shell-ului
atunci când opțiunea „-e” este activată.

Dacă nu sunt furnizate argumente, «trap» afișează lista de comenzi asociate
fiecărui semnal.

Opțiuni:
-l afișează o listă de nume de semnale și numerele corespunzătoare
ale acestora
-p afișează comenzile de captură asociate fiecărui SIGNAL_SPEC

Fiecare SIGNAL_SPEC este fie un nume de semnal în <signal.h>, fie un număr
de semnal. Numele semnalelor nu fac distincție între majuscule și minuscule,
iar prefixul SIG este opțional. Un semnal poate fi trimis către shell cu
«kill -signal $$».

Starea de ieșire:
Returnează succes, cu excepția cazului în care un SIGSPEC este nevalid sau
este dată o opțiune nevalidă.Tastați «%s -c "help set"» pentru mai multe informații despre opțiunile shell-ului.
Tastați «%s -c help» pentru mai multe informații despre comenzile interne ale shell-ului.
Semnal necunoscut #%dEroare necunoscutăStare necunoscutăAnulează valorile și atributele variabilelor și funcțiilor shell.

Pentru fiecare NUME, elimină variabila sau funcția corespunzătoare.

Opțiuni:
-f tratează fiecare NUME ca pe o funcție shell
-v tratează fiecare NUME ca pe o variabilă shell
-n tratează fiecare NUME ca referință de nume și anulează variabila
în sine, în loc de variabila la care face referire

Fără opțiuni, „unset” încearcă mai întâi să anuleze o variabilă și, dacă
aceasta nu reușește, încearcă să anuleze o funcție.

Unele variabile nu pot fi anulate; consultați, de asemenea, «readonly».

Starea de ieșire:
Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
sau un NUME este doar pentru citire.Condiție In/Ieș urgentăUtilizare: %s [GNU opțiune lungă] [opțiune] ...
%s [GNU opțiune lungă] [opțiune] fișier-script ...
Utilizați „%s” pentru a părăsi shell-ul.
Utilizați comanda «bashbug» pentru a raporta erori.
Semnal utilizator 1Semnal utilizator 2Așteaptă finalizarea lucrării și returnează starea de ieșire.

Așteaptă fiecare proces identificat printr-un ID, care poate fi un ID de
proces sau o specificație de lucrare și raportează starea de terminare
a acestuia. Dacă ID-ul nu este dat, așteaptă toate procesele secundare
active în prezent și starea de returnare este zero. Dacă ID-ul este o
specificație de lucrare, așteaptă toate procesele din secvența de comenzi
respectivă a lucrării.

Dacă este furnizată opțiunea „-n”, așteaptă o singură lucrare din lista de
ID-uri sau, dacă nu sunt furnizate ID-uri, pentru finalizarea următoarei
lucrări și returnează starea de ieșire.

Dacă este furnizată opțiunea „-p”, identificatorul de proces sau de lucrare al
lucrării pentru care este returnată starea de ieșire este atribuit variabilei
VAR numită de argumentul opțiunii. Variabila va fi anulată inițial, înainte
de orice atribuire. Acest lucru este util numai atunci când este furnizată
opțiunea „-n”.

Dacă este furnizată opțiunea „-f” și controlul lucrării este activat,
așteaptă ca ID-ul specificat să se termine, în loc să aștepte ca acesta să
își schimbe starea.

Starea de ieșire:
Returnează starea ultimului ID; eșuează dacă ID-ul este nevalid sau este
dată o opțiune nevalidă sau dacă „-n” este furnizată și shell-ul nu are
niciun copil pe care să-l aștepte.Așteaptă finalizarea procesului și returnează starea de ieșire.

Așteaptă fiecare proces specificat de un PID și raportează starea de terminare a
acestuia. Dacă nu este dat PID, așteaptă toate procesele copil active în prezent,
iar starea returnată este zero. PID trebuie să fie un ID de proces.

Starea de ieșire:
Returnează starea ultimului PID; eșuează dacă PID este nevalid sau este dată
o opțiune nevalidă.Fereastră schimbatăScrie argumente la ieșirea standard.

Afișează ARGumentele la ieșirea standard urmate de o linie nouă.

Opțiuni:
-n nu adaugă o nouă linie

Starea de ieșire:
Returnează succes cu excepția cazului în care apare o eroare de scriere.Scrie argumente la ieșirea standard.

Afișează ARGumentele, separate printr-un singur caracter de spațiu și urmate
de o nouă linie, în ieșirea standard.

Opțiuni:
-n nu adaugă o nouă linie
-e activează interpretarea următoarelor eludări de bară oblică inversă
-E suprimă în mod explicit interpretarea eludărilor de bară oblică inversă

«echo» interpretează următoarele caractere de eludare de bară oblică inversă:
alertă (clopoțel)
\b mută cursorul înapoi cu unul sau mai multe spații
\c suprimă ieșirea ulterioară
\e caracter de eludare
\E caracter de eludare
\f alimentare cu „hîrtie”
\n linie nouă
\r returul de caret↵
\t tabulator orizontal
\v tabulator vertical
\\ bară oblică inversă
\0nnn caracterul al cărui cod ASCII este NNN (octal). NNN poate fi
de la 0 la 3 digiți octali
\xHH caracterul de opt biți a cărui valoare este HH (hexazecimal). HH
poate fi unu sau doi digiți hexazecimali
\uHHHH caracterul Unicode a cărui valoare este valoarea hexazecimală HHHH.
HHHH poate fi de la unu până la patru digiți hexazecimali.
\UHHHHHHHH caracterul Unicode a cărui valoare este valoarea hexazecimală
HHHHHHHH. HHHHHHHH poate fi de la unu până la opt digiți hexazecimali.

Starea de ieșire:
Returnează succes cu excepția cazului în care apare o eroare de scriere.Aveți mail în $_Aveți mail nou în $_[ arg... ][[ expresie ]]„%c”: comandă incorectă„%c”: caracter de format nevalid„%c”: caracter de mod simbolic nevalid„%c”: operator de mod simbolic nevalid„%c”: specificație a formatului de timp nevalidă„%s”: atribuirea nu poate fi ștearsă„%s”: nu se poate înlătura combinația de taste atribuită la comandă„%s”: nume alias nevalid`%s': nume de combinație de taste nevalid„%s”: nume de variabilă nevalid pentru referință la nume„%s”: este o comandă internă specială„%s”: lipsește caracterul de format„%s”: nu este un pid sau o specificație validă de lucru„%s” nu este un identificator valid„%s”: nume de funcție necunoscutse aștepta „)'”se aștepta „)”, s-a găsit %sse aștepta „:” după expresia condiționalăadd_process: pid %5ld (%s) marcat ca încă în viațăalias [-p] [nume[=valoare] ... ]all_local_variables: nu există context de funcție în domeniul actualargumentse aștepta un parametrueste necesar suport pentru variabilă matrices-a încercat asignare către non-variabilăindice de matrice greșittip de comandă greșitconector greșitsalt eronatînlocuire greșită: fără „`” de închidere în %sînlocuire greșită: nu se închide „%s” în %sPagina principală a lui „bash”: <http://www.gnu.org/software/bash>
bash_execute_unix_command: nu se poate găsi combinația de taste pentru comandăbg [id_lucrare ...]bgp_delete: BUCLĂ: psi (%d) == storage[psi].bucket_nextbgp_search: BUCLĂ: psi (%d) == storage[psi].bucket_nextbind [-lpsvPSVX] [-m comb_taste] [-f nume_fișier] [-q nume] [-u nume] [-r secv_taste] [-x secv_taste:comandă_shell] [secv_taste:funcție-readline sau comandă-readline]expansiunea de acolade: nu se poate aloca memorie pentru %sexpansiunea de acolade: a eșuat alocarea memoriei pentru %u elementeexpansiunea de acolade: a eșuat alocarea memoriei pentru „%s”break [n]eroare: simbol de atribuire al expresiei greșitbuiltin [comandă_internă-shell [arg ...]]caller [expr]„return”, se poate utiliza doar de la o funcție sau script executat(ă) de la „source”poate fi folosit doar într-o funcțienu se poate aloca un nou descriptor de fișier pentru intrarea bash din fd %dnu se poate crea un fișier temporar pentru «here-document»: %snu se poate duplica descriptorul de fișier %d în descriptorul de fișier %dnu se poate duplica linia de conectare numită %s ca fd %dnu se poate găsi %s în obiectul partajat %s: %snu se poate crea un proces-copil pentru substituția de comandănu se poate crea un proces-copil pentru substituirea procesului: %snu se poate crea linia de conectare pentru substituția de comandănu se poate crea linia de conectare pentru substituția procesuluinu se poate deschide linia de conectare numită %s pentru citirenu se poate deschide linia de conectare numită %s pentru scrierenu poate deschide obiectul partajat %s: %snu se poate redirecționa intrarea standard de la /dev/null: %snu se poate redefini modul „nodelay” pentru descriptorul de fișier %dnu se pot activa și dezactiva simultan opțiunile de shellnu se poate stabili gid la %d: gid efectiv %dnu se poate configura grupul de procese din terminal (%d)nu se poate stabili uid la %d: uid efectiv %dnu se pot anula simultan o funcție și o variabilănu se poate porni depanatorul; modul de depanare a fost dezactivatnu se poate suspendanu se poate suspenda un shell de autentificarenu se poate utiliza „-f” pentru a face funcțiinu se poate folosi mai mult de o opțiune dintre „-a, -n, -r sau -w”case CUVÂNT in [MODEL[[MODEL]..) COMENZI ;;]... esaccd [-L|[-P [-e]] [-@]] [dir]setpgid proces-copil (de la %ld la %ld)command [-pVv] comandă [arg ...]substituție de comandă: octetul null din intrare este ignoratcommand_substitute: nu se poate duplica linia de conectare ca descriptor de fișier 1(fd 1)compgen [-abcdefgjksuv] [-o opțiune] [-A acțiune] [-G tipar_glob] [-W listă_cuvinte] [-F funcție] [-C comandă] [-X tipar_filtru] [-P prefix] [-S sufix] [cuvânt]complete [-abcdefgjksuv] [-pr] [-DEI] [-o opțiune] [-A acțiune] [-G tipar_glob] [-W listă_cuvinte] [-F funcție] [-C comandă] [-X tipar_filtru [- P prefix] [-S sufix] [nume ...]completare: funcția „%s” nu a fost găsităcompopt [-o|+o opțiune] [-DEI] [nume ...]se aștepta operator binar condiționalcontinue [n]coproc [NUME] comanda [redirecționări]nu s-a putut găsi «/tmp», vă rugăm să-l creați!cprintf: „%c”: caracter de format nevalidactualdeclare [-aAfFgiIlnrtux] [nume[=valoare] ...] sau declare -p [-aAfFilnrtux] [nume ...]se șterge lucrarea oprită %d cu grupul de procese %lddescribe_pid: %ld: nu există un asemenea pidstiva de directoare este goalăindexul stivei de directoaredirs [-clpv] [+N] [-N]disown [-h] [-ar] [id_lucrare ... | pid ...]împărțire la 0încărcarea dinamică nu este disponibilăecho [-n] [arg ...]echo [-neE] [arg ...]nume de variabilă matrice golenable [-a] [-dnps] [-f nume_fișier]] [nume ...]eroare la obținerea atributelor terminalului: %seroare în importarea definiției funcției pentru „%s”eroare la configurarea atributelor terminalului: %seval [arg ...]eval: s-a depășit nivelul maxim de suprapunere de «eval» (%d)exec [-cl] [-a nume] [comandă [argument ...]] [redirectare ...]execute_coproc: coproc [%d:%s] încă existăexit [n]se aștepta „)”exponent mai mic de 0export [-fn] [nume[=valoare] ...] sau export -pse așteaptă expresienivel de recursivitate al expresiei depășitfc [-e enume] [-lnr] [prim] [ultim] sau fc -s [pat=rep] [comandă]fg [id_lucrare]descriptor de fișier în afara intervaluluieste necesar argumentul nume_de_fișierfor (( exp1; exp2; exp3 )); do COMENZI; donefor NUME [in CUVINTE ... ] ; do COMENZI; donepid-ul bifurcat %d apare în lucrarea în execuție %dproblemă cu analizarea formatului: %sfree: apelat cu un argument bloc deja eliberatfree: apelat cu un argument de bloc nealocatfree: dimensiunile bucăților de început și de sfârșit sunt diferitefree: s-a detectat o depășire insuficientă; magic8 coruptfree: s-a detectat o depășire insuficientă; mh_nbytes în afara intervaluluifunction nume { COMENZI ; } sau nume () { COMENZI ; }versiunile viitoare ale shell-ului vor forța evaluarea ca o substituție aritmeticăgetcwd: nu s-au putut accesa directoarele părintegetopts șir_opțiuni nume [arg ...]hash [-lr] [-p nume_rută [-dt] [nume ...]asocierea este desactivatăhelp [-dms] [tipar ...]ajutorul nu este disponibil în această versiune«here-document» la linia %d delimitat de sfârșitul fișierului (se aștepta „%s”)history [-c] [-d decalaj] [n] sau history -anrw [nume_fișier] sau history -ps arg [arg...]poziție în registrul istoric al comenzilorspecificație de istoricpotriviri comandă
se aștepta un identificator după pre-increment sau pre-decrementif COMENZI; then COMENZI; [elif COMENZI; then COMENZI; ]... [ else COMENZI; ] fiinitialize_job_control: getpgrp a eșuatinitialize_job_control: disciplină linieinitialize_job_control: nu există control de lucrări în fundalinitialize_job_control: setpgidbază aritmetică nevalidăbază nevalidăcaracter nevalid %d în exportstr pentru %snumăr hexazecimal nevalidconstantă de număr întreg nevalidănumăr nevalidnumăr octal nevalidnumăr de semnal nevalidlucrarea %d a început fără controlul lucrăriiid_lucrare [&]jobs [-lnprs] [id_lucrare ...] sau jobs -x comandă [args]kill [-s id_semnal | -n num_semnal | -id_semnal] pid | id_lucrare ... sau kill -l [id_semnal]ultima comandă: %s
let arg [arg ...]limitălinia %d: editarea liniilor nu este activatăfuncția de încărcare pentru %s returnează eroarea (%d): încărcarea a eșuatlocal [opțiune] nume[=valoare] ...deautentificare
logout [n]contor buclămake_here_document: tip de instrucțiune greșit %dmake_local_variable: nu există context de funcție în domeniul actualmake_redirection: instrucțiunea de redirecționare „%d” este în afara intervaluluimalloc: bloc suprascris pe lista liberămalloc: a eșuat aserțiunea: %s
mapfile [-d delim] [-n cont] [-O origin] [-s cont] [-t] [-u fd] [-C apelare] [-c cantitate] [matrice]numărul maxim de «here-document» a fost depășitmigrare proces spre alt CPU„)” lipseștelipsește „]”lipsește o cifră hexazecimală pentru \xlipsește o cifră unicode pentru \%coperațiunile de rețea nu sunt acceptatenu există „=” în exportstr pentru %snu se închide „%c” în %snu s-a găsit nici-o comandăniciun subiect de ajutor nu se potrivește cu „%s”. Încercați «help help» sau «man -k %s» sau «info %s».nu există un control de lucrărinu există niciun control de lucrări în acest shellnicio potrivire: %sniciun alt directornu sunt permise alte opțiuni cu „-x”în prezent funcția de completare nu ruleazănu este un shell de autentificare: utilizați „exit”director nulnumăr octalare sens numai într-o buclă „for”, „while” sau „until”eroare de linie de conectarepop_scope: partea de sus din shell_variables nu este un domeniu de mediu temporarpop_var_context: partea de sus din shell_variables nu este un context de funcțiepop_var_context: nu există un context global_variablespopd [-n] [+N | -N]probleme electrice iminentemodul de imprimare „drăguț” este ignorat în shell-urile interactiveprint_command: conector greșit „%d”printf [-v var] format [argumente]progcomp_insert: %s: COMPSPEC nullprogramable_completion: %s: posibilă buclă de reîncercareeroare de programarepushd [-n] [+N | -N | dir]pwd [-LP]read [-ers] [-a matrice] [-d delim] [-i text] [-n nr_carac] [-N nr_carac [-p prompt] [-t timp] [-u fd] [nume ...]eroare de citire: %d: %sreadarray [-d delim] [-n cantitate] [-O origine] [-s cantitate] [-t] [-u fd] [-C apelare] [-c sumă_de] [matrice]readonly [-aAf] [nume[=valoare] ...] sau readonly -prealloc: apelat cu un argument de bloc nealocatrealloc: dimensiunile bucăților de început și de sfârșit, diferărealloc: s-a detectat o depășire insuficientă; magic8 coruptrealloc: s-a detectat o depășire insuficientă; mh_nbytes țn afara intervaluluistivă recursivă sub nivelul de depășireeroare de redirectare: nu se poate duplica descriptorul de fișierregister_alloc: %p deja în tabel ca fiind alocat?
register_alloc: tabelul de alocare este plin cu FIND_ALLOC?
register_alloc: %p deja în tabel ca liber?
restricționatreturn [n]run_pending_traps: valoare greșită în trap_list[%d]: %prun_pending_traps: gestionarul de semnal este SIG_DFL, se retrimite %d (%s) către minesave_bash_input: memorie tampon deja existentă pentru noul descriptor de fișier %dselect NUME [in CUVINTE ... ;] do COMENZI; doneset [-abefhkmnptuvxBCEHPT] [-o nume-opțiune] [--] [-] [arg ...]setlocale: %s: nu se poate schimba parametrul de limbă (%s)setlocale: %s: nu se poate schimba parametrul de limbă (%s): %ssetlocale: LC_ALL: nu se poate schimba parametrul de limbă (%s)setlocale: LC_ALL: nu se poate schimba parametrul de limbă (%s): %snivelul shell-ului (%d) prea mare, se reinițializează la 1shell_getc: shell_input_line_size (%zu) depășește SIZE_MAX (%lu): linie trunchiatăshift [n]contor deplasare(shift)shopt [-pqsu] [-o] [nume_opțiune ...]sigprocmask: %d: operație nevalidăsource nume_fișier [argumente]start_pipeline: linie de conectare pgrpsuspend [-f]eroare de sintaxăeroare de sintaxă în expresia condiționalăeroare de sintaxă în expresia condițională: simbol neașteptat „%s”eroare de sintaxă în expresieeroare de sintaxă în atribuirea variabileieroare de sintaxă neașteptată lângă „%s”eroare de sintaxă neașteptată lângă „%s”eroare de sintaxă: „%s” neașteptateroare de sintaxă: „((%s))”eroare de sintaxă: „;” neașteptateroare de sintaxă: expresie aritmetică necesarăeroare de sintaxă: operator aritmetic nevalideroare de sintaxă: se aștepta un operanderoare de sintaxă: sfârșit de fișier neașteptatcădere iminentă a sistemuluitest [expr]time [-p] secvența_de_comenzi(pipeline)prea mulți parametritrap [-lp] [[arg] id_semnal ...]gestionarul de capturare: nivelul maxim de gestionări de capturare a fost depășit (%d)trap_handler: semnal nevalid %dtype [-afptP] nume [nume ...]typeset [-aAfFgiIlnrtux] nume[=valoare] ... sau typeset -p [-aAfFilnrtux] [nume ...]ulimit [-SHabcdefiklmnpqrstuvxPRT] [limită]umask [-p] [-S] [mod]unalias [-a] nume [nume ...]sfârșit neașteptat al fișierului(EOF) în timp ce se căuta „]]”sfârșit neașteptat al fișierului(EOF) în timp ce se căuta coincidența pentru „%c”sfârșit neașteptat al fișierului în timp ce se căuta după perechea lui „)”argument neașteptat „%s” pentru operatorul binar condiționalargument neașteptat „%s” pentru operatorul unar condiționalargument neașteptat pentru operatorul binar condiționalargument neașteptat pentru operatorul unar condiționalidentificator neașteptat %d în comanda condiționalăidentificator neașteptat „%c” în comanda condiționalăidentificator neașteptat „%s” în comanda condiționalăidentificator neașteptat „%s”, se aștepta operator binar condiționalsimbol neașteptat „%s”, așteptat „)”necunoscuteroare de comandă necunoscutăunset [-f] [-v] [-n] [nume ...]until COMENZI; do COMENZI-2; donevaloare prea mare pentru bazăvariables - Numele și semnificațiile unor variabile din shellwait [-fn] [-p var] [id ...]wait [pid ...]wait: pid %ld nu este un proces-copil al acestui shellwait_for: Nu există nicio înregistrare a procesului %ldwait_for_job: lucrarea %d este oprităwaitchld: se activează WNOHANG pentru a evita blocarea pe termen nedefinitavertizare: avertizare: %s: %savertisment: este posibil ca opțiunea „-C” să nu funcționeze așa cum vă așteptațiavertisment: este posibil ca opțiunea „-F” să nu funcționeze așa cum vă așteptațiwhile COMENZI; do COMENZI-2; doneeroare de scriere: %sxtrace fd (%d) != nrfișier xtrace fp (%d)xtrace_set: %d: descriptor de fișier nevalidxtrace_set: indicatorul pentru fișier este NULL{ COMENZI ; }