TODO: Show some alternate usages involving
+functions and local variables for initialization.\
+
+## Examples
+
+### Simple counter
+
+A simple counter, the loop iterates 101 times (\"0\" to \"100\" are 101
+numbers -\> 101 runs!), and everytime the variable `x` is set to the
+current value.
+
+- It **initializes** `x = 0`
+- Before every iteration it **checks** if `x ≤ 100`
+- After every iteration it **changes** `x++`
+
+```{=html}
+
+```
+ for ((x = 0 ; x <= 100 ; x++)); do
+ echo "Counter: $x"
+ done
+
+### Stepping counter
+
+This is the very same counter (compare it to the simple counter example
+above), but the **change** that is made is a `x += 10`. That means, it
+will count from 0 to 100, but with a **step of 10**.
+
+ for ((x = 0 ; x <= 100 ; x += 10)); do
+ echo "Counter: $x"
+ done
+
+### Bits analyzer
+
+This example loops through the bit-values of a Byte, beginning from 128,
+ending at 1. If that bit is set in the `testbyte`, it prints \"`1`\",
+else \"`0`\" =\> it prints the binary representation of the `testbyte`
+value (8 bits).
+
+ #!/usr/bin/env bash
+ # Example written for http://wiki.bash-hackers.org/syntax/ccmd/c_for#bits_analyzer
+ # Based on TheBonsai's original.
+
+ function toBin {
+ typeset m=$1 n=2 x='x[(n*=2)>m]'
+ for ((x = x; n /= 2;)); do
+ printf %d $(( m & n && 1))
+ done
+ }
+
+ function main {
+ [[ $1 == +([0-9]) ]] || return
+ typeset result
+ if (( $(ksh -c 'printf %..2d $1' _ "$1") == ( result = $(toBin "$1") ) )); then
+ printf '%s is %s in base 2!\n' "$1" "$result"
+ else
+ echo 'Oops, something went wrong with our calculation.' >&2
+ exit 1
+ fi
+ }
+
+ main "${1:-123}"
+
+ # vim: set fenc=utf-8 ff=unix ft=sh :
+
+\
+
+ testbyte=123
+ for (( n = 128 ; n >= 1 ; n /= 2 )); do
+ if (( testbyte & n )); then
+ printf %d 1
+ else
+ printf %s 0
+ fi
+ done
+ echo
+
+\
+
+Why that one begins at 128 (highest value, on the left) and not 1
+(lowest value, on the right)? It\'s easier to print from left to
+right\...
+
+We arrive at 128 for `n` through the recursive arithmetic expression
+stored in `x`, which calculates the next-greatest power of 2 after `m`.
+To show that it works, we use ksh93 to double-check the answer, because
+it has a built-in feature for `printf` to print a representation of any
+number in an arbitrary base (up to 64). Very few languages have that
+ability built-in, even things like Python.
+
+### Up, down, up, down\...
+
+This counts up and down from `0` to `${1:-5}`, `${2:-4}` times,
+demonstrating more complicated arithmetic expressions with multiple
+variables.
+
+ for (( incr = 1, n=0, times = ${2:-4}, step = ${1:-5}; (n += incr) % step || (incr *= -1, --times);)); do
+ printf '%*s\n' "$((n+1))" "$n"
+ done
+
+\
\~ \$ bash \<(xclip -o) 1
+
+ 2
+ 3
+ 4
+ 5
+ 4
+ 3
+ 2
+
+1 0 1
+
+ 2
+ 3
+ 4
+ 5
+ 4
+ 3
+ 2
+
+1 \
+
+## Portability considerations
+
+- C-style for loops aren\'t POSIX. They are available in Bash, ksh93,
+ and zsh. All 3 have essentially the same syntax and behavior.
+- C-style for loops aren\'t available in mksh.
+
+## Bugs
+
+- *Fixed in 4.3*. ~~There appears to be a bug as of Bash 4.2p10 in
+ which command lists can\'t be distinguished from the for loop\'s
+ arithmetic argument delimiter (both semicolons), so command
+ substitutions within the C-style for loop expression can\'t contain
+ more than one command.~~
+
+## 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)
diff --git a/docs/syntax/ccmd/case.md b/docs/syntax/ccmd/case.md
new file mode 100644
index 0000000..06420d0
--- /dev/null
+++ b/docs/syntax/ccmd/case.md
@@ -0,0 +1,161 @@
+# The case statement
+
+## Synopsis
+
+ case
in
+ [(] ) ;; # or ;& or ;;& in Bash 4
+ [(] ) ;;
+ [(] | ) ;;
+ ...
+ [(] ) [;;]
+ esac
+
+## Description
+
+The `case`-statement can execute commands based on a [pattern
+matching](/syntax/pattern) decision. The word `` is matched
+against every pattern `` and on a match, the associated
+[list](/syntax/basicgrammar#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
+is optionally preceded by a `(`.
+
+Bash 4 introduces two new action terminators. The classic behavior using
+`;;` is to execute only the list associated with the first matching
+pattern, then break out of the `case` block. The `;&` terminator causes
+`case` to also execute the next block without testing its pattern. The
+`;;&` operator is like `;;`, except the case statement doesn\'t
+terminate after executing the associated list - Bash just continues
+testing the next pattern as though the previous pattern didn\'t match.
+Using these terminators, a `case` statement can be configured to test
+against all patterns, or to share code between blocks, for example.
+
+The word `` is expanded using *tilde*, *parameter* and *variable
+expansion*; *arithmetic*, *command* and *process substitution*; and
+*quote removal*. **No word splitting, brace, or pathname expansion is
+done**, which means you can leave expansions unquoted without problems:
+
+ var="test word"
+
+ case $var in
+ ...
+ esac
+
+This is similar to the behavior of the [conditional expression command
+(\"new test command\")](/syntax/ccmd/conditional_expression) (also no
+word splitting for expansions).
+
+Unlike the C-case-statement, only the matching list and nothing else is
+executed. If more patterns match the word, only the first match is
+taken. (**Note** the comment about Bash v4 changes above.)
+
+Multiple `|`-delimited patterns can be specified for a single block.
+This is a POSIX-compatable equivalent to the `@(pattern-list)` extglob
+construct.
+
+The `case` statement is one of the most difficult commands to indent
+clearly, and people frequently ask about the most \"correct\" style.
+Just do your best - there are many variations of indenting style for
+`case` and no real agreed-upon best practice.
+
+## Examples
+
+Another one of my stupid examples\...
+
+ printf '%s ' 'Which fruit do you like most?'
+ read -${BASH_VERSION+e}r fruit
+
+ case $fruit in
+ apple)
+ echo 'Mmmmh... I like those!'
+ ;;
+ banana)
+ echo 'Hm, a bit awry, no?'
+ ;;
+ orange|tangerine)
+ echo $'Eeeks! I don\'t like those!\nGo away!'
+ exit 1
+ ;;
+ *)
+ echo "Unknown fruit - sure it isn't toxic?"
+ esac
+
+Here\'s a practical example showing a common pattern involving a `case`
+statement. If the first argument is one of a valid set of alternatives,
+then perform some sysfs operations under Linux to control a video
+card\'s power profile. Otherwise, show a usage synopsis, and print the
+current power profile and GPU temperature.
+
+``` bash
+# Set radeon power management
+function clk {
+ typeset base=/sys/class/drm/card0/device
+ [[ -r ${base}/hwmon/hwmon0/temp1_input && -r ${base}/power_profile ]] || return 1
+
+ case $1 in
+ low|high|default)
+ printf '%s\n' "temp: $(<${base}/hwmon/hwmon0/temp1_input)C" "old profile: $(<${base}/power_profile)"
+ echo "$1" >${base}/power_profile
+ echo "new profile: $(<${base}/power_profile)"
+ ;;
+ *)
+ echo "Usage: $FUNCNAME [ low | high | default ]"
+ printf '%s\n' "temp: $(<${base}/hwmon/hwmon0/temp1_input)C" "current profile: $(<${base}/power_profile)"
+ esac
+}
+```
+
+A template for experiments with `case` logic, showing shared code
+between blocks using `;&`, and the non-short-circuiting `;;&` operator:
+
+``` bash
+#!/usr/bin/env bash
+
+f() {
+ local -a "$@"
+ local x
+
+ for x; do
+ case $x in
+ $1)
+ local "$x"'+=(1)' ;;&
+ $2)
+ local "$x"'+=(2)' ;&
+ $3)
+ local "$x"'+=(3)' ;;
+ $1|$2)
+ local "$x"'+=(4)'
+ esac
+ IFS=, local -a "$x"'=("${x}: ${'"$x"'[*]}")'
+ done
+
+ for x; do
+ echo "${!x}"
+ done
+}
+
+f a b c
+
+# output:
+# a: 1,4
+# b: 2,3
+# c: 3
+```
+
+## Portability considerations
+
+- Only the `;;` delimiter is specified by POSIX.
+- zsh and mksh use the `;|` control operator instead of Bash\'s `;;&`.
+ Mksh has `;;&` for Bash compatability (undocumented).
+- ksh93 has the `;&` operator, but no `;;&` or equivalent.
+- ksh93, mksh, zsh, and posh support a historical syntax where open
+ and close braces may be used in place of `in` and `esac`:
+ `case word { x) ...; };`. This is similar to the alternate form Bash
+ supports for its [for loops](syntax/ccmd/classic_for), but Bash
+ doesn\'t support this syntax for `case..esac`.
+
+## See also
+
+- [POSIX case conditional
+ construct](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_09_04_05)
diff --git a/docs/syntax/ccmd/classic_for.md b/docs/syntax/ccmd/classic_for.md
new file mode 100644
index 0000000..9490af8
--- /dev/null
+++ b/docs/syntax/ccmd/classic_for.md
@@ -0,0 +1,188 @@
+# The classic for-loop
+
+## Synopsis
+
+ for ; do
+
+ done
+
+ for in ; do
+
+ done
+
+alternative, historical and undocumented syntax [^1]
+
+ for ; {
+
+ }
+
+ for in ; {
+
+ }
+
+## Description
+
+For every word in ``, one iteration of the loop is performed and
+the variable `` is set to the current word. If no \"`in `\"
+is present to give an own word-list, then the positional parameters
+(`"$@"`) are used (the arguments to the script or function). In this
+case (and only in this case), the semicolon between the variable name
+and the `do` is optional.
+
+If you use the loop-variable inside the for-loop and it can contain
+spaces, you need to quote it, since normal word-splitting procedures
+apply.
+
+:!: Like all loops (both `for`-loops, `while` and `until`), this loop
+can be
+
+- terminated (broken) by the `break` command, optionally as `break N`
+ to break `N` levels of nested loops
+- forced to immediately do the next iteration using the `continue`
+ command, optionally as `continue N` analog to `break N`
+
+Bash knows an alternative syntax for the `for` loop, enclosing the loop
+body in `{...}` instead of `do ... done`:
+
+``` bash
+for x in 1 2 3
+{
+ echo $x
+}
+```
+
+This syntax is **not documented** and should not be used. I found the
+parser definitions for it in 1.x code, and in modern 4.x code. My guess
+is that it\'s there for compatiblity reasons. This syntax is not
+specified by POSIX(r).
+
+### Return status
+
+The return status is the one of the last command executed in `` or
+`0` (`TRUE`), if the item list `` evaluates to nothing (i.e.:
+\"is empty\"!).
+
+## Examples
+
+### Iterate over array elements
+
+With some array syntax (see [arrays](/syntax/arrays)) you can easily
+\"feed\" the for-loop to iterate over all elements in an array (by
+mass-expanding all elements):
+
+``` bash
+for element in "${myarray[@]}"; do
+ echo "Element: $element"
+done
+```
+
+Another way is to mass-expand all used indexes and access the array by
+index:
+
+``` bash
+for index in "${!myarray[@]}"; do
+ echo "Element[$index]: ${myarray[$index]}"
+done
+```
+
+### List positional parameters
+
+You can use this
+[function](/syntax/basicgrammar#shell_function_definitions) to test how
+arguments to a command will be interpreted and parsed, and finally used:
+
+``` bash
+argtest() {
+ n=1
+ for arg; do
+ echo "Argument $((n++)): \"$arg\""
+ done
+}
+```
+
+### Loop through a directory
+
+Since pathname expansion will expand all filenames to separate words,
+regardless of spaces, you can use the for-loop to iterate through
+filenames in a directory:
+
+``` bash
+for fn in *; do
+ if [ -h "$fn" ]; then
+ echo -n "Symlink: "
+ elif [ -d "$fn" ]; then
+ echo -n "Dir: "
+ elif [ -f "$fn" ]; then
+ echo -n "File: "
+ else
+ echo -n "Unknown: "
+ fi
+ echo "$fn"
+done
+```
+
+Stupid example, I know ;-)
+
+### Loop over lines of output
+
+To be complete: You can change the internal field separator (IFS) to a
+newline and thus make a for-loop iterating over lines instead of words:
+
+``` bash
+IFS=$'\n'
+for f in $(ls); do
+ echo $f
+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)
+ is a better joice to iterate over lines
+
+### Nested for-loops
+
+It\'s of course possible to use another for-loop as ``. Here,
+counting from 0 to 99 in a weird way:
+
+``` bash
+for x in 0 1 2 3 4 5 6 7 8 9; do
+ for y in 0 1 2 3 4 5 6 7 8 9; do
+ echo $x$y
+ done
+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
+numbers, and this form does not create leading zeroes unless you ask for
+them:
+
+``` bash
+# 100 numbers, no leading zeroes
+for x in {0..99}; do
+ echo $x
+done
+```
+
+``` bash
+# Every other number, width 3
+for x in {000..99..2}; do
+ echo $x
+done
+```
+
+WARNING: the entire list is created before looping starts. If your list
+is huge this may be an issue, but no more so than for a glob that
+expands to a huge list.
+
+## Portability considerations
+
+## See also
+
+- [c_for](/syntax/ccmd/c_for)
+
+[^1]:
diff --git a/docs/syntax/ccmd/conditional_expression.md b/docs/syntax/ccmd/conditional_expression.md
new file mode 100644
index 0000000..b1db4b5
--- /dev/null
+++ b/docs/syntax/ccmd/conditional_expression.md
@@ -0,0 +1,211 @@
+# The conditional expression
+
+## Synopsis
+
+ [[ ]]
+
+## Description
+
+The conditional expression is meant as the modern variant of the
+[classic test command](/commands/classictest). Since it is **not** a
+normal command, Bash doesn\'t need to apply the normal commandline
+parsing rules like recognizing `&&` as [command
+list](/syntax/basicgrammar#lists) operator.
+
+The testing features basically are the same (see the lists for [classic
+test command](/commands/classictest)), with some additions and
+extensions.
+
+ -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Operator Description
+ -------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------
+ `( )` Used to group expressions, to influence precedence of operators
+
+ ` && ` `TRUE` if ``**and**`` are `TRUE` (do **not** use `-a`!)
+
+ ` || ` `TRUE` if ``**or**`` is `TRUE` (do **not** use `-o`!)
+
+ ` == ` `` is checked against the pattern `` - `TRUE` on a match\
+ *But note¹, quoting the pattern forces a literal comparison.*
+
+ ` = ` equivalent to the `==` operator
+
+ ` != ` `` is checked against the pattern `` - `TRUE` on **no match**
+
+ ` =~ ` `` is checked against the [extended regular expression](https://en.wikipedia.org/wiki/Regular_expression#POSIX_extended) `` - `TRUE` on a match
+
+ See the [classic test operators](/commands/classictest#file_tests) Do **not** use the `test`-typical operators `-a` and `-o` for AND and OR.
+
+ See also [arithmetic comparisons](/syntax/arith_expr#comparisons) Using `(( ))`, the [arithmetic expression compound command](/syntax/ccmd/arithmetic_eval)
+ -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+When the `==` and `!=` operators are used, the string to the right of
+the operator is considered a pattern and matched according to the rules
+of [Pattern Matching](/syntax/pattern). If the shell option
+`nocasematch` is enabled, the match is performed without regard to the
+case of alphabetic characters.
+
+¹Any part of the pattern may be quoted to force it to be matched as a
+literal string.
+
+When the operators `<` and `>` are used (string collation order), the
+test happens using the current locale when the `compat` level is greater
+than \"40\".
+
+Operator precedence (highest =\> lowest):
+
+- `( )`
+- `! `
+- ` && `
+- ` || `
+
+Do **not** use the `test`-typical operators `-a` and `-o` for AND and
+OR, they are not known to the conditional expression. Instead, use the
+operators `&&` and `||`.
+
+### Word splitting
+
+[Word splitting](/syntax/expansion/wordsplit) and [pathname
+expansion](/syntax/expansion/globs) are not performed in the expression
+you give. That means, a variable containing spaces can be used without
+quoting:
+
+ sentence="Be liberal in what you accept, and conservative in what you send"
+ checkme="Be liberal in what you accept, and conservative in what you send"
+ if [[ $sentence == $checkme ]]; then
+ echo "Matched...!"
+ else
+ echo "Sorry, no match :-("
+ fi
+
+Compare that to the [classic test command](/commands/classictest), where
+word splitting is done (because it\'s a normal command, not something
+special):
+
+ sentence="Be liberal in what you accept, and conservative in what you send"
+ checkme="Be liberal in what you accept, and conservative in what you send"
+ if [ "$sentence" == "$checkme" ]; then
+ echo "Matched...!"
+ else
+ echo "Sorry, no match :-("
+ fi
+
+You need to quote that variable reference in the classic test command,
+since (due to the spaces) the word splitting will break it otherwise!
+
+### Regular Expression Matching
+
+Using the operator `=~`, the left hand side operand is matched against
+the **extended regular expression (ERE)** on the right hand side.
+
+This is consistent with matching against patterns: Every quoted part of
+the regular expression is taken literally, even if it contains regular
+expression special characters.
+
+Best practise is to put the regular expression to match against into a
+variable. This is to avoid shell parsing errors on otherwise valid
+regular expressions.
+
+ REGEX="^[[:upper:]]{2}[[:lower:]]*$"
+
+ # Test 1
+ STRING=Hello
+ if [[ $STRING =~ $REGEX ]]; then
+ echo "Match."
+ else
+ echo "No match."
+ fi
+ # ==> "No match."
+
+ # Test 2
+ STRING=HEllo
+ if [[ $STRING =~ $REGEX ]]; then
+ echo "Match."
+ else
+ echo "No match."
+ fi
+ # ==> "Match."
+
+The interpretation of quoted regular expression special characters can
+be influenced by setting the `compat31` and `compat32` shell options
+(`compat*` in general). See [shell_options](/internals/shell_options).
+
+#### The special BASH_REMATCH array variable
+
+An array variable whose members are assigned by the `=~` binary operator
+to the `[[` conditional command.
+
+The element with index 0 is the portion of the string matching the
+entire regular expression. The element with index n is the portion of
+the string matching the nth parenthesized subexpression.
+
+See [BASH_REMATCH](syntax/shellvars#bash_rematch).
+
+Example:
+
+ if [[ "The quick, red fox" =~ ^The\ (.*),\ (.*)\ fox$ ]]; then
+ echo "${BASH_REMATCH[0]} is ${BASH_REMATCH[1]} and ${BASH_REMATCH[2]}.";
+ fi
+
+ ==> The quick, red fox is quick and red.
+
+### Behaviour differences compared to the builtin test command
+
+As of Bash 4.1 alpha, the test primaries \'\<\' and \'\>\' (compare
+strings lexicographically) use the current locale settings, while the
+same primitives for the builtin test command don\'t. This leads to the
+following situation where they behave differently:
+
+ $ ./cond.sh
+ [[ ' 4' < '1' ]] --> exit 1
+ [[ 'step+' < 'step-' ]] --> exit 1
+ [ ' 4' \< '1' ] --> exit 0
+ [ 'step+' \< 'step-' ] --> exit 0
+
+It won\'t be aligned. The conditional expression continues to respect
+the locate, as introduced with 4.1-alpha, the builtin `test`/`[` command
+continues to behave differently.
+
+### Implicit arithmetic context
+
+When you use a numeric comparison, the arguments are evaluated as an
+arithmetic expression. The arithmetic expression must be quoted if it
+both contains whitespace and is not the result of an expansion.
+
+ [[ 'i=5, i+=2' -eq 3+4 ]] && echo true # prints true.
+
+## Examples
+
+## Portability considerations
+
+- `[[ ... ]]` functionality isn\'t specified by POSIX(R), though it\'s
+ a reserved word
+- Amongst the major \"POSIX-shell superset languages\" (for lack of a
+ better term) which do have `[[`, the test expression compound
+ command is one of the very most portable non-POSIX features. Aside
+ from the `=~` operator, almost every major feature is consistent
+ between Ksh88, Ksh93, mksh, Zsh, and Bash. Ksh93 also adds a large
+ number of unique pattern matching features not supported by other
+ shells including support for several different regex dialects, which
+ are invoked using a different syntax from Bash\'s `=~`, though `=~`
+ is still supported by ksh and defaults to ERE.
+- As an extension to POSIX ERE, most GNU software supports
+ backreferences in ERE, including Bash. According to POSIX, only BRE
+ is supposed to support them. This requires Bash to be linked against
+ glibc, so it won\'t necessarily work on all platforms. For example,
+ `$(m='(abc(def))(\1)(\2)'; [[ abcdefabcdefdef =~ $m ]]; printf '<%s> ' $? "${BASH_REMATCH[@]}" )`
+ will give `<0> `.
+- the `=~` (regex) operator was introduced in Bash 3.0, and its
+ behaviour changed in Bash 3.2: since 3.2, quoted strings and
+ substrings are matched as literals by default.
+- the behaviour of the `<` and `>` operators (string collation order)
+ has changed since Bash 4.0
+
+## See also
+
+- Internal: [pattern matching language](/syntax/pattern)
+- Internal: [the classic test command](/commands/classictest)
+- Internal: [the if-clause](/syntax/ccmd/if_clause)
+- [What is the difference between test, \[ and \[\[
+ ?](http://mywiki.wooledge.org/BashFAQ/031) - BashFAQ 31 - Greg\'s
+ wiki.
diff --git a/docs/syntax/ccmd/grouping_plain.md b/docs/syntax/ccmd/grouping_plain.md
new file mode 100644
index 0000000..070f6fb
--- /dev/null
+++ b/docs/syntax/ccmd/grouping_plain.md
@@ -0,0 +1,71 @@
+# Grouping commands
+
+## Synopsis
+
+ { ; }
+
+ {
+
+ }
+
+## Description
+
+The [list](/syntax/basicgrammar#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.
+
+The input and output **filedescriptors** are cumulative:
+
+ {
+ echo "PASSWD follows"
+ cat /etc/passwd
+ echo
+ echo "GROUPS follows"
+ cat /etc/group
+ } >output.txt
+
+This compound command also usually is the body of a [function
+definition](/syntax/basicgrammar#shell_function_definitions), though not
+the only compound command that\'s valid there:
+
+ print_help() {
+ echo "Options:"
+ echo "-h This help text"
+ echo "-f FILE Use config file FILE"
+ echo "-u USER Run as user USER"
+ }
+
+## Examples
+
+### A Try-Catch block
+
+ try_catch() {
+ { # Try-block:
+ eval "$@"
+ } ||
+ { # Catch-block:
+ echo "An error occurred"
+ return -1
+ }
+ }
+
+## Portability considerations
+
+## See also
+
+ * [[syntax:ccmd:grouping_subshell | grouping commands in a subshell]]
+
+[^1]: Actually any properly terminated compound command will work
+ without extra separator (also in some other shells), **example**:
+ `{ while sleep 1; do echo ZzZzzZ; done }` is valid. But this is not
+ documented, infact the documentation explicitly says that a
+ semicolon or a newline must separate the enclosed list. \-- thanks
+ `geirha` at Freenode
+
+[^2]: The main reason is the fact that in shell grammar, the curly
+ braces are not control operators but reserved words \-- TheBonsai
diff --git a/docs/syntax/ccmd/grouping_subshell.md b/docs/syntax/ccmd/grouping_subshell.md
new file mode 100644
index 0000000..5fa6dc9
--- /dev/null
+++ b/docs/syntax/ccmd/grouping_subshell.md
@@ -0,0 +1,35 @@
+# Grouping commands in a subshell
+
+## Synopsis
+
+ ( )
+
+## Description
+
+The [list](/syntax/basicgrammar#lists) `` is executed in a
+separate shell - a subprocess. No changes to the environment (variables
+etc\...) are reflected in the \"main shell\".
+
+## Examples
+
+Execute a command in a different directory.
+
+``` bash
+echo "$PWD"
+( cd /usr; echo "$PWD" )
+echo "$PWD" # Still in the original directory.
+```
+
+## Portability considerations
+
+- The subshell compound command is specified by POSIX.
+- Avoid ambiguous syntax.
+
+``` bash
+(((1+1))) # Equivalent to: (( (1+1) ))
+```
+
+## See also
+
+- [grouping commands](/syntax/ccmd/grouping_plain)
+- [Subshells on Greycat\'s wiki](http://mywiki.wooledge.org/SubShell)
diff --git a/docs/syntax/ccmd/if_clause.md b/docs/syntax/ccmd/if_clause.md
new file mode 100644
index 0000000..e6bed60
--- /dev/null
+++ b/docs/syntax/ccmd/if_clause.md
@@ -0,0 +1,91 @@
+# The if-clause
+
+## Synopsis
+
+ if ; then
+
+ fi
+
+ if ; then
+
+ else
+
+ fi
+
+ if ; then
+
+ elif ; then
+