Index: doc/refrat/Makefile =================================================================== --- doc/refrat/Makefile (revision d3ed39f8b97ed4f3146139cbff06f8c72311b75c) +++ doc/refrat/Makefile (revision 83e9bd3542d6b3c6755e50591bde755e42a80a44) @@ -44,5 +44,5 @@ ${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \ - ../LaTeXmacros/common.tex ../LaTeXmacros/indexstyle ../bibliography/cfa.bib + ../LaTeXmacros/common.tex ../LaTeXmacros/lstlang.sty ../LaTeXmacros/indexstyle ../bibliography/cfa.bib # Conditionally create an empty *.ind (index) file for inclusion until makeindex is run. if [ ! -r ${basename $@}.ind ] ; then touch ${basename $@}.ind ; fi @@ -70,4 +70,8 @@ fig2dev -L ps $< > $@ +%.pstex : %.fig + fig2dev -L pstex $< > $@ + fig2dev -L pstex_t -p $@ $< > $@_t + # Local Variables: # # compile-command: "make" # Index: doc/refrat/refrat.bib =================================================================== --- doc/refrat/refrat.bib (revision d3ed39f8b97ed4f3146139cbff06f8c72311b75c) +++ doc/refrat/refrat.bib (revision 83e9bd3542d6b3c6755e50591bde755e42a80a44) @@ -2,50 +2,50 @@ @manual{ANS:C, - keywords = {ANSI C}, - contributer = {gjditchfield@msg}, - title = {American National Standard for Information Systems -- + keywords = {ANSI C}, + contributer = {gjditchfield@msg}, + title = {American National Standard for Information Systems -- Programming Language -- {C}}, - organization = {American National Standards Institute}, - address = {1430 Broadway, New York, New York 10018}, - month = dec, year = 1989, - note = {X3.159-1989} + organization= {American National Standards Institute}, + address = {1430 Broadway, New York, New York 10018}, + month = dec, year = 1989, + note = {X3.159-1989} } @manual{ANS:C11, - keywords = {ANS:C11}, - contributer = {gjditchfield@acm.org}, - title = {American National Standard Information Systems -- + keywords = {ANS:C11}, + contributer = {gjditchfield@acm.org}, + title = {American National Standard Information Systems -- Programming languages -- {C}}, - organization = {American National Standards Institute}, - address = {25 West 43rd Street, New York, New York 10036}, - month = may, year = 2012, - note = {INCITS/ISO/IEC 9899-2011[2012]} + organization= {American National Standards Institute}, + address = {25 West 43rd Street, New York, New York 10036}, + month = may, year = 2012, + note = {INCITS/ISO/IEC 9899-2011[2012]} } @book{c++, - keywords = {C++, ANSI}, - author = {Margaret A. Ellis and Bjarne Stroustrup}, - title = {The Annotated {C}{\tt ++} Reference Manual}, - publisher = {Addison Wesley}, - year = 1990, - edition = {first} + keywords = {C++, ANSI}, + author = {Margaret A. Ellis and Bjarne Stroustrup}, + title = {The Annotated {C}{\tt ++} Reference Manual}, + publisher = {Addison Wesley}, + year = 1990, + edition = {first} } @Unpublished{Ditchfield96:Overview, - author = "Glen Ditchfield", - title = "An Overview of Cforall", - note = "in preparation", - year = 1996 + author = "Glen Ditchfield", + title = "An Overview of Cforall", + note = "in preparation", + year = 1996 } @article{Bak:overload, - keywords = {compilation}, - contributer = {gjditchfield@msg}, - author = {T. P. Baker}, - title = {A One-Pass Algorithm for Overload Resolution in {Ada}}, - journal = toplas, - year = 1982, - month = oct, volume = 4, number = 4, pages = {601--614}, - abstract = { + keywords = {compilation}, + contributer = {gjditchfield@msg}, + author = {T. P. Baker}, + title = {A One-Pass Algorithm for Overload Resolution in {Ada}}, + journal = toplas, + year = 1982, + month = oct, volume = 4, number = 4, pages = {601--614}, + abstract = { A simple method is presented for detecting ambiguities and finding the correct interpretations of expressions in the programming @@ -56,5 +56,5 @@ approach is demonstrated by a brief formal argument. }, - comment = { + comment = { See also \cite{D:overload}. } @@ -77,23 +77,23 @@ @book{clu, - keywords = {CLU}, - contributer = {gjditchfield@msg}, - author = {Barbara Liskov and Russell Atkinson and Toby Bloom and Eliot + keywords = {CLU}, + contributer = {gjditchfield@msg}, + author = {Barbara Liskov and Russell Atkinson and Toby Bloom and Eliot Moss and J. Craig Schaffert and Robert Scheifler and Alan Snyder}, - title = {CLU Reference Manual}, - publisher = {Springer-Verlag}, - year = 1981, - volume = 114, - series = {Lecture Notes in Computer Science} + title = {CLU Reference Manual}, + publisher = {Springer-Verlag}, + year = 1981, + volume = 114, + series = {Lecture Notes in Computer Science} } @manual{SIMULA87, - keywords = {Simula standard}, - contributer = {gjditchfield@msg}, - title = {Databehandling -- Programspr{\aa}k -- {SIMULA}}, - organization = {Standardiseringskommissionen i Sverige}, - note = {Svensk Standard SS 63 61 14}, - year = 1987, - abstract = { + keywords = {Simula standard}, + contributer = {gjditchfield@msg}, + title = {Databehandling -- Programspr{\aa}k -- {SIMULA}}, + organization = {Standardiseringskommissionen i Sverige}, + note = {Svensk Standard SS 63 61 14}, + year = 1987, + abstract = { Standard for the programming language SIMULA. Written in English. } @@ -112,8 +112,8 @@ @inproceedings{Thompson90new, - title = {A New C Compiler}, - author = {Ken Thompson}, - booktitle = {Proceedings of the Summer 1990 UKUUG Conference}, - year = 1990, - pages = {41--51} + title = {A New {C} Compiler}, + author = {Ken Thompson}, + booktitle = {Proceedings of the Summer 1990 UKUUG Conference}, + year = 1990, + pages = {41--51} } Index: doc/refrat/refrat.tex =================================================================== --- doc/refrat/refrat.tex (revision d3ed39f8b97ed4f3146139cbff06f8c72311b75c) +++ doc/refrat/refrat.tex (revision 83e9bd3542d6b3c6755e50591bde755e42a80a44) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:52:25 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Wed Apr 5 23:23:28 2017 -%% Update Count : 79 +%% Last Modified On : Fri Jun 2 10:43:14 2017 +%% Update Count : 83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -29,4 +29,5 @@ \usepackage{epic,eepic} \usepackage{upquote} % switch curled `'" to straight +\usepackage{calc} \usepackage{xspace} \usepackage{varioref} % extended references @@ -62,5 +63,4 @@ % Names used in the document. \newcommand{\Version}{\input{../../version}} - \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}} \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}} @@ -97,4 +97,5 @@ \renewcommand{\chaptermark}[1]{\markboth{\thechapter\quad #1}{\thechapter\quad #1}} \renewcommand{\sectionmark}[1]{\markboth{\thesection\quad #1}{\thesection\quad #1}} +\renewcommand{\subsectionmark}[1]{\markboth{\thesubsection\quad #1}{\thesubsection\quad #1}} \pagenumbering{roman} \linenumbers % comment out to turn off line numbering @@ -121,8 +122,10 @@ This document is a reference manual and rationale for \CFA, a polymorphic extension of the C programming language. -It makes frequent reference to the {\c11} standard \cite{C11}, and occasionally compares \CFA to {\CC} \cite{C++}. - -The manual deliberately imitates the ordering of the {\c11} standard (although the section numbering differs). -Unfortunately, this means the manual contains more ``forward references'' than usual, making it harder to follow if the reader does not have a copy of the {\c11} standard. +It covers low-level syntactic and semantic details of the language to address complex language issues for programmers, and provide language implementers with a precise language description. +It makes frequent reference to the \Celeven standard~\cite{C11}, and occasionally compares \CFA to \CC~\cite{C++}. +Changes to the syntax and additional features are expected to be included in later revisions. + +The manual deliberately imitates the ordering of the \Celeven standard (although the section numbering differs). +Unfortunately, this means the manual contains more ``forward references'' than usual, making it harder to follow if the reader does not have a copy of the \Celeven standard. For a simple introduction to \CFA, see the companion document ``An Overview of \CFA'' \cite{Ditchfield96:Overview}. @@ -139,5 +142,5 @@ \chapter{Terms, definitions, and symbols} -Terms from the {\c11} standard used in this document have the same meaning as in the {\c11} standard. +Terms from the \Celeven standard used in this document have the same meaning as in the \Celeven standard. % No ``Conformance'' or ``Environment'' chapters yet. @@ -149,5 +152,5 @@ \section{Notation} -The syntax notation used in this document is the same as in the {\c11} standard, with one exception: ellipsis in the definition of a nonterminal, as in ``\emph{declaration:} \ldots'', indicates that these rules extend a previous definition, which occurs in this document or in the {\c11} standard. +The syntax notation used in this document is the same as in the \Celeven standard, with one exception: ellipsis in the definition of a nonterminal, as in ``\emph{declaration:} \ldots'', indicates that these rules extend a previous definition, which occurs in this document or in the \Celeven standard. @@ -162,5 +165,5 @@ \begin{rationale} Hence, a \CFA program can declare an ©int v© and a ©float v© in the same scope; -a {\CC} program can not. +a \CC program can not. \end{rationale} @@ -285,5 +288,5 @@ \begin{rationale} -Note that {\c11} does not include conversion from \Index{real type}s to \Index{complex type}s in the usual arithmetic conversions, and \CFA does not include them as safe conversions. +Note that \Celeven does not include conversion from \Index{real type}s to \Index{complex type}s in the usual arithmetic conversions, and \CFA does not include them as safe conversions. \end{rationale} @@ -370,5 +373,5 @@ \begin{rationale} As in C, there is an implicit conversion from ©void *© to any pointer type. -This is clearly dangerous, and {\CC} does not have this implicit conversion. +This is clearly dangerous, and \CC does not have this implicit conversion. \CFA\index{deficiencies!void * conversion} keeps it, in the interest of remaining as pure a superset of C as possible, but discourages it by making it unsafe. \end{rationale} @@ -608,10 +611,10 @@ There are two notable differences between \CFA's overload resolution rules and the rules for -{\CC} defined in \cite{C++}. +\CC defined in \cite{C++}. First, the result type of a function plays a role. -In {\CC}, a function call must be completely resolved based on the arguments to the call in most circumstances. +In \CC, a function call must be completely resolved based on the arguments to the call in most circumstances. In \CFA, a function call may have several interpretations, each with a different result type, and the interpretations of the containing context choose among them. Second, safe conversions are used to choose among interpretations of all sorts of functions; -in {\CC}, the ``usual arithmetic conversions'' are a separate set of rules that apply only to the built-in operators. +in \CC, the ``usual arithmetic conversions'' are a separate set of rules that apply only to the built-in operators. \end{rationale} @@ -637,5 +640,5 @@ \begin{rationale} -Expression syntax is quoted from the {\c11} standard. +Expression syntax is quoted from the \Celeven standard. The syntax itself defines the precedence and associativity of operators. The sections are arranged in decreasing order of precedence, with all operators in a section having the same precedence. @@ -665,5 +668,5 @@ The \Index{valid interpretation} of an \nonterm{identifier} are given by the visible\index{visible} declarations of the identifier. -A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by {\c11}. +A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by \Celeven. The predefined integer identifiers ``©1©'' and ``©0©'' have the integer values 1 and 0, respectively. The other two predefined ``©0©'' identifiers are bound to polymorphic pointer values that, when specialized\index{specialization} with a data type or function type respectively, produce a null pointer of that type. @@ -1113,5 +1116,5 @@ forall( otype T ) T restrict * ?++( T restrict *restrict volatile * ); \end{lstlisting} with ©T© inferred to be ©float *©. -This looks odd, because {\c11} contains a constraint that requires restrict-qualified types to be pointer-to-object types, and ©T© is not syntactically a pointer type. \CFA loosens the constraint. +This looks odd, because \Celeven contains a constraint that requires restrict-qualified types to be pointer-to-object types, and ©T© is not syntactically a pointer type. \CFA loosens the constraint. \end{enumerate} \end{rationale} @@ -1477,5 +1480,5 @@ \begin{rationale} -{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the \Index{usual arithmetic conversion}s. Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern. +\Celeven does not include conversions from the \Index{real type}s to \Index{complex type}s in the \Index{usual arithmetic conversion}s. Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern. \end{rationale} @@ -1506,5 +1509,5 @@ \begin{rationale} -{\c11} defines most arithmetic operations to apply an \Index{integer promotion} to any argument that belongs to a type that has an \Index{integer conversion rank} less than that of ©int©. +\Celeven defines most arithmetic operations to apply an \Index{integer promotion} to any argument that belongs to a type that has an \Index{integer conversion rank} less than that of ©int©. If ©s© is a ©short int©, ``©s *s©'' does not have type ©short int©; it is treated as ``©( (int)s ) * ( (int)s )©'', and has type ©int©. \CFA matches that pattern; @@ -1519,5 +1522,5 @@ \end{lstlisting} Since \CFA does not define a multiplication operator for ©short int©, ©square( s )© is treated as ©square( (int)s )©, and the result has type ©int©. -This is mildly surprising, but it follows the {\c11} operator pattern. +This is mildly surprising, but it follows the \Celeven operator pattern. A more troubling example is @@ -1617,5 +1620,5 @@ ©ptrdiff_t© is an implementation-defined identifier defined in ©© that is synonymous with a signed integral type that is large enough to hold the difference between two pointers. It seems reasonable to use it for pointer addition as well. (This is technically a difference between \CFA and C, which only specifies that pointer addition uses an \emph{integral} argument.) Hence it is also used for subscripting, which is defined in terms of pointer addition. -The {\c11} standard uses ©size_t© in several cases where a library function takes an argument that is used as a subscript, but ©size_t© is unsuitable here because it is an unsigned type. +The \Celeven standard uses ©size_t© in several cases where a library function takes an argument that is used as a subscript, but ©size_t© is unsuitable here because it is an unsigned type. \end{rationale} @@ -1930,5 +1933,5 @@ \end{lstlisting} The logical expression calls the ©Rational© inequality operator, passing it ©*rp© and the ©Rational 0©, and getting a 1 or 0 as a result. -In contrast, {\CC} would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation. +In contrast, \CC would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation. The conversion to ©int© would produce a general integer value, which is unfortunate, and possibly dangerous if the conversion was not written with this situation in mind. \end{rationale} @@ -2626,13 +2629,13 @@ \begin{itemize} \item a typedef name may be redefined to denote the same type as it currently does, provided that type is not a variably modified type; -\item tags may be redeclared as specified in section 6.7.2.3 of the {\c11} standard. +\item tags may be redeclared as specified in section 6.7.2.3 of the \Celeven standard. \end{itemize} \begin{rationale} -This constraint adds the phrase ``with compatible types'' to the {\c11} constraint, to allow overloading. +This constraint adds the phrase ``with compatible types'' to the \Celeven constraint, to allow overloading. \end{rationale} An identifier declared by a type declaration shall not be redeclared as a parameter in a function definition whose declarator includes an identifier list. \begin{rationale} -This restriction echos {\c11}'s ban on the redeclaration of typedef names as parameters. +This restriction echos \Celeven's ban on the redeclaration of typedef names as parameters. This avoids an ambiguity between old-style function declarations and new-style function prototypes: \begin{lstlisting} @@ -2661,5 +2664,5 @@ \semantics -\CFA extends the {\c11} definition of \define{anonymous structure} to include structure specifiers with tags, and extends the {\c11} definition of \define{anonymous union} to include union specifiers with tags. +\CFA extends the \Celeven definition of \define{anonymous structure} to include structure specifiers with tags, and extends the \Celeven definition of \define{anonymous union} to include union specifiers with tags. \begin{rationale} This extension imitates an extension in the Plan 9 C compiler \cite{Thompson90new}. @@ -2854,6 +2857,6 @@ \begin{rationale} -©lvalue© provides some of the functionality of {\CC}'s ``©T&©'' ( reference to object of type ©T©) type. -Reference types have four uses in {\CC}. +©lvalue© provides some of the functionality of \CC's ``©T&©'' ( reference to object of type ©T©) type. +Reference types have four uses in \CC. \begin{itemize} \item @@ -2862,5 +2865,5 @@ \item A reference can be used to define an alias for a complicated lvalue expression, as a way of getting some of the functionality of the Pascal ©with© statement. -The following {\CC} code gives an example. +The following \CC code gives an example. \begin{lstlisting} { @@ -2874,5 +2877,5 @@ A reference parameter can be used to allow a function to modify an argument without forcing the caller to pass the address of the argument. This is most useful for user-defined assignment operators. -In {\CC}, plain assignment is done by a function called ``©operator=©'', and the two expressions +In \CC, plain assignment is done by a function called ``©operator=©'', and the two expressions \begin{lstlisting} a = b; @@ -2887,5 +2890,5 @@ \item References to \Index{const-qualified} types can be used instead of value parameters. Given the -{\CC} function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is +\CC function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is ©Thing©, the type of ©fiddle© could be either of \begin{lstlisting} @@ -3216,5 +3219,5 @@ The Simula class \cite{SIMULA87} is essentially a record type. Since the only operations on a record are member selection and assignment, which can not be overloaded, there is never any ambiguity as to whether the abstraction or the implementation view is being used. -In {\CC} +In \CC \cite{C++}, operations on class instances include assignment and ``©&©'', which can be overloaded. A ``scope resolution'' operator can be used inside the class to specify whether the abstract or implementation version of the operation should be used. @@ -3548,5 +3551,5 @@ \subsection{Predefined macro names} -The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the {\c11} standard. +The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the \Celeven standard. It shall not define the macro name ©__STDC__©. @@ -3634,5 +3637,5 @@ \subsection{Pointer and array types} -Array types can barely be said to exist in {\c11}, since in most cases an array name is treated as a constant pointer to the first element of the array, and the subscript expression ``©a[i]©'' is equivalent to the dereferencing expression ``©(*( a+( i )))©''. +Array types can barely be said to exist in \Celeven, since in most cases an array name is treated as a constant pointer to the first element of the array, and the subscript expression ``©a[i]©'' is equivalent to the dereferencing expression ``©(*( a+( i )))©''. Technically, pointer arithmetic and pointer comparisons other than ``©==©'' and ``©!=©'' are only defined for pointers to array elements, but the type system does not enforce those restrictions. Consequently, there is no need for a separate ``array type'' specification. @@ -3712,5 +3715,5 @@ Different operators often have related meanings; for instance, in C, ``©+©'', ``©+=©'', and the two versions of ``©++©'' perform variations of addition. -Languages like {\CC} and Ada allow programmers to define operators for new types, but do not require that these relationships be preserved, or even that all of the operators be implemented. +Languages like \CC and Ada allow programmers to define operators for new types, but do not require that these relationships be preserved, or even that all of the operators be implemented. Completeness and consistency is left to the good taste and discretion of the programmer. It is possible to encourage these attributes by providing generic operator functions, or member functions of abstract classes, that are defined in terms of other, related operators. @@ -3823,4 +3826,5 @@ \end{theindex} + \end{document}