%%%----- Licensing notice ---------------------------------------------------
%%%
-%%% This file is part of the Sensble Object Design, an object system for C.
+%%% This file is part of the Sensible Object Design, an object system for C.
%%%
%%% SOD is free software; you can redistribute it and/or modify
%%% it under the terms of the GNU General Public License as published by
%%%--------------------------------------------------------------------------
-Fortunately, Sod is syntactically quite simple. I've used a little slightly
-unusual notation in order to make the presentation easier to read. For any
-nonterminal $x$:
+Fortunately, Sod is syntactically quite simple. The notation is slightly
+unusual in order to make the presentation shorter and easier to read.
+
+Anywhere a simple nonterminal name $x$ may appear in the grammar, an
+\emph{indexed} nonterminal $x[a_1, \ldots, a_n]$ may also appear. On the
+left-hand side of a production rule, the indices $a_1$, \ldots, $a_n$ are
+variables which vary over all nonterminal and terminal symbols, and the
+variables may also appear on the right-hand side in place of a nonterminal.
+Such a rule stands for a family of rules, in each variable is replaced by
+each possible simple nonterminal or terminal symbol.
+
+The letter $\epsilon$ denotes the empty nonterminal
+\begin{quote}
+ \syntax{$\epsilon$ ::=}
+\end{quote}
+
+The following indexed productions are used throughout the grammar, some often
+enough that they deserve special notation.
\begin{itemize}
-\item $\epsilon$ denotes the empty nonterminal:
+\item @[$x$@] abbreviates @<optional>$[x]$, denoting an optional occurrence
+ of $x$:
\begin{quote}
- $\epsilon$ ::=
+ \syntax{@[$x$@] ::= <optional>$[x]$ ::= $\epsilon$ @! $x$}
\end{quote}
-\item @[$x$@] means an optional $x$:
+\item $x^*$ abbreviates @<zero-or-more>$[x]$, denoting a sequence of zero or
+ more occurrences of $x$:
\begin{quote}
- \syntax{@[$x$@] ::= $\epsilon$ @! $x$}
+ \syntax{$x^*$ ::= <zero-or-more>$[x]$ ::=
+ $\epsilon$ @! <zero-or-more>$[x]$ $x$}
\end{quote}
-\item $x^*$ means a sequence of zero or more $x$s:
+\item $x^+$ abbreviates @<one-or-more>$[x]$, denoting a sequence of zero or
+ more occurrences of $x$:
\begin{quote}
- \syntax{$x^*$ ::= $\epsilon$ @! $x^*$ $x$}
+ \syntax{$x^+$ ::= <one-or-more>$[x]$ ::= <zero-or-more>$[x]$ $x$}
\end{quote}
-\item $x^+$ means a sequence of one or more $x$s:
+\item @<list>$[x]$ denotes a sequence of one or more occurrences of $x$
+ separated by commas:
\begin{quote}
- \syntax{$x^+$ ::= $x$ $x^*$}
- \end{quote}
-\item $x$@<-list> means a sequence of one or more $x$s separated
- by commas:
- \begin{quote}
- \syntax{$x$<-list> ::= $x$ @! $x$<-list> "," $x$}
+ \syntax{<list>$[x]$ ::= $x$ @! <list>$[x]$ "," $x$}
\end{quote}
\end{itemize}
\alt <octal-integer>
\alt <hex-integer>
-<decimal-integer> ::= <nonzero-digit-char> @<digit-char>^*
+<decimal-integer> ::= "0" | <nonzero-digit-char> @<digit-char>^*
<binary-integer> ::= "0" @("b"|"B"@) @<binary-digit-char>^+
The @<s-expression> is evaluated immediately. It can do anything it likes.
-\textbf{Warning!} This means that hostile Sod modules are a security hazard.
-Lisp code can read and write files, start other programs, and make network
-connections. Don't install Sod modules from sources that you don't
-trust.\footnote{%
- Presumably you were going to run the corresponding code at some point, so
- this isn't as unusually scary as it sounds. But please be careful.} %
+\begin{boxy}[Warning!]
+ This means that hostile Sod modules are a security hazard. Lisp code can
+ read and write files, start other programs, and make network connections.
+ Don't install Sod modules from sources that you don't trust.\footnote{%
+ Presumably you were going to run the corresponding code at some point, so
+ this isn't as unusually scary as it sounds. But please be careful.} %
+\end{boxy}
\subsubsection{Declaring type names} \label{sec:syntax.defs.typename}
\begin{grammar}
<typename-definition> ::=
- "typename" <identifier-list> ";"
+ "typename" <list>$[\mbox{@<identifier>}]$ ";"
\end{grammar}
Each @<identifier> is declared as naming a C type. This is important because
"code" <identifier> ":" <identifier> @[<constraints>@]
"{" <c-fragment> "}"
-<constraints> ::= "[" <constraint-list> "]"
+<constraints> ::= "[" <list>$[\mbox{@<constraint>}]$ "]"
<constraint> ::= @<identifier>^+
\end{grammar}
\subsection{Property sets} \label{sec:syntax.propset}
\begin{grammar}
-<properties> ::= "[" <property-list> "]"
+<properties> ::= "[" <list>$[\mbox{@<property>}]$ "]"
<property> ::= <identifier> "=" <expression>
\end{grammar}
\alt "void" | "char" | "int" | "float" | "double"
\alt "short" | "long"
\alt "signed" | "unsigned"
+\alt "bool" | "_Bool"
+\alt "imaginary" | "_Imaginary" | "complex" | "_Complex"
\alt <qualifier>
<qualifier> ::= "const" | "volatile" | "restrict"
\end{grammar}
A @<type-name> is an identifier which has been declared as being a type name,
-using the @"typename" or @"class" definitions.
+using the @"typename" or @"class" definitions. The following type names are
+defined in the built-in module.
+\begin{itemize}
+\item @"va_list"
+\item @"size_t"
+\item @"ptrdiff_t"
+\item @"wchar_t"
+\end{itemize}
Declaration specifiers may appear in any order. However, not all
combinations are permitted. A declaration specifier must consist of zero or
\item @<type-name>
\item @"struct" @<identifier>, @"union" @<identifier>, @"enum" @<identifier>
\item @"void"
+\item @"_Bool", @"bool"
\item @"char", @"unsigned char", @"signed char"
\item @"short", @"unsigned short", @"signed short"
\item @"short int", @"unsigned short int", @"signed short int"
\item @"long long", @"unsigned long long", @"signed long long"
\item @"long long int", @"unsigned long long int", @"signed long long int"
\item @"float", @"double", @"long double"
+\item @"float _Imaginary", @"double _Imaginary", @"long double _Imaginary"
+\item @"float imaginary", @"double imaginary", @"long double imaginary"
+\item @"float _Complex", @"double _Complex", @"long double _Complex"
+\item @"float complex", @"double complex", @"long double complex"
\end{itemize}
All of these have their usual C meanings.
\subsubsection{Declarators} \label{sec:syntax.c-types.declarator}
-
\begin{grammar}
<declarator>$[k]$ ::= @<pointer>^* <primary-declarator>$[k]$
<primary-declarator>$[k]$ ::= $k$
\alt "(" <primary-declarator>$[k]$ ")"
-\alt <primary-declarator>$[k]$ @<declarator-suffix>^*
+\alt <primary-declarator>$[k]$ @<declarator-suffix>
<pointer> ::= "*" @<qualifier>^*
<declarator-suffix> ::= "[" <c-fragment> "]"
\alt "(" <arguments> ")"
-<arguments> ::= $\epsilon$ | "..."
-\alt <argument-list> @["," "..."@]
+<argument-list> ::= $\epsilon$ | "..."
+\alt <list>$[\mbox{@<argument>}]$ @["," "..."@]
<argument> ::= @<declaration-specifier>^+ <argument-declarator>
-<argument-declarator> ::= <declarator>@[<identifier> @! $\epsilon$@]
+<argument-declarator> ::= <declarator>$[\mbox{@<identifier> @! $\epsilon$}]$
-<simple-declarator> ::= <declarator>@[<identifier>@]
+<simple-declarator> ::= <declarator>$[\mbox{@<identifier>}]$
<dotted-name> ::= <identifier> "." <identifier>
-
-<dotted-declarator> ::= <declarator>@[<dotted-name>@]
\end{grammar}
The declarator syntax is taken from C, but with some differences.
\end{grammar}
\subsubsection{Forward declarations} \label{sec:class.class.forward}
-
\begin{grammar}
<class-forward-declaration> ::= "class" <identifier> ";"
\end{grammar}
\begin{grammar}
<full-class-definition> ::=
@[<properties>@]
- "class" <identifier> ":" <identifier-list>
- "{" @<class-item>^* "}"
+ "class" <identifier> ":" <list>$[\mbox{@<identifier>}]$
+ "{" @<properties-class-item>^* "}"
+
+<properties-class-item> ::= @[<properties>@] <class-item>
-<class-item> ::= <slot-item> ";"
+<class-item> ::= <slot-item>
+\alt <initializer-item>
\alt <message-item>
\alt <method-item>
-\alt <initializer-item> ";"
\end{grammar}
A full class definition provides a complete description of a class.
or an existing type name. It is conventional to give classes `MixedCase'
names, to distinguish them from other kinds of identifiers.
-The @<identifier-list> names the direct superclasses for the new class. It
-is an error if any of these @<identifier>s does not name a defined class.
+The @<list>$[\mbox{@<identifier>}]$ names the direct superclasses for the new
+class. It is an error if any of these @<identifier>s does not name a defined
+class.
The @<properties> provide additional information. The standard class
properties are as follows.
\begin{grammar}
<slot-item> ::=
- @[<properties>@]
- @<declaration-specifier>^+ <init-declarator-list>
+ @<declaration-specifier>^+ <list>$[\mbox{@<init-declarator>}]$ ";"
-<init-declarator> ::= <declarator> @["=" <initializer>@]
+<init-declarator> ::= <simple-declarator> @["=" <initializer>@]
\end{grammar}
A @<slot-item> defines one or more slots. All instances of the class and any
subclass will contain these slot, with the names and types given by the
@<declaration-specifiers> and the @<declarators>. Slot declarators may not
-contain qualified identifiers.
+contain dotted names.
It is not possible to declare a slot with function type: such an item is
interpreted as being a @<message-item> or @<method-item>. Pointers to
\subsubsection{Initializer items} \label{sec:syntax.class.init}
\begin{grammar}
-<initializer-item> ::= @["class"@] <slot-initializer-list>
+<initializer-item> ::= @["class"@] <list>$[\mbox{@<slot-initializer>}]$ ";"
-<slot-initializer> ::= <qualified-identifier> "=" <initializer>
+<slot-initializer> ::= <dotted-name> "=" <initializer>
<initializer> :: "{" <c-fragment> "}" | <c-fragment>
\end{grammar}
prefixed by @"class", then the initial values are for class slots (i.e.,
slots of the class object itself); otherwise they are for instance slots.
-The first component of the @<qualified-identifier> must be the nickname of
-one of the class's superclasses (including itself); the second must be the
-name of a slot defined in that superclass.
+The first component of the @<dotted-name> must be the nickname of one of the
+class's superclasses (including itself); the second must be the name of a
+slot defined in that superclass.
The initializer has one of two forms.
\begin{itemize}
\begin{grammar}
<message-item> ::=
- @[<properties>@]
- @<declaration-specifier>^+ <declarator> @[<method-body>@]
+ @<declaration-specifier>^+
+ <keyword-declarator>$[\mbox{@<identifier>}]$
+ @[<method-body>@]
\end{grammar}
\subsubsection{Method items} \label{sec:syntax.class.method}
\begin{grammar}
<method-item> ::=
- @[<properties>@]
- @<declaration-specifier>^+ <declarator> <method-body>
+ @<declaration-specifier>^+
+ <keyword-declarator>$[\mbox{@<dotted-name>}]$
+ <method-body>
<method-body> ::= "{" <c-fragment> "}" | "extern" ";"
\end{grammar}
-
%%%----- That's all, folks --------------------------------------------------
%%% Local variables:
~mdw / sod / blobdiff