format(docs): remove escaped 's character pairs

Author: coronary

docs/bash4.md

@@ -77,7 +77,7 @@ The `read` builtin command has some interesting new features.
 The `-t` option to specify a timeout value has been slightly tuned. It
 now accepts fractional values and the special value 0 (zero). When
 `-t 0` is specified, `read` immediately returns with an exit status
-indicating if there\'s data waiting or not. However, when a timeout is
+indicating if there's data waiting or not. However, when a timeout is
 given, and the `read` builtin times out, any partial data recieved up to
 the timeout is stored in the given variable, rather than lost. When a
 timeout is hit, `read` exits with a code greater than 128.

docs/commands/builtin/caller.md

@@ -59,7 +59,7 @@ f3
 
 ## Notes
 
--   `caller` produces no output unless used within a script that\'s run
+-   `caller` produces no output unless used within a script that's run
     from a real file. It isn\'t particularly useful for interactive use,
     but can be used to create a decent `die` function to track down
     errors in moderately complex scripts.
@@ -68,7 +68,7 @@ f3
     are available and a number of special parameters that give more
     detail than caller (e.g. BASH_ARG{C,V}). Tools such as
     [Bashdb](http://bashdb.sourceforge.net/) can assist in using some of
-    Bash\'s more advanced debug features.
+    Bash's more advanced debug features.
 -   The Bash manpage and help text specifies that the argument to
     `caller` is an \"expr\" (whatever that means). Only an integer is
     actually allowed, with no special interpretation of an

docs/commands/builtin/cd.md

@@ -13,7 +13,7 @@ The `cd` builtin command is used to change the current working directory
 -   to the given directory (`cd DIRECTORY`)
 -   to the previous working directory (`cd -`) as saved in the
     [OLDPWD](../../syntax/shellvars.md#OLDPWD) shell variable
--   to the user\'s home directory as specified in the
+-   to the user's home directory as specified in the
     [HOME](../../syntax/shellvars.md#HOME) environment variable (when used
     without a `DIRECTORY` argument)
 
@@ -30,7 +30,7 @@ is given or the shell is configured to do so (see the `-P` option of
   -------- ----------------------------------------------------
   `-L`     Follow symbolic links (default)
   `-P`     Do not follow symbolic links
-  `-@`     Browse a file\'s extended attributed, if supported
+  `-@`     Browse a file's extended attributed, if supported
 
 ### Exit status
 
@@ -41,7 +41,7 @@ is given or the shell is configured to do so (see the `-P` option of
 
 ## Examples
 
-### Change the working directory to the user\'s home directory
+### Change the working directory to the user's home directory
 
     cd
 

docs/commands/builtin/declare.md

@@ -22,7 +22,7 @@ variable.
 When used in a function, `declare` makes `NAMEs` local variables, unless
 used with the `-g` option.
 
-Don\'t use it\'s synonym `typeset` when coding for Bash, since it\'s
+Don\'t use it's synonym `typeset` when coding for Bash, since it's
 tagged as obsolete.
 
 ### Options
@@ -52,7 +52,7 @@ Below, `[-+]X` indicates an attribute, use `-X` to set the attribute,
   `[-+]n`   make NAME a reference to the variable named by its value. Introduced in Bash 4.3-alpha.\
             \'\' \${!NAME}\'\' reveals the reference variable name, VALUE.\
             Use `unset -n NAME` to unset the variable. (`unset -v NAME` unsets the VALUE variable.)\
-            Use `[[ -R NAME ]]` to test if NAME has been set to a VALUE, another variable\'s name.
+            Use `[[ -R NAME ]]` to test if NAME has been set to a VALUE, another variable's name.
 
   `-p`      display the attributes and value of each NAME
 
@@ -156,9 +156,9 @@ a=(1 2 3); b=(6 5 4); c=(2 4 6) sum total a b c printf \'Final value of
 \"total\" is: %d\\n\' \"\$total\" \</div\>
 
 `typeset -n` is currently implemented in ksh93, mksh, and Bash 4.3. Bash
-and mksh\'s implementations are quite similar, but much different from
-ksh93\'s. See [Portability considerations](#portability_considerations)
-for details. ksh93 namerefs are much more powerful than Bash\'s.
+and mksh's implementations are quite similar, but much different from
+ksh93's. See [Portability considerations](#portability_considerations)
+for details. ksh93 namerefs are much more powerful than Bash's.
 
 ## Portability considerations
 

docs/commands/builtin/echo.md

@@ -6,7 +6,7 @@
 
 ## Description
 
-`echo` outputs it\'s args to stdout, separated by spaces, followed by a
+`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.md) option `xpg_echo` is set, Bash
 dynamically determines whether echo should expand escape characters

docs/commands/builtin/eval.md

@@ -168,7 +168,7 @@ identical to those of [let](../../commands/builtin/let.md).
     eval](http://mywiki.wooledge.org/BashFAQ/006#Assigning_indirect.2BAC8-reference_variables)
 -   [More indirection via
     eval](http://fvue.nl/wiki/Bash:_Passing_variables_by_reference)
--   [Martin Väth\'s \"push\"](https://github.com/vaeth/push) \--
+-   [Martin Väth's \"push\"](https://github.com/vaeth/push) \--
     `printf %q` work-alike for POSIX.
 -   [The \"magic alias\"
     hack](http://www.chiark.greenend.org.uk/~sgtatham/aliases.html)

docs/commands/builtin/let.md

@@ -44,8 +44,8 @@ command](../../syntax/ccmd/arithmetic_eval.md):
 \<WRAP info\> Remember that inside arithmetic evaluation contexts, all
 other expansions are processed as usual (from left-to-right), and the
 resulting text is evaluated as an arithmetic expression. Arithmetic
-already has a way to control precedence using parentheses, so it\'s very
-rare to need to nest arithmetic expansions within one another. It\'s
+already has a way to control precedence using parentheses, so it's very
+rare to need to nest arithmetic expansions within one another. It's
 used above only to illustrate how this precedence works. \</WRAP\>
 
 Unlike `((`, being a simple command `let` has its own environment. In
@@ -87,10 +87,10 @@ needed.
     is more \"standard\" than `let`, the above should always be
     preferred. Both [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
+    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 recognizes as a separate word and then concatenates
-    them into a single expression that\'s evaluated according to it\'s
+    them into a single expression that's evaluated according to it's
     own rules (which differ from shell arithmetic). `let` parses each
     word it recieves on its own and evaluates it as an expression
     without generating any output other than a return code.

docs/commands/builtin/local.md

@@ -48,7 +48,7 @@ way, and takes all the same options, with 3 exceptions:
     variables follow roughly
     [lexical-scoping](http://community.schemewiki.org/?lexical-scope),
     except that functions themselves don\'t have scope, just like Bash.
-    This means that even functions defined within a \"function\'s
+    This means that even functions defined within a \"function's
     scope\" don\'t have access to non-local variables except through
     `namerefs`.
 

docs/commands/builtin/mapfile.md

@@ -29,7 +29,7 @@ given array `ARRAY` is set readonly.
   `-t`            Remove any trailing newline from a line read, before it is assigned to an array element.
   `-u FD`         Read from filedescriptor `FD` rather than standard input.
 
-While `mapfile` isn\'t a common or portable shell feature, it\'s
+While `mapfile` isn\'t a common or portable shell feature, it's
 functionality will be familiar to many programmers. Almost all
 programming languages (aside from shells) with support for compound
 datatypes like arrays, and which handle open file objects in the
@@ -43,13 +43,13 @@ use.
 
 ## Examples
 
-Here\'s a real-world example of interactive use borrowed from Gentoo
+Here's a real-world example of interactive use borrowed from Gentoo
 workflow. Xorg updates require rebuilding drivers, and the
-Gentoo-suggested command is less than ideal, so let\'s Bashify it. The
+Gentoo-suggested command is less than ideal, so let's Bashify it. The
 first command produces a list of packages, one per line. We can read
 those into the array named \"args\" using `mapfile`, stripping trailing
 newlines with the \'-t\' option. The resulting array is then expanded
-into the arguments of the \"emerge\" command - an interface to Gentoo\'s
+into the arguments of the \"emerge\" command - an interface to Gentoo's
 package manager. This type of usage can make for a safe and effective
 replacement for xargs(1) in certain situations. Unlike xargs, all
 arguments are guaranteed to be passed to a single invocation of the
@@ -59,13 +59,13 @@ business.
     # eix --only-names -IC x11-drivers | { mapfile -t args; emerge -av1 "${args[@]}" <&1; }
 
 Note the use of command grouping to keep the emerge command inside the
-pipe\'s subshell and within the scope of \"args\". Also note the unusual
+pipe's subshell and within the scope of \"args\". Also note the unusual
 redirection. This is because the -a flag makes emerge interactive,
 asking the user for confirmation before continuing, and checking with
 isatty(3) to abort if stdin isn\'t pointed at a terminal. Since stdin of
 the entire command group is still coming from the pipe even though
 mapfile has read all available input, we just borrow FD 1 as it just so
-happens to be pointing where we want it. More on this over at greycat\'s
+happens to be pointing where we want it. More on this over at greycat's
 wiki: <http://mywiki.wooledge.org/BashFAQ/024>
 
 ### The callback
@@ -209,7 +209,7 @@ each subsequent 2 iterations. The RETURN trap is unimportant.
 
 ## To Do
 
--   Create an implementation as a shell function that\'s portable
+-   Create an implementation as a shell function that's portable
     between Ksh, Zsh, and Bash (and possibly other bourne-like shells
     with array support).
 
@@ -218,4 +218,4 @@ each subsequent 2 iterations. The RETURN trap is unimportant.
 -   [arrays](../../syntax/arrays.md)
 -   [read](../../commands/builtin/read.md) - If you don\'t know about this yet,
     why are you reading this page?
--   <http://mywiki.wooledge.org/BashFAQ/001> - It\'s FAQ 1 for a reason.
+-   <http://mywiki.wooledge.org/BashFAQ/001> - It's FAQ 1 for a reason.

docs/commands/builtin/printf.md

@@ -23,7 +23,7 @@ POSIX(r) recommends that `printf` is preferred over `echo`.
 ## General
 
 The `printf` command provides a method to print preformatted text
-similar to the `printf()` system interface (C function). It\'s meant as
+similar to the `printf()` system interface (C function). It's meant as
 successor for `echo` and has far more features and possibilities.
 
 Beside other reasons, POSIX(r) has a very good argument to recommend it:
@@ -164,7 +164,7 @@ introductory `%` and the character that specifies the format:
 
   Field output format   
   --------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-  `<N>`                 **Any number**: Specifies a **minimum field width**, if the text to print is shorter, it\'s padded with spaces, if the text is longer, the field is expanded
+  `<N>`                 **Any number**: Specifies a **minimum field width**, if the text to print is shorter, it's padded with spaces, if the text is longer, the field is expanded
   `.`                   **The dot**: Together with a field width, the field is **not** expanded when the text is longer, the text is truncated instead. \"`%.s`\" is an undocumented equivalent for \"`%.0s`\", which will force a field width of zero, effectively hiding the field from output
   `*`                   **The asterisk**: the width is given as argument before the string or number. Usage (the \"`*`\" corresponds to the \"`20`\"): `printf "%*s\n" 20 "test string"`
   `#`                   \"Alternative format\" for numbers: see table below
@@ -178,8 +178,8 @@ introductory `%` and the character that specifies the format:
 
   Alternative Format                                 
   -------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------
-  `%#o`                                              The octal number is printed with a leading zero, unless it\'s zero itself
-  `%#x`, `%#X`                                       The hex number is printed with a leading \"`0x`\"/\"`0X`\", unless it\'s zero
+  `%#o`                                              The octal number is printed with a leading zero, unless it's zero itself
+  `%#x`, `%#X`                                       The hex number is printed with a leading \"`0x`\"/\"`0X`\", unless it's zero
   `%#g`, `%#G`                                       The float number is printed with **trailing zeros** until the number of digits for the current precision is reached (usually trailing zeros are not printed)
   all number formats except `%d`, `%o`, `%x`, `%X`   Always print a decimal point in the output, even if no digits follow it
 
@@ -382,7 +382,7 @@ readability.
     use `%c`, you\'re actually asking for the first byte of the
     argument. Likewise, the maximum field width modifier (dot) in
     combination with `%s` goes by bytes, not characters. This limits
-    some of printf\'s functionality to working with ascii only. ksh93\'s
+    some of printf's functionality to working with ascii only. ksh93's
     `printf` supports the `L` modifier with `%s` and `%c` (but so far
     not `%S` or `%C`) in order to treat precision as character width,
     not byte count. zsh appears to adjust itself dynamically based upon
@@ -409,7 +409,7 @@ fmt++;
 -   mksh has no built-in printf by default (usually). There is an
     unsupported compile-time option to include a very poor, basically
     unusable implementation. For the most part you must rely upon the
-    system\'s `/usr/bin/printf` or equivalent. The mksh maintainer
+    system's `/usr/bin/printf` or equivalent. The mksh maintainer
     recommends using `print`. The development version (post- R40f) adds
     a new parameter expansion in the form of `${name@Q}` which fills the
     role of `printf %q` \-- expanding in a shell-escaped format.
@@ -418,7 +418,7 @@ fmt++;
 <!-- -->
 ```
 -   ksh93 optimizes builtins run from within a command substitution and
-    which have no redirections to run in the shell\'s process. Therefore
+    which have no redirections to run in the shell's process. Therefore
     the `printf -v` functionality can be closely matched by
     `var=$(printf ...)` without a big performance hit.
 
@@ -447,8 +447,8 @@ fmt++;
 
 -   The optional Bash loadable `print` may be useful for ksh
     compatibility and to overcome some of
-    [echo](../../commands/builtin/echo.md)\'s portability pitfalls. Bash, ksh93,
-    and zsh\'s `print` have an `-f` option which takes a `printf` format
+    [echo](../../commands/builtin/echo.md)'s portability pitfalls. Bash, ksh93,
+    and zsh's `print` have an `-f` option which takes a `printf` format
     string and applies it to the remaining arguments. Bash lists the
     synopsis as:
     `print: print [-Rnprs] [-u unit] [-f format] [arguments]`. However,
@@ -472,5 +472,5 @@ fmt++;
     function](http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html)
 -   [Code snip: Print a horizontal
     line](../../snipplets/print_horizontal_line.md) uses some `printf` examples
--   [Greg\'s BashFAQ 18: How can I use numbers with leading zeros in a
+-   [Greg's BashFAQ 18: How can I use numbers with leading zeros in a
     loop, e.g., 01, 02?](BashFAQ>018)

docs/commands/builtin/read.md

@@ -43,7 +43,7 @@ line is read). That means the timeout can occur during input, too.
   ---------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
   `-a <ARRAY>`     read the data word-wise into the specified array `<ARRAY>` instead of normal variables
   `-d <DELIM>`     recognize `<DELIM>` as data-end, rather than `<newline>`
-  `-e`             on interactive shells: use Bash\'s readline interface to read the data. Since version 5.1-alpha, this can also be used on specified file descriptors using `-u`
+  `-e`             on interactive shells: use Bash's readline interface to read the data. Since version 5.1-alpha, this can also be used on specified file descriptors using `-u`
   `-i <STRING>`    preloads the input buffer with text from `<STRING>`, only works when Readline (`-e`) is used
   `-n <NCHARS>`    reads `<NCHARS>` characters of input, then quits
   `-N <NCHARS>`    reads `<NCHARS>` characters of input, *ignoring any delimiter*, then quits
@@ -56,7 +56,7 @@ line is read). That means the timeout can occur during input, too.
 When both, `-a <ARRAY>` and a variable name `<NAME>` is given, then the
 array is set, but not the variable.
 
-Of course it\'s valid to set individual array elements without using
+Of course it's valid to set individual array elements without using
 `-a`:
 
     read MYARRAY[5]
@@ -99,7 +99,7 @@ array name and index:
 Essentially all you need to know about `-r` is to **ALWAYS** use it. The
 exact behavior you get without `-r` is completely useless even for weird
 purposes. It basically allows the escaping of input which matches
-something in IFS, and also escapes line continuations. It\'s explained
+something in IFS, and also escapes line continuations. It's explained
 pretty well in the [POSIX
 read](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/read.html#tag_20_109)
 spec.
@@ -141,7 +141,7 @@ some baskslash-escapes or switches (like `-n`).
 
 ### Press any key\...
 
-Remember the MSDOS `pause` command? Here\'s something similar:
+Remember the MSDOS `pause` command? Here's something similar:
 
     pause() {
       local dummy

docs/commands/builtin/shift.md

@@ -77,7 +77,7 @@ maintainer refuses to change either the `shift` or `command` builtins.~~
 [Fixed](https://github.com/MirBSD/mksh/commit/996e05548ab82f7ef2dea61f109cc7b6d13837fa).
 (Thanks!)
 
--   Perhaps almost as bad as the above, busybox sh\'s `shift` always
+-   Perhaps almost as bad as the above, busybox sh's `shift` always
     returns success, even when attempting to shift beyond the final
     argument. \<code\> \$ bb -c \'f() { if shift; then echo \"\$1\";
     else echo \"no args\"; fi; }; f\'

docs/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.md) 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