Sets the syntax bits and/or macro property of the given character.

In general, if the data₂ is a FIXNUM, SETSYNTAX will treat it as a "translation character" (see the CHTRAN option to STATUS and SSTATUS). If the data₂ is a function name (symbol or LAMBDA expression), SETSYNTAX will assign a "readmacro" which is that function.

If data₁ is the symbol MACRO and data₂ is a function, arranges for function to be called when the character is found by READ. The result of the call is the result is used by READ directly. For example:

If data₁ is the symbol SPLICING and data₂ is a function, arranges for function to be called when the character is found by READ. In this case, the result of the call is "spliced" into the containing list. (It's an error if there is no containing list.) Here's an example:

Note that the semicolon readmacro is implemented as a splicing macro that simply returns the empty list (see +INTERNAL-/;-MACRO).

If data₁ is the symbol SINGLE and data₂ is a character to translate to, then when READ sees the character, it will substitute a symbol whose name is the single character having the code given by data₂.

With some care, individual syntax bits can be assigned. See (STATUS SYNTAX) for details on the bits.

See also: (STATUS SYNTAX), (STATUS CHTRAN character)

To see a list of pre-defined readmacros, see the Reader Macro Index.

Typing the character slash makes the next character not have its normal reader syntax and behave as alphabetic instead. For example, to keep the semicolon character from being a comment character and to type the symbol whose name is the three characters "A;B" you can type "A/;B". To type a slash, you must quote it with a slash. Hence, the division operator, whose name is the single character "/" must be typed as "//". Slashing a character which already has alphabetic syntax has no effect. The syntaxes /F/O/O and FOO denote the same three-letter symbol FOO. Except on Multics, lowercase characters will be uppercased by READ. Typing slashes before lowercase characters will inhibit this effect. The syntax Foo denotes the symbol FOO, but the syntax F/o/o denotes the symbol |Foo| (see below).

Typing lots of slashes may get to be tedious. For example, the symbol named "..." can be typed as "/././." but it can also be typed as "|...|". Placing vertical bars around a section of text is the same as typing slash before each of the characters with the following exception: Slash can still be inserted before characters inside of vertical bars. Before any character except "/" or "|" it is ignored, but before those characters, it makes their normal syntax not apply.

This process of attaching slashes or vertical bars is called slashification. Lisp's internal representation of symbols' pnames does not include any information about slashification; it only includes the characters which really make up the symbol's name. The Lisp output function PRINC will print objects without slashification, but that output will not be suitable for being re-read by READ. the PRIN1 (and PRINT) functions will output objects with any slashification necessary for them to be later re-read by READ. Because symbols have more than one input syntax, PRIN1 will try to select what it feels is the most aesthetic presentation style to type the symbol back at you. Here are some examples of ways a programmer might input some symbols and how PRINC and PRIN1 would display those symbols.

Typing 'form is equivalent to typing (QUOTE form).

Typing #'form is equivalent to typing (FUNCTION form). The shorthand form is preferred.

See also: SETSYNTAX, SETSYNTAX-SHARP-MACRO, +INTERNAL-/'-MACRO

Typing semicolon begins a comment field which extends to the end of the line (marked by a carriage return). Semicolon commenting is implemented as a splicing readmacro, so is suppressed immediately after a slash or anywhere between matched vertical bars or doublequotes. For example, the expression

is the same as (+ 1 x y).

See also: SETSYNTAX, +INTERNAL-/;-MACRO

If "_" occurs inside a fixnum, it means left shift the number to the left by the amount specified to the right. e.g., 3_18. is the same as #o3000000. This syntax always yields a fixnum.

If "^" occurs inside a fixnum, as in n^m, it means add m zeros to the end of n. Note that both n and m are read in the current radix. e.g., #o3^10 is the same as #o300000000.

An expression of the form "#|...|#" is a comment. Also, these comments nest correctly. So "#|...#|...|#...|#" terminates after the second "|#" rather than the first. Thus the expression

is parsed by READ the same as (TIMES 3.14159 2)

Usage of this syntax for comments is rare. Most users still prefer that comments be clearly marked on each line by a semicolon. Its introduction into the language was intended primarily to allow functions to be commented out without changing their indentation.

There are two meanings for expressions bounded by doublequotes in Lisp. Both are intended to provide approximations to a string functionality. For more info on this, see documentation on the String concept.

Backquote is a readmacro which is seen most commonly in DEFMACRO forms, though it has other applications as well.

Typing backquote before a form, as in `form, is equivalent to typing (QUOTE form) except that

In a backquote expression, any subform of form which is:

For example, consider the following equivalencies

Use of RPLACA, RPLACD, NCONC, NREVERSE, or other destructive operations on the result of evaluating a backquote expression is not advised. Backquote makes no claim to how much sharing there will be between the backquote form and the structures produced by that form. It will try to maximize sharing, but it is a violation of its abstraction to assume that certain resulting structure will or will not be shared.

Now let's consider some code where we might want to use backquote...

can be more easily written as

However, since backquote expressions can nest, they may also be written as

The particular style to be used is largely a matter of taste. What backquote offers is an opportunity to show the general shape of the expression which will result. Prior to the existence of backquote, one would have written DEF-FUNCALLED as:

which didn't give one a good feel for what the shape of the result might be. In some cases, using nested backquotes will make the program more clear; in some cases it will make it less clear. There are programmers who fear sophisticated constructs like backquote because they feel they just clutter their programs; and there are programmers who blindly resist an occasional call to LIST or CONS when backquote would express the result just fine. The best programmer, however, will maintain a clear knowledge of what tools are available at any given time and pick those which most clearly express his intent to others who might read his program.

The character sequences "," and ",." and ",@" are used internally to the backquote readmacro.

This character sequence, followed immediately by any ASCII character, is parsed by READ as that character's ASCII code. For example, #/A reads as the fixnum 101 octal (65 decimal).

This character sequence, followed immediately by a symbol which names that character, is parsed by READ as the ASCII code for the character whose name is that symbol. For example, #\ALT reads as 33 octal (27 decimal). To find the preferred name for a character, call (FORMAT NIL "~@C" char).

Since control characters are sometimes hard to type in for use with "#/", this allows the user to type their ASCII codes symbolically. Followed by a character, char, this reads as Control-char's ASCII value. For example, #^G (sharpsign uparrow G) reads as the fixnum 7. Many characters have symbolic names as well; when such a name exists, the "#\" syntax is generally preferred.

The expression #nRnumber causes number to be read in radix n instead of the default input radix (given by IBASE). The n is always read in base 10 (decimal). For example, #5r12 is read as 7. Whitespace is permitted between the #r and the number which follows it. Note that for input bases greater than ten, a sign is required for numbers which contain other than the digits 0 through 9. (See also (STATUS +).)

The expression #Onumber causes number to be read in octal (radix 8) instead of the default input radix (given by IBASE). For example, #o11 is read as 9.

The expression #Xnumber causes number to be read in hex (radix 16) instead of the default input radix (given by IBASE). For example, #x+A is read as 10. Note that in hex, as with any input base greater than ten, a sign is required for numbers which contain other than the digits 0 through 9. (See also (STATUS +).)

If the first form after a #+ is a symbol sym, then if (STATUS FEATURE sym) is true, then the second form following will be seen by READ; otherwise it will be invisible to READ. For example:

will READ as

if (STATUS FEATURE DEBUG) is true, and

otherwise.

It is possible to combine conditions using lists that begin with AND, OR and NOT. For example:

will be read iff

is true.

Note: There are frequently better ways to conditionalize code without resorting to readmacros. Think twice before cluttering your code in this way.

Like "#+" but the second form is read if the feature description given by the first form is not true. These are sometimes seen together to implement code portability between differing dialects in the Maclisp family (Maclisp, NIL, Lisp, Lisp Machine Lisp, Franz Lisp). For example,

or just:

This is shorthand for "#+MACLISP".

This is shorthand for "#+NIL".

This is shorthand for "#+LISPM".

Typing #.expression will cause READ to return the result of evaluating expression, rather than expression itself. For example,

is the same as writing

since the subtraction happens at readtime rather than runtime.

Sharp dot may also be useful inside quoted data in some limited cases. For example,

will read using the values of *A* and *B* in the indicated places.

This requires that the variables be bound at readtime rather than at runtime. Contrast this with backquote, which allows you to effectively de-quote regions using values available at run-time:

For interpreted code, this is the same as "#." but for compiled code, the evaluation of the expression is delayed until the compiled code is loaded into its target environment rather than happening at readtime in the compiler as would happen with "#."

In rare cases, macro libraries may need this feature, which allows readtime macro expansion of the form which follows. Typing

is equivalent to typing

Note, however, that MACROEXPAND expands only macrocalls at the toplevel of the given list. to expand the SETF, you would have to write

The argument conventions for these syntax controlling STATUS and SSTATUS options are quite obscure. In this subsection, the argument ch means a character. If ch is atomic, it will not be evaluated and may be either a fixnum representing the character's ASCII value or a single character symbol. If the ch argument is non-atomic, it will be evaluated and must evaluate to a fixnum character representation. It is recommended as a point of style that the option of using a symbol be avoided as it is somewhat visually confusing.

bit	meaning
1	Alphabetic; i.e., #/A to #/Z
2	Lowercase and extended alphabetic; i.e., #/a to #/z and #/!, #/%, etc.
4	Decimal digit; i.e., #/0 through #/9
10	Sign Character; i.e., #/+ or #/-
20	Fixnum Shift Character; i.e., #/^ or #/_
40	Second choice denoter for 10, 20, 1000, and 4000
100	PRINT should slashify if not first char
200	Decimal point for numbers; i.e., #/.
400	PRINT should slashify when in first position
1000	The rubout character, or the tty force feed char
2000	The syntax quote character for READ; i.e., #//
4000	A macro or splicing macro character; e.g., #/'
10000	Close paren; i.e., #/)
20000	"Consing dot"; i.e., #/.
40000	Open Paren; i.e., #/(
100000	Space or Tab
200000	Single character object (no such character by default)
400000	Worthless characters, and any with 200 or 1000-400000 on.

(DEFUN +INTERNAL-/'-MACRO () (LIST 'QUOTE (READ)))

(DEFUN +INTERNAL-/;-MACRO () (READLINE) NIL) ;discard rest of line

Sample Usage:

(PROGN (SETQ A 1. +A 2.) ;Confusing variable names!
       (SETQ IBASE 16. BASE 16.) ;Enable Base-16 I/O
       (DEFUN F (A) (+ A 3)) ;Define a test function
       'DONE)
DONE
(F A) ; Our variable A has value 1)
+4
(F +A) ; Our variable +A has a value 2
+5
(SSTATUS + T) ;Enable + input syntax
T
(F A) ; 'A' still denotes our variable A
+4
(F +A) ; But '+A' now denotes the number 10 (base 16)
+D
(F /+A) ; /+A still means the symbol +A, however.
+5

Synonym:

(DEFUN /#-MACRO-char bvl . body)
(SETSYNTAX-SHARP-MACRO char 'ind '/#-MACRO-char)

Sample Usage:

;; Define odd macro
(defsharp /~ (arg) arg ;ignored
  (reverse read)))
/#-MACRO-~

#~(3 2 +)
5

'(* x #~(c b a +))
(* X (+ A B C))

;;Define an odd comment macro
(defsharp /! splicing (arg) arg ;ignored
  (read) nil) ;read next form on stream but ignore it
/#-MACRO-!

(plus 2 #!(pi) 3.14159)
5.14159

'#~((A B) #!FOO C #!(3 #~(4 5 6)) D #!#~(X Y) #~#!(AA BB) (CC DD))
((DD CC) D C (A B))