V|%1*12</2$l2 22222233 33=3O3f3}33333 34404H4(d4/4;4$4:5Y5l55(5'5"56#6@63^66 6&6&6/7/C7s77.77"78+'8S8e8/~8888"8939D9b9~9"9/999:-&:T:j:::::::;);)F;p;;;;;;< <!?<a<w<,<< << =0=.H=w=0==== >>.>E>]>w>> >>>&>?4?/R???)???&@3-@a@~@@ @&@@@@ AA9+A#eAAA AAHEHH IFI`JoJ J J J JJP Pw[1[m[ ]0]^]afbT?fhlX_p+uLw1yy?|$-t= Owf^Xg@uv |i 8Oj?ذԱ $ 4>G[ oyNϲJQ,r=fDDS$P x\ 2<@FFL`Xt>', s9Z`3D b:"B"S"g" |"O"*# $$,$E$5^$O$B%'&B+E@,, ,,},4/XH//*/ / /04J6Y6C7;< <$<5<G<%f<$<'<<%<=,=.F=u==!=== >>'.>0V>>9>>>>$?@?T? e?s?&|?'?3?9?9@6K@6@@.MA:|A3A AA!B 0B3>BrB=B-BB'C&EC*lC*C)C)C%D%T IT+TT9T;T$TUd9U$UU U UUV 1VRVmVVHVVV WW")W+LWxWW W4W WDW?5X,uXXX2X!Y""Y"EY0hYYY YoY@ZfSZ1Z/Z)[-F[3t[[&[2[5\,R\ \ \1\I\4].F]>u](],], ^07^)h^N^ ^ ^ ^"_;_W_ q_ ~_&_=__# `/`'F`n```,`)`a$6a[a qa}aa"a6aabQ7b*bbb%b.c-=c7kc6c2c1 d*?d,jd,d;d#e$e,eBe#bee6eee*f"-fPf6pf ff-f-f#gAg'Qg'yggg(g=i5j=Kj'jjjj%jk%k?kXk mkyk$kk.k!l#l#Alel1llll'l:mFSmZm&m=nZn&onn@n5n1&oXo soo6oo:p8>p+wpHp;p(qBq8^q'q+qq;rCr"[r;~r#r/rs-+sYsts8s"ssAt4Ft{tttPt!u!@ubuzuu/uuu v"'v4Jv"v!v"vvvw#0w%Tw2zwww8w x(5x^x}x?xKx*y:Cy%~yy%yy z!z?z _zzzzz#z,{?{W{@w{"{${2|!3|U|6h|@|||}4}=D}}}}}}M}2'~Z~s~~o~ ̆ކf,U "ƈ   ߜ8#)՞1EwlZE%xw-  _f-  O w'EZwR)#"9)\!' 2?YG5D Kyp## % %j07 1D8vZ8;?K@\B0F8(I>aKLaWNfNn OPR GTRTgTxPX[Sdgwj{ ~~)Ԇ Obhw 0&؏9Y]%RY֙^00̚k07   &5$S*x*6ή*L0}*?ů,(2=['%"17Q G-,Bo 94H-Qvȳ8ܳ8N;E5B{ 0ȵ+ %_3&MAMJ:1ӷ@CFCBθ@AR*?J;J-9-4BQ.3ػH 5U'!м?[250*'G o(|6-ܿ V7h- ,"O+a11;:3vA@-<js/-BU,e',-6&L.s,I<OV5U22$e*1Y[u,B+Pn()ATt+&21K}:]%:L T#_Q#  3#GWX(!!eC4 *%I)o*u!w5).!8P  DQQW7J(\""< 8qBq4?/tG?R,+B3<",_ :WT9/@<@<@}D<V@ &$'% MZ.mK,151g( '2 .>*m4 (! 7YXT,ErH\UKBA9&8`7==KM. !5?T69&1KX \\!!~*-0 @Q+|F%&C<Y_#5{ob0nlx$/?O =" !H>f1Pg* vh0;LPu'N6MrT?`\:>7NkX<*BWmYb6R"T6&>EC~ %B`'}9K(IfS.@m3@ $FM: 5 nx?[z 4 @G!QQS! L#JB^WKP;U%(^/HyTu0Z2tp #, RHZ.4,dU1V{Ai\FIl$-8kIpc+yVG3:eJgADG"v5<h8qt,N Oj;r_17s9Jww) V Dc].U)Cs/2i}4*+Ae] zd=jq-a[ 8K'&73XL9Eo (EDa~OS-|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 nameABORT 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. 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.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: 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 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 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: 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 Language-Team: Romanian 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 validInstrucț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: 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ă 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 , 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”: 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 ; }