diff options
Diffstat (limited to 'tcsh.html.markdown')
| -rw-r--r-- | tcsh.html.markdown | 790 |
1 files changed, 790 insertions, 0 deletions
diff --git a/tcsh.html.markdown b/tcsh.html.markdown new file mode 100644 index 00000000..a95a84b0 --- /dev/null +++ b/tcsh.html.markdown @@ -0,0 +1,790 @@ +--- +language: tcsh +filename: LearnTCSH.csh +contributors: + - ["Nicholas Christopoulos", "https://github.com/nereusx"] +lang: en +--- +tcsh ("tee-see-shell") is a Unix shell based on and compatible with the C shell (csh). +It is essentially the C shell with programmable command-line completion, command-line editing, +and a few other features. +It is the native root shell for BSD-based systems such as FreeBSD. + +Almost all Linux distros and BSD today use tcsh instead of the original csh. In +most cases csh is a symbolic link that points to tcsh. +This is because tcsh is backward compatible with csh, and the last +is not maintained anymore. + +- [TCSH Home](http://www.tcsh.org/) +- [TCSH Wikipedia](https://en.wikipedia.org/wiki/Tcsh) +- [TCSH manual page](http://www.tcsh.org/tcsh.html/top.html) +- [“An Introduction to the C shell”, William Joy](https://docs.freebsd.org/44doc/usd/04.csh/paper.html) +- [TCSH Bug reports and/or features requests](https://bugs.gw.com/) + +Some more files: +[tcsh help command (for 132x35 terminal size)](https://github.com/nereusx/dotfiles/blob/master/csh-help), +[my ~/.tcshrc](https://github.com/nereusx/dotfiles/blob/master/.tcshrc) + +```tcsh +#!/bin/tcsh +# First line of the script is shebang which tells the system how to execute the +# script: http://en.wikipedia.org/wiki/Shebang_(Unix) +# TCSH emulates the shebang on systems which don't understand it. + +# In most cases you'll use `#!/bin/tcsh -f', because `-f' option does not load +# any resource or start-up files, or perform any command hashing, and thus +# starts faster. + +# --- the echo command -------------------------------------------------------- +# The `echo' writes each word to the shell's standard output, separated by +# spaces and terminated with a newline. The echo_style shell variable may be +# set to emulate (or not) the flags and escape sequences. + +# Display the value of echo_style +echo $echo_style + +# Enable `echo' to support backslashed characters and `-n' option (no new line) +# This is the default for tcsh, but your distro may change it. Slackware has +# done so. +set echo_style = both + +# Prints "Hello world" +echo Hello world +echo "Hello world" +echo 'Hello world' +echo `echo Hello world` + +# This prints "twonlines" in one line +echo two\nlines + +# Prints the two lines +echo "two\nlines" +echo 'two\nlines' + +# --- Basic Syntax ------------------------------------------------------------ + +# A special character (including a blank or tab) may be prevented from having +# its special meaning by preceding it with a backslash `\'. +# this will display the last history commands +echo !! +# this will not +echo \!\! + +# Single quotes prevents expanding special characters too, but some +# characters like `!' and backslash have higher priority +# `$' (variable value) will not expands +echo '$1 tip' +# `!' (history) will expands +echo '!!' + +# Strings enclosed by back-quotes will be executed and replaced by the result. +echo `ls` + +# Semi-colon separate commands +echo 'first line'; echo 'second line' + +# There is also conditional execution +echo "Always executed" || echo "Only executed if first command fails" +echo "Always executed" && echo "Only executed if first command does NOT fail" + +# Parenthesised commands are always executed in a subshell, + +# example: create a project and then informs you that it finished while +# it does the installation. +make && ( espeak "BOSS, compilation finished"; make install ) + +# prints the home directory but leaving you where you were +(cd; pwd); pwd + +# Read tcsh man-page documentation +man tcsh + +# --- Variables --------------------------------------------------------------- +# The shell maintains a list of variables, each of which has as value a list of +# zero or more words. The values of shell variables can be displayed and +# changed with the `set' and `unset' commands. +# The system maintains its own list of ``environment'' variables. +# These can be displayed and changed with `printenv', `setenv' and `unsetenv'. +# The syntax of setenv is similar to POSIX sh. + +# Assign a value or nothing will create a variable +# Assign nothing +set var +# Assign a numeric value +# the '@' denotes the expression is arithmetic; it works similar to 'set' but +# the right value can be a numeric expression. +@ var = 1 + 2 +# Assign a string value +set var = "Hello, I am the contents of 'var' variable" +# Assign the output of a program +set var = `ls` + +# Remove a variable +unset var +# Prints 1 (true) if the variable `var' exists otherwise prints 0 (false) +echo $?var +# Print all variables and their values +set + +# Prints the contents of 'var' +echo $var; +echo "$var"; +# Prints the string `$var' +echo \$var +echo '$var' +# braces can be used to separate variable from the rest when its needed +set num = 12; echo "There ${num}th element" + +# Prints the number of characters of the value: 6 +set var = '123456'; echo $%var + +### LISTs +# Assign a list of values +set var = ( one two three four five ) +# Print all the elements: one two three four five +echo $var +echo $var[*] +# Print the count of elements: 5 +echo $#var +# Print indexed element; prints the second element: two +echo $var[2] +# Print range of elements; prints 2nd up to 3rd: two, three +echo $var[2-3] +# Prints all elements starting from the 3rd: three four five +echo $var[3-] +# Prints print all up to 3rd element: one two three +echo $var[-3] + +### Special Variables +# $argv list of command-line arguments +# $argv[0] this file-name (the file of the script file) +# $# $0, $n, $* are the same as $#argv, $argv[0], $argv[n], $argv[*] +# $status, $? the exit code of the last command that executed +# $_ the previous command line +# $! the PID of the last background process started by this shell +# $$ script's PID + +# $path, $PATH the list of directories that will search for executable to run +# $home, $HOME user's home directory, also the `~' can be used instead +# $uid user's login ID +# $user user's login name +# $gid the user's group ID +# $group the user's group-name +# $cwd, $PWD the Current/Print Working Directory +# $owd the previous working directory +# $tcsh tcsh version +# $tty the current tty; ttyN for linux console, pts/N for terminal +# emulators under X +# $term the terminal type +# $verbose if set, causes the words of each command to be printed. +# can be set by the `-v' command line option too. +# $loginsh if set, it is a login shell + +# TIP: $?0 is always false in interactive shells +# TIP: $?prompt is always false in non-interactive shells +# TIP: if `$?tcsh' is unset; you run the original `csh' or something else; +# try `echo $shell' +# TIP: $verbose this is useful to debugging scripts +# NOTE: $PWD and $PATH are synchronised with $cwd and $pwd automatically. + +# --- Variable modifiers ------------------------------------------------------ +# Syntax: ${var}:m[:mN] +# Where <m> is: +# h : the directory t : the filenane r : remove extension e : the extension +# u : uppercase the first lowercase letter +# l : lowercase the first uppercase letter +# p : print but do not execute it (hist) +# q : quote the substituted words, preventing further substitutions +# x : like q, but break into words at white spaces +# g : apply the following modifier once to each word +# a : apply the following modifier as many times as possible to single word +# s/l/r/ : search for `l' and replace with `r', not regex; the `&' in the r is +# replaced by l +# & : Repeat the previous substitution + +# start with this file +set f = ~/Documents/Alpha/beta.txt +# prints ~/Documents/Alpha/beta +echo $f:r +# prints ~/Documents/Alpha +echo $f:h +# prints beta.txt +echo $f:t +# prints txt +echo $f:e +# prints beta +echo $f:t:r +# prints Beta +echo $f:t:r:u +# prints Biota +echo $f:t:r:u:s/eta/iota/ + +# --- Redirection ------------------------------------------------------------- + +# Create file.txt and write the standard output to it +echo 'this string' > file.txt +# Create file.txt and write the standard output and standard error to it +echo 'this string' >& file.txt +# Append the standard output to file.txt +echo 'this string' >> file.txt +# Append the standard output and standard error to file.txt +echo 'this string' >>& file.txt +# Redirect the standard input from file.txt +cat < file.txt +# Input from keyboard; this stores the input line to variable `x' +set x = $< +# Document here; +cat << LABEL +...text here... +LABEL + +# TIP: this is how to get standard error separated: +(grep 'AGP' /usr/src/linux/Documentation/* > output-file.txt) >& error-file.txt + +# example: read a name from standard input and display a greetings message +echo -n "Enter your name? " +set name = $< +echo "Greetings $name" + +# --- Expressions ------------------------------------------------------------ + +# Operators: +# == equal != not equal ! not +# > greater than < less than >= greater or equal <= less or equal +# && logical AND || logical OR + +if ( $name != $user ) then + echo "Your name isn't your username" +else + echo "Your name is your username" +endif + +# single-line form +if ( $name != $user ) echo "Your name isn't your username" + +# NOTE: if $name is empty, tcsh sees the above condition as: +# if ( != $user ) ... +# which is invalid syntax +# so the "safe" way to use potentially empty variables in tcsh is: +# if ( "$name" != $user ) ... +# which, when $name is empty, is seen by tcsh as: +# if ( "" != $user ) ... +# which works as expected + +# There is also conditional execution +echo "Always executed" || echo "Only executed if first command fails" +echo "Always executed" && echo "Only executed if first command does NOT fail" + +# To use && and || with if statements, you don't need multiple pairs of +# square brackets: +if ( "$name" == "Steve" && "$age" == 15 ) then + echo "This will run if $name is Steve AND $age is 15." +endif + +if ( "$name" == "Daniya" || "$name" == "Zach" ) then + echo "This will run if $name is Daniya OR Zach." +endif + +# String matching operators ( `=~' and `!~' ) +# The ‘==’ ‘!=’ ‘=~’ and ‘!~’ operators compare their arguments as strings; +# all others operate on numbers. The operators ‘=~’ and ‘!~’ are like ‘!=’ +# and ‘==’ except that the right hand side is a glob-pattern against which +# the left hand operand is matched. + +if ( $user =~ ni[ck]* ) echo "Greetings Mr. Nicholas." +if ( $user !~ ni[ck]* ) echo "Hey, get out of Nicholas PC." + +# Arithmetic expressions are denoted with the following format: +@ result = 10 + 5 +echo $result + +# Arithmetic Operators +# +, -, *, /, % +# +# Arithmetic Operators which must be parenthesised +# !, ~, |, &, ^, ~, <<, >>, +# Compare and logical operators +# +# All operators are same as in C. + +# It is non so well documented that numeric expressions require spaces +# in-between; Also, `@' has its own parser, it seems that work well when the +# expression is parenthesised otherwise the primary parser seems it is active. +# Parenthesis require spaces around, this is documented. + +# wrong +@ x = $y+1 +@ x = 0644 & 022; echo $x +@ x = (0644 & 022) +1; echo $x +@ x = (0644 & 022)+ 1; echo $x +@ x = ( ~077 ); echo $x + +# correct +@ x = $y + 1 +@ x = ( 0644 & 022 ) + 1; echo $x +@ x = ( ~ 077 ); echo $x +@ x = ( ~ 077 | 022 ); echo $x +@ x = ( ! 0 ); echo $x + +# C's operators ++ and -- are supported if there is not assignment +@ result ++ + +# None shell created to do mathematics; +# Except for the basic operations, use an external command with backslashes. +# +# I suggest the calc as the best option. +# (http://www.isthe.com/chongo/tech/comp/calc/) +# +# The standard Unix's bc as second option +# (https://www.gnu.org/software/bc/manual/html_mono/bc.html) +# +# The standard Unix's AWK as third option +# (https://www.gnu.org/software/gawk/manual/gawk.html) + +# You can also use `perl', `php' or even several BASICs, but prefer the +# above utilities for faster load-and-run results. + +# real example: (that I answer in StackExchange) +# REQ: x := 1001b OR 0110b + +# in `tcsh' expression (by using octal) +@ x = ( 011 | 06 ); echo $x + +# the same by using `calc' (and using binary as the original req) +set x = `calc '0b1001 | 0b110'`; echo $x + +# --- File Inquiry Operators -------------------------------------------------- +# NOTE: The builtin `filetest' command do the same thing. + +#### Boolean operators +# -r read access -w write access -x execute access -e existence +# -f plain file -d directory -l symbolic link -p named pipe +# -S socket file +# -o ownership -z zero size -s non-zero size +# -u SUID is set -g SGID is set -k sticky is set +# -b block device -c char device +# -t file (digit) is an open file descriptor for a terminal device + +# if the file `README' exists, displays a message +if ( -e README ) echo "I have already README file" + +# if the `less' program is installed, use this instead of `more' +if ( -e `where less` ) then + alias more 'less' +endif + +#### Non-boolean operators +# -Z returns the file size in bytes +# -M returns the modification time (mtime) -M: returns mtime string +# -A returns the lass access time (atime) -A: returns atime string +# -U returns the owners user ID -U: returns the owners user-name +# -G returns the group ID -G: returns the group-name +# -P returns the permissions as octal number -Pmode returns perm. AND mode + +# this will display the date as Unix-time integer: 1498511486 +filetest -M README.md + +# This will display "Tue Jun 27 00:11:26 2017" +filetest -M: README.md + +# --- Basic Commands ---------------------------------------------------------- + +# Navigate though file system with `chdir' (cd) +cd path # change working directory +cd # change to home directory +cd - # change to previous directory +cd .. # go up one directory + +# Examples: +cd ~/Downloads # go to my `Downloads' directory + +# Use `mkdir` to create new directories. +mkdir newdir +# The `-p` flag causes new intermediate directories to be created as necessary. +mkdir -p ~/.backup/saves + +# which & where +# find if csh points to tcsh +ls -lha `which csh` +# find if csh is installed on more than one directory +where csh + +# --- Pipe-lines -------------------------------------------------------------- +# A pipeline is a sequence of processes chained together by their standard +# streams, so that the output of each process (stdout) feeds directly as input +# (stdin) to the next one. This `pipes' are created with the `|' special +# character and it is one of the most powerful characteristics of Unix. + +# example: +ls -l | grep key | less +# "ls -l" produces a process, the output (stdout) of which is piped to the +# input (stdin) of the process for "grep key"; and likewise for the process +# for "less". + +# the `ls', the `grep' and the `less' are programs of Unix and they have their +# own man-page. The `pipe' mechanism is part of the kernel but the syntax +# and the control is job of the shell, the tcsh in our case. + +# NOTE: `pipe' mechanism has Windows too, but it is buggy and I sign it for all +# versions until Windows XP SP3 API32 which was the last one that I worked on. +# Microsoft still denied it but is well known bug since it is a common method +# for inter-process communication. For small I/O it will work well. +# tcsh, along with grep, gcc and perl is one of the first Unix programs that +# ported to DOS (with EMX DOS extender) and later to Windows (1998). + +# example: this will convert tcsh to PostScript and will show it with okular +zcat /usr/man/man1/tcsh.1.gz | groff -Tps -man | okular - + +# a better version +zcat `locate -b -n 1 '\tcsh.1.gz'` | groff -Tps -man | okular - + +# even better +set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz"); + zcat `eval $loc` | groff -Tps -man | okular - + +# the same, modified to create man page pdf +set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz"); + zcat `eval $loc` | groff -Tps -man | ps2pdf - ${page}.pdf + +# the same, but now shows the ${page}.pdf too +set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz"); + zcat `eval $loc` | groff -Tps -man | ps2pdf - ${page}.pdf && okular tcsh.pdf + +# NOTE: `okular' is the default application of KDE environment and it shows +# postcript and pdf files. You can replace it with your lovely pdf viewer. +# zcat, locate, groff, are common programs in all Unices. `ps2pdf' program +# is part of `ghostscript' package that is widely used. + +# --- Control Flow ------------------------------------------------------------ + +#### IF-THEN-ELSE-ENDIF +# Syntax: +# if ( expr ) then +# ... +# [else if ( expr2 ) then +# ...] +# [else +# ...] +# endif +# +# If the specified expr is true then the commands to the first else are +# executed; otherwise if expr2 is true then the commands to the second else +# are executed, etc. +# Any number of else-if pairs are possible; only one endif is needed. +# +# Single-line form: +# +# if ( expr ) command +# +# If `expr' evaluates true, then command is executed. +# `command' must be a simple command, not an alias, a pipeline, a command list +# or a parenthesized command list. With few words, avoid to use it. +# +# BUG: Input/output redirection occurs even if expr is false and command is +# thus not executed. +# + +# check if we are in non-interactive shell and quit if true +if ( $?USER == 0 || $?prompt == 0 ) exit + +# check if we are a login shell +if ( $?loginsh ) then + # check if you are on linux console (not X's terminal) + if ( $tty =~ tty* ) then + # enable keypad application keys (man console_codes) + echo '\033=' + endif +endif + +#### SWITCH-ENDSW +# Syntax: +# switch ( expr ) +# case pattern: +# ... +# [breaksw] +# [default: +# ...] +# endsw +# +# tcsh uses a case statement that works similarly to switch in C. +# Each case label is successively matched, against the specified string which +# is first command and filename expanded. The file metacharacters `*', `?' +# and `[...]' may be used in the case labels. If none of the labels match the +# execution begins after the default label if its defined. +# The command `breaksw' causes execution to continue after the endsw. Otherwise +# control may fall through case labels and default labels as in C. + +switch ( $var ) +case *.[1-9]: +case *.[1-9].gz: + echo "$var is a man-page." + breaksw +case *gz: + echo "$var is gzipped" + breaksw +default: + file $var +endsw + +#### FOREACH-END +# Syntax: +# foreach name ( wordlist ) +# ... +# [break | continue] +# end +# +# Successively sets the variable `name' to each member of `wordlist' and +# executes the sequence of commands between this command and the matching +# `end' keyword. The `continue' keyword jump to the next element back to +# top; and the `break' keyword terminates the loop. +# +# BUG: `foreach' doesn't ignore here documents when looking for its end. + +# example: counting 1 to 10 +foreach i ( `seq 1 10` ) + echo $i +end + +# example: type all files in the list +foreach f ( a.txt b.txt c.txt ) + cat $f +end + +# example: convert wma to ogg +foreach f ( *.wma ) + ffmpeg -i "$f" "$f:r".ogg +end + +#### WHILE-END +# while ( expr ) +# ... +# [break | continue] +# end +# +# Executes the commands between the `while' and the matching `end' while `expr' +# evaluates non-zero. `break' and `continue' may be used to terminate or +# continue the loop prematurely. + +# count from 1 to 10 +set num = 1 +while ( $num <= 10 ) + echo $num + @ num ++ +end + +# print all directories of CWD +set lst = ( * ) +while ( $#lst ) + if ( -d $lst[1] ) echo $lst[1] is directory + shift lst +end + +# separate command-line arguments to options or parameters +set options +set params +set lst = ( $* ) +while ( $#lst ) + if ( "$lst[1]" =~ '-*' ) then + set options = ( $options $lst[1] ) + else + set params = ( $params $lst[1] ) + endif + shift lst +end +echo 'options =' $options +echo 'paramaters =' $params + +#### REPEAT +# Syntax: repeat count command +# +# The specified command, which is subject to the same restrictions as the +# command in the one line if statement above, is executed count times. +# I/O redirections occur exactly once, even if count is 0. +# +# TIP: in most cases prefer `while' + +repeat 3 echo "ding dong" + +# --- Functions --------------------------------------------------------------- +# tcsh has no functions but its expression syntax is advanced enough to use +# `alias' as functions. Another method is recursion + +# Alias argument selectors; the ability to define an alias to take arguments +# supplied to it and apply them to the commands that it refers to. +# Tcsh is the only shell that provides this feature. +# +# \!# argument selector for all arguments, including the alias/command +# itself; arguments need not be supplied. +# \!* argument selector for all arguments, excluding the alias/command; +# arguments need not be supplied. +# \!$ argument selector for the last argument; argument need not be supplied, +# but if none is supplied, the alias name is considered to be the +# last argument. +# \!^ argument selector for first argument; argument MUST be supplied. +# \!:n argument selector for the nth argument; argument MUST be supplied; +# n=0 refers to the alias/command name. +# \!:m-n argument selector for the arguments from the mth to the nth; +# arguments MUST be supplied. +# \!:n-$ argument selector for the arguments from the nth to the last; +# at least argument n MUST be supplied. + +# Alias the cd command so that when you change directories, the contents +# are immediately displayed. +alias cd 'cd \!* && ls' + +# --- Recursion method --- begin --- +#!/bin/tcsh -f +set todo = option1 +if ( $#argv > 0 ) then + set todo = $argv[1] +endif + +switch ( $todo ) +case option1: +# ... + $0 results + breaksw +case option2: +# ... + $0 results + breaksw +case results: + echo "print the results here" +# ... + breaksw +default: + echo "Unknown option: $todo" +# exit 0 +endsw +# --- Recursion method --- end --- + +# --- examples ---------------------------------------------------------------- + +# this script prints available power-states if no argument is set; +# otherwise it set the state of the $argv[1] +# --- power-state script --- begin -------------------------------------------- +#!/bin/tcsh -f +# get parameter ("help" for none) +set todo = help +if ( $#argv > 0 ) then + set todo = $argv[1] +endif +# available options +set opts = `cat /sys/power/state` +# is known? +foreach o ( $opts ) + if ( $todo == $o ) then + # found; execute it + echo -n $todo > /sys/power/state + break + endif +end +# print help and exit +echo "usage: $0 [option]" +echo "available options on kernel: $opts" +# --- power-state script --- end ---------------------------------------------- + +# Guess the secret number game +# --- secretnum.csh --- begin ------------------------------------------------- +#!/bin/tcsh -f +set secret=`shuf -i1-100 -n1` +echo "I have a secret number from 1 up to 100" +while ( 1 ) + echo -n "Guess: " + set guess = $< + if ( $secret == $guess ) then + echo "You found it" + exit 1 + else + if ( $secret > $guess ) then + echo "its greater" + else if ( $secret < $guess ) then + echo "its lesser" + endif + endif + endif +end +# --- secretnum.csh --- end --------------------------------------------------- + +# ----------------------------------------------------------------------------- +# Appendices + +#### About [T]CSH: +# * CSH is notorious about its bugs; +# * It was also famous about its advanced interactive mode. +# * TCSH is famous that have the most advanced completition subsystem. +# * TCSH is famous that have the most advanced aliases subsystem; aliases +# can take parameters and often used as functions! +# * TCSH is well known that preferred by people (me too) because of better +# syntax. All shells are using Thomson's syntax with exception of [t]csh, +# fish and plan9's shells (rc, ex). +# * It is smaller and consume far less memory than bash, zsh even mksh! +# (memusage reports) +# * TCSH still has bugs; less but have; if you write readable clean code you'll +# find none; well almost none... This has to do with the implementation of +# csh; that no means the other shells has good implementation. +# * no one well known shell is capable for regular programming; if your script +# getting big, use a programming language, or at least PHP or Perl (good +# script languages). +# +# Advises: +# 1. Do not use redirection in single-line if (it is well documented bug) +# In most cases avoid to use single-line IFs. +# 2. Do not mess up with other shells code, c-shell is not compatible with +# other shells and has different abilities and priorities. +# 3. Use spaces as you'll use them to write readable code in any language. +# A bug of csh was `set x=1' worked, `set x = 1' worked, `set x =1' did not! +# 4. It is well documented that numeric expressions require spaces in-between; +# also parenthesise all bit-wise and unary operators. +# 5. Do not write a huge weird expression with several quotes, backslashes etc +# It is bad practice for generic programming, it is dangerous in any shell. +# 6. Help tcsh, report the bug here <https://bugs.gw.com/> +# 7. Read the man page, `tcsh' has huge number of options, and variables. +# +# I suggest the following options enabled by default +# -------------------------------------------------- +# Even in non-interactive shells +# set echo_style=both +# set backslash_quote +# set parseoctal +# unset noclobber +# +# Whatever... +# set inputmode=insert +# set autolist +# set listjobs +# set padhour +# set color +# set colorcat +# set nobeep +# set cdtohome +# +# set histdup +# set histlit +# set nohistclop +# +# unset compat_expr +# unset noglob +# unset autologout +# unset time +# unset tperiod +# +# NOTE: If the `backslash_quote' is set, it may create compatibility issues +# with other tcsh scripts which was written without it. +# +# NOTE: The same for `parseoctal', but it is better to fix the problematic +# scripts. +# +# NOTE: **for beginners only** +# This enable automatically rescan `path' directories if need to. (like bash) +# set autorehash + +#### common aliases +# alias hist 'history 20' +# alias ll 'ls --color -lha' +# alias today "date '+%d%h%y' +# alias ff 'find . -name ' + +#### a nice prompt +# set prompt = "%B%{\033[35m%}%t %{\033[32m%}%n@%m%b %C4 %# " +``` |