Changeset f94ca7e for doc


Ignore:
Timestamp:
Jun 2, 2017, 5:42:10 PM (8 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
0db6fc0
Parents:
2164637 (diff), 2c6c893 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Location:
doc
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • doc/bibliography/cfa.bib

    r2164637 rf94ca7e  
    44244424    keywords    = {Plan 9},
    44254425    contributer = {pabuhr@plg},
    4426     title       = {A New C Compiler},
     4426    title       = {A New {C} Compiler},
    44274427    author      = {Ken Thompson},
    44284428    booktitle   = {Proceedings of the Summer 1990 UKUUG Conference},
    44294429    year        = 1990,
    44304430    pages       = {41--51},
    4431     url         = {http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}
     4431    note        = {\href{http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}{http://\-doc.cat-v.org/\-bell\_labs/\-new\_c\_compilers/\-new\_c\_compiler.pdf}},
    44324432}
    44334433

  • doc/refrat/Makefile

    r2164637 rf94ca7e  
    4444
    4545${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \
    46                 ../LaTeXmacros/common.tex ../LaTeXmacros/indexstyle ../bibliography/cfa.bib
     46                ../LaTeXmacros/common.tex ../LaTeXmacros/lstlang.sty ../LaTeXmacros/indexstyle ../bibliography/cfa.bib
    4747        # Conditionally create an empty *.ind (index) file for inclusion until makeindex is run.
    4848        if [ ! -r ${basename $@}.ind ] ; then touch ${basename $@}.ind ; fi
    … …  
    7070        fig2dev -L ps $< > $@
    7171
     72%.pstex : %.fig
     73        fig2dev -L pstex $< > $@
     74        fig2dev -L pstex_t -p $@ $< > $@_t
     75
    7276# Local Variables: #
    7377# compile-command: "make" #

  • doc/refrat/refrat.bib

    r2164637 rf94ca7e  
    22
    33@manual{ANS:C,
    4     keywords = {ANSI C},
    5     contributer = {gjditchfield@msg},
    6     title = {American National Standard for Information Systems --
     4    keywords    = {ANSI C},
     5    contributer = {gjditchfield@msg},
     6    title       = {American National Standard for Information Systems --
    77          Programming Language -- {C}},
    8     organization = {American National Standards Institute},
    9     address = {1430 Broadway, New York, New York  10018},
    10     month = dec, year = 1989,
    11     note = {X3.159-1989}
     8    organization= {American National Standards Institute},
     9    address     = {1430 Broadway, New York, New York  10018},
     10    month       = dec, year     = 1989,
     11    note        = {X3.159-1989}
    1212}
    1313
    1414@manual{ANS:C11,
    15     keywords = {ANS:C11},
    16     contributer = {gjditchfield@acm.org},
    17     title = {American National Standard Information Systems --
     15    keywords    = {ANS:C11},
     16    contributer = {gjditchfield@acm.org},
     17    title       = {American National Standard Information Systems --
    1818          Programming languages -- {C}},
    19     organization = {American National Standards Institute},
    20     address = {25 West 43rd Street, New York, New York 10036},
    21     month = may, year = 2012,
    22     note = {INCITS/ISO/IEC 9899-2011[2012]}
     19    organization= {American National Standards Institute},
     20    address     = {25 West 43rd Street, New York, New York 10036},
     21    month       = may, year     = 2012,
     22    note        = {INCITS/ISO/IEC 9899-2011[2012]}
    2323}
    2424
    2525@book{c++,
    26     keywords = {C++, ANSI},
    27     author = {Margaret A. Ellis and Bjarne Stroustrup},
    28     title = {The Annotated {C}{\tt ++} Reference Manual},
    29     publisher = {Addison Wesley},
    30     year = 1990,
    31     edition = {first}
     26    keywords    = {C++, ANSI},
     27    author      = {Margaret A. Ellis and Bjarne Stroustrup},
     28    title       = {The Annotated {C}{\tt ++} Reference Manual},
     29    publisher   = {Addison Wesley},
     30    year        = 1990,
     31    edition     = {first}
    3232}
    3333
    3434@Unpublished{Ditchfield96:Overview,
    35   author =      "Glen Ditchfield",
    36   title =        "An Overview of Cforall",
    37   note =        "in preparation",
    38   year =        1996
     35    author      = "Glen Ditchfield",
     36    title       = "An Overview of Cforall",
     37    note        = "in preparation",
     38    year        = 1996
    3939}
    4040
    4141@article{Bak:overload,
    42     keywords = {compilation},
    43     contributer = {gjditchfield@msg},
    44     author = {T. P. Baker},
    45     title = {A One-Pass Algorithm for Overload Resolution in {Ada}},
    46     journal = toplas,
    47     year = 1982,
    48     month = oct, volume = 4, number = 4, pages = {601--614},
    49     abstract = {
     42    keywords    = {compilation},
     43    contributer = {gjditchfield@msg},
     44    author      = {T. P. Baker},
     45    title       = {A One-Pass Algorithm for Overload Resolution in {Ada}},
     46    journal     = toplas,
     47    year        = 1982,
     48    month       = oct, volume   = 4, number     = 4, pages      = {601--614},
     49    abstract    = {
    5050        A simple method is presented for detecting ambiguities and finding
    5151        the correct interpretations of expressions in the programming
    … …  
    5656        approach is demonstrated by a brief formal argument.
    5757    },
    58     comment = {
     58    comment     = {
    5959        See also \cite{D:overload}.
    6060        }
    … …  
    7777
    7878@book{clu,
    79     keywords = {CLU},
    80     contributer = {gjditchfield@msg},
    81     author = {Barbara Liskov and Russell Atkinson and Toby Bloom and Eliot
     79    keywords    = {CLU},
     80    contributer = {gjditchfield@msg},
     81    author      = {Barbara Liskov and Russell Atkinson and Toby Bloom and Eliot
    8282    Moss and J. Craig Schaffert and Robert Scheifler and Alan Snyder},
    83     title = {CLU Reference Manual},
    84     publisher = {Springer-Verlag},
    85     year = 1981,
    86     volume = 114,
    87     series = {Lecture Notes in Computer Science}
     83    title       = {CLU Reference Manual},
     84    publisher   = {Springer-Verlag},
     85    year        = 1981,
     86    volume      = 114,
     87    series      = {Lecture Notes in Computer Science}
    8888}
    8989
    9090@manual{SIMULA87,
    91     keywords = {Simula standard},
    92     contributer = {gjditchfield@msg},
    93     title = {Databehandling -- Programspr{\aa}k -- {SIMULA}},
    94     organization = {Standardiseringskommissionen i Sverige},
    95     note = {Svensk Standard SS 63 61 14},
    96     year = 1987,
    97     abstract = {
     91    keywords    = {Simula standard},
     92    contributer = {gjditchfield@msg},
     93    title       = {Databehandling -- Programspr{\aa}k -- {SIMULA}},
     94    organization        = {Standardiseringskommissionen i Sverige},
     95    note        = {Svensk Standard SS 63 61 14},
     96    year        = 1987,
     97    abstract    = {
    9898        Standard for the programming language SIMULA.  Written in English.
    9999    }
    … …  
    112112
    113113@inproceedings{Thompson90new,
    114   title = {A New C Compiler},
    115   author = {Ken Thompson},
    116   booktitle = {Proceedings of the Summer 1990 UKUUG Conference},
    117   year = 1990,
    118   pages = {41--51}
     114    title       = {A New {C} Compiler},
     115    author      = {Ken Thompson},
     116    booktitle   = {Proceedings of the Summer 1990 UKUUG Conference},
     117    year        = 1990,
     118    pages       = {41--51}
    119119}

  • doc/refrat/refrat.tex

    r2164637 rf94ca7e  
    1111%% Created On       : Wed Apr  6 14:52:25 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Wed Apr  5 23:23:28 2017
    14 %% Update Count     : 79
     13%% Last Modified On : Fri Jun  2 10:43:14 2017
     14%% Update Count     : 83
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    2929\usepackage{epic,eepic}
    3030\usepackage{upquote}                                                                    % switch curled `'" to straight
     31\usepackage{calc}
    3132\usepackage{xspace}
    3233\usepackage{varioref}                                                                   % extended references
    … …  
    6263% Names used in the document.
    6364\newcommand{\Version}{\input{../../version}}
    64 
    6565\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
    6666\newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
    … …  
    9797\renewcommand{\chaptermark}[1]{\markboth{\thechapter\quad #1}{\thechapter\quad #1}}
    9898\renewcommand{\sectionmark}[1]{\markboth{\thesection\quad #1}{\thesection\quad #1}}
     99\renewcommand{\subsectionmark}[1]{\markboth{\thesubsection\quad #1}{\thesubsection\quad #1}}
    99100\pagenumbering{roman}
    100101\linenumbers                                            % comment out to turn off line numbering
    … …  
    121122
    122123This document is a reference manual and rationale for \CFA, a polymorphic extension of the C programming language.
    123 It makes frequent reference to the {\c11} standard \cite{C11}, and occasionally compares \CFA to {\CC} \cite{C++}.
    124 
    125 The manual deliberately imitates the ordering of the {\c11} standard (although the section numbering differs).
    126 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.
     124It 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.
     125It makes frequent reference to the \Celeven standard~\cite{C11}, and occasionally compares \CFA to \CC~\cite{C++}.
     126Changes to the syntax and additional features are expected to be included in later revisions.
     127
     128The manual deliberately imitates the ordering of the \Celeven standard (although the section numbering differs).
     129Unfortunately, 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.
    127130For a simple introduction to \CFA, see the companion document ``An Overview of \CFA''
    128131\cite{Ditchfield96:Overview}.
    … …  
    139142\chapter{Terms, definitions, and symbols}
    140143
    141 Terms from the {\c11} standard used in this document have the same meaning as in the {\c11} standard.
     144Terms from the \Celeven standard used in this document have the same meaning as in the \Celeven standard.
    142145
    143146% No ``Conformance'' or ``Environment'' chapters yet.
    … …  
    149152
    150153\section{Notation}
    151 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.
     154The 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.
    152155
    153156
    … …  
    162165\begin{rationale}
    163166Hence, a \CFA program can declare an ©int v© and a ©float v© in the same scope;
    164 a {\CC} program can not.
     167a \CC program can not.
    165168\end{rationale}
    166169
    … …  
    285288
    286289\begin{rationale}
    287 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.
     290Note 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.
    288291\end{rationale}
    289292
    … …  
    370373\begin{rationale}
    371374As in C, there is an implicit conversion from ©void *© to any pointer type.
    372 This is clearly dangerous, and {\CC} does not have this implicit conversion.
     375This is clearly dangerous, and \CC does not have this implicit conversion.
    373376\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.
    374377\end{rationale}
    … …  
    608611
    609612There are two notable differences between \CFA's overload resolution rules and the rules for
    610 {\CC} defined in \cite{C++}.
     613\CC defined in \cite{C++}.
    611614First, the result type of a function plays a role.
    612 In {\CC}, a function call must be completely resolved based on the arguments to the call in most circumstances.
     615In \CC, a function call must be completely resolved based on the arguments to the call in most circumstances.
    613616In \CFA, a function call may have several interpretations, each with a different result type, and the interpretations of the containing context choose among them.
    614617Second, safe conversions are used to choose among interpretations of all sorts of functions;
    615 in {\CC}, the ``usual arithmetic conversions'' are a separate set of rules that apply only to the built-in operators.
     618in \CC, the ``usual arithmetic conversions'' are a separate set of rules that apply only to the built-in operators.
    616619\end{rationale}
    617620
    … …  
    637640
    638641\begin{rationale}
    639 Expression syntax is quoted from the {\c11} standard.
     642Expression syntax is quoted from the \Celeven standard.
    640643The syntax itself defines the precedence and associativity of operators.
    641644The sections are arranged in decreasing order of precedence, with all operators in a section having the same precedence.
    … …  
    665668The \Index{valid interpretation} of an \nonterm{identifier} are given by the visible\index{visible} declarations of the identifier.
    666669
    667 A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by {\c11}.
     670A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by \Celeven.
    668671The predefined integer identifiers ``©1©'' and ``©0©'' have the integer values 1 and 0, respectively.
    669672The 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.
    … …  
    11131116forall( otype T ) T restrict * ?++( T restrict *restrict volatile * );
    11141117\end{lstlisting} with ©T© inferred to be ©float *©.
    1115 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.
     1118This 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.
    11161119\end{enumerate}
    11171120\end{rationale}
    … …  
    14771480
    14781481\begin{rationale}
    1479 {\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.
     1482\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.
    14801483\end{rationale}
    14811484
    … …  
    15061509
    15071510\begin{rationale}
    1508 {\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©.
     1511\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©.
    15091512If ©s© is a ©short int©, ``©s *s©'' does not have type ©short int©;
    15101513it is treated as ``©( (int)s ) * ( (int)s )©'', and has type ©int©. \CFA matches that pattern;
    … …  
    15191522\end{lstlisting}
    15201523Since \CFA does not define a multiplication operator for ©short int©, ©square( s )© is treated as ©square( (int)s )©, and the result has type ©int©.
    1521 This is mildly surprising, but it follows the {\c11} operator pattern.
     1524This is mildly surprising, but it follows the \Celeven operator pattern.
    15221525
    15231526A more troubling example is
    … …  
    16171620©ptrdiff_t© is an implementation-defined identifier defined in ©<stddef.h>© that is synonymous with a signed integral type that is large enough to hold the difference between two pointers.
    16181621It 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.
    1619 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.
     1622The \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.
    16201623\end{rationale}
    16211624
    … …  
    19301933\end{lstlisting}
    19311934The logical expression calls the ©Rational© inequality operator, passing it ©*rp© and the ©Rational 0©, and getting a 1 or 0 as a result.
    1932 In contrast, {\CC} would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation.
     1935In contrast, \CC would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation.
    19331936The 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.
    19341937\end{rationale}
    … …  
    26262629\begin{itemize}
    26272630\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;
    2628 \item tags may be redeclared as specified in section 6.7.2.3 of the {\c11} standard.
     2631\item tags may be redeclared as specified in section 6.7.2.3 of the \Celeven standard.
    26292632\end{itemize}
    26302633\begin{rationale}
    2631 This constraint adds the phrase ``with compatible types'' to the {\c11} constraint, to allow overloading.
     2634This constraint adds the phrase ``with compatible types'' to the \Celeven constraint, to allow overloading.
    26322635\end{rationale}
    26332636
    26342637An identifier declared by a type declaration shall not be redeclared as a parameter in a function definition whose declarator includes an identifier list.
    26352638\begin{rationale}
    2636 This restriction echos {\c11}'s ban on the redeclaration of typedef names as parameters.
     2639This restriction echos \Celeven's ban on the redeclaration of typedef names as parameters.
    26372640This avoids an ambiguity between old-style function declarations and new-style function prototypes:
    26382641\begin{lstlisting}
    … …  
    26612664
    26622665\semantics
    2663 \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.
     2666\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.
    26642667\begin{rationale}
    26652668This extension imitates an extension in the Plan 9 C compiler \cite{Thompson90new}.
    … …  
    28542857
    28552858\begin{rationale}
    2856 ©lvalue© provides some of the functionality of {\CC}'s ``©T&©'' ( reference to object of type ©T©) type.
    2857 Reference types have four uses in {\CC}.
     2859©lvalue© provides some of the functionality of \CC's ``©T&©'' ( reference to object of type ©T©) type.
     2860Reference types have four uses in \CC.
    28582861\begin{itemize}
    28592862\item
    … …  
    28622865\item
    28632866A 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.
    2864 The following {\CC} code gives an example.
     2867The following \CC code gives an example.
    28652868\begin{lstlisting}
    28662869{
    … …  
    28742877A reference parameter can be used to allow a function to modify an argument without forcing the caller to pass the address of the argument.
    28752878This is most useful for user-defined assignment operators.
    2876 In {\CC}, plain assignment is done by a function called ``©operator=©'', and the two expressions
     2879In \CC, plain assignment is done by a function called ``©operator=©'', and the two expressions
    28772880\begin{lstlisting}
    28782881a = b;
    … …  
    28872890\item
    28882891References to \Index{const-qualified} types can be used instead of value parameters.  Given the
    2889 {\CC} function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is
     2892\CC function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is
    28902893©Thing©, the type of ©fiddle© could be either of
    28912894\begin{lstlisting}
    … …  
    32163219The Simula class \cite{SIMULA87} is essentially a record type.
    32173220Since 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.
    3218 In {\CC}
     3221In \CC
    32193222\cite{C++}, operations on class instances include assignment and ``©&©'', which can be overloaded.
    32203223A ``scope resolution'' operator can be used inside the class to specify whether the abstract or implementation version of the operation should be used.
    … …  
    35483551\subsection{Predefined macro names}
    35493552
    3550 The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the {\c11} standard.
     3553The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the \Celeven standard.
    35513554It shall not define the macro name ©__STDC__©.
    35523555
    … …  
    36343637\subsection{Pointer and array types}
    36353638
    3636 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 )))©''.
     3639Array 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 )))©''.
    36373640Technically, 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.
    36383641Consequently, there is no need for a separate ``array type'' specification.
    … …  
    37123715Different operators often have related meanings;
    37133716for instance, in C, ``©+©'', ``©+=©'', and the two versions of ``©++©'' perform variations of addition.
    3714 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.
     3717Languages 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.
    37153718Completeness and consistency is left to the good taste and discretion of the programmer.
    37163719It 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.
    … …  
    38233826\end{theindex}
    38243827
     3828
    38253829\end{document}
    38263830

  • doc/user/user.tex

    r2164637 rf94ca7e  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Tue May 30 11:45:46 2017
    14 %% Update Count     : 2098
     13%% Last Modified On : Fri Jun  2 10:07:51 2017
     14%% Update Count     : 2128
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    185185While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
    186186
    187 This document is a user manual for the \CFA programming language, targeted at \CFA programmers.
     187This document is a programmer reference-manual for the \CFA programming language.
     188The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
     189The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
     190A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented as well as some experience programming in C/\CC.
    188191Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
    189 In its current state, this document covers the intended core features of the language.
    190192Changes to the syntax and additional features are expected to be included in later revisions.
    191193
    … …  
    52425244\begin{description}
    52435245\item[fill]
    5244 after allocation the storage is or is not filled with a specified character.
     5246after allocation the storage is filled with a specified character.
    52455247\item[resize]
    52465248an existing allocation is decreased or increased in size.
    52475249In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
    5248 For an increase in storage size, new storage after the copied data may or may not be filled.
     5250For an increase in storage size, new storage after the copied data may be filled.
    52495251\item[alignment]
    52505252an allocation starts on a specified memory boundary, e.g., an address multiple of 64 or 128 for cache-line purposes.
    52515253\item[array]
    52525254the allocation size is scaled to the specified number of array elements.
    5253 An array may or not be filled, resized, or aligned.
     5255An array may be filled, resized, or aligned.
    52545256\end{description}
    5255 
    5256 The following table show the allocation routines supporting different combinations of storage-management capabilities:
     5257The table shows allocation routines supporting different combinations of storage-management capabilities:
    52575258\begin{center}
    5258 \begin{tabular}{@{}r|l|l|l|l@{}}
    5259                                         & fill                          & resize        & alignment     & array \\
     5259\begin{tabular}{@{}lr|l|l|l|l@{}}
     5260                &                                       & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
    52605261\hline
    5261 ©malloc©                        & no/yes                        & no/yes        & no            & no    \\
    5262 ©amalloc©                       & no/copy data/yes      & no/yes        & no            & yes   \\
    5263 ©calloc©                        & yes (0 only)          & no            & no            & yes   \\
    5264 ©realloc©                       & no/copy data          & yes           & no            & no    \\
    5265 ©memalign©                      & no/yes                        & no            & yes           & no    \\
    5266 ©amemalign©                     & no/yes                        & no            & yes           & yes   \\
    5267 ©align_alloc©           & no                            & no            & yes           & no    \\
    5268 ©posix_memalign©        & no                            & no            & yes           & no    \\
     5262C               & ©malloc©                      & no                    & no            & no            & no    \\
     5263                & ©calloc©                      & yes (0 only)  & no            & no            & yes   \\
     5264                & ©realloc©                     & no/copy               & yes           & no            & no    \\
     5265                & ©memalign©            & no                    & no            & yes           & no    \\
     5266                & ©posix_memalign©      & no                    & no            & yes           & no    \\
     5267C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
     5268\CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
     5269                & ©align_alloc©         & no/yes                & no            & yes           & yes   \\
    52695270\end{tabular}
    52705271\end{center}
    5271 % When ©amalloc© resizes and fills, the space after the copied data from the source is set to the fill character.
    52725272It is impossible to resize with alignment because the underlying ©realloc© allocates storage if more space is needed, and it does not honour alignment from the original allocation.
    52735273
    52745274\leavevmode
    52755275\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    5276 // allocation, non-array types
    5277 forall( dtype T | sized(T) ) T * malloc( void );§\indexc{malloc}§
    5278 forall( dtype T | sized(T) ) T * malloc( char fill );
    5279 
    5280 // allocation, array types
    5281 forall( dtype T | sized(T) ) T * calloc( size_t dim );§\indexc{cmalloc}§
    5282 forall( dtype T | sized(T) ) T * amalloc( size_t dim );§\indexc{amalloc}§  // alternate name for calloc
    5283 forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill );
    5284 
    5285 // resize, non-array types
    5286 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );§\indexc{realloc}§
    5287 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
    5288 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );  // alternate name for realloc
    5289 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill );
    5290 
    5291 // resize, array types
    5292 forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim );
    5293 forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill );
    5294 
    5295 // alignment, non-array types
    5296 forall( dtype T | sized(T) ) T * memalign( size_t alignment );§\indexc{memalign}§
    5297 forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill );
    5298 forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );§\indexc{aligned_alloc}§
    5299 forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );§\indexc{posix_memalign}§
    5300 
    5301 // alignment, array types
    5302 forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim );§\indexc{amemalign}§
    5303 forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill );
    5304 
    5305 // data, non-array types
     5276// C unsafe allocation
     5277extern "C" {
     5278void * mallac( size_t size );§\indexc{memset}§
     5279void * calloc( size_t dim, size_t size );§\indexc{calloc}§
     5280void * realloc( void * ptr, size_t size );§\indexc{realloc}§
     5281void * memalign( size_t align, size_t size );§\indexc{memalign}§
     5282int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
     5283}
     5284
     5285// §\CFA§ safe equivalents, i.e., implicit size specification
     5286forall( dtype T | sized(T) ) T * malloc( void );
     5287forall( dtype T | sized(T) ) T * calloc( size_t dim );
     5288forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
     5289forall( dtype T | sized(T) ) T * memalign( size_t align );
     5290forall( dtype T | sized(T) ) T * aligned_alloc( size_t align );
     5291forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align );
     5292
     5293// §\CFA§ safe general allocation, fill, resize, array
     5294forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§
     5295forall( dtype T | sized(T) ) T * alloc( char fill );
     5296forall( dtype T | sized(T) ) T * alloc( size_t dim );
     5297forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill );
     5298forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim );
     5299forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     5300
     5301// §\CFA§ safe general allocation, align, fill, array
     5302forall( dtype T | sized(T) ) T * align_alloc( size_t align );
     5303forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill );
     5304forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim );
     5305forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill );
     5306
     5307// C unsafe initialization/copy
     5308extern "C" {
     5309void * memset( void * dest, int c, size_t size );
     5310void * memcpy( void * dest, const void * src, size_t size );
     5311}
     5312
     5313// §\CFA§ safe initialization/copy
    53065314forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§
    53075315forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
    53085316
    5309 // data, array types
    5310 forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c );§\indexc{amemset}§
    5311 forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim );§\indexc{amemcpy}§
    5312 
    5313 // allocation/deallocation and constructor/destructor
    5314 forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );§\indexc{new}§
     5317// §\CFA§ safe initialization/copy array
     5318forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c );
     5319forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim );
     5320
     5321// §\CFA§ allocation/deallocation and constructor/destructor
     5322forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§
    53155323forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§
    5316 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete(Params); } ) void delete( T * ptr, Params rest );
     5324forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
     5325  void delete( T * ptr, Params rest );
     5326
     5327// §\CFA§ allocation/deallocation and constructor/destructor, array
     5328forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
     5329forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
     5330forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
     5331  void adelete( size_t dim, T arr[], Params rest );
    53175332\end{cfa}
    53185333

  • doc/working/exception/impl/except.c

    r2164637 rf94ca7e  
    44
    55#include "lsda.h"
     6
     7// This macro should be the only thing that needs to change across machines.
     8// struct _Unwind_Context * -> _Unwind_Reason_Code(*)()
     9#define MATCHER_FROM_CONTEXT(ptr_to_context) \
     10        (*(_Unwind_Reason_Code(**)())(_Unwind_GetCFA(ptr_to_context) + 8))
     11
    612
    713//Global which defines the current exception
    … …  
    1723                     struct _Unwind_Exception* unwind_exception, struct _Unwind_Context* context)
    1824{
     25        printf("CFA: 0x%lx\n", _Unwind_GetCFA(context));
     26
    1927        //DEBUG
    2028        printf("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
    … …  
    111119
    112120                                        //Get a function pointer from the relative offset and call it
    113                                         _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;                                     
     121                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;                                   
     122
     123                                        _Unwind_Reason_Code (*matcher)() =
     124                                                MATCHER_FROM_CONTEXT(context);
    114125                                        _Unwind_Reason_Code ret = matcher();
    115126

  • doc/working/exception/impl/main.c

    r2164637 rf94ca7e  
    11#include <stdio.h>
    22#include "except.h"
     3
     4// Requires -fexceptions to work.
    35
    46#define EXCEPTION 2
    … …  
    2628extern int this_exception;
    2729_Unwind_Reason_Code foo_try_match() {
    28         return this_exception == 3 ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND;
     30        printf(" (foo_try_match called)");
     31        return this_exception == EXCEPTION ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND;
    2932}
    3033
    … …  
    3437//for details
    3538__attribute__((noinline))
    36 void try( void (*try_block)(), void (*catch_block)() )
     39void try( void (*try_block)(), void (*catch_block)(),
     40          _Unwind_Reason_Code (*match_block)() )
    3741{
     42        volatile int xy = 0;
     43        printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
     44
    3845        //Setup statments
    3946        //These 2 statments won't actually result in any code,
    … …  
    95102        "       .uleb128 .CATCH-try\n"                          //Hanlder landing pad adress  (relative to start of function)
    96103        "       .uleb128 1\n"                                           //Action code, gcc seems to use always 0
    97         //Beyond this point we don't match gcc data'
    98         "       .uleb128 foo_try_match-try\n"                   //Handler routine to check if the exception is matched
    99104        ".LLSDACSECFA2:\n"                                              //BODY end
    100105        "       .text\n"                                                        //TABLE footer
    … …  
    122127
    123128        //Actual call to the try block
    124         try( foo_try_block, foo_catch_block );
     129        try( foo_try_block, foo_catch_block, foo_try_match );
    125130
    126131        printf( "Foo exited normally\n" );
    127132}
    128133
     134// Not in main.cfa
     135void fy() {
     136        // Currently not destroyed if the exception is caught in fee.
     137        raii_t a = { "Fy dtor" };
     138
     139        void fy_try_block() {
     140                raii_t b = { "Fy try dtor" };
     141
     142                throw( 3 );
     143        }
     144
     145        void fy_catch_block() {
     146                printf("Fy caught exception\n");
     147        }
     148
     149        _Unwind_Reason_Code fy_match_block() {
     150                return this_exception == 2 ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND;
     151        }
     152
     153        try(fy_try_block, fy_catch_block, fy_match_block);
     154
     155        printf( "Fy exited normally\n" );
     156}
     157
     158void fee() {
     159        raii_t a = { "Fee dtor" };
     160
     161        void fee_try_block() {
     162                raii_t b = { "Fee try dtor" };
     163
     164                fy();
     165
     166                printf("fy returned\n");
     167        }
     168
     169        void fee_catch_block() {
     170                printf("Fee caught exception\n");
     171        }
     172
     173        _Unwind_Reason_Code fee_match_block() {
     174                return this_exception == 3 ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND;
     175        }
     176
     177        try(fee_try_block, fee_catch_block, fee_match_block);
     178
     179        printf( "Fee exited normally\n" );
     180}
     181// End not in main.cfa
     182
    129183int main() {
    130184        raii_t a = { "Main dtor" };
    131185
    132         for (unsigned int i = 0 ; i < 100000000 ; ++i) foo();
     186        //for (unsigned int i = 0 ; i < 100000000 ; ++i)
     187        foo();
     188        fee();
    133189
    134190        printf("End of program reached\n");

  • doc/working/exception/reference.c

    r2164637 rf94ca7e  
    114114// __builtin_eh_return_data_regno(^) ^=[0..3]? gives index.
    115115
     116// Locally we also seem to have:
     117_Unwind_Word _Unwind_GetCFA (struct _Unwind_Context *);
    116118
    117119// GCC (Dwarf2 ?) Frame Layout Macros
    118 // https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html
     120// See: https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html
     121// Include from: ???
    119122
    120123FIRST_PARAM_OFFSET(fundecl)
Note: See TracChangeset for help on using the changeset viewer.