.Open Syntax of LISP . Lexical Elements of LISP Many of the undefined terms in this document like `cond`, `car`, `cdr`, and so on are lexemes: .See http://www/dick/samples/lisp.lexemes.html .See http://www/dick/samples/comp.text.ASCII.html dot::=http://www/dick/samples/lisp.lexemes.html#dot . Syntax of LISP The two fundamental pieces of LISP syntax are the idea of a list of things and the dotted pair: For any set of strings X, list_of(X)::="(" # X ")", For any set of strings X, dotted_pair(X)::="(" X \$dot X ")". A dotted pair is the external image of a node in an internal data structure with two components called "car" and "cdr" for historical reasons. Each component in the pair points at an atomic item or another list. Each list is coded internally as dotted pairs: .As_is (A) = (A.NIL). .As_is (A B) = (A.(B.NIL)). .As_is (A B C ) = (A.(B.(C.NIL)) ). .As_is (A B C D ... Y Z) = (A.(B.(C.(.D ... (Y. (Z. NIL)) ... ). After the lexical analysis the interpreter parses input as a `list_structure` before evaluating it. A list_structure is empty, or a dotted_pair, or an atom, or any number of lists inside a pair of parenthesis. We often call a list structure a list for short. But always be careful to distinguishing 'a list of numbers' from a 'list structure of numbers' list_structure::=\$atom | \$dotted_pair(\$list_structure) | \$list_of(\$list_structure). Note. In old LISP, commas were optional separators in lists... but not in XLISP and Scheme. Note. The separating spaces, tabs, etc in a list are all sieved out by the lexical scan. This scan also removes comment lines that start with a semicolon .See http://www/dick/samples/lisp.lexemes.html#comment atom::= .See http://www/dick/samples/lisp.lexemes.html#atom .Open Syntax of S_expressions Note: Syntax assumes that a lexical analysis process has already divided the input into lexemes and deleted any extra whitespace. . Constants constant::= nil | true | number | \$string | \$quoted_list, word::= .See http://www/dick/samples/lisp.lexemes.html#word string::= .See http://www/dick/samples/lisp.lexemes.html#string quoted_list::="(" "QUOTE" \$list_structure ")" | \$single_quote \$list_structure, -- The second form is an abbreviation for the first. quoted_list::="( QUOTE ( A B C ) )" | " '( A B C )" | .... . Expressions expression::=\$S_expression | \$macro_call. S_expression::=Syntax_expression. S_expression::= \$constant | "(" \$function #\$expression ")" | \$variable. -- The function determines the correct number of expressions. function::=car | cdr | cons | ..., function::= \$word & (predefined_function | created_by_define ). macro_call::="(" \$macro_name #\$list_structure "), -- In a macro the arguments are not automatically evaluated and can be anything at all. macro_name::=cond | define | lambda |..., macro_name::=\$word & (predefined_macro | created_by_defmacro). macro::=\$lambda_form | \$conditional | \$definition |..., lambda_form::= "(" lambda \$list_of(\$word) \$expression ")". conditional::= "(" cond #( "(" \$expression #\$expression ")" )")". definition::="(" define "(" \$function \$arguments ")" #\$expression ")" | "(" defun \$function \$list_of(\$word) #\$expression ")". program::=`Not in pure LISP!`, program::="(" progn #\$expression ")". program:semantics::=`The n expressions are evaluated in sequence and the last value (the n'th) is printed`. block::="(" let "(" #\$local_variable")" \$\$expression ")". local_variable::= "(" atom \$expression ")". block::semantics=`each local variable is bound to the value of the expression next to it and then the expressions after the local variables are executed`. arguments::= #\$word. variable::=\$word & (global | local). 'global' variables are created by commands like 'setq' by the user. 'Local' variables are created in lambda_forms, definitions, LETs, PROGs,.... and deleted at the end of the expression or form. .Close Expressions .Close Syntax