diff --git a/bash4.md b/bash4.md index 85ed868..0fe55a6 100644 --- a/bash4.md +++ b/bash4.md @@ -1,11 +1,11 @@ # Bash 4 - a rough overview -| :shell: Attention: Since Bash 4 has been around for quite some time now (4.3 will come soon), I consider it to be "standard". This page is not maintained anymore and is left here to keep your links working. See the [bashchanges](/scripting/bashchanges) page for new stuff introduced. | +| :shell: Attention: Since Bash 4 has been around for quite some time now (4.3 will come soon), I consider it to be "standard". This page is not maintained anymore and is left here to keep your links working. See the [bashchanges](/scripting/bashchanges.md) page for new stuff introduced. | | --- | Besides many bugfixes since Bash 3.2, Bash 4 will bring some interesting new features for shell users and scripters. See also -[bashchanges](/scripting/bashchanges) for a small general overview with +[bashchanges](/scripting/bashchanges.md) for a small general overview with more details. Not all of the changes and news are included here, just the biggest or @@ -33,7 +33,7 @@ files that represent the filedescriptors of the started process. In other words: It lets you start a process in background and communicate with its input and output data streams. -See [The coproc keyword](/syntax/keywords/coproc) +See [The coproc keyword](/syntax/keywords/coproc.md) ### The new "mapfile" builtin @@ -42,7 +42,7 @@ an array. This avoids having to fill an array yourself using a loop. It enables you to define the range of lines to read, and optionally call a callback, for example to display a progress bar. -See: [mapfile](/commands/builtin/mapfile) +See: [mapfile](/commands/builtin/mapfile.md) ### Changes to the "case" keyword @@ -54,7 +54,7 @@ list (rather than terminate the `case` construct). The `;;&` terminator causes the `case` construct to test the next given pattern instead of terminating the whole execution. -See [case](/syntax/ccmd/case) +See [case](/syntax/ccmd/case.md) ### Changes to the "declare" builtin @@ -85,7 +85,7 @@ A new option, `-i`, was introduced to be able to preload the input buffer with some text (when Readline is used, with `-e`). The user is able to change the text, or press return to accept it. -See [read](/commands/builtin/read) +See [read](/commands/builtin/read.md) ### Changes to the "help" builtin @@ -109,7 +109,7 @@ Besides the use of the 512 bytes blocksize everywhere in POSIX mode, The brace expansion was tuned to provide expansion results with leading zeros when requesting a row of numbers. -See [brace](/syntax/expansion/brace) +See [brace](/syntax/expansion/brace.md) ### Parameter Expansion @@ -119,7 +119,7 @@ On expansion time you can modify the syntax by adding operators to the parameter name. See [Case modification on parameter -expansion](/syntax/pe#case_modification) +expansion](/syntax/pe.md#case_modification) ### Substring expansion @@ -140,7 +140,7 @@ current level. The new shell option `dirspell` enables spelling corrections on directory names during globbing. -See [globs](/syntax/expansion/globs) +See [globs](/syntax/expansion/globs.md) ## Associative Arrays @@ -156,7 +156,7 @@ something like ASSOC[Hello]="second element" ASSOC[Peter Pan]="A weird guy" -See [arrays](/syntax/arrays) +See [arrays](/syntax/arrays.md) ## Redirection @@ -167,17 +167,17 @@ good old `>>FILE 2>&1` notation. The parser now understands `|&` as a synonym for `2>&1 |`, which redirects the standard error for a command through a pipe. -See [redirection](/syntax/redirection) +See [redirection](/syntax/redirection.md) ## Interesting new shell variables | Variable | Description | |----------------------------------------------------|--------------------------------------------------------------------------------| -| [BASHPID](/syntax/shellvars#BASHPID) | contains the PID of the current shell (this is different than what `$$` does!) | -| [PROMPT_DIRTRIM](/syntax/shellvars#PROMPT_DIRTRIM) | specifies the max. level of unshortened pathname elements in the prompt | -| [FUNCNEST](/syntax/shellvars#FUNCNEST) | control the maximum number of shell function recursions | +| [BASHPID](/syntax/shellvars.md#BASHPID) | contains the PID of the current shell (this is different than what `$$` does!) | +| [PROMPT_DIRTRIM](/syntax/shellvars.md#PROMPT_DIRTRIM) | specifies the max. level of unshortened pathname elements in the prompt | +| [FUNCNEST](/syntax/shellvars.md#FUNCNEST) | control the maximum number of shell function recursions | -See [shellvars](/syntax/shellvars) +See [shellvars](/syntax/shellvars.md) ## Interesting new Shell Options @@ -192,7 +192,7 @@ mentioned. | `globstar` | enables recursive globbing with `**` | | `lastpipe` | (4.2) to execute the last command in a pipeline in the current environment | -See [shell_options](/internals/shell_options) +See [shell_options](/internals/shell_options.md) ## Misc @@ -205,7 +205,7 @@ See [shell_options](/internals/shell_options) - The output target for the `xtrace` (`set -x`/`set +x`) feature is configurable **since Bash 4.1** (previously, it was fixed to `stderr`): a variable named - [BASH_XTRACEFD](/syntax/shellvars#BASH_XTRACEFD) can be set to the + [BASH_XTRACEFD](/syntax/shellvars.md#BASH_XTRACEFD) can be set to the filedescriptor that should get the output - Bash 4.1 is able to log the history to syslog (only to be enabled at compile time in `config-top.h`) diff --git a/commands/builtin/declare.md b/commands/builtin/declare.md index 6d4e549..9543ea2 100644 --- a/commands/builtin/declare.md +++ b/commands/builtin/declare.md @@ -155,6 +155,6 @@ for details. ksh93 namerefs are much more powerful than Bash's. ## See also -- [arrays](/syntax/arrays) -- [readonly](/commands/builtin/readonly) -- [unset](/commands/builtin/unset) +- [arrays](/syntax/arrays.md) +- [readonly](/commands/builtin/read.mdonly) +- [unset](/commands/builtin/unset.md) diff --git a/commands/builtin/echo.md b/commands/builtin/echo.md index ba467a6..5c51382 100644 --- a/commands/builtin/echo.md +++ b/commands/builtin/echo.md @@ -8,7 +8,7 @@ `echo` outputs it's args to stdout, separated by spaces, followed by a newline. The return status is always `0`. If the -[shopt](/commands/builtin/shopt) option `xpg_echo` is set, Bash +[shopt](/commands/builtin/shopt.md) option `xpg_echo` is set, Bash dynamically determines whether echo should expand escape characters (listed below) by default based on the current platform. `echo` doesn't interpret `--` as the end of options, and will simply print this string @@ -68,7 +68,7 @@ if given. - **Never use options to `echo`! *Ever*!** Any time you feel tempted to use `echo -e`, `-n`, or any other special feature of echo, **use - [printf](/commands/builtin/printf) instead!** If portability is a + [printf](/commands/builtin/printf.md) instead!** If portability is a requirement, you should consider using `printf` *exclusively* and just ignore that `echo` even exists. If you must use `echo -e` and refuse to use `printf`, it is usually acceptable to use ''echo \$'...' ''if @@ -78,11 +78,11 @@ if given. - `ksh93` has a `print` command, which if coding specifically for `ksh93` should be preferred over `echo`. - [printf](/commands/builtin/printf) still includes most of the + [printf](/commands/builtin/printf.md) still includes most of the functionality of both, and should usually be the most preferred option. ## See also -- [printf](/commands/builtin/printf) +- [printf](/commands/builtin/printf.md) - diff --git a/commands/builtin/eval.md b/commands/builtin/eval.md index aec3f25..4e4df60 100644 --- a/commands/builtin/eval.md +++ b/commands/builtin/eval.md @@ -18,7 +18,7 @@ process. ## Examples In this example, the literal text within the -[here-document](/syntax/redirection#here_documents) is executed as Bash +[here-document](/syntax/redirection.md#here_documents) is executed as Bash code exactly as though it were to appear within the script in place of the `eval` command below it. diff --git a/commands/builtin/exec.md b/commands/builtin/exec.md index bb95610..be5d3ff 100644 --- a/commands/builtin/exec.md +++ b/commands/builtin/exec.md @@ -28,7 +28,7 @@ shell without executing any program. - on redirection errors it returns 1, otherwise 0 - on exec failures: - a non-interactive shell terminates; if the [shell option - execfail](/internals/shell_options#execfail) is set `exec` returns + execfail](/internals/shell_options.md#execfail) is set `exec` returns failure - in an interactive shell, `exec` returns failure @@ -82,4 +82,4 @@ exec >/var/adm/my.log 2>&1 ## See also -- [redirection](/syntax/redirection) +- [redirection](/syntax/redirection.md) diff --git a/commands/builtin/export.md b/commands/builtin/export.md index 3a935b7..e19d3fc 100644 --- a/commands/builtin/export.md +++ b/commands/builtin/export.md @@ -49,4 +49,4 @@ Set your default text editor (e.g. SublimeText): ## See also -- [declare](/commands/builtin/declare) +- [declare](/commands/builtin/declare.md) diff --git a/commands/builtin/let.md b/commands/builtin/let.md index c998a40..b0ba8a0 100644 --- a/commands/builtin/let.md +++ b/commands/builtin/let.md @@ -7,27 +7,27 @@ ## Description The `let` builtin command evaluates each supplied word from left to -right as an [arithmetic expression](/syntax/arith_expr) and returns an +right as an [arithmetic expression](/syntax/arith_expr.md) and returns an exit code according to the truth value of the rightmost expression. - 0 (TRUE) when `arg` evaluated to not 0 (arithmetic "true") - 1 (FALSE) when `arg` evaluated to 0 (arithmetic "false") For this return code mapping, please see [this -section](/syntax/arith_expr#arithmetic_expressions_and_return_codes). +section](/syntax/arith_expr.md#arithmetic_expressions_and_return_codes). They work in the same way as `((`. ## Examples -`let` is very similar to [((](/syntax/ccmd/arithmetic_eval) - the only +`let` is very similar to [((](/syntax/ccmd/arithmetic_eval.md) - the only difference being `let` is a builtin (simple command), and `((` is a compound command. The arguments to `let` are therefore subject to all the same expansions and substitutions as any other simple command - requiring proper quoting and escaping - whereas the contents of `((` -aren't subject to [word-splitting](/syntax/expansion/wordsplit) or -[pathname expansion](/syntax/expansion/globs) (almost never desirable +aren't subject to [word-splitting](/syntax/expansion/wordsplit.md) or +[pathname expansion](/syntax/expansion/globs.md) (almost never desirable for arithmetic). For this reason, **the [arithmetic compound -command](/syntax/ccmd/arithmetic_eval) should generally be preferred +command](/syntax/ccmd/arithmetic_eval.md) should generally be preferred over `let`**. $ let 'b = a' "(a += 3) + $((a = 1)), b++" @@ -35,7 +35,7 @@ over `let`**. 4 - 2 - 0 Is equivalent to the [arithmetic evaluation compound -command](/syntax/ccmd/arithmetic_eval): +command](/syntax/ccmd/arithmetic_eval.md): $ (( b = a, (a += 3) + $((a = 1)), b++ )) $ echo "$a - $b - $?" @@ -86,7 +86,7 @@ needed. - [expr(1)](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/expr.html#tag_20_42) is a command one is likely to come across sooner or later. While it is more "standard" than `let`, the above should always be preferred. Both - [arithmetic expansion](/syntax/arith_expr)s and the `[` test operator + [arithmetic expansion](/syntax/arith_expr.md)s and the `[` test operator are specified by POSIX(r) and satisfy almost all of expr's use-cases. Unlike `let`, `expr` cannot assign directly to bash variables but instead returns a result on stdout. `expr` takes each operator it @@ -104,7 +104,7 @@ needed. ## See also -- Internal: [arithmetic expansion](/syntax/expansion/arith) -- Internal: [arithmetic expressions](/syntax/arith_expr) +- Internal: [arithmetic expansion](/syntax/expansion/arith.md) +- Internal: [arithmetic expressions](/syntax/arith_expr.md) [^1]: ... diff --git a/commands/builtin/local.md b/commands/builtin/local.md index 10db47a..648393a 100644 --- a/commands/builtin/local.md +++ b/commands/builtin/local.md @@ -6,7 +6,7 @@ ## Description -`local` is identical to [declare](/commands/builtin/declare) in every +`local` is identical to [declare](/commands/builtin/declare.md) in every way, and takes all the same options, with two exceptions: - Usage outside of a function is an error. Both `declare` and `local` diff --git a/commands/builtin/mapfile.md b/commands/builtin/mapfile.md index bdae700..c60308f 100644 --- a/commands/builtin/mapfile.md +++ b/commands/builtin/mapfile.md @@ -214,7 +214,7 @@ each subsequent 2 iterations. The RETURN trap is unimportant. ## See also -- [arrays](/syntax/arrays) -- [read](/commands/builtin/read) - If you don't know about this yet, why +- [arrays](/syntax/arrays.md) +- [read](/commands/builtin/read.md) - If you don't know about this yet, why are you reading this page? - - It's FAQ 1 for a reason. diff --git a/commands/builtin/printf.md b/commands/builtin/printf.md index cdbc0b7..8f341a3 100644 --- a/commands/builtin/printf.md +++ b/commands/builtin/printf.md @@ -93,9 +93,9 @@ the format string is re-used until the last argument is interpreted. If fewer format specifiers than arguments are present, then number-formats are set to zero, while string-formats are set to null (empty). -Take care to avoid [word splitting](/syntax/expansion/wordsplit), as +Take care to avoid [word splitting](/syntax/expansion/wordsplit.md), as accidentally passing the wrong number of arguments can produce wildly -different and unexpected results. See [this article](/syntax/words). +different and unexpected results. See [this article](/syntax/words.md). | :warning: **Again, attention:** When a numerical format expects a number, the internal `printf`-command will use the common Bash @@ -454,7 +454,7 @@ fmt++; - Assigning to variables: The `printf -v` way is slightly different to the way using command-substitution. [Command - substitution](/syntax/expansion/cmdsubst) removes trailing newlines + substitution](/syntax/expansion/cmdsubst.md) removes trailing newlines before substituting the text, `printf -v` preserves all output. ## See also diff --git a/commands/builtin/read.md b/commands/builtin/read.md index 3e1d5da..7dc7301 100644 --- a/commands/builtin/read.md +++ b/commands/builtin/read.md @@ -16,13 +16,13 @@ Since Bash 4.3-alpha, `read` skips any `NUL` (ASCII code 0) characters in input. If `` is given, the line is word-split using -[IFS](/syntax/shellvars#IFS) variable, and every word is assigned to one +[IFS](/syntax/shellvars.md#IFS) variable, and every word is assigned to one ``. The remaining words are all assigned to the last `` if more words than variable names are present. \ If no `` is given, the whole line read (without performing word-splitting!) is assigned to the shell -variable [REPLY](/syntax/shellvars#REPLY). Then, `REPLY` really contains +variable [REPLY](/syntax/shellvars.md#REPLY). Then, `REPLY` really contains the line as it was read, without stripping pre- and postfix spaces and other things! @@ -33,7 +33,7 @@ other things! \ If a timeout is given, or if the shell variable -[TMOUT](/syntax/shellvars#TMOUT) is set, it is counted from initially +[TMOUT](/syntax/shellvars.md#TMOUT) is set, it is counted from initially waiting for input until the completion of input (i.e. until the complete line is read). That means the timeout can occur during input, too. @@ -64,7 +64,7 @@ Of course it's valid to set individual array elements without using \ Reading into array elements using the syntax above **may cause [pathname -expansion](/syntax/expansion/globs) to occur**. +expansion](/syntax/expansion/globs.md) to occur**. Example: You are in a directory with a file named `x1`, and you want to read into an array `x`, index `1` with @@ -172,7 +172,7 @@ Take care that you cannot use a pipe: Why? because the commands of the pipe run in subshells that cannot modify the parent shell. As a result, the variables `col1`, `col2` and `col3` of the parent shell are not modified (see article: -[processtree](/scripting/processtree)). +[processtree](/scripting/processtree.md)). If the variable has more fields than there are variables, the last variable get the remaining of the line: @@ -184,7 +184,7 @@ variable get the remaining of the line: By default reads separates the line in fields using spaces or tabs. You can modify this using the *special variable* -[IFS](/syntax/shellvars#IFS), the Internal Field Separator. +[IFS](/syntax/shellvars.md#IFS), the Internal Field Separator. IFS=":" read -r col1 col2 <<< "hello:world" printf "col1: %s col2: %s\n" "$col1" "$col2" @@ -264,6 +264,6 @@ date/time string are recognized correctly. ## See also -- Internal: [The printf builtin command](/commands/builtin/printf) +- Internal: [The printf builtin command](/commands/builtin/printf.md) [^1]: fixed in 4.2-rc1 diff --git a/commands/builtin/readonly.md b/commands/builtin/readonly.md index 8eaeff4..3fa989e 100644 --- a/commands/builtin/readonly.md +++ b/commands/builtin/readonly.md @@ -41,4 +41,4 @@ An argument of `--` disables further option processing. ## See also -- [declare](/commands/builtin/declare) +- [declare](/commands/builtin/declare.md) diff --git a/commands/builtin/set.md b/commands/builtin/set.md index 3f051f2..6de6759 100644 --- a/commands/builtin/set.md +++ b/commands/builtin/set.md @@ -11,7 +11,7 @@ FIXME incomplete - text, examples, maybe extended description `set` is primarily made to - set the positional parameters (see [handling positional - parameters](/scripting/posparams)) to `` + parameters](/scripting/posparams.md)) to `` - set shell attributes with short options (see below) - set shell attributes with long option names (see below) @@ -29,7 +29,7 @@ set flags (true for most commands on UNIX(r)). | `-a` | `allexport` | Automatically mark new and altered variables to be exported to subsequent environments. | | `-b` | `notify` | Don't wait for the next prompt to print when showing the reports for a terminated background job (only with job control) | | `-e` | `errexit` | When set, the shell exits when a simple command in a command list exits non-zero (`FALSE`). This is not done in situations, where the exit code is already checked (`if`, `while`, `until`, `||`, `&&`) | -| `-f` | `noglob` | Disable [pathname expansion](/syntax/expansion/globs) (globbing) | +| `-f` | `noglob` | Disable [pathname expansion](/syntax/expansion/globs.md) (globbing) | | `-h` | `hashall` | Remembers the location of commands when they're called (hashing). Enabled by default. | | `-k` | `keyword` | Allows to place environment-assignments everywhere in the commandline, not only infront of the called command. | | `-m` | `monitor` | **Monitor mode**. With job control, a short descriptive line is printed when a backgroud job ends. Default is "on" for interactive shells (with job control). | @@ -40,8 +40,8 @@ set flags (true for most commands on UNIX(r)). | `-u` | `nounset` | Treat unset variables as an error when performing parameter expansion. Non-interactive shells exit on this error. | | `-v` | `verbose` | Print shell input lines as they are read - useful for debugging. | | `-x` | `xtrace` | Print commands just before execution - with all expansions and substitutions done, and words marked - useful for debugging. | -| `-B` | `braceexpand` | The shell performs [brace expansion](/syntax/expansion/brace) This is on by default. | -| `-C` | \`noclobber` | Don't overwrite files on redirection operations. You can override that by specifying the `>|` redirection operator when needed. See [redirection](/syntax/redirection) | +| `-B` | `braceexpand` | The shell performs [brace expansion](/syntax/expansion/brace.md) This is on by default. | +| `-C` | \`noclobber` | Don't overwrite files on redirection operations. You can override that by specifying the `>|` redirection operator when needed. See [redirection](/syntax/redirection.md) | | `-E` | `errtrace` | `ERR`-traps are inherited by by shell functions, command substitutions, and commands executed in a subshell environment. | | `-H` | `histexpand` | Enable `!`-style history expansion. Defaults to `on` for interactive shells. | | `-P` | `physical` | Don't follow symlinks when changing directories - use the physical filesystem structure. | @@ -51,7 +51,7 @@ set flags (true for most commands on UNIX(r)). | | Long options usable with `-o` without a short equivalent | | | | `emacs` | Use an emacs-style command line editing interface. This is enabled by default when the shell is interactive, unless the shell is started with `--noediting` option. | | | `history` | If set, command historization is done (enabled by default on interactive shells) | -| | `ignoreeof` | The effect is as if the shell command `IGNOREEOF=10` had been executed. See [shell variables](/syntax/shellvars). | +| | `ignoreeof` | The effect is as if the shell command `IGNOREEOF=10` had been executed. See [shell variables](/syntax/shellvars.md). | | | `nolog` | **(currently ignored)** | | | `pipefail` | If set, the exit code from a pipeline is different from the normal ("last command in pipeline") behaviour: `TRUE` when no command failed, `FALSE` when something failed (code of the rightmost command that failed) | | | `posix` | When set, Bash runs in POSIX mode. | @@ -78,4 +78,4 @@ naturally. ## See also -- Internal: [The shopt builtin command](/commands/builtin/shopt) +- Internal: [The shopt builtin command](/commands/builtin/shopt.md) diff --git a/commands/builtin/shift.md b/commands/builtin/shift.md index a4920f3..2640122 100644 --- a/commands/builtin/shift.md +++ b/commands/builtin/shift.md @@ -28,7 +28,7 @@ When you use `shift 1`, they will be changed to: | 2 | a | | 3 | test | -The [special parameter](/syntax/shellvars#special_parameters) `$#` will +The [special parameter](/syntax/shellvars.md#special_parameters) `$#` will reflect the final number of positional parameters. If the number given is 0, no changes are made to the positional diff --git a/commands/builtin/shopt.md b/commands/builtin/shopt.md index f049367..8634721 100644 --- a/commands/builtin/shopt.md +++ b/commands/builtin/shopt.md @@ -1,6 +1,6 @@ # The shopt builtin command -The `shopt` builtin manages [shell options](/internals/shell_options), a +The `shopt` builtin manages [shell options](/internals/shell_options.md), a set of boolean (`on`/`off`) configuration variables that control the behaviour of the shell. @@ -11,13 +11,13 @@ behaviour of the shell. ## Description Note: Some of these options and other shell options can also be set with -[the set builtin](/commands/builtin/set). +[the set builtin](/commands/builtin/set.md). ### Options | Option | Description | |--------|--------------------------------------------------------------------------------------------------------------------------| -| `-o` | Restrict the values of `` to only those also known by [the set builtin](/commands/builtin/set) | +| `-o` | Restrict the values of `` to only those also known by [the set builtin](/commands/builtin/set.md) | | `-p` | Print all shell options and their current value. **Default**. | | `-q` | Quiet mode. Set exit code if named option is set. For multiple options: `TRUE` if all options are set, `FALSE` otherwise | | `-s` | Enable (set) the shell options named by `` or list all *enabled* options if no names are given | @@ -47,5 +47,5 @@ The `shopt` command is not portable accross different shells. ## See also -- Internal: [The set builtin command](/commands/builtin/set) -- Internal: [List of shell options](/internals/shell_options) +- Internal: [The set builtin command](/commands/builtin/set.md) +- Internal: [List of shell options](/internals/shell_options.md) diff --git a/commands/builtin/trap.md b/commands/builtin/trap.md index 4255b67..2e29ade 100644 --- a/commands/builtin/trap.md +++ b/commands/builtin/trap.md @@ -34,7 +34,7 @@ Special events | `EXIT` | 0 | executed on shell exit | | `DEBUG` | | executed before every simple command | | `RETURN` | | executed when a shell function or a sourced code finishes executing | -| `ERR` | | executed each time a command's failure would cause the shell to exit when the [`-e` option (`errexit`)](/commands/builtin/set) is enabled | +| `ERR` | | executed each time a command's failure would cause the shell to exit when the [`-e` option (`errexit`)](/commands/builtin/set.md) is enabled | ### Options @@ -68,5 +68,5 @@ Special events ## See also -- [the set command](/commands/builtin/set) for the `-e` (`errexit`) +- [the set command](/commands/builtin/set.md) for the `-e` (`errexit`) option diff --git a/commands/builtin/unset.md b/commands/builtin/unset.md index cb750fd..dc923ec 100644 --- a/commands/builtin/unset.md +++ b/commands/builtin/unset.md @@ -175,5 +175,5 @@ using `unset`. Also, I prefer it as a matter of style. ## See also -- [declare](/commands/builtin/declare) -- [unset](/commands/builtin/unset) +- [declare](/commands/builtin/declare.md) +- [unset](/commands/builtin/unset.md) diff --git a/commands/classictest.md b/commands/classictest.md index 888a4fe..b110517 100644 --- a/commands/classictest.md +++ b/commands/classictest.md @@ -67,7 +67,7 @@ normal ordinary command ("test" or "\[") the shell will word-split the expansion of the variable `mymusic`: You need to quote it when you don't want the `test`-command to complain about too many arguments for this test-type! If you didn't understand it, please read the [article about -words...](/syntax/words) +words...](/syntax/words.md) Please also note that the file-tests want **one filename** to test. Don't give a glob (filename-wildcards) as it can expand to many @@ -147,7 +147,7 @@ ACLs, if the underlying filesystem/OS supports them. | \ **-o** \ | True, if either \ **or** \ is true (OR). | | **!** \ | True, if \ is **false** (NOT). | | **(** \ **)** | Group a test (for precedence). **Attention:** In normal shell-usage, the "(" and ")" must be escaped; use "\\" and "\\"! | -| **-o** \ | True, if the [shell option](/internals/shell_options) \ is set. | +| **-o** \ | True, if the [shell option](/internals/shell_options.md) \ is set. | | **-v** \ | True if the variable \ has been set. Use `var[n]` for array elements. | | **-R** \ | True if the variable \ has been set and is a nameref variable (since 4.3-alpha) | @@ -539,7 +539,7 @@ Some code snipplets follow, different ways of shell reaction is used. - `[ "$MYVAR" ]` - **Note:** There are possibilities to make a difference if a variable is *undefined* or *NULL* - see [Parameter Expansion - Using an - alternate value](/syntax/pe#use_an_alternate_value) + alternate value](/syntax/pe.md#use_an_alternate_value) - **check if a directory exists, if not, create it** - `test ! -d /home/user/foo && mkdir /home/user/foo` - `[ ! -d /home/user/foo ] && mkdir /home/user/foo` @@ -547,11 +547,11 @@ Some code snipplets follow, different ways of shell reaction is used. - **check if minimum one parameter was given, and that one is "Hello"** - `test $# -ge 1 -a "$1" = "Hello" || exit 1` - `[ $# -ge 1 ] && [ "$1" = "Hello" ] || exit 1` (see [lists - description](/syntax/basicgrammar#lists)) + description](/syntax/basicgrammar.md#lists)) ### Listing directories -Using a [for-loop](/syntax/ccmd/classic_for) to iterate through all +Using a [for-loop](/syntax/ccmd/classic_for.md) to iterate through all entries of a directory, if an entry is a directory (`[ -d "$fn" ]`), print its name: @@ -562,7 +562,7 @@ print its name: ## See also - Internal: [conditional - expression](/syntax/ccmd/conditional_expression) (aka "the new test + expression](/syntax/ccmd/conditional_expression.md) (aka "the new test command") [^1]: \Of course, one can wonder what is the use of including the diff --git a/howto/dissectabadoneliner.md b/howto/dissectabadoneliner.md index fbb7c00..a5f5470 100644 --- a/howto/dissectabadoneliner.md +++ b/howto/dissectabadoneliner.md @@ -31,13 +31,13 @@ The goal here seems to be get the filename without its `.zip` extension. In fact, there is a POSIX(r)-compliant command to do this: `basename` The implementation here is suboptimal in several ways, but the only thing that's genuinely error-prone with this is "`echo $i`". Echoing an -*unquoted* variable means [wordsplitting](/syntax/expansion/wordsplit) +*unquoted* variable means [wordsplitting](/syntax/expansion/wordsplit.md) will take place, so any whitespace in `$i` will essentially be normalized. In `sh` it is necessary to use an external command and a subshell to achieve the goal, but we can eliminate the pipe (subshells, external commands, and pipes carry extra overhead when they launch, so they can really hurt performance in a loop). Just for good measure, -let's use the more readable, [modern](/syntax/expansion/cmdsubst) `$()` +let's use the more readable, [modern](/syntax/expansion/cmdsubst.md) `$()` construct instead of the old style backticks: ``` bash @@ -46,7 +46,7 @@ sh $ for i in *.zip; do j=$(basename "$i" ".zip"); mkdir $j; cd $j; unzip ../$i; In Bash we don't need the subshell or the external basename command. See [Substring removal with parameter -expansion](/syntax/pe#substring_removal): +expansion](/syntax/pe.md#substring_removal): ``` bash bash $ for i in *.zip; do j="${i%.zip}"; mkdir $j; cd $j; unzip ../$i; cd ..; done @@ -64,7 +64,7 @@ hurt: When a following command depends on the success of a previous command(s), check for success! You can do this with the "`&&`" conjunction, that way, if the previous command fails, bash will not try to execute the following command(s). It's fully POSIX(r). Oh, and -remember what I said about [wordsplitting](/syntax/expansion/wordsplit) +remember what I said about [wordsplitting](/syntax/expansion/wordsplit.md) in the previous step? Well, if you don't quote `$j`, wordsplitting can happen again. diff --git a/howto/getopts_tutorial.md b/howto/getopts_tutorial.md index 63afd13..bc885e9 100644 --- a/howto/getopts_tutorial.md +++ b/howto/getopts_tutorial.md @@ -23,7 +23,7 @@ are: Some other methods to parse positional parameters - using neither **getopt** nor **getopts** - are described in: [How to handle positional -parameters](/scripting/posparams). +parameters](/scripting/posparams.md). ### Terminology @@ -88,9 +88,9 @@ which means [end of options](/dict/terms/end_of_options). | variable | description | |------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| [OPTIND](/syntax/shellvars#OPTIND) | Holds the index to the next argument to be processed. This is how `getopts` "remembers" its own status between invocations. Also useful to shift the positional parameters after processing with `getopts`. `OPTIND` is initially set to 1, and **needs to be re-set to 1 if you want to parse anything again with getopts** | -| [OPTARG](/syntax/shellvars#OPTARG) | This variable is set to any argument for an option found by `getopts`. It also contains the option flag of an unknown option. | -| [OPTERR](/syntax/shellvars#OPTERR) | (Values 0 or 1) Indicates if Bash should display error messages generated by the `getopts` builtin. The value is initialized to **1** on every shell startup - so be sure to always set it to **0** if you don't want to see annoying messages! **`OPTERR` is not specified by POSIX for the `getopts` builtin utility --- only for the C `getopt()` function in `unistd.h` (`opterr`).** `OPTERR` is bash-specific and not supported by shells such as ksh93, mksh, zsh, or dash. | +| [OPTIND](/syntax/shellvars.md#OPTIND) | Holds the index to the next argument to be processed. This is how `getopts` "remembers" its own status between invocations. Also useful to shift the positional parameters after processing with `getopts`. `OPTIND` is initially set to 1, and **needs to be re-set to 1 if you want to parse anything again with getopts** | +| [OPTARG](/syntax/shellvars.md#OPTARG) | This variable is set to any argument for an option found by `getopts`. It also contains the option flag of an unknown option. | +| [OPTERR](/syntax/shellvars.md#OPTERR) | (Values 0 or 1) Indicates if Bash should display error messages generated by the `getopts` builtin. The value is initialized to **1** on every shell startup - so be sure to always set it to **0** if you don't want to see annoying messages! **`OPTERR` is not specified by POSIX for the `getopts` builtin utility --- only for the C `getopt()` function in `unistd.h` (`opterr`).** `OPTERR` is bash-specific and not supported by shells such as ksh93, mksh, zsh, or dash. | `getopts` also uses these variables for error reporting (they're set to value-combinations which arent possible in normal operation). @@ -133,7 +133,7 @@ messages. #### Custom arguments to parse The `getopts` utility parses the [positional -parameters](/scripting/posparams) of the current shell or function by +parameters](/scripting/posparams.md) of the current shell or function by default (which means it parses `"$@"`). You can give your own set of arguments to the utility to parse. Whenever @@ -345,9 +345,9 @@ Let's provide **the argument**: ## See also -- Internal: [posparams](/scripting/posparams) -- Internal: [case](/syntax/ccmd/case) -- Internal: [while_loop](/syntax/ccmd/while_loop) +- Internal: [posparams](/scripting/posparams.md) +- Internal: [case](/syntax/ccmd/case.md) +- Internal: [while_loop](/syntax/ccmd/while_loop.md) - POSIX [getopts(1)](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/getopts.html#tag_20_54) and diff --git a/internals/shell_options.md b/internals/shell_options.md index 215b1aa..e4aece5 100644 --- a/internals/shell_options.md +++ b/internals/shell_options.md @@ -6,7 +6,7 @@ This information was taken from a Bash version "`4.1`", every now and then new options are added, so likely, this list isn't complete. The shell-options can be set with the [shopt builtin -command](/commands/builtin/shopt). +command](/commands/builtin/shopt.md). ## Shell options @@ -78,8 +78,8 @@ stopped. If set, Bash checks the window size after each command and, if necessary, updates the values of the variables -[LINES](/syntax/shellvars#LINES) and -[COLUMNS](/syntax/shellvars#COLUMNS). +[LINES](/syntax/shellvars.md#LINES) and +[COLUMNS](/syntax/shellvars.md#COLUMNS). ### cmdhist @@ -174,7 +174,7 @@ match a glob. | Shell mode: | all | Default: | off | If set, Bash includes filenames beginning with a `.` (dot) in the -results of [pathname expansion](/syntax/expansion/globs). +results of [pathname expansion](/syntax/expansion/globs.md). ### execfail @@ -209,7 +209,7 @@ If set, behavior intended for use by debuggers is enabled. |:------------|:----------|:---------|:------------| | Shell mode: | all | Default: | off | -If set, the extended [pattern matching](/syntax/pattern) features are +If set, the extended [pattern matching](/syntax/pattern.md) features are enabled. See the important note below under [Parser configurations](#parser_configurations). @@ -220,7 +220,7 @@ configurations](#parser_configurations). | Shell mode: | all | Default: | on | If set, `$'string'` and `$"string"` quoting is performed within -[parameter expansions](/syntax/pe) enclosed in double quotes. See the +[parameter expansions](/syntax/pe.md) enclosed in double quotes. See the important note below under [Parser configurations](#parser_configurations). @@ -240,7 +240,7 @@ result in an error message. | Shell mode: | interactive | Default: | on | If set, the suffixes specified by the -[FIGNORE](/syntax/shellvars#FIGNORE) shell variable cause words to be +[FIGNORE](/syntax/shellvars.md#FIGNORE) shell variable cause words to be ignored when performing word completion even if the ignored words are the only possible completions. This option is enabled by default. @@ -280,7 +280,7 @@ message format". | Shell mode: | interactive (?) | Default: | off | If set, the history list is appended to the file named by the value of -the [HISTFILE](/syntax/shellvars#HISTFILE) variable when the shell +the [HISTFILE](/syntax/shellvars.md#HISTFILE) variable when the shell exits, rather than overwriting the file. ### histreedit @@ -324,7 +324,7 @@ interactive login shell exits. |:------------|:-----------------------|:---------|:--------| | Shell mode: | interactive | Default: | on | -Allow [commenting](/scripting/basics#comments) in interactive shells, on +Allow [commenting](/scripting/basics.md#comments) in interactive shells, on by default. ### lastpipe @@ -505,5 +505,5 @@ parsed: ## See also -- Internal: [shopt builtin command](/commands/builtin/shopt) -- Internal: [set builtin command](/commands/builtin/set) +- Internal: [shopt builtin command](/commands/builtin/shopt.md) +- Internal: [set builtin command](/commands/builtin/set.md) diff --git a/scripting/bashbehaviour.md b/scripting/bashbehaviour.md index 1e819ff..efc4422 100644 --- a/scripting/bashbehaviour.md +++ b/scripting/bashbehaviour.md @@ -67,7 +67,7 @@ conforming to the POSIX(r) standard as well. The profile files read are `/etc/profile` and `~/.profile`, if it's a login shell. If it's not a login shell, the environment variable -[ENV](/syntax/shellvars#ENV) is evaluated and the resulting filename is +[ENV](/syntax/shellvars.md#ENV) is evaluated and the resulting filename is used as the name of the startup file. After the startup files are read, Bash enters the [POSIX(r) compatiblity @@ -83,7 +83,7 @@ mode (for running, not for starting!)](#posix_run_mode). When Bash is started in POSIX(r) mode, it follows the POSIX(r) standard for startup files. In this mode, **interactive shells** expand the -[ENV](/syntax/shellvars#ENV) variable and commands are read and executed +[ENV](/syntax/shellvars.md#ENV) variable and commands are read and executed from the file whose name is the expanded value. No other startup files are read. Hence, a non-interactive shell doesn't read any startup files in POSIX(r) mode. @@ -92,7 +92,7 @@ read any startup files in POSIX(r) mode. - the commandline option `--posix` is specified - the environment variable - [POSIXLY_CORRECT](/syntax/shellvars#POSIXLY_CORRECT) is set + [POSIXLY_CORRECT](/syntax/shellvars.md#POSIXLY_CORRECT) is set ### Quick startup file reference @@ -301,12 +301,12 @@ FIXME help me to find out what breaks in POSIX(r) mode! - Bash starting as `sh` (the basename of `argv[0]` is `sh`) - starting Bash with the commandline option `--posix` - on startup, the environment variable - [POSIXLY_CORRECT](/syntax/shellvars#POSIXLY_CORRECT) is set + [POSIXLY_CORRECT](/syntax/shellvars.md#POSIXLY_CORRECT) is set - the command `set -o posix` **Tests for the POSIX(r) mode:** -- the variable [SHELLOPTS](/syntax/shellvars#SHELLOPTS) contains `posix` +- the variable [SHELLOPTS](/syntax/shellvars.md#SHELLOPTS) contains `posix` in its list ### Restricted shell @@ -316,9 +316,9 @@ far more controlled and limited than the standard shell mode. It acts like normal Bash with the following restrictions: - the `cd` command can't be used to change directories -- the variables [SHELL](/syntax/shellvars#SHELL), - [PATH](/syntax/shellvars#PATH), [ENV](/syntax/shellvars#ENV) and - [BASH_ENV](/syntax/shellvars#BASH_ENV) can't be set or unset +- the variables [SHELL](/syntax/shellvars.md#SHELL), + [PATH](/syntax/shellvars.md#PATH), [ENV](/syntax/shellvars.md#ENV) and + [BASH_ENV](/syntax/shellvars.md#BASH_ENV) can't be set or unset - command names that contain a `/` (slash) can't be called (hence you're limited to `PATH`) - filenames containing a `/` (slash) can't be specified as argument to @@ -327,7 +327,7 @@ like normal Bash with the following restrictions: the `-p` option of the `hash` builtin command - function definitions are not inherited from the environment at shell startup -- the environment variable [SHELLOPTS](/syntax/shellvars#SHELLOPTS) is +- the environment variable [SHELLOPTS](/syntax/shellvars.md#SHELLOPTS) is ignored at startup - redirecting output using the `>`, `>|`, `<>`, `>&`, `&>`, and `>>` redirection operators isn't allowed diff --git a/scripting/bashchanges.md b/scripting/bashchanges.md index 21f616f..391e3cf 100644 --- a/scripting/bashchanges.md +++ b/scripting/bashchanges.md @@ -19,8 +19,8 @@ Note that the `shopt` builtin command first appeared in Bash 2.0. For this topic, see also -- [shell_options](/internals/shell_options) -- [set](/commands/builtin/set) +- [shell_options](/internals/shell_options.md) +- [set](/commands/builtin/set.md) | Feature or change description | Appeared in Bash version | See also/remarks | |:--------------------------------|:-------------------------|:--------------------------------------------------------------------------------| @@ -77,7 +77,7 @@ For this topic, see also For this topic, see also -- [printf](/commands/builtin/printf) +- [printf](/commands/builtin/printf.md) | Feature or change description | Appeared in Bash version | See also/remarks | |:------------------------------------------------------------|:-------------------------|:-------------------------------------------------------| @@ -98,8 +98,8 @@ For this topic, see also For this topic, see also -- [conditional_expression](/syntax/ccmd/conditional_expression) -- [classictest](/commands/classictest) +- [conditional_expression](/syntax/ccmd/conditional_expression.md) +- [classictest](/commands/classictest.md) | Feature or change description | Appeared in Bash version | See also/remarks | |:-------------------------------------------------------------------|:-------------------------|:-------------------------------------------------------------------------------------| @@ -121,23 +121,23 @@ For this topic, see also | `bashbug` | new | 1.14.0 | | | `select` | new | 1.14.0 | | | `disown` | new | 2.0 | | -| `shopt` | new | 2.0 | [shopt](/commands/builtin/shopt) | +| `shopt` | new | 2.0 | [shopt](/commands/builtin/shopt.md) | | `declare` | new options `-a` and `-F` | 2.0 | | | `enable` | builtin has basic plugin support (dlopen) | 2.0 | | | `exec` | options `-l`, `-c` and `-a` | 2.0 | | -| `read` | options `-p`, `-e` and `-a` | 2.0 | [read](/commands/builtin/read) | -| `readonly` | option `-a` | 2.0 | [arrays](/syntax/arrays) | +| `read` | options `-p`, `-e` and `-a` | 2.0 | [read](/commands/builtin/read.md) | +| `readonly` | option `-a` | 2.0 | [arrays](/syntax/arrays.md) | | `time` | new keyword | 2.0 | | | `shopt` | `-p` (reusable output) | 2.02 | | | `umask` | `-p` (reusable output) | 2.02 | | | `complete` | new | 2.04-devel | for and together with support for programmable completion | | `compgen` | new | 2.04-devel | for and together with support for programmable completion | -| `read` | options `-t`, `-n`, `-d`, `-s` | 2.04-devel | [read](/commands/builtin/read) | +| `read` | options `-t`, `-n`, `-d`, `-s` | 2.04-devel | [read](/commands/builtin/read.md) | | `for ((...;...;...))` | new | 2.04-devel | KSH93 | | `set` | print shell functions in a format reusable as input | 2.05-beta1 | | | `for` | allow an empty word list | 2.05a-alpha1 | | -| `read` | new option `-u` | 2.05b-alpha1 | [read](/commands/builtin/read) | -| `caller` | new | 3.0 | [caller](/commands/builtin/caller) | +| `read` | new option `-u` | 2.05b-alpha1 | [read](/commands/builtin/read.md) | +| `caller` | new | 3.0 | [caller](/commands/builtin/caller.md) | | `coproc` | new | 4.0-alpha | | | `declare` | new options `-l` and `-u` | 4.0-alpha | together with case-changing expansion forms | | `case` | new action list terminators '';;& and '';& | 4.0-alpha | ksh93: only `;&`. zsh and mksh: `;|`. mksh: all 4, (`;;&` is undocumented Bash compatibility) | @@ -241,7 +241,7 @@ For this topic, see also For this topic, see also -- [pe](/syntax/pe). +- [pe](/syntax/pe.md). | Feature or change description | Appeared in Bash version | Remarks | |:-----------------------------------------------------------------------------------------------------|:-------------------------|:--------------------------------------------------------------------------------------------------------------| @@ -282,8 +282,8 @@ For this topic, see also For this topic, see also -- [arith_expr](/syntax/arith_expr) -- [arith](/syntax/expansion/arith) +- [arith_expr](/syntax/arith_expr.md) +- [arith](/syntax/expansion/arith.md) | Feature or change description | Appeared in Bash version | Remarks | |:-------------------------------------------|:-------------------------|:------------------------------------------| @@ -299,7 +299,7 @@ For this topic, see also For this topic, see also -- [redirection](/syntax/redirection) +- [redirection](/syntax/redirection.md) | Feature or change description | Appeared in Bash version | Remarks | |:--------------------------------------------------------------------------------------|:-------------------------|:--------| diff --git a/scripting/basics.md b/scripting/basics.md index e3bbb2e..39ed316 100644 --- a/scripting/basics.md +++ b/scripting/basics.md @@ -71,7 +71,7 @@ specified by the shebang. \ **Additional note:** When you specify `#!/bin/sh` as shebang and that's a link to a Bash, then Bash will run in POSIX(r) mode! See: -- [Bash behaviour](/scripting/bashbehaviour). +- [Bash behaviour](/scripting/bashbehaviour.md). A common method is to specify a shebang like @@ -113,7 +113,7 @@ When you write a script: To learn more about the standard filedescriptors, especially about redirection and piping, see: -- [An illustrated redirection tutorial](/howto/redirection_tutorial) +- [An illustrated redirection tutorial](/howto/redirection_tutorial.md) ## Variable names @@ -183,7 +183,7 @@ else fi ``` -Read more about [the test command](/commands/classictest) +Read more about [the test command](/commands/classictest.md) A common exit code check method uses the "`||`" or "`&&`" operators. This lets you execute a command based on whether or not the previous @@ -246,7 +246,7 @@ effectively, the entire block was ignored. The here-document-tag was quoted here **to avoid substitutions** in the "commented" text! Check [redirection with -here-documents](/syntax/redirection#tag_heredoc) for more +here-documents](/syntax/redirection.md#tag_heredoc) for more ## Variable scope @@ -277,7 +277,7 @@ everywhere in that script, both in functions and in the "main program". example a *subshell*, they will be set there, but you will **never** have access to them outside of that subshell. One way to create a subshell is the pipe. It's all mentioned in a small article about [Bash -in the processtree](/scripting/processtree)! +in the processtree](/scripting/processtree.md)! ### Local variables diff --git a/scripting/debuggingtips.md b/scripting/debuggingtips.md index 522070e..d887a3c 100644 --- a/scripting/debuggingtips.md +++ b/scripting/debuggingtips.md @@ -55,13 +55,13 @@ Insert **echos** everywhere you can, and print to `stderr`: echo "DEBUG: current i=$i" >&2 If you read input from **anywhere**, such as a file or [command -substitution](/syntax/expansion/cmdsubst), print the debug output with +substitution](/syntax/expansion/cmdsubst.md), print the debug output with literal quotes, to see leading and trailing spaces! pid=$(< fooservice.pid) echo "DEBUG: read from file: pid=\"$pid\"" >&2 -Bash's [printf](/commands/builtin/printf) command has the `%q` format, +Bash's [printf](/commands/builtin/printf.md) command has the `%q` format, which is handy for verifying whether strings are what they appear to be. foo=$(< inputfile) @@ -77,17 +77,17 @@ There are two useful debug outputs for that task (both are written to - print commands to be executed to `stderr` as if they were read from input (script file or keyboard) - print everything **before** any ([substitution and - expansion](/syntax/expansion/intro), ...) is applied + expansion](/syntax/expansion/intro.md), ...) is applied - `set -x` mode (`set -o xtrace`) - print everything as if it were executed, after [substitution and - expansion](/syntax/expansion/intro) is applied + expansion](/syntax/expansion/intro.md) is applied - indicate the depth-level of the subshell (by default by prefixing a `+` (plus) sign to the displayed command) - indicate the recognized words after [word - splitting](/syntax/expansion/wordsplit) by marking them like `'x y'` + splitting](/syntax/expansion/wordsplit.md) by marking them like `'x y'` - in shell version 4.1, this debug output can be printed to a configurable file descriptor, rather than sdtout by setting the - [BASH_XTRACEFD](/syntax/shellvars#BASH_XTRACEFD) variable. + [BASH_XTRACEFD](/syntax/shellvars.md#BASH_XTRACEFD) variable. **Hint:** These modes can be entered when calling Bash: @@ -97,7 +97,7 @@ There are two useful debug outputs for that task (both are written to ### Simple example of how to interpret xtrace output Here's a simple command (a string comparison using the [classic test -command](/commands/classictest)) executed while in `set -x` mode: +command](/commands/classictest.md)) executed while in `set -x` mode: set -x foo="bar baz" @@ -125,7 +125,7 @@ words (which you would have realized if you READ THE ERROR MESSAGES ;) (by AnMaster) `xtrace` output would be more useful if it contained source file and -line number. Add this assignment [PS4](/syntax/shellvars#PS4) at the +line number. Add this assignment [PS4](/syntax/shellvars.md#PS4) at the beginning of your script to enable the inclusion of that information: export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }' @@ -219,7 +219,7 @@ This can be wrapped in a shell function for more readable code. Usually indicates exactly what it says: An unexpected end of file. It's unexpected because Bash waits for the closing of a [compound -command](/syntax/ccmd/intro): +command](/syntax/ccmd/intro.md): - did you close your `do` with a `done`? - did you close your `if` with a `fi`? @@ -230,7 +230,7 @@ command](/syntax/ccmd/intro): **Note:** It seems that here-documents (tested on versions `1.14.7`, `2.05b`, `3.1.17` and `4.0`) are correctly terminated when there is an EOF before the end-of-here-document tag (see -[redirection](/syntax/redirection)). The reason is unknown, but it seems +[redirection](/syntax/redirection.md)). The reason is unknown, but it seems to be deliberate. Bash 4.0 added an extra message for this: `` warning: here-document at line delimited by end-of-file (wanted `') `` @@ -246,7 +246,7 @@ These *unmatched errors* occur with: - double-quote pairs - single-quote pairs (also `$'string'`!) -- missing a closing `}` with [parameter expansion syntax](/syntax/pe) +- missing a closing `}` with [parameter expansion syntax](/syntax/pe.md) ### Too many arguments @@ -365,7 +365,7 @@ the possibility that`^M` is involved. Find and eliminate it! | ## See also -- [the set builtin command](/commands/builtin/set) (for `-v` and `-x`) +- [the set builtin command](/commands/builtin/set.md) (for `-v` and `-x`) FIXME diff --git a/scripting/newbie_traps.md b/scripting/newbie_traps.md index 7f66a8a..2da03aa 100644 --- a/scripting/newbie_traps.md +++ b/scripting/newbie_traps.md @@ -24,8 +24,8 @@ them with Bash, and run them with Bash in native mode. See also: -- [Bash startup mode: SH mode](/scripting/bashbehaviour#sh_mode) -- [Bash run mode: POSIX mode](/scripting/bashbehaviour#posix_run_mode) +- [Bash startup mode: SH mode](/scripting/bashbehaviour.md#sh_mode) +- [Bash run mode: POSIX mode](/scripting/bashbehaviour.md#posix_run_mode) ### Your script named "test" doesn't execute @@ -62,7 +62,7 @@ filename expansion happens **after** that, so there is a chance that Please see: -- [brace](/syntax/expansion/brace) +- [brace](/syntax/expansion/brace.md) ## Test-command @@ -73,7 +73,7 @@ Please see: Please see: - [The classic test command - - pitfalls](/commands/classictest#pitfalls_summarized) + pitfalls](/commands/classictest.md#pitfalls_summarized) ## Variables @@ -161,7 +161,7 @@ of the referenced variables/parameters. i.e. **not** (`$PATH`): echo "The first character of PATH is ${PATH:0:1}" Note that if you are using variables in [arithmetic -expressions](/syntax/arith_expr), then the bare **name** is allowed: +expressions](/syntax/arith_expr.md), then the bare **name** is allowed: ((a=$a+7)) # Add 7 to a ((a = a + 7)) # Add 7 to a. Identical to the previous command. @@ -171,10 +171,10 @@ expressions](/syntax/arith_expr), then the bare **name** is allowed: Please see: -- [words](/syntax/words) -- [quoting](/syntax/quoting) -- [wordsplit](/syntax/expansion/wordsplit) -- [pe](/syntax/pe) +- [words](/syntax/words.md) +- [quoting](/syntax/quoting.md) +- [wordsplit](/syntax/expansion/wordsplit.md) +- [pe](/syntax/pe.md) ### Exporting @@ -204,7 +204,7 @@ In this case, the export command is of no use. Please see: -- [processtree](/scripting/processtree) +- [processtree](/scripting/processtree.md) ## Exit codes @@ -240,7 +240,7 @@ you need only a "true/false" exit indication, there's no need for `$?`. See also: -- [Exit codes](/scripting/basics#exit_codes) +- [Exit codes](/scripting/basics.md#exit_codes) ### Output vs. Return Value @@ -274,5 +274,5 @@ Make sure you're using the form you intended: Please see: -- [intro](/syntax/ccmd/intro) -- [cmdsubst](/syntax/expansion/cmdsubst) +- [intro](/syntax/ccmd/intro.md) +- [cmdsubst](/syntax/expansion/cmdsubst.md) diff --git a/scripting/nonportable.md b/scripting/nonportable.md index d827ab5..0ae3900 100644 --- a/scripting/nonportable.md +++ b/scripting/nonportable.md @@ -8,7 +8,7 @@ syntax, with some extensions and derivations. If scripts need to be portable, some of the BASH-specific syntax elements should be avoided. Others should be avoided for all scripts, e.g. if there is a corresponding POSIX(r)-compatible syntax (see -[obsolete](/scripting/obsolete)). +[obsolete](/scripting/obsolete.md)). Some syntax elements have a BASH-specific, and a portable[^1]) pendant. In these cases the portable syntax should be preferred. @@ -72,7 +72,7 @@ or
test EXPRESSION The Bashish test keyword is reserved by POSIX(r), but not defined. Use the old fashioned way with the -test command. See the +test command. See the classic test command POSIX(r) and others @@ -159,7 +159,7 @@ Why? (list of known behaviours) variables or the build options, especially KSH93 and Bash) For these, and possibly other, reasons, POSIX (SUS) standardized the -existance of [the `printf` command](/commands/builtin/printf). +existance of [the `printf` command](/commands/builtin/printf.md). ### Parameter expansions @@ -173,7 +173,7 @@ existance of [the `printf` command](/commands/builtin/printf). #### PWD -[PWD](/syntax/shellvars#PWD) is POSIX but not Bourne. Most shells are +[PWD](/syntax/shellvars.md#PWD) is POSIX but not Bourne. Most shells are *not POSIX* in that they don't ignore the value of the `PWD` environment variable. Workaround to fix the value of `PWD` at the start of your script: @@ -182,7 +182,7 @@ script: #### RANDOM -[RANDOM](/syntax/shellvars#RANDOM) is Bash/KSH/ZSH specific variable +[RANDOM](/syntax/shellvars.md#RANDOM) is Bash/KSH/ZSH specific variable that will give you a random number up to 32767 (2^15-1). Among many other available external options, you can use awk to generate a random number. There are multiple implementations of awk and which version your @@ -208,12 +208,12 @@ complaining about possible stupid code!* #### SECONDS -[SECONDS](/syntax/shellvars#SECONDS) is KSH/ZSH/Bash specific. Avoid it. +[SECONDS](/syntax/shellvars.md#SECONDS) is KSH/ZSH/Bash specific. Avoid it. Find another method. ### Check for a command in PATH -The [PATH](/syntax/shellvars#PATH) variable is a colon-delimited list of +The [PATH](/syntax/shellvars.md#PATH) variable is a colon-delimited list of directory names, so it's basically possible to run a loop and check every `PATH` component for the command you're looking for and for executability. diff --git a/scripting/posparams.md b/scripting/posparams.md index a20197e..18f4345 100644 --- a/scripting/posparams.md +++ b/scripting/posparams.md @@ -10,12 +10,12 @@ parameters are described below: | Parameter(s) | Description | |------------------|---------------------------------------------------------------------------------------------------------------------------------| -| `$0` | the first positional parameter, equivalent to `argv[0]` in C, see [the first argument](/scripting/posparams#the_first_argument) | +| `$0` | the first positional parameter, equivalent to `argv[0]` in C, see [the first argument](/scripting/posparams.md#the_first_argument) | | `$FUNCNAME` | the function name (**attention**: inside a function, `$0` is still the `$0` of the shell, **not** the function name) | | `$1 ... $9` | the argument list elements from 1 to 9 | -| `${10} ... ${N}` | the argument list elements beyond 9 (note the [parameter expansion](/syntax/pe) syntax!) | -| `$*` | all positional parameters except `$0`, see [mass usage](/scripting/posparams#mass_usage) | -| `$@` | all positional parameters except `$0`, see [mass usage](/scripting/posparams#mass_usage) | +| `${10} ... ${N}` | the argument list elements beyond 9 (note the [parameter expansion](/syntax/pe.md) syntax!) | +| `$*` | all positional parameters except `$0`, see [mass usage](/scripting/posparams.md#mass_usage) | +| `$@` | all positional parameters except `$0`, see [mass usage](/scripting/posparams.md#mass_usage) | | `$#` | the number of arguments, not counting `$0` | These positional parameters reflect exactly what was given to the script @@ -104,7 +104,7 @@ There are several ways to loop through the positional parameters. ------------------------------------------------------------------------ -You can code a [C-style for-loop](/syntax/ccmd/c_for) using `$#` as the +You can code a [C-style for-loop](/syntax/ccmd/c_for.md) using `$#` as the end value. On every iteration, the `shift`-command is used to shift the argument list: @@ -135,7 +135,7 @@ a given wordlist. The loop uses the positional parameters as a wordlist: The next method is similar to the first example (the `for` loop), but it doesn't test for reaching `$#`. It shifts and checks if `$1` still -expands to something, using the [test command](/commands/classictest): +expands to something, using the [test command](/commands/classictest.md): while [ "$1" ] do @@ -146,7 +146,7 @@ expands to something, using the [test command](/commands/classictest): Looks nice, but has the disadvantage of stopping when `$1` is empty (null-string). Let's modify it to run as long as `$1` is defined (but may be null), using [parameter expansion for an alternate -value](/syntax/pe#use_an_alternate_value): +value](/syntax/pe.md#use_an_alternate_value): while [ "${1+defined}" ]; do echo "$1" @@ -156,7 +156,7 @@ value](/syntax/pe#use_an_alternate_value): ### Getopts There is a [small tutorial dedicated to -`getopts`](/howto/getopts_tutorial) (*under construction*). +`getopts`](/howto/getopts_tutorial.md) (*under construction*). ## Mass usage @@ -202,8 +202,8 @@ Well, let's just say: **You almost always want a quoted `"$@"`!** Another way to mass expand the positional parameters is similar to what is possible for a range of characters using [substring -expansion](/syntax/pe#substring_expansion) on normal parameters and the -mass expansion range of [arrays](/syntax/arrays). +expansion](/syntax/pe.md#substring_expansion) on normal parameters and the +mass expansion range of [arrays](/syntax/arrays.md). `${@:START:COUNT}` @@ -236,7 +236,7 @@ when the positional parameters are in use. A `START` of `1` begins at ## Setting Positional Parameters Setting positional parameters with command line arguments, is not the -only way to set them. The [builtin command, set](/commands/builtin/set) +only way to set them. The [builtin command, set](/commands/builtin/set.md) may be used to "artificially" change the positional parameters from inside the script or function: @@ -381,16 +381,16 @@ options" for `ls` and doesn't change anything after it: ### Using getopts There is a [small tutorial dedicated to -`getopts`](/howto/getopts_tutorial) (*under construction*). +`getopts`](/howto/getopts_tutorial.md) (*under construction*). ## See also -- Internal: [getopts_tutorial](/howto/getopts_tutorial) -- Internal: [while_loop](/syntax/ccmd/while_loop) -- Internal: [c_for](/syntax/ccmd/c_for) -- Internal: [arrays](/syntax/arrays) (for equivalent syntax for +- Internal: [getopts_tutorial](/howto/getopts_tutorial.md) +- Internal: [while_loop](/syntax/ccmd/while_loop.md) +- Internal: [c_for](/syntax/ccmd/c_for.md) +- Internal: [arrays](/syntax/arrays.md) (for equivalent syntax for mass-expansion) - Internal: [Substring expansion on a - parameter](/syntax/pe#substring_expansion) (for equivalent syntax for + parameter](/syntax/pe.md#substring_expansion) (for equivalent syntax for mass-expansion) - Dictionary, internal: [parameter](/dict/terms/parameter) diff --git a/scripting/processtree.md b/scripting/processtree.md index d95b715..854f5f0 100644 --- a/scripting/processtree.md +++ b/scripting/processtree.md @@ -25,8 +25,8 @@ into the environment with the bash builtin command `export`: export MYVAR -Common system variables like [PATH](/syntax/shellvars#PATH) or -[HOME](/syntax/shellvars#HOME) are usually part of the environment (as +Common system variables like [PATH](/syntax/shellvars.md#PATH) or +[HOME](/syntax/shellvars.md#HOME) are usually part of the environment (as set by login scripts or programs). ## Executing programs @@ -161,7 +161,7 @@ are run inside a subshell: ### Command substitution -With [command substitution](/syntax/expansion/cmdsubst) you re-use the +With [command substitution](/syntax/expansion/cmdsubst.md) you re-use the output of another command as text in your command line, for example to set a variable. The other command is run in a subshell: diff --git a/scripting/style.md b/scripting/style.md index c467980..93102cf 100644 --- a/scripting/style.md +++ b/scripting/style.md @@ -33,7 +33,7 @@ many may prefer 4 spaces, see below in the discussion section): Speaking of hard-tabs: Avoid them if possible. They only make trouble. I can imagine one case where they're useful: Indenting -[here-documents](/syntax/redirection#here_documents). +[here-documents](/syntax/redirection.md#here_documents). ### Breaking up lines @@ -55,7 +55,7 @@ supports the visual impression of "these belong together". ### Breaking compound commands -[Compound commands](/syntax/ccmd/intro) form the structures that make a +[Compound commands](/syntax/ccmd/intro.md) form the structures that make a shell script different from a stupid enumeration of commands. Usually they contain a kind of "head" and a "body" that contains command lists. This type of compound command is relatively easy to indent. @@ -241,7 +241,7 @@ Bash, but is not a good idea. ### Command substitution As noted in [the article about command -substitution](/syntax/expansion/cmdsubst), you should use the `$( ... )` +substitution](/syntax/expansion/cmdsubst.md), you should use the `$( ... )` form. If portability is a concern, use the backquoted form `` ` ... ` ``. @@ -313,7 +313,7 @@ have to ensure they're in a specific order. The portable form of the function definition should be used, without the `function` keyword (here using the [grouping compound -command](/syntax/ccmd/grouping_plain)): +command](/syntax/ccmd/grouping_plain.md)): getargs() { ... diff --git a/scripting/tutoriallist.md b/scripting/tutoriallist.md index 91fd2de..461f24b 100644 --- a/scripting/tutoriallist.md +++ b/scripting/tutoriallist.md @@ -225,27 +225,27 @@ Some stuff I didn't like there: - uses external, unreliable command `which` instead of builtin `type -p` to determinate the location of a program -- lacks [sane quoting](/syntax/quoting) +- lacks [sane quoting](/syntax/quoting.md) - uses `function SOMENAME` keyword instead of the common POSIX-compatible variant `SOMENAME()` to [define a - function](/syntax/basicgrammar#shell_function_definitions) + function](/syntax/basicgrammar.md#shell_function_definitions) - uses backticks instead of `$( ... )` for [command - substitution](/syntax/expansion/cmdsubst) + substitution](/syntax/expansion/cmdsubst.md) - incorrectly uses an additional array to store [positional - parameters](/scripting/posparams), disregarding that `$@` already is + parameters](/scripting/posparams.md), disregarding that `$@` already is array-like - uses `echo -e` and the historical control character `\c` instead of - modern [printf](/commands/builtin/printf) + modern [printf](/commands/builtin/printf.md) - uses `` for a in `seq 1 10` `` instead of a [C-like counter - loop](/syntax/ccmd/c_for) `for ((a=1; a <= 10; a++))` + loop](/syntax/ccmd/c_for.md) `for ((a=1; a <= 10; a++))` - the `if/else` stuff looks as if the `test` (or `[ ...]`) command is the only thing Bash can execute and check - a `for` loop example that **will** explode on - [word-splitting](/syntax/expansion/wordsplit) + [word-splitting](/syntax/expansion/wordsplit.md) - arithmetic tests (the while/until loop examples) using the historical "old way" with `test`, not [modern arithmetic - components](/syntax/arith_expr) -- useless [quoting](/syntax/quoting) of one-word strings (not that it + components](/syntax/arith_expr.md) +- useless [quoting](/syntax/quoting.md) of one-word strings (not that it hurts per se, but it shows that the author has no clue when to use quotes) - a weird construct I don't understand (example for stdout/err @@ -274,7 +274,7 @@ learning tutorial - but that is not the goal. One point (I **have** to criticize **something** ;-) ): - the article says that there are no [C-styled - for-loops](/syntax/ccmd/c_for) in Bash, this is wrong (maybe the + for-loops](/syntax/ccmd/c_for.md) in Bash, this is wrong (maybe the article is for a very old (pre `2.05b`) Bash version) \ @@ -288,14 +288,14 @@ A few points: - uses `function SOMENAME` instead of more common and most portable `SOMENAME()` to [define - functions](/syntax/basicgrammar#shell_function_definitions) -- wrong description of the [if clause](/syntax/ccmd/if_clause) (says + functions](/syntax/basicgrammar.md#shell_function_definitions) +- wrong description of the [if clause](/syntax/ccmd/if_clause.md) (says "the base \[...\] is `if [expression];`", which is wrong) -- a [for-loop example](/syntax/ccmd/classic_for) will explode due to - [word splitting](/syntax/expansion/wordsplit) (`for i in $( ls )` - +- a [for-loop example](/syntax/ccmd/classic_for.md) will explode due to + [word splitting](/syntax/expansion/wordsplit.md) (`for i in $( ls )` - evil!) - the mentioned C-like for-loop is not the [real C-like - for-loop](/syntax/ccmd/c_for), it just calls `seq(1)`+ + for-loop](/syntax/ccmd/c_for.md), it just calls `seq(1)`+ - Many syntax errors: The examples won't even parse correctly I like the style this article is written in. If the points are fixed, it diff --git a/snipplets/start.md b/snipplets/start.md index a3696a5..fad6296 100644 --- a/snipplets/start.md +++ b/snipplets/start.md @@ -12,7 +12,7 @@ tutorial. ## List of snippets -[reset filter](/snipplets/start) +[reset filter](/snipplets/start.md) ---- datacloud snippet ---- field: snipplet_tags diff --git a/start.md b/start.md index 2d20f94..19bd0ce 100644 --- a/start.md +++ b/start.md @@ -32,88 +32,88 @@ only there to prevent SPAM. - [Bash v4 - a rough overview](bash4.md) (unmaintained, since Bash 4 is more or less standard) -- [style](/scripting/style.md) -- an assorted collection of style and optic +- [style](/scripting/style.md.md) -- an assorted collection of style and optic hints -- [basics](/scripting/basics.md) -- [newbie_traps](/scripting/newbie_traps.md) -- [bashbehaviour](/scripting/bashbehaviour.md) -- [posparams](/scripting/posparams.md) -- [processtree](/scripting/processtree.md) -- [obsolete](/scripting/obsolete.md) -- [nonportable](/scripting/nonportable.md) -- [debuggingtips](/scripting/debuggingtips.md) -- [terminalcodes](/scripting/terminalcodes.md) -- [tutoriallist](/scripting/tutoriallist.md) +- [basics](/scripting/basics.md.md) +- [newbie_traps](/scripting/newbie_traps.md.md) +- [bashbehaviour](/scripting/bashbehaviour.md.md) +- [posparams](/scripting/posparams.md.md) +- [processtree](/scripting/processtree.md.md) +- [obsolete](/scripting/obsolete.md.md) +- [nonportable](/scripting/nonportable.md.md) +- [debuggingtips](/scripting/debuggingtips.md.md) +- [terminalcodes](/scripting/terminalcodes.md.md) +- [tutoriallist](/scripting/tutoriallist.md.md) ## Code snippets -There is a [section that holds small code snippets](/snipplets/start.md). +There is a [section that holds small code snippets](/snipplets/start.md.md). -See also [some Bash source code excerpts](/misc/readthesourceluke.md). +See also [some Bash source code excerpts](/misc/readthesourceluke.md.md). ## How to -[Doing specific tasks: concepts, methods, ideas](/howto/start.md): +[Doing specific tasks: concepts, methods, ideas](/howto/start.md.md): -- [Simple locking (against parallel run)](/howto/mutex.md) -- [Rudimentary config files for your scripts](/howto/conffile.md) -- [Editing files with ed(1)](/howto/edit-ed.md) -- [Collapsing Functions](/howto/collapsing_functions.md) -- [Illustrated Redirection Tutorial](/howto/redirection_tutorial.md) +- [Simple locking (against parallel run)](/howto/mutex.md.md) +- [Rudimentary config files for your scripts](/howto/conffile.md.md) +- [Editing files with ed(1)](/howto/edit-ed.md.md) +- [Collapsing Functions](/howto/collapsing_functions.md.md) +- [Illustrated Redirection Tutorial](/howto/redirection_tutorial.md.md) - [Calculate with dc(1)](/howto/calculate-dc.md) -- [Introduction to pax - the POSIX archiver](/howto/pax.md) -- [getopts_tutorial](/howto/getopts_tutorial.md) (*under construction!*) -- [dissectabadoneliner](/howto/dissectabadoneliner.md) An example of a bad +- [Introduction to pax - the POSIX archiver](/howto/pax.md.md) +- [getopts_tutorial](/howto/getopts_tutorial.md.md) (*under construction!*) +- [dissectabadoneliner](/howto/dissectabadoneliner.md.md) An example of a bad oneliner, breakdown and fix (by `kojoro`) -- [Write tests for ./your-script.sh](/howto/testing-your-scripts.md) by +- [Write tests for ./your-script.sh](/howto/testing-your-scripts.md.md) by using bashtest util ## Bash syntax and operations -- [Bash features overview by version](/scripting/bashchanges.md) -- [Basic grammar rules](/syntax/basicgrammar.md) -- [Quoting and character escaping](/syntax/quoting.md) -- [Parsing and execution](/syntax/grammar/parser_exec.md) -- [Some words about words...](/syntax/words.md) -- [Patterns and pattern matching](/syntax/pattern.md) -- [Arithmetic expressions](/syntax/arith_expr.md) -- [List of shell options](/internals/shell_options.md) -- [Redirection](/syntax/redirection.md) -- [Special parameters and shell variables](/syntax/shellvars.md) -- [Arrays](/syntax/arrays.md) +- [Bash features overview by version](/scripting/bashchanges.md.md) +- [Basic grammar rules](/syntax/basicgrammar.md.md) +- [Quoting and character escaping](/syntax/quoting.md.md) +- [Parsing and execution](/syntax/grammar/parser_exec.md.md) +- [Some words about words...](/syntax/words.md.md) +- [Patterns and pattern matching](/syntax/pattern.md.md) +- [Arithmetic expressions](/syntax/arith_expr.md.md) +- [List of shell options](/internals/shell_options.md.md) +- [Redirection](/syntax/redirection.md.md) +- [Special parameters and shell variables](/syntax/shellvars.md.md) +- [Arrays](/syntax/arrays.md.md) ## Compound commands -| **[Compound commands overview](/syntax/ccmd/intro.md)** | | +| **[Compound commands overview](/syntax/ccmd/intro.md.md)** | | |:-----------------------------------------------------|------------------------------------------------------------------| | Grouping | | -| `{ ...; }` | [command grouping](/syntax/ccmd/grouping_plain.md) | -| `( ... )` | [command grouping in a subshell](/syntax/ccmd/grouping_subshell.md) | +| `{ ...; }` | [command grouping](/syntax/ccmd/grouping_plain.md.md) | +| `( ... )` | [command grouping in a subshell](/syntax/ccmd/grouping_subshell.md.md) | | Conditionals | | -| `[[ ... ]]` | [conditional expression](/syntax/ccmd/conditional_expression.md) | -| `if ...; then ...; fi` | [conditional branching](/syntax/ccmd/if_clause.md) | -| `case ... esac` | [pattern-based branching](/syntax/ccmd/case.md) | +| `[[ ... ]]` | [conditional expression](/syntax/ccmd/conditional_expression.md.md) | +| `if ...; then ...; fi` | [conditional branching](/syntax/ccmd/if_clause.md.md) | +| `case ... esac` | [pattern-based branching](/syntax/ccmd/case.md.md) | | Loops | | -| `for word in ...; do ...; done` | [classic for-loop](/syntax/ccmd/classic_for.md) | -| `for ((x=1; x<=10; x++)); do ...; done` | [C-style for-loop](/syntax/ccmd/c_for.md) | -| `while ...; do ...; done` | [while loop](/syntax/ccmd/while_loop.md) | -| `until ...; do ...; done` | [until loop](/syntax/ccmd/until_loop.md) | +| `for word in ...; do ...; done` | [classic for-loop](/syntax/ccmd/classic_for.md.md) | +| `for ((x=1; x<=10; x++)); do ...; done` | [C-style for-loop](/syntax/ccmd/c_for.md.md) | +| `while ...; do ...; done` | [while loop](/syntax/ccmd/while_loop.md.md) | +| `until ...; do ...; done` | [until loop](/syntax/ccmd/until_loop.md.md) | | Misc | | -| `(( ... ))` | [arithmetic evaluation](/syntax/ccmd/arithmetic_eval.md) | -| `select word in ...; do ...; done` | [user selections](/syntax/ccmd/user_select.md) | +| `(( ... ))` | [arithmetic evaluation](/syntax/ccmd/arithmetic_eval.md.md) | +| `select word in ...; do ...; done` | [user selections](/syntax/ccmd/user_select.md.md) | ## Expansions and substitutions -| **[Introduction to expansions and substitutions](/syntax/expansion/intro.md)** | | +| **[Introduction to expansions and substitutions](/syntax/expansion/intro.md.md)** | | |:----------------------------------------------------------------------------|------------------------------------------------------| -| `{A,B,C} {A..C}` | [Brace expansion](/syntax/expansion/brace.md) | -| `~/ ~root/` | [Tilde expansion](/syntax/expansion/tilde.md) | -| `$FOO ${BAR%.mp3}` | [Parameter expansion](/syntax/pe.md) | -| `` `command` $(command) `` | [Command substitution](/syntax/expansion/cmdsubst.md) | -| `<(command) >(command)` | [Process substitution](/syntax/expansion/proc_subst.md) | -| `$((1 + 2 + 3)) $[4 + 5 + 6]` | [Arithmetic expansion](/syntax/expansion/arith.md) | -| `Hello <---> Word!` | [Word splitting](/syntax/expansion/wordsplit.md) | -| `/data/*-av/*.mp?` | [Pathname expansion](/syntax/expansion/globs.md) | +| `{A,B,C} {A..C}` | [Brace expansion](/syntax/expansion/brace.md.md) | +| `~/ ~root/` | [Tilde expansion](/syntax/expansion/tilde.md.md) | +| `$FOO ${BAR%.mp3}` | [Parameter expansion](/syntax/pe.md.md) | +| `` `command` $(command) `` | [Command substitution](/syntax/expansion/cmdsubst.md.md) | +| `<(command) >(command)` | [Process substitution](/syntax/expansion/proc_subst.md.md) | +| `$((1 + 2 + 3)) $[4 + 5 + 6]` | [Arithmetic expansion](/syntax/expansion/arith.md.md) | +| `Hello <---> Word!` | [Word splitting](/syntax/expansion/wordsplit.md.md) | +| `/data/*-av/*.mp?` | [Pathname expansion](/syntax/expansion/globs.md.md) | ## Builtin Commands @@ -137,7 +137,7 @@ datastructures. declare +href="/commands/builtin/declare.md.md">declare Display or set shell variables or functions along with attributes. typeset @@ -167,14 +167,14 @@ href="/commands/builtin/local">local readonly +href="/commands/builtin/read.md.mdonly">readonly Mark variables or functions as read-only. typeset -r special builtin unset +href="/commands/builtin/unset.md.md">unset Unset variables and functions. - special builtin @@ -197,7 +197,7 @@ streams. coproc +href="/syntax/keywords/coproc.md.md">coproc Co-processes: Run a command in the background with pipes for reading / writing its standard streams. - @@ -212,21 +212,21 @@ href="/commands/builtin/echo">echo mapfile +href="/commands/builtin/mapfile.md.md">mapfile Read lines of input into an array. readarray builtin printf +href="/commands/builtin/printf.md.md">printf "advanced echo." - builtin read +href="/commands/builtin/read.md.md">read Read input into variables or arrays, or split strings into fields using delimiters. - @@ -241,14 +241,14 @@ Commands that modify shell behavior, change special options, assist in debugging caller +href="/commands/builtin/caller.md.md">caller Identify/print execution frames. - builtin set +href="/commands/builtin/set.md.md">set Set the positional parameters and/or set options that affect shell behaviour. - @@ -256,7 +256,7 @@ behaviour. shopt +href="/commands/builtin/shopt.md.md">shopt set/get some bash-specific shell options. - builtin @@ -305,7 +305,7 @@ href="/commands/builtin/continueBreak">continue / break let +href="/commands/builtin/let.md.md">let Arithmetic evaluation simple command. - builtin @@ -319,7 +319,7 @@ href="/commands/builtin/return">return [ +href="/commands/classictest.md.md">[ The classic test simple command. test builtin @@ -334,7 +334,7 @@ signals, process groups, subshells. exec +href="/commands/builtin/exec.md.md">exec Replace the current shell process or set redirections. - special builtin @@ -385,7 +385,7 @@ href="/commands/builtin/wait">wait ## Dictionary -| :bulb: A list of expressions, words, and their meanings is [here](/dict/index.md). | +| :bulb: A list of expressions, words, and their meanings is [here](/dict/index.md.md). | | --- | ## Links @@ -474,7 +474,7 @@ href="/commands/builtin/wait">wait commands](https://www.rosehosting.com/blog/basic-shell-commands-after-putty-ssh-logon/) - [Bashphorism list from the Bash IRC channel on Freenode](/misc/bashphorisms) -- [Some more or less funny commandline stuff](/misc/shell_humor.md) +- [Some more or less funny commandline stuff](/misc/shell_humor.md.md) - [How to Enable SSH on Ubuntu Tutorial](https://thishosting.rocks/how-to-enable-ssh-on-ubuntu/) - [How To Make an Awesome Custom Shell with @@ -499,7 +499,7 @@ If you have critiques or suggestions, please feel free to send a mail using the contact form on the right. Note that there is a simple discussion option below every article. -Please also see the [imprint](/user/thebonsai/imprint.md) if you have +Please also see the [imprint](/user/thebonsai/imprint.md.md) if you have problems with the site and its contents (legality, ...)! It also would be nice to drop a line when diff --git a/syntax/arith_expr.md b/syntax/arith_expr.md index 58bf030..3ca5a78 100644 --- a/syntax/arith_expr.md +++ b/syntax/arith_expr.md @@ -4,13 +4,13 @@ Arithmetic expressions are used in several situations: -- [arithmetic evaluation command](/syntax/ccmd/arithmetic_eval) -- [arithmetic expansion](/syntax/expansion/arith) -- [substring parameter expansion](/syntax/pe#substring_expansion) -- [the `let` builtin command](/commands/builtin/let) -- [C-style for loop](/syntax/ccmd/c_for) -- [array indexing](/syntax/arrays) -- [conditional expressions](/syntax/ccmd/conditional_expression) +- [arithmetic evaluation command](/syntax/ccmd/arithmetic_eval.md) +- [arithmetic expansion](/syntax/expansion/arith.md) +- [substring parameter expansion](/syntax/pe.md#substring_expansion) +- [the `let` builtin command](/commands/builtin/let.md) +- [C-style for loop](/syntax/ccmd/c_for.md) +- [array indexing](/syntax/arrays.md) +- [conditional expressions](/syntax/ccmd/conditional_expression.md) - Assignment statements, and arguments to declaration commands of variables with the integer attribute. @@ -95,7 +95,7 @@ and what numbers are and how they are built, then you don't need different bases. If you want to convert between the usual bases (octal, decimal, hex), -use [the printf command](/commands/builtin/printf) and its format +use [the printf command](/commands/builtin/printf.md) and its format strings. ## Shell variables @@ -121,7 +121,7 @@ When variables are referenced, the notation `1 + $X` is equivalent to the notation `1 + X`, both are allowed. When variables are referenced like `$X`, the rules of [parameter -expansion](/syntax/pe) apply and are performed **before** the expression +expansion](/syntax/pe.md) apply and are performed **before** the expression is evaluated. Thus, a construct like `${MYSTRING:4:3}` is valid inside an arithmetic expression. @@ -130,7 +130,7 @@ an arithmetic expression. Unlike command exit and return codes, arithmetic expressions evaluate to logical "true" when they are not 0. When they are 0, they evaluate to "false". The [arithmetic evaluation compound -command](/syntax/ccmd/arithmetic_eval) reverses the "truth" of an +command](/syntax/ccmd/arithmetic_eval.md) reverses the "truth" of an arithmetic expression to match the "truth" of command exit codes: - if the arithmetic expression brings up a value not 0 (arithmetic @@ -153,16 +153,16 @@ That means, the following `if`-clause will execute the `else`-thread: | Operator | Description | |---------------------|----------------------------------------------------------------------------------------------------| | ` = ` | normal assignment | -| ` *= ` | equivalent to ` = * `, see [calculation operators](/syntax/arith_expr#calculations) | -| ` /= ` | equivalent to ` = / `, see [calculation operators](/syntax/arith_expr#calculations) | -| ` %= ` | equivalent to ` = % `, see [calculation operators](/syntax/arith_expr#calculations) | -| ` += ` | equivalent to ` = + `, see [calculation operators](/syntax/arith_expr#calculations) | -| ` -= ` | equivalent to ` = - `, see [calculation operators](/syntax/arith_expr#calculations) | -| ` <<= ` | equivalent to ` = << `, see [bit operations](/syntax/arith_expr#bit_operations) | -| ` >>= ` | equivalent to ` = >> `, see [bit operations](/syntax/arith_expr#bit_operations) | -| ` &= ` | equivalent to ` = & `, see [bit operations](/syntax/arith_expr#bit_operations) | -| ` ^= ` | equivalent to ` = ^ `, see [bit operations](/syntax/arith_expr#bit_operations) | -| ` |= ` | equivalent to ` = | `, see [bit operations](/syntax/arith_expr#bit_operations) | +| ` *= ` | equivalent to ` = * `, see [calculation operators](/syntax/arith_expr.md#calculations) | +| ` /= ` | equivalent to ` = / `, see [calculation operators](/syntax/arith_expr.md#calculations) | +| ` %= ` | equivalent to ` = % `, see [calculation operators](/syntax/arith_expr.md#calculations) | +| ` += ` | equivalent to ` = + `, see [calculation operators](/syntax/arith_expr.md#calculations) | +| ` -= ` | equivalent to ` = - `, see [calculation operators](/syntax/arith_expr.md#calculations) | +| ` <<= ` | equivalent to ` = << `, see [bit operations](/syntax/arith_expr.md#bit_operations) | +| ` >>= ` | equivalent to ` = >> `, see [bit operations](/syntax/arith_expr.md#bit_operations) | +| ` &= ` | equivalent to ` = & `, see [bit operations](/syntax/arith_expr.md#bit_operations) | +| ` ^= ` | equivalent to ` = ^ `, see [bit operations](/syntax/arith_expr.md#bit_operations) | +| ` |= ` | equivalent to ` = | `, see [bit operations](/syntax/arith_expr.md#bit_operations) | ### Calculations @@ -368,7 +368,7 @@ under set -e. \ ## Arithmetic expressions in Bash -- [The C-style for-loop](/syntax/ccmd/c_for) -- [Arithmetic expansion](/syntax/expansion/arith) -- [Arithmetic evaluation compound command](/syntax/ccmd/arithmetic_eval) -- [The "let" builtin command](/commands/builtin/let) +- [The C-style for-loop](/syntax/ccmd/c_for.md) +- [Arithmetic expansion](/syntax/expansion/arith.md) +- [Arithmetic evaluation compound command](/syntax/ccmd/arithmetic_eval.md) +- [The "let" builtin command](/commands/builtin/let.md) diff --git a/syntax/arrays.md b/syntax/arrays.md index b25093d..65dc559 100644 --- a/syntax/arrays.md +++ b/syntax/arrays.md @@ -30,7 +30,7 @@ Bash supports two different types of ksh-like one-dimensional arrays. - *Indexed arrays* use positive integer numbers as keys. Indexed arrays are **always sparse**, meaning indexes are not necessarily contiguous. All syntax used for both assigning and dereferencing indexed arrays is - an [arithmetic evaluation context](/syntax/arith_expr) (see + an [arithmetic evaluation context](/syntax/arith_expr.md) (see [\#Referencing](#Referencing)). As in C and many other languages, the numerical array indexes start at 0 (zero). Indexed arrays are the most common, useful, and portable type. Indexed arrays were first @@ -75,7 +75,7 @@ the closing bracket up to the end of the parameter name. With few exceptions, names of this form may be used anywhere ordinary parameter names are valid, such as within [arithmetic -expressions](/syntax/arith_expr), [parameter expansions](/syntax/pe), +expressions](/syntax/arith_expr.md), [parameter expansions](/syntax/pe.md), and as arguments to builtins that accept parameter names. An *array* is a Bash parameter that has been given the `-a` (for indexed) or `-A` (for associative) *attributes*. However, any regular (non-special or @@ -116,7 +116,7 @@ variables. | Syntax | Description | |:--------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| `ARRAY[N]=VALUE` | Sets the element `N` of the **indexed** array `ARRAY` to `VALUE`. **`N` can be any valid [arithmetic expression](/syntax/arith_expr)**. | +| `ARRAY[N]=VALUE` | Sets the element `N` of the **indexed** array `ARRAY` to `VALUE`. **`N` can be any valid [arithmetic expression](/syntax/arith_expr.md)**. | | `ARRAY[STRING]=VALUE` | Sets the element indexed by `STRING` of the **associative array** `ARRAY`. | | `ARRAY=VALUE` | As above. If no index is given, as a default the zeroth element is set to `VALUE`. Careful, this is even true of associative arrays - there is no error if no key is specified, and the value is assigned to string index "0". | | `ARRAY=(E1\ E2\ ...)` | Compound array assignment - sets the whole array `ARRAY` to the given list of elements indexed sequentially starting at zero. The array is unset before assignment unless the += operator is used. When the list is empty (`ARRAY=()`), the array will be set to an empty array. This method obviously does not use explicit indexes. An **associative array** can **not** be set like that! Clearing an associative array using `ARRAY=()` works. | @@ -130,7 +130,7 @@ As of now, arrays can't be exported. ### Getting values | :shell: For completeness and details on several parameter expansion -variants, see the [article about parameter expansion](/syntax/pe) and +variants, see the [article about parameter expansion](/syntax/pe.md) and check the notes about arrays. | | --- | @@ -138,13 +138,13 @@ check the notes about arrays. | |-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `${ARRAY[N]}` | Expands to the value of the index `N` in the **indexed** array `ARRAY`. If `N` is a negative number, it's treated as the offset from the maximum assigned index (can't be used for assignment) - 1 | | `${ARRAY[S]}` | Expands to the value of the index `S` in the **associative** array `ARRAY`. | -| `"${ARRAY[@]}" ${ARRAY[@]} "${ARRAY[*]}" ${ARRAY[*]}` | Similar to [mass-expanding positional parameters](/scripting/posparams#mass_usage), this expands to all elements. If unquoted, both subscripts `*` and `@` expand to the same result, if quoted, `@` expands to all elements individually quoted, `*` expands to all elements quoted as a whole. | -| `"${ARRAY[@]:N:M}" ${ARRAY[@]:N:M} "${ARRAY[*]:N:M}" ${ARRAY[*]:N:M}` | Similar to what this syntax does for the characters of a single string when doing [substring expansion](/syntax/pe#substring_expansion), this expands to `M` elements starting with element `N`. This way you can mass-expand individual indexes. The rules for quoting and the subscripts `*` and `@` are the same as above for the other mass-expansions. | +| `"${ARRAY[@]}" ${ARRAY[@]} "${ARRAY[*]}" ${ARRAY[*]}` | Similar to [mass-expanding positional parameters](/scripting/posparams.md#mass_usage), this expands to all elements. If unquoted, both subscripts `*` and `@` expand to the same result, if quoted, `@` expands to all elements individually quoted, `*` expands to all elements quoted as a whole. | +| `"${ARRAY[@]:N:M}" ${ARRAY[@]:N:M} "${ARRAY[*]:N:M}" ${ARRAY[*]:N:M}` | Similar to what this syntax does for the characters of a single string when doing [substring expansion](/syntax/pe.md#substring_expansion), this expands to `M` elements starting with element `N`. This way you can mass-expand individual indexes. The rules for quoting and the subscripts `*` and `@` are the same as above for the other mass-expansions. | For clarification: When you use the subscripts `@` or `*` for mass-expanding, then the behaviour is exactly what it is for `$@` and `$*` when [mass-expanding the positional -parameters](/scripting/posparams#mass_usage). You should read this +parameters](/scripting/posparams.md#mass_usage). You should read this article to understand what's going on. ### Metadata @@ -220,7 +220,7 @@ variables with unset. | :warning: Specifying unquoted array elements as arguments to any command, such as with the syntax above **may cause [pathname -expansion](/syntax/expansion/globs) to occur** due to the presence of +expansion](/syntax/expansion/globs.md) to occur** due to the presence of glob characters. Example: You are in a directory with a file named `x1`, and you want to @@ -710,10 +710,10 @@ to generate these results. ## See also -- [Parameter expansion](/syntax/pe) (contains sections for arrays) -- [classic_for](/syntax/ccmd/classic_for) (contains some examples to +- [Parameter expansion](/syntax/pe.md) (contains sections for arrays) +- [classic_for](/syntax/ccmd/classic_for.md) (contains some examples to iterate over arrays) -- [declare](/commands/builtin/declare) +- [declare](/commands/builtin/declare.md) - [BashFAQ 005 - How can I use array variables?](http://mywiki.wooledge.org/BashFAQ/005) - A very detailed discussion on arrays with many examples. diff --git a/syntax/basicgrammar.md b/syntax/basicgrammar.md index 0063e41..1811c73 100644 --- a/syntax/basicgrammar.md +++ b/syntax/basicgrammar.md @@ -42,7 +42,7 @@ issue to report back to the calling program. **base** for all higher constructs. Everything you execute, from pipelines to functions, finally ends up in (many) simple commands. That's why Bash only has one method to [expand and execute a simple -command](/syntax/grammar/parser_exec). \ +command](/syntax/grammar/parser_exec.md). \ ## Pipelines @@ -81,7 +81,7 @@ the leading `!` will "invert" the exit code, and the shell sees (and acts on) exit code 0 (TRUE) and the `then` part of the `if` stanza is executed. One could say we checked for "`not grep "^root" /etc/passwd`". -The [set option pipefail](/commands/builtin/set#attributes) determines +The [set option pipefail](/commands/builtin/set.md#attributes) determines the behavior of how bash reports the exit code of a pipeline. If it's set, then the exit code (`$?`) is the last command that exits with non zero status, if none fail, it's zero. If it's not set, then `$?` always @@ -131,7 +131,7 @@ Your whole Bash script technically is one big single list! ## Compound Commands -See also the [list of compound commands](/syntax/ccmd/intro). +See also the [list of compound commands](/syntax/ccmd/intro.md). There are two forms of compound commands: @@ -150,17 +150,17 @@ overview): | Compound command syntax | Description | |------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------| -| `( )` | Execute `` in an extra subshell =\> [article](/syntax/ccmd/grouping_subshell) | -| `{ ; }` | Execute `` as separate group (but not in a subshell) =\> [article](/syntax/ccmd/grouping_plain) | -| `(( ))` | Evaluate the arithmetic expression `` =\> [article](/syntax/ccmd/arithmetic_eval) | -| `[[ ]]` | Evaluate the conditional expression `` (aka "the new test command") =\> [article](/syntax/ccmd/conditional_expression) | -| `for in ; do ; done` | Executes `` while setting the variable `` to one of `` on every iteration (classic for-loop) =\> [article](/syntax/ccmd/classic_for) | -| `for (( ; ; )) ; do ; done` | C-style for-loop (driven by arithmetic expressions) =\> [article](/syntax/ccmd/c_for) | -| `select in ; do ; done` | Provides simple menus =\> [article](/syntax/ccmd/user_select) | -| `case in ) ;; ... esac` | Decisions based on pattern matching - executing `` on match =\> [article](/syntax/ccmd/case) | -| `if ; then ; else ; fi` | The if clause: makes decisions based on exit codes =\> [article](/syntax/ccmd/if_clause) | -| `while ; do ; done` | Execute `` while `` returns TRUE (exit code) =\> [article](/syntax/ccmd/while_loop) | -| `until ; do ; done` | Execute `` until `` returns TRUE (exit code) =\> [article](/syntax/ccmd/until_loop) | +| `( )` | Execute `` in an extra subshell =\> [article](/syntax/ccmd/grouping_subshell.md) | +| `{ ; }` | Execute `` as separate group (but not in a subshell) =\> [article](/syntax/ccmd/grouping_plain.md) | +| `(( ))` | Evaluate the arithmetic expression `` =\> [article](/syntax/ccmd/arithmetic_eval.md) | +| `[[ ]]` | Evaluate the conditional expression `` (aka "the new test command") =\> [article](/syntax/ccmd/conditional_expression.md) | +| `for in ; do ; done` | Executes `` while setting the variable `` to one of `` on every iteration (classic for-loop) =\> [article](/syntax/ccmd/classic_for.md) | +| `for (( ; ; )) ; do ; done` | C-style for-loop (driven by arithmetic expressions) =\> [article](/syntax/ccmd/c_for.md) | +| `select in ; do ; done` | Provides simple menus =\> [article](/syntax/ccmd/user_select.md) | +| `case in ) ;; ... esac` | Decisions based on pattern matching - executing `` on match =\> [article](/syntax/ccmd/case.md) | +| `if ; then ; else ; fi` | The if clause: makes decisions based on exit codes =\> [article](/syntax/ccmd/if_clause.md) | +| `while ; do ; done` | Execute `` while `` returns TRUE (exit code) =\> [article](/syntax/ccmd/while_loop.md) | +| `until ; do ; done` | Execute `` until `` returns TRUE (exit code) =\> [article](/syntax/ccmd/until_loop.md) | ## Shell Function Definitions @@ -320,10 +320,10 @@ Let's invert test command exit code, only one thing changes: ## See also -- Internal: [List of compound commands](/syntax/ccmd/intro) +- Internal: [List of compound commands](/syntax/ccmd/intro.md) - Internal: [Parsing and execution of simple - commands](/syntax/grammar/parser_exec) -- Internal: [Quoting and escaping](/syntax/quoting) + commands](/syntax/grammar/parser_exec.md) +- Internal: [Quoting and escaping](/syntax/quoting.md) - Internal: [Introduction to expansions and - substitutions](/syntax/expansion/intro) -- Internal: [Some words about words...](/syntax/words) + substitutions](/syntax/expansion/intro.md) +- Internal: [Some words about words...](/syntax/words.md) diff --git a/syntax/ccmd/arithmetic_eval.md b/syntax/ccmd/arithmetic_eval.md index 5eb408e..c36881a 100644 --- a/syntax/ccmd/arithmetic_eval.md +++ b/syntax/ccmd/arithmetic_eval.md @@ -6,17 +6,17 @@ ## Description -This command evaluates the [arithmetic expression](/syntax/arith_expr) +This command evaluates the [arithmetic expression](/syntax/arith_expr.md) ``. If the expression evaluates to 0 then the exit code of the expression is set to 1 (`FALSE`). If the expression evaluates to something else than 0, then the exit code of the expression is set to 0 (`TRUE`). For this return code mapping, please see [this -section](/syntax/arith_expr#arithmetic_expressions_and_return_codes). +section](/syntax/arith_expr.md#arithmetic_expressions_and_return_codes). The functionality basically is equivalent to what the [`let` builtin -command](/commands/builtin/let) does. The arithmetic evaluation compound +command](/commands/builtin/let.md) does. The arithmetic evaluation compound command should be preferred. ## Examples @@ -25,6 +25,6 @@ command should be preferred. ## See also -- Internal: [arithmetic expressions](/syntax/arith_expr) -- Internal: [arithmetic expansion](/syntax/expansion/arith) -- Internal: [The `let` builtin command](/commands/builtin/let) +- Internal: [arithmetic expressions](/syntax/arith_expr.md) +- Internal: [arithmetic expansion](/syntax/expansion/arith.md) +- Internal: [The `let` builtin command](/commands/builtin/let.md) diff --git a/syntax/ccmd/c_for.md b/syntax/ccmd/c_for.md index dfedb2b..67a32d2 100644 --- a/syntax/ccmd/c_for.md +++ b/syntax/ccmd/c_for.md @@ -29,7 +29,7 @@ mechanisms available in the language. The `((;;))` syntax at the top of the loop is not an ordinary [arithmetic compound command](syntax/ccmd/arithmetic_eval), but is part of the C-style for-loop's own syntax. The three sections separated by -semicolons are [arithmetic expression](/syntax/arith_expr) contexts. +semicolons are [arithmetic expression](/syntax/arith_expr.md) contexts. Each time one of the sections is to be evaluated, the section is first processed for: brace, parameter, command, arithmetic, and process substitution/expansion as usual for arithmetic contexts. When the loop @@ -60,7 +60,7 @@ loop can be: The equivalent construct using a [while loop](syntax/ccmd/while_loop) and the [arithmetic expression compound -command](/syntax/ccmd/arithmetic_eval) would be structured as: +command](/syntax/ccmd/arithmetic_eval.md) would be structured as: (( )) while (( )); do @@ -135,7 +135,7 @@ ending at 1. If that bit is set in the `testbyte`, it prints "`1`", else bits). #!/usr/bin/env bash - # Example written for http://wiki.bash-hackers.org/syntax/ccmd/c_for#bits_analyzer + # Example written for http://wiki.bash-hackers.org/syntax/ccmd/c_for.md#bits_analyzer # Based on TheBonsai's original. function toBin { @@ -231,6 +231,6 @@ variables. ## See also -- Internal: [Arithmetic expressions](/syntax/arith_expr) -- Internal: [The classic for-loop](/syntax/ccmd/classic_for) -- Internal: [The while-loop](/syntax/ccmd/while_loop) +- Internal: [Arithmetic expressions](/syntax/arith_expr.md) +- Internal: [The classic for-loop](/syntax/ccmd/classic_for.md) +- Internal: [The while-loop](/syntax/ccmd/while_loop.md) diff --git a/syntax/ccmd/case.md b/syntax/ccmd/case.md index 794d41d..9a5cf3b 100644 --- a/syntax/ccmd/case.md +++ b/syntax/ccmd/case.md @@ -13,9 +13,9 @@ ## Description The `case`-statement can execute commands based on a [pattern -matching](/syntax/pattern) decision. The word `` is matched +matching](/syntax/pattern.md) decision. The word `` is matched against every pattern `` and on a match, the associated -[list](/syntax/basicgrammar#lists) `` is executed. Every +[list](/syntax/basicgrammar.md#lists) `` is executed. Every commandlist is terminated by `;;`. This rule is optional for the very last commandlist (i.e., you can omit the `;;` before the `esac`). Every `` is separated from it's associated `` by a `)`, and @@ -43,7 +43,7 @@ done**, which means you can leave expansions unquoted without problems: esac This is similar to the behavior of the [conditional expression command -("new test command")](/syntax/ccmd/conditional_expression) (also no word +("new test command")](/syntax/ccmd/conditional_expression.md) (also no word splitting for expansions). Unlike the C-case-statement, only the matching list and nothing else is diff --git a/syntax/ccmd/classic_for.md b/syntax/ccmd/classic_for.md index e8b2a81..bc9df36 100644 --- a/syntax/ccmd/classic_for.md +++ b/syntax/ccmd/classic_for.md @@ -66,7 +66,7 @@ empty"!). ### Iterate over array elements -With some array syntax (see [arrays](/syntax/arrays)) you can easily +With some array syntax (see [arrays](/syntax/arrays.md)) you can easily "feed" the for-loop to iterate over all elements in an array (by mass-expanding all elements): @@ -88,7 +88,7 @@ done ### List positional parameters You can use this -[function](/syntax/basicgrammar#shell_function_definitions) to test how +[function](/syntax/basicgrammar.md#shell_function_definitions) to test how arguments to a command will be interpreted and parsed, and finally used: ``` bash @@ -138,7 +138,7 @@ done This is just an example. In *general* - it's not a good idea to parse `ls(1)` output -- the [while loop](/syntax/ccmd/while_loop) (using the `read` command) +- the [while loop](/syntax/ccmd/while_loop.md) (using the `read` command) is a better joice to iterate over lines ### Nested for-loops @@ -157,7 +157,7 @@ done ### Loop over a number range Beginning in Bash 4, you can also use "sequence expression" form of -[brace expansion](/syntax/expansion/brace) syntax when looping over +[brace expansion](/syntax/expansion/brace.md) syntax when looping over numbers, and this form does not create leading zeroes unless you ask for them: diff --git a/syntax/ccmd/grouping_plain.md b/syntax/ccmd/grouping_plain.md index 1071424..fea1c1b 100644 --- a/syntax/ccmd/grouping_plain.md +++ b/syntax/ccmd/grouping_plain.md @@ -10,14 +10,14 @@ ## Description -The [list](/syntax/basicgrammar#lists) `` is simply executed in +The [list](/syntax/basicgrammar.md#lists) `` is simply executed in the **current** shell environment. The list must be terminated with a **newline** or **semicolon**. For parsing reasons, the curly braces must be separated from `` by a **semicolon** and **blanks** if they're in the same line! [^1][^2] This is known as a **group command**. The return status is the [exit -status (exit code)](/scripting/basics#exit_codes) of the list. +status (exit code)](/scripting/basics.md#exit_codes) of the list. The input and output **filedescriptors** are cumulative: @@ -30,7 +30,7 @@ The input and output **filedescriptors** are cumulative: } >output.txt This compound command also usually is the body of a [function -definition](/syntax/basicgrammar#shell_function_definitions), though not +definition](/syntax/basicgrammar.md#shell_function_definitions), though not the only compound command that's valid there: print_help() { diff --git a/syntax/ccmd/grouping_subshell.md b/syntax/ccmd/grouping_subshell.md index 739940f..b187bd2 100644 --- a/syntax/ccmd/grouping_subshell.md +++ b/syntax/ccmd/grouping_subshell.md @@ -6,7 +6,7 @@ ## Description -The [list](/syntax/basicgrammar#lists) `` is executed in a +The [list](/syntax/basicgrammar.md#lists) `` is executed in a separate shell - a subprocess. No changes to the environment (variables etc...) are reflected in the "main shell". @@ -31,5 +31,5 @@ echo "$PWD" # Still in the original directory. ## See also -- [grouping commands](/syntax/ccmd/grouping_plain) +- [grouping commands](/syntax/ccmd/grouping_plain.md) - [Subshells on Greycat's wiki](http://mywiki.wooledge.org/SubShell) diff --git a/syntax/ccmd/if_clause.md b/syntax/ccmd/if_clause.md index 385cdd1..1d580ac 100644 --- a/syntax/ccmd/if_clause.md +++ b/syntax/ccmd/if_clause.md @@ -26,10 +26,10 @@ The `if`-clause can control the script's flow (what's executed) by looking at the exit codes of other commands. All commandsets `` are interpreted as [command -lists](/syntax/basicgrammar#lists), thus they can contain the whole -palette from [simple commands](/syntax/basicgrammar#simple_commands) -over [pipelines](/syntax/basicgrammar#pipelines) to [compound -commands](/syntax/basicgrammar#compound_commands) (and their +lists](/syntax/basicgrammar.md#lists), thus they can contain the whole +palette from [simple commands](/syntax/basicgrammar.md#simple_commands) +over [pipelines](/syntax/basicgrammar.md#pipelines) to [compound +commands](/syntax/basicgrammar.md#compound_commands) (and their combination) as condition. ### Operation @@ -88,4 +88,4 @@ example above (multiple commands): ## See also -- Internal: [the classic test command](/commands/classictest) +- Internal: [the classic test command](/commands/classictest.md) diff --git a/syntax/ccmd/intro.md b/syntax/ccmd/intro.md index c39a11a..36ff4dd 100644 --- a/syntax/ccmd/intro.md +++ b/syntax/ccmd/intro.md @@ -2,8 +2,8 @@ The main part of Bash's syntax are the so-called **compound commands**. They're called like that because they use "real" commands ([simple -commands](/syntax/basicgrammar#simple_commands) or -[lists](/syntax/basicgrammar#lists)) and knit some intelligence around +commands](/syntax/basicgrammar.md#simple_commands) or +[lists](/syntax/basicgrammar.md#lists)) and knit some intelligence around them. That is what the essential "Bash language" is made of. ## Command grouping @@ -14,7 +14,7 @@ them. That is what the essential "Bash language" is made of. ## Conditional reactions Note that conditionals can also be scripted using -[list](/syntax/basicgrammar#lists), which are syntax elements, not +[list](/syntax/basicgrammar.md#lists), which are syntax elements, not commands. - the "new" test command: [conditional diff --git a/syntax/ccmd/until_loop.md b/syntax/ccmd/until_loop.md index 3df78ff..86d401f 100644 --- a/syntax/ccmd/until_loop.md +++ b/syntax/ccmd/until_loop.md @@ -9,12 +9,12 @@ ## Description The until-loop is relatively simple in what it does: it executes the -[command list](/syntax/basicgrammar#lists) `` and if the exit +[command list](/syntax/basicgrammar.md#lists) `` and if the exit code of it was **not** 0 (FALSE) it executes ``. This happens again and again until `` returns TRUE. This is exactly the opposite of the [while -loop](/syntax/ccmd/while_loop). +loop](/syntax/ccmd/while_loop.md). :!: Like all loops (both `for`-loops, `while` and `until`), this loop can be @@ -35,4 +35,4 @@ or `0` (`TRUE`) if none was executed. ## See also -- Internal: [The while loop](/syntax/ccmd/while_loop) +- Internal: [The while loop](/syntax/ccmd/while_loop.md) diff --git a/syntax/ccmd/user_select.md b/syntax/ccmd/user_select.md index 5cbd17f..8625d4a 100644 --- a/syntax/ccmd/user_select.md +++ b/syntax/ccmd/user_select.md @@ -27,7 +27,7 @@ This compound command provides a kind of menu. The user is prompted with a *numbered list* of the given words, and is asked to input the index number of the word. If a word was selected, the variable `` is set -to this word, and the [list](/syntax/basicgrammar#lists) `` is +to this word, and the [list](/syntax/basicgrammar.md#lists) `` is executed. If no `in ` is given, then the positional parameters are taken as diff --git a/syntax/ccmd/while_loop.md b/syntax/ccmd/while_loop.md index 578a8f3..6d39156 100644 --- a/syntax/ccmd/while_loop.md +++ b/syntax/ccmd/while_loop.md @@ -9,12 +9,12 @@ ## Description The while-loop is relatively simple in what it does: it executes the -[command list](/syntax/basicgrammar#lists) `` and if the exit +[command list](/syntax/basicgrammar.md#lists) `` and if the exit code of it was 0 (TRUE) it executes ``. This happens again and again until `` returns FALSE. This is exactly the opposite of the [until -loop](/syntax/ccmd/until_loop). +loop](/syntax/ccmd/until_loop.md). :!: Like all loops (both `for`-loops, `while` and `until`), this loop can be @@ -35,7 +35,7 @@ or `0` (`TRUE`) if none was executed. ## See also -- Internal: [The until loop](/syntax/ccmd/until_loop) +- Internal: [The until loop](/syntax/ccmd/until_loop.md) - Internal: [code examples of the read builtin - command](/commands/builtin/read#code_examples) to see how you can loop + command](/commands/builtin/read.md#code_examples) to see how you can loop over lines diff --git a/syntax/expansion/arith.md b/syntax/expansion/arith.md index 6b60ef4..9583417 100644 --- a/syntax/expansion/arith.md +++ b/syntax/expansion/arith.md @@ -4,7 +4,7 @@ $[ ] -The [arithmetic expression](/syntax/arith_expr) `` is +The [arithmetic expression](/syntax/arith_expr.md) `` is evaluated and expands to the result. The output of the arithmetic expansion is guaranteed to be one word and a digit in Bash. @@ -29,7 +29,7 @@ function printSum { **Note** that in Bash you don't need the arithmetic expansion to check for the boolean value of an arithmetic expression. This can be done using the [arithmetic evaluation compound -command](/syntax/ccmd/arithmetic_eval): +command](/syntax/ccmd/arithmetic_eval.md): ``` bash printf %s 'Enter a number: ' >&2 @@ -66,8 +66,8 @@ echo $(($x[0])) # Error. This expands to $((1[0])), an invalid expression. ## See also -- [arithmetic expressions](/syntax/arith_expr) -- [arithmetic evaluation compound command](/syntax/ccmd/arithmetic_eval) -- [Introduction to expansion and substitution](/syntax/expansion/intro) +- [arithmetic expressions](/syntax/arith_expr.md) +- [arithmetic evaluation compound command](/syntax/ccmd/arithmetic_eval.md) +- [Introduction to expansion and substitution](/syntax/expansion/intro.md) - [POSIX definition](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_04) diff --git a/syntax/expansion/brace.md b/syntax/expansion/brace.md index 845099c..ff81afd 100644 --- a/syntax/expansion/brace.md +++ b/syntax/expansion/brace.md @@ -40,7 +40,7 @@ embedded inside a for loop : `for i in $(eval echo {$a..$b})` This requires that the entire command be properly escaped to avoid unexpected expansions. If the sequence expansion is to be assigned to an array, another method is possible using [declaration -commands](/commands/builtin/declare): +commands](/commands/builtin/declare.md): `declare -a 'pics=(img{'"$a..$b"'}.png)'; mv "${pics[@]}" ../imgs` This is significantly safer, but one must still be careful to control the values of \$a and \$b. Both the exact quoting, and explicitly diff --git a/syntax/expansion/cmdsubst.md b/syntax/expansion/cmdsubst.md index b35465e..544ef4f 100644 --- a/syntax/expansion/cmdsubst.md +++ b/syntax/expansion/cmdsubst.md @@ -14,8 +14,8 @@ All **trailing** newlines are removed (below is an example for a workaround). In later steps, **if not quoted**, the results undergo [word -splitting](/syntax/expansion/wordsplit) and [pathname -expansion](/syntax/expansion/globs). You have to remember that, because +splitting](/syntax/expansion/wordsplit.md) and [pathname +expansion](/syntax/expansion/globs.md). You have to remember that, because the word splitting will also remove embedded newlines and other `IFS` characters and break the results up into several words. Also you'll probably get unexpected pathname matches. **If you need the literal @@ -25,14 +25,14 @@ The second form `` `COMMAND` `` is more or less obsolete for Bash, since it has some trouble with nesting ("inner" backticks need to be escaped) and escaping characters. Use `$(COMMAND)`, it's also POSIX! -When you [call an explicit subshell](/syntax/ccmd/grouping_subshell) +When you [call an explicit subshell](/syntax/ccmd/grouping_subshell.md) `(COMMAND)` inside the command substitution `$()`, then take care, this way is **wrong**: $((COMMAND)) Why? because it collides with the syntax for [arithmetic -expansion](/syntax/expansion/arith). You need to separate the command +expansion](/syntax/expansion/arith.md). You need to separate the command substitution from the inner `(COMMAND)`: $( (COMMAND) ) @@ -133,5 +133,5 @@ output with its trailing newlines. ## See also - Internal: [Introduction to expansion and - substitution](/syntax/expansion/intro) -- Internal: [Obsolete and deprecated syntax](/scripting/obsolete) + substitution](/syntax/expansion/intro.md) +- Internal: [Obsolete and deprecated syntax](/scripting/obsolete.md) diff --git a/syntax/expansion/globs.md b/syntax/expansion/globs.md index a835395..6fbad18 100644 --- a/syntax/expansion/globs.md +++ b/syntax/expansion/globs.md @@ -11,16 +11,16 @@ expanded filenames as its arguments (here, all filenames matching grep "changes:" *.log The base syntax for the pathname expansion is the [pattern -matching](/syntax/pattern) syntax. The pattern you describe is matched +matching](/syntax/pattern.md) syntax. The pattern you describe is matched against all existing filenames and the matching ones are substituted. Since this substitution happens **after [word -splitting](/syntax/expansion/wordsplit)**, all resulting filenames are +splitting](/syntax/expansion/wordsplit.md)**, all resulting filenames are literal and treated as separate words, no matter how many spaces or other `IFS`-characters they contain. ## Normal behaviour -- with [the set command](/commands/builtin/set) (`-f`, `noglob`) you can +- with [the set command](/commands/builtin/set.md) (`-f`, `noglob`) you can entirely disable pathname expansion - when matching a pathname, the slash-character (`/`) always needs to be matched explicitly @@ -49,7 +49,7 @@ other `IFS`-characters they contain. globs (e.g. `[A-Z]`) use C locale order rather than the configured locale's order (i.e. `ABC...abc...` instead of e.g. `AaBbCc...`) - since 4.3-alpha -- the variable [GLOBIGNORE](/syntax/shellvars#GLOBIGNORE) can be set to +- the variable [GLOBIGNORE](/syntax/shellvars.md#GLOBIGNORE) can be set to a colon-separated list of patterns to be removed from the list before it is returned @@ -66,7 +66,7 @@ In this example, no files matched the pattern, so the glob was left intact (a literal asterisk, followed by dot-txt). This can be very annoying, for example when you drive a -[for-loop](/syntax/ccmd/classic_for) using the pathname expansion: +[for-loop](/syntax/ccmd/classic_for.md) using the pathname expansion: for filename in *.txt; do echo "=== BEGIN: $filename ===" @@ -106,8 +106,8 @@ followed by two numbers, followed by at least 3 more characters: ## See also -- [Introduction to expansion and substitution](/syntax/expansion/intro) -- [pattern matching syntax](/syntax/pattern) -- [the set builtin command](/commands/builtin/set) -- [the shopt builtin command](/commands/builtin/shopt) -- [list of shell options](/internals/shell_options) +- [Introduction to expansion and substitution](/syntax/expansion/intro.md) +- [pattern matching syntax](/syntax/pattern.md) +- [the set builtin command](/commands/builtin/set.md) +- [the shopt builtin command](/commands/builtin/shopt.md) +- [list of shell options](/internals/shell_options.md) diff --git a/syntax/expansion/intro.md b/syntax/expansion/intro.md index f87c980..08fc068 100644 --- a/syntax/expansion/intro.md +++ b/syntax/expansion/intro.md @@ -21,7 +21,7 @@ string "`$mystring`" to "`Hello world`", so that `echo` will only see After all these expansions and substitutions are done, all quotes that are not meant literally (i.e., [the quotes that marked contiguous -words](/syntax/quoting), as part of the shell syntax) are removed from +words](/syntax/quoting.md), as part of the shell syntax) are removed from the commandline text, so the called program won't see them. This step is called **quote-removal**. @@ -30,28 +30,28 @@ called **quote-removal**. Saw a possible expansion syntax but don't know what it is? Here's a small list. -- [Parameter expansion](/syntax/pe) (it has its own [overview - section](/syntax/pe#overview)) +- [Parameter expansion](/syntax/pe.md) (it has its own [overview + section](/syntax/pe.md#overview)) - `$WORD` - `${STUFF...}` -- [Pathname expansion](/syntax/expansion/globs) +- [Pathname expansion](/syntax/expansion/globs.md) - `*.txt` - `page_1?.html` -- [Arithmetic expansion](/syntax/expansion/arith) +- [Arithmetic expansion](/syntax/expansion/arith.md) - `$(( EXPRESSION ))` - `$[ EXPRESSION ]` -- [Command substitution](/syntax/expansion/cmdsubst) +- [Command substitution](/syntax/expansion/cmdsubst.md) - `$( COMMAND )` - `` ` COMMAND ` `` -- [Tilde expansion](/syntax/expansion/tilde) +- [Tilde expansion](/syntax/expansion/tilde.md) - `~` - `~+` - `~-` -- [Brace expansion](/syntax/expansion/brace) +- [Brace expansion](/syntax/expansion/brace.md) - `{X,Y,Z}` - `{X..Y}` - `{X..Y..Z}` -- [Process substitution](/syntax/expansion/proc_subst) +- [Process substitution](/syntax/expansion/proc_subst.md) - `<( COMMAND )` - `>( COMMAND )` @@ -64,25 +64,25 @@ splitting!). The order is (from first to last): -- [Brace expansion](/syntax/expansion/brace) -- [Tilde expansion](/syntax/expansion/tilde) +- [Brace expansion](/syntax/expansion/brace.md) +- [Tilde expansion](/syntax/expansion/tilde.md) - The following expansions happen at the same time, in a left-to-right fashion on the commandline (see below) - - [Parameter expansion](/syntax/pe) - - [Arithmetic expansion](/syntax/expansion/arith) - - [Command substitution](/syntax/expansion/cmdsubst) -- [Word splitting](/syntax/expansion/wordsplit) -- [Pathname expansion](/syntax/expansion/globs) + - [Parameter expansion](/syntax/pe.md) + - [Arithmetic expansion](/syntax/expansion/arith.md) + - [Command substitution](/syntax/expansion/cmdsubst.md) +- [Word splitting](/syntax/expansion/wordsplit.md) +- [Pathname expansion](/syntax/expansion/globs.md) -[Process substitution](/syntax/expansion/proc_subst) is performed -**simultaneously** with [parameter expansion](/syntax/pe), [command -substitution](/syntax/expansion/cmdsubst) and [arithmetic -expansion](/syntax/expansion/arith). It is only performed when the +[Process substitution](/syntax/expansion/proc_subst.md) is performed +**simultaneously** with [parameter expansion](/syntax/pe.md), [command +substitution](/syntax/expansion/cmdsubst.md) and [arithmetic +expansion](/syntax/expansion/arith.md). It is only performed when the underlying operating system supports it. -The 3 steps [parameter expansion](/syntax/pe), [arithmetic -expansion](/syntax/expansion/arith) and [command -substitution](/syntax/expansion/cmdsubst) happen at the same time in a +The 3 steps [parameter expansion](/syntax/pe.md), [arithmetic +expansion](/syntax/expansion/arith.md) and [command +substitution](/syntax/expansion/cmdsubst.md) happen at the same time in a left-to-right fashion on nthe commandline. This means i=1 diff --git a/syntax/expansion/proc_subst.md b/syntax/expansion/proc_subst.md index d4327a0..bff33bf 100644 --- a/syntax/expansion/proc_subst.md +++ b/syntax/expansion/proc_subst.md @@ -10,11 +10,11 @@ of a process (some sequence of commands) appear as a temporary file. >( ) Process substitution is performed **simultaneously** with [parameter -expansion](/syntax/pe), [command -substitution](/syntax/expansion/cmdsubst) and [arithmetic -expansion](/syntax/expansion/arith). +expansion](/syntax/pe.md), [command +substitution](/syntax/expansion/cmdsubst.md) and [arithmetic +expansion](/syntax/expansion/arith.md). -The [command list](/syntax/basicgrammar#lists) `` is executed and +The [command list](/syntax/basicgrammar.md#lists) `` is executed and its - standard output filedescriptor in the `<( ... )` form or @@ -127,7 +127,7 @@ echo "$counter files" This is the normal input file redirection `< FILE`, just that the `FILE` in this case is the result of process substitution. It's important to note that the space is required in order to disambiguate the syntax from -[here documents](/syntax/redirection#here_documents). +[here documents](/syntax/redirection.md#here_documents). ``` bash : < <(COMMAND) # Good. @@ -179,7 +179,7 @@ ${dev[${dev='dev[1>(${dev[dev]})]'}]} ## See also - Internal: [Introduction to expansion and - substitution](/syntax/expansion/intro) -- Internal: [Bash in the process tree](/scripting/processtree) + substitution](/syntax/expansion/intro.md) +- Internal: [Bash in the process tree](/scripting/processtree.md) (subshells) -- Internal: [Redirection](/syntax/redirection) +- Internal: [Redirection](/syntax/redirection.md) diff --git a/syntax/expansion/tilde.md b/syntax/expansion/tilde.md index 08cd80b..f638e5b 100644 --- a/syntax/expansion/tilde.md +++ b/syntax/expansion/tilde.md @@ -43,7 +43,7 @@ I don't know yet, if this is a bug or intended. | | --- | This way you can correctly use the tilde expansion in your -[PATH](/syntax/shellvars#PATH): +[PATH](/syntax/shellvars.md#PATH): PATH=~/mybins:~peter/mybins:$PATH @@ -69,7 +69,7 @@ operating system for the associated home directory for ``. To find the home directory of the current user (`~`), Bash has a precedence: -- expand to the value of [HOME](/syntax/shellvars#HOME) if it's defined +- expand to the value of [HOME](/syntax/shellvars.md#HOME) if it's defined - expand to the home directory of the user executing the shell (operating system) @@ -80,7 +80,7 @@ at least regarding tilde expansion. ~+ -This expands to the value of the [PWD](/syntax/shellvars#PWD) variable, +This expands to the value of the [PWD](/syntax/shellvars.md#PWD) variable, which holds the currect working directory: echo "CWD is $PWD" @@ -93,7 +93,7 @@ is equivalent to (note it **must** be a separate word!): ~- -This expands to the value of the [OLDPWD](/syntax/shellvars#OLDPWD) +This expands to the value of the [OLDPWD](/syntax/shellvars.md#OLDPWD) variable, which holds the previous working directory (the one before the last `cd`). If `OLDPWD` is unset (never changed the directory), it is not expanded. @@ -107,4 +107,4 @@ not expanded. ## See also - Internal: [Introduction to expansion and - substitution](/syntax/expansion/intro) + substitution](/syntax/expansion/intro.md) diff --git a/syntax/expansion/wordsplit.md b/syntax/expansion/wordsplit.md index d24933c..54c5536 100644 --- a/syntax/expansion/wordsplit.md +++ b/syntax/expansion/wordsplit.md @@ -5,9 +5,9 @@ FIXME to be continued! Word splitting occurs once any of the following expansions are done (and only then!) -- [Parameter expansion](/syntax/pe) -- [Command substitution](/syntax/expansion/cmdsubst) -- [Arithmetic expansion](/syntax/expansion/arith) +- [Parameter expansion](/syntax/pe.md) +- [Command substitution](/syntax/expansion/cmdsubst.md) +- [Arithmetic expansion](/syntax/expansion/arith.md) Bash will scan the results of these expansions for special `IFS` characters that mark word boundaries. This is only done on results that @@ -43,5 +43,5 @@ solely responsible. ## See also -- [Introduction to expansion and substitution](/syntax/expansion/intro) -- [Quoting and escaping](/syntax/quoting) +- [Introduction to expansion and substitution](/syntax/expansion/intro.md) +- [Quoting and escaping](/syntax/quoting.md) diff --git a/syntax/grammar/parser_exec.md b/syntax/grammar/parser_exec.md index 9490267..7f9bdfa 100644 --- a/syntax/grammar/parser_exec.md +++ b/syntax/grammar/parser_exec.md @@ -4,7 +4,7 @@ FIXME work in progress... ![](keywords>bash shell scripting syntax language behaviour executing execution) -Nearly everything in [Bash grammar](/syntax/basicgrammar) can be broken +Nearly everything in [Bash grammar](/syntax/basicgrammar.md) can be broken down to a "simple command". The only thing Bash has to expand, evaluate and execute is the simple command. @@ -27,16 +27,16 @@ the simple command **from left to right**): - variable assignments precede the command name and have the form `WORD=WORD` - redirections can appear anywhere in the simple command -2. The rest of the words are [expanded](/syntax/expansion/intro). If +2. The rest of the words are [expanded](/syntax/expansion/intro.md). If any words remain after expansion, the first word is taken to be the **name of the command** and the remaining words are the **arguments**. -3. [Redirections](/syntax/redirection) are performed. +3. [Redirections](/syntax/redirection.md) are performed. 4. The text after the `=` in each variable assignment undergoes [tilde - expansion](/syntax/expansion/tilde), [parameter - expansion](/syntax/pe), [command - substitution](/syntax/expansion/cmdsubst), [arithmetic - expansion](/syntax/expansion/arith), and quote removal before being + expansion](/syntax/expansion/tilde.md), [parameter + expansion](/syntax/pe.md), [command + substitution](/syntax/expansion/cmdsubst.md), [arithmetic + expansion](/syntax/expansion/arith.md), and quote removal before being assigned to the variable. If **no command name** results after expansion: @@ -119,6 +119,6 @@ FIXME to be continued ## See also -- Internal: [Redirection](/syntax/redirection) +- Internal: [Redirection](/syntax/redirection.md) - Internal: [Introduction to expansions and - substitutions](/syntax/expansion/intro) + substitutions](/syntax/expansion/intro.md) diff --git a/syntax/pattern.md b/syntax/pattern.md index 031553c..132f46c 100644 --- a/syntax/pattern.md +++ b/syntax/pattern.md @@ -4,14 +4,14 @@ A pattern is a **string description**. Bash uses them in various ways: -- [Pathname expansion](/syntax/expansion/globs) (Globbing - matching +- [Pathname expansion](/syntax/expansion/globs.md) (Globbing - matching filenames) - Pattern matching in [conditional - expressions](/syntax/ccmd/conditional_expression) -- [Substring removal](/syntax/pe#substring_removal) and [search and - replace](/syntax/pe#search_and_replace) in [Parameter - Expansion](/syntax/pe) -- Pattern-based branching using the [case command](/syntax/ccmd/case) + expressions](/syntax/ccmd/conditional_expression.md) +- [Substring removal](/syntax/pe.md#substring_removal) and [search and + replace](/syntax/pe.md#search_and_replace) in [Parameter + Expansion](/syntax/pe.md) +- Pattern-based branching using the [case command](/syntax/ccmd/case.md) The pattern description language is relatively easy. Any character that's not mentioned below matches itself. The `NUL` character may not @@ -75,7 +75,7 @@ Some simple examples using normal pattern matching: ## Extended pattern language -If you set the [shell option](/internals/shell_options) `extglob`, Bash +If you set the [shell option](/internals/shell_options.md) `extglob`, Bash understands some powerful patterns. A `` is one or more patterns, separated by the pipe-symbol (`PATTERN|PATTERN`). @@ -99,13 +99,13 @@ patterns, separated by the pipe-symbol (`PATTERN|PATTERN`). | option | classification | description | |-------------------|-------------------------------------|-------------------------------------------------------------------------------| -| `dotglob` | [globbing](/syntax/expansion/globs) | see [Pathname expansion customization](/syntax/expansion/globs#Customization) | +| `dotglob` | [globbing](/syntax/expansion/globs.md) | see [Pathname expansion customization](/syntax/expansion/globs.md#Customization) | | `extglob` | global | enable/disable extended pattern matching language, as described above | -| `failglob` | [globbing](/syntax/expansion/globs) | see [Pathname expansion customization](/syntax/expansion/globs#Customization) | -| `nocaseglob` | [globbing](/syntax/expansion/globs) | see [Pathname expansion customization](/syntax/expansion/globs#Customization) | +| `failglob` | [globbing](/syntax/expansion/globs.md) | see [Pathname expansion customization](/syntax/expansion/globs.md#Customization) | +| `nocaseglob` | [globbing](/syntax/expansion/globs.md) | see [Pathname expansion customization](/syntax/expansion/globs.md#Customization) | | `nocasematch` | pattern/string matching | perform pattern matching without regarding the case of individual letters | -| `nullglob` | [globbing](/syntax/expansion/globs) | see [Pathname expansion customization](/syntax/expansion/globs#Customization) | -| `globasciiranges` | [globbing](/syntax/expansion/globs) | see [Pathname expansion customization](/syntax/expansion/globs#Customization) | +| `nullglob` | [globbing](/syntax/expansion/globs.md) | see [Pathname expansion customization](/syntax/expansion/globs.md#Customization) | +| `globasciiranges` | [globbing](/syntax/expansion/globs.md) | see [Pathname expansion customization](/syntax/expansion/globs.md#Customization) | ## Bugs and Portability considerations diff --git a/syntax/pe.md b/syntax/pe.md index fab9034..653b6c5 100644 --- a/syntax/pe.md +++ b/syntax/pe.md @@ -9,7 +9,7 @@ is an entity that stores values and is referenced by a **name**, a **number** or a **special symbol**. - parameters referenced by a name are called **variables** (this also - applies to [arrays](/syntax/arrays)) + applies to [arrays](/syntax/arrays.md)) - parameters referenced by a number are called **positional parameters** and reflect the arguments given to a shell - parameters referenced by a **special symbol** are auto-set parameters @@ -25,7 +25,7 @@ check what it can be, try the overview section below! **Arrays** can be special cases for parameter expansion, every applicable description mentions arrays below. Please also see the -[article about arrays](/syntax/arrays). +[article about arrays](/syntax/arrays.md). For a more technical view what a parameter is and which types exist, [see the dictionary entry for "parameter"](/dict/terms/parameter). @@ -113,7 +113,7 @@ positional parameters (arguments to a script) beyond `$9`: ### Simple usage: Arrays -See also the [article about general array syntax](/syntax/arrays) +See also the [article about general array syntax](/syntax/arrays.md) For arrays you always need the braces. The arrays are expanded by individual indexes or mass arguments. An individual index behaves like a @@ -178,7 +178,7 @@ conflicts with ksh-like shells which have the more powerful "name-reference" form of indirection, where the exact same syntax is used to expand to the name of the variable being referenced. -Indirect references to [array names](/syntax/arrays) are also possible +Indirect references to [array names](/syntax/arrays.md) are also possible since the Bash 3 series (exact version unknown), but undocumented. See [syntax/arrays#indirection](syntax/arrays#indirection) for details. @@ -237,7 +237,7 @@ names or titles. Just assign it to an array: `declare -a title=(my hello world john smith)` -For [array](/syntax/arrays) expansion, the case modification applies to +For [array](/syntax/arrays.md) expansion, the case modification applies to **every expanded element, no matter if you expand an individual index or mass-expand** the whole array using `@` or `*` subscripts. Some examples: @@ -274,7 +274,7 @@ This will show all defined variable names (not values!) beginning with $ echo ${!BASH*} BASH BASH_ARGC BASH_ARGV BASH_COMMAND BASH_LINENO BASH_SOURCE BASH_SUBSHELL BASH_VERSINFO BASH_VERSION -This list will also include [array names](/syntax/arrays). +This list will also include [array names](/syntax/arrays.md). ## Substring removal @@ -289,7 +289,7 @@ This list will also include [array names](/syntax/arrays). This one can **expand only a part** of a parameter's value, **given a pattern to describe what to remove** from the string. The pattern is interpreted just like a pattern to describe a filename to match -(globbing). See [Pattern matching](/syntax/pattern) for more. +(globbing). See [Pattern matching](/syntax/pattern.md) for more. Example string (*just a quote from a big man*): @@ -299,7 +299,7 @@ Example string (*just a quote from a big man*): `${PARAMETER#PATTERN}` and `${PARAMETER##PATTERN}` -This form is to remove the described [pattern](/syntax/pattern) trying +This form is to remove the described [pattern](/syntax/pattern.md) trying to **match it from the beginning of the string**. The operator "`#`" will try to remove the shortest text matching the pattern, while "`##`" tries to do it with the longest text matching. Look at the following @@ -352,7 +352,7 @@ on your needs, you might need to adjust shortest/longest match. ### Substring removal: Arrays As for most parameter expansion features, working on -[arrays](/syntax/arrays) **will handle each expanded element**, for +[arrays](/syntax/arrays.md) **will handle each expanded element**, for individual expansion and also for mass expansion. Simple example, removing a trailing `is` from all array elements (on @@ -377,7 +377,7 @@ All other variants of this expansion behave the same. `${PARAMETER//PATTERN}` This one can substitute (*replace*) a substring [matched by a -pattern](/syntax/pattern), on expansion time. The matched substring will +pattern](/syntax/pattern.md), on expansion time. The matched substring will be entirely removed and the given string will be inserted. Again some example string for the tests: @@ -437,7 +437,7 @@ specifying an empty replacement: ### Search and replace: Arrays -This parameter expansion type applied to [arrays](/syntax/arrays) +This parameter expansion type applied to [arrays](/syntax/arrays.md) **applies to all expanded elements**, no matter if an individual element is expanded, or all elements using the mass expansion syntaxes. @@ -471,7 +471,7 @@ There's not much to say about it, mh? ### (String) length: Arrays -For [arrays](/syntax/arrays), this expansion type has two meanings: +For [arrays](/syntax/arrays.md), this expansion type has two meanings: - For **individual** elements, it reports the string length of the element (as for every "normal" parameter) @@ -506,7 +506,7 @@ is negative, it's taken as a second offset into the string, counting from the end of the string. `OFFSET` and `LENGTH` can be **any** [arithmetic -expression](/syntax/arith_expr). **Take care:** The `OFFSET` starts at +expression](/syntax/arith_expr.md). **Take care:** The `OFFSET` starts at 0, not at 1! Example string (a quote from a big man): @@ -543,7 +543,7 @@ the colon: ${MYSTRING:(-10):5} Why? Because it's interpreted as the parameter expansion syntax to [use -a default value](/syntax/pe#use_a_default_value). +a default value](/syntax/pe.md#use_a_default_value). ### Negative Length Value @@ -557,11 +557,11 @@ then: `Be liberal in what you accept, and conservative in what you send` This works since Bash 4.2-alpha, see also -[bashchanges](/scripting/bashchanges). +[bashchanges](/scripting/bashchanges.md). ### Substring/Element expansion: Arrays -For [arrays](/syntax/arrays), this expansion type has again 2 meanings: +For [arrays](/syntax/arrays.md), this expansion type has again 2 meanings: - For **individual** elements, it expands to the specified substring (as for every “normal” parameter) @@ -608,7 +608,7 @@ gender. Note that the default value is **used on expansion time**, it is ### Use a default value: Arrays -For [arrays](/syntax/arrays), the behaviour is very similar. Again, you +For [arrays](/syntax/arrays.md), the behaviour is very similar. Again, you have to make a difference between expanding an individual element by a given index and mass-expanding the array using the `@` and `*` subscripts. @@ -669,7 +669,7 @@ Example code (please try the example cases yourself): `${PARAMETER=WORD}` This one works like the [using default -values](/syntax/pe#use_a_default_value), but the default text you give +values](/syntax/pe.md#use_a_default_value), but the default text you give is not only expanded, but also **assigned** to the parameter, if it was unset or null. Equivalent to using a default value, when you omit the `:` (colon), as shown in the second form, the default value will only be @@ -691,7 +691,7 @@ Let's change our code example from above: ### Assign a default value: Arrays -For [arrays](/syntax/arrays) this expansion type is limited. For an +For [arrays](/syntax/arrays.md) this expansion type is limited. For an individual index, it behaves like for a "normal" parameter, the default value is assigned to this one element. The mass-expansion subscripts `@` and `*` **can not be used here** because it's not possible to assign to @@ -740,7 +740,7 @@ if variables you need (and that can be empty) are undefined: ### Use an alternate value: Arrays -Similar to the cases for [arrays](/syntax/arrays) to expand to a default +Similar to the cases for [arrays](/syntax/arrays.md) to expand to a default value, this expansion behaves like for a "normal" parameter when using individual array elements by index, but reacts differently when using the mass-expansion subscripts `@` and `*`: @@ -816,8 +816,8 @@ Removing the first 6 characters from a text string: `${arr[@]}`, `$*`, and `${arr[*]}` when [IFS](http://mywiki.wooledge.org/IFS) is set to null. POSIX is unclear about the expected behavior. A null IFS causes both [word - splitting](/syntax/expansion/wordsplit) and [pathname - expansion](/syntax/expansion/globs) to behave randomly. Since there + splitting](/syntax/expansion/wordsplit.md) and [pathname + expansion](/syntax/expansion/globs.md) to behave randomly. Since there are few good reasons to leave `IFS` set to null for more than the duration of a command or two, and even fewer to expand `$@` and `$*` unquoted, this should be a rare issue. **Always quote @@ -1040,5 +1040,5 @@ the difference may introduce a possible compatibility problem. ## See also - Internal: [Introduction to expansion and - substitution](/syntax/expansion/intro) -- Internal: [Arrays](/syntax/arrays) + substitution](/syntax/expansion/intro.md) +- Internal: [Arrays](/syntax/arrays.md) diff --git a/syntax/quoting.md b/syntax/quoting.md index 4e3d5a6..1787cff 100644 --- a/syntax/quoting.md +++ b/syntax/quoting.md @@ -71,14 +71,14 @@ below). Inside a weak-quoted string there's **no special interpretion of**: - spaces as word-separators (on inital command line splitting and on - [word splitting](/syntax/expansion/wordsplit)!) + [word splitting](/syntax/expansion/wordsplit.md)!) - single-quotes to introduce strong-quoting (see below) - characters for pattern matching - tilde expansion - pathname expansion - process substitution -Everything else, especially [parameter expansion](/syntax/pe), is +Everything else, especially [parameter expansion](/syntax/pe.md), is performed! ls -l "*" @@ -197,7 +197,7 @@ documentation](http://www.gnu.org/software/gettext/manual/html_node/bash.html) ### String lists in for-loops -The [classic for loop](/syntax/ccmd/classic_for) uses a list of words to +The [classic for loop](/syntax/ccmd/classic_for.md) uses a list of words to iterate through. The list can also be in a variable: mylist="DOG CAT BIRD HORSE" @@ -221,7 +221,7 @@ is seen as **one word**. The for loop iterates exactly one time, with ### Working out the test-command The command `test` or `[ ... ]` ([the classic test -command](/commands/classictest)) is an ordinary command, so ordinary +command](/commands/classictest.md)) is an ordinary command, so ordinary syntax rules apply. Let's take string comparison as an example: [ WORD = WORD ] @@ -259,13 +259,13 @@ Now the command has three parameters, which makes sense for a binary (two argument) operator. **Hint:** Inside the [conditional -expression](/syntax/ccmd/conditional_expression) (`[[ ]]`) Bash doesn't +expression](/syntax/ccmd/conditional_expression.md) (`[[ ]]`) Bash doesn't perform word splitting, and thus you don't need to quote your variable references - they are always seen as "one word". ## See also -- Internal: [Some words about words...](/syntax/words) -- Internal: [Word splitting](/syntax/expansion/wordsplit) +- Internal: [Some words about words...](/syntax/words.md) +- Internal: [Word splitting](/syntax/expansion/wordsplit.md) - Internal: [Introduction to expansions and - substitutions](/syntax/expansion/intro) + substitutions](/syntax/expansion/intro.md) diff --git a/syntax/redirection.md b/syntax/redirection.md index 1a653bd..219ff50 100644 --- a/syntax/redirection.md +++ b/syntax/redirection.md @@ -5,7 +5,7 @@ Redirection makes it possible to control where the output of a command goes to, and where the input of a command comes from. It's a mighty tool that, together with pipelines, makes the shell powerful. The redirection operators are checked whenever a [simple command is about to be -executed](/syntax/grammar/parser_exec). +executed](/syntax/grammar/parser_exec.md). Under normal circumstances, there are 3 files open, accessible by the file descriptors 0, 1 and 2, all connected to your terminal: @@ -79,7 +79,7 @@ This redirects the file descriptor number `N` to the target `TARGET`. If **truncated** before writing starts. If the option `noclobber` is set with [the set -builtin](/commands/builtin/set), with cause the redirection to fail, +builtin](/commands/builtin/set.md), with cause the redirection to fail, when `TARGET` names a regular file that already exists. You can manually override that behaviour by forcing overwrite with the redirection operator `>|` instead of `>`. @@ -108,7 +108,7 @@ Since Bash4, there's `&>>TARGET`, which is equivalent to \This syntax is deprecated and should not be used. See the page about [obsolete and deprecated -syntax](/scripting/obsolete).\ +syntax](/scripting/obsolete.md).\ ## Appending redirected output and error output @@ -160,9 +160,9 @@ used to mark the end of input later: As you see, substitutions are possible. To be precise, the following substitutions and expansions are performed in the here-document data: -- [Parameter expansion](/syntax/pe) -- [Command substitution](/syntax/expansion/cmdsubst) -- [Arithmetic expansion](/syntax/expansion/arith) +- [Parameter expansion](/syntax/pe.md) +- [Command substitution](/syntax/expansion/cmdsubst.md) +- [Arithmetic expansion](/syntax/expansion/arith.md) You can avoid that by quoting the tag: @@ -238,10 +238,10 @@ How to make a program quiet (assuming all output goes to `STDOUT` and ## See also - Internal: [Illustrated Redirection - Tutorial](/howto/redirection_tutorial) -- Internal: [The noclobber option](/commands/builtin/set#tag_noclobber) -- Internal: [The exec builtin command](/commands/builtin/exec) + Tutorial](/howto/redirection_tutorial.md) +- Internal: [The noclobber option](/commands/builtin/set.md#tag_noclobber) +- Internal: [The exec builtin command](/commands/builtin/exec.md) - Internal: [Simple commands parsing and - execution](/syntax/grammar/parser_exec) -- Internal: [Process substitution syntax](/syntax/expansion/proc_subst) -- Internal: [Obsolete and deprecated syntax](/scripting/obsolete) + execution](/syntax/grammar/parser_exec.md) +- Internal: [Process substitution syntax](/syntax/expansion/proc_subst.md) +- Internal: [Obsolete and deprecated syntax](/scripting/obsolete.md) diff --git a/syntax/shellvars.md b/syntax/shellvars.md index dcb6027..7eef3ce 100644 --- a/syntax/shellvars.md +++ b/syntax/shellvars.md @@ -15,7 +15,7 @@ * asterisk The positional parameters starting from the first. When used inside -doublequotes (see quoting), like +doublequotes (see quoting), like "$*", it expands to all positional parameters as one word, delimited by the first character of the IFS variable (a space in this example): "$1 $2 $3 $4".
@@ -26,26 +26,26 @@ delimiter.
When used unquoted, it will just expand to the strings, one by one, not preserving the word boundaries (i.e. word splitting will split the text again, if it contains IFS characters.
-See also the scripting article about +See also the scripting article about handling positional parameters. @ at-sign The positional parameters starting from the first. When used inside -doublequotes (see quoting), like +doublequotes (see quoting), like "$@", it expands all positional parameters as separate words: "$1" "$2" "$3" "$4"
Without doublequotes, the behaviour is like the one of * without doublequotes.
-See also the scripting article about +See also the scripting article about handling positional parameters. # hash mark Number of positional parameters (decimal)
-See also the scripting article about +See also the scripting article about handling positional parameters. @@ -58,7 +58,7 @@ handling positional parameters. - dash Current option flags set by the shell itself, on invocation, or -using the set builtin command. It's +using the set builtin command. It's just a set of characters, like himB for h, i, m and B. @@ -66,7 +66,7 @@ just a set of characters, like himB for h, $ dollar-sign The process ID (PID) of the shell. In an explicit subshell it expands +href="/syntax/ccmd/grouping_subshell.md">explicit subshell it expands to the PID of the current "main shell", not the subshell. This is different from $BASHPID! @@ -125,7 +125,7 @@ Bash. A colon-separated list of enabled shell options. Each word in the list is a valid argument for the `-s` option to the -[shopt builtin command](/commands/builtin/shopt). The options appearing +[shopt builtin command](/commands/builtin/shopt.md). The options appearing in `BASHOPTS` are those reported as on by `shopt`. If this variable is in the environment when Bash starts up, each shell option in the list will be enabled before reading any startup files. @@ -525,7 +525,7 @@ element of `FUNCNAME` has corresponding elements in `BASH_LINENO` and `BASH_SOURCE` to describe the call stack. For instance, `${FUNCNAME[$i]}` was called from the file `${BASH_SOURCE[$i+1]}` at line number `${BASH_LINENO[$i]}`. The [caller builtin -command](/commands/builtin/caller) displays the current call stack using +command](/commands/builtin/caller.md) displays the current call stack using this information. This variable exists only when a shell function is executing. @@ -626,7 +626,7 @@ Example content: | Set by Bash: | yes | Default: | n/a | An array variable created to hold the text read by the [mapfile builtin -command](/commands/builtin/mapfile) when no variable name is supplied. +command](/commands/builtin/mapfile.md) when no variable name is supplied. ### OLDPWD @@ -739,10 +739,10 @@ with `bind -x`. | Variable: | `REPLY` | Since: | unknown | |:-------------|:-----------------------------------------------------------|:-----------|:--------| | Type: | normal variable | Read-only: | no | -| Set by Bash: | only by the [read builtin command](/commands/builtin/read) | Default: | n/a | +| Set by Bash: | only by the [read builtin command](/commands/builtin/read.md) | Default: | n/a | Set to the line of input read by the [read builtin -command](/commands/builtin/read) when no arguments are supplied that +command](/commands/builtin/read.md) when no arguments are supplied that name target variables. ### SECONDS @@ -769,7 +769,7 @@ is subsequently reset. A colon-separated list of enabled shell options. Each word in the list is a valid argument for the `-o` option to the [set builtin -command](/commands/builtin/set). The options appearing in `SHELLOPTS` +command](/commands/builtin/set.md). The options appearing in `SHELLOPTS` are those reported as on by `set -o`. If this variable is in the environment when Bash starts up, each shell @@ -807,9 +807,9 @@ If this parameter is set when Bash is executing a shell script, its value is interpreted as a filename containing commands to initialize the shell, as in `~/.bashrc`. The value of `BASH_ENV` is subjected to -- [parameter expansion](/syntax/pe) -- [command substitution](/syntax/expansion/cmdsubst) -- [arithmetic expansion](/syntax/expansion/arith) +- [parameter expansion](/syntax/pe.md) +- [command substitution](/syntax/expansion/cmdsubst.md) +- [arithmetic expansion](/syntax/expansion/arith.md) before being interpreted as a file name. @@ -1060,7 +1060,7 @@ The home directory of the current user. The default argument for the [cd builtin command](/commands/builtin/cd). The value of this variable is also used when performing [tilde -expansion](/syntax/expansion/tilde). +expansion](/syntax/expansion/tilde.md). ### HOSTFILE @@ -1438,7 +1438,7 @@ A trailing newline is added when the format string is displayed. | Set by Bash: | no | Default: | n/a | If set to a value greater than zero, `TMOUT` is treated as the default -timeout for the [read builtin command](/commands/builtin/read). +timeout for the [read builtin command](/commands/builtin/read.md). The [select command](/commands/builtin/select) terminates if input does not arrive after `TMOUT` seconds when input is coming from a terminal. diff --git a/syntax/words.md b/syntax/words.md index 4d53676..a82e01a 100644 --- a/syntax/words.md +++ b/syntax/words.md @@ -89,7 +89,7 @@ take care of the spaces. But Bash also does another type of splitting. ## Word splitting For a more technical description, please read the [article about word -splitting](/syntax/expansion/wordsplit)! +splitting](/syntax/expansion/wordsplit.md)! The first kind of splitting is done to parse the command line into separate tokens. This is what was described above, it's a pure **command @@ -138,9 +138,9 @@ the command line"): | Word 1 | Word 2 | Word 3 | Word 4 | Word 5 | Word 6 | | `echo` | `The` | `file` | `is` | `named` | `$MYFILE` | -A [parameter/variable expansion](/syntax/pe) is part of that command +A [parameter/variable expansion](/syntax/pe.md) is part of that command line, Bash will perform the substitution, and the [word -splitting](/syntax/expansion/wordsplit) on the results: +splitting](/syntax/expansion/wordsplit.md) on the results: | Word splitting after substitution: | | | | | | | |------------------------------------|--------|--------|--------|---------|--------|------------| @@ -158,7 +158,7 @@ Now let's imagine we quoted `$MYFILE`, the command line now looks like: ***Bold Text*72i love this world**===== See also ===== -- Internal: [Quoting and character escaping](/syntax/quoting) -- Internal: [Word splitting](/syntax/expansion/wordsplit) +- Internal: [Quoting and character escaping](/syntax/quoting.md) +- Internal: [Word splitting](/syntax/expansion/wordsplit.md) - Internal: [Introduction to expansions and - substitutions](/syntax/expansion/intro) + substitutions](/syntax/expansion/intro.md) diff --git a/wishes.md b/wishes.md index 8abc5ea..2a3b6a7 100644 --- a/wishes.md +++ b/wishes.md @@ -46,7 +46,7 @@ bash I found here: - -> added to [the for-loop-article](/syntax/ccmd/classic_for) as example, +> added to [the for-loop-article](/syntax/ccmd/classic_for.md) as example, > but also made some critical comments; thanks --- Jan ### Getopts tutorial