Changes in / [2c6c893:93684eb]


Ignore:
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • doc/bibliography/cfa.bib

    r2c6c893 r93684eb  
    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     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}},
     4431    url         = {http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}
    44324432}
    44334433

  • doc/refrat/Makefile

    r2c6c893 r93684eb  
    4444
    4545${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \
    46                 ../LaTeXmacros/common.tex ../LaTeXmacros/lstlang.sty ../LaTeXmacros/indexstyle ../bibliography/cfa.bib
     46                ../LaTeXmacros/common.tex ../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 
    7672# Local Variables: #
    7773# compile-command: "make" #

  • doc/refrat/refrat.bib

    r2c6c893 r93684eb  
    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

    r2c6c893 r93684eb  
    1111%% Created On       : Wed Apr  6 14:52:25 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Jun  2 10:43:14 2017
    14 %% Update Count     : 83
     13%% Last Modified On : Wed Apr  5 23:23:28 2017
     14%% Update Count     : 79
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    2929\usepackage{epic,eepic}
    3030\usepackage{upquote}                                                                    % switch curled `'" to straight
    31 \usepackage{calc}
    3231\usepackage{xspace}
    3332\usepackage{varioref}                                                                   % extended references
    … …  
    6362% Names used in the document.
    6463\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}}
    10099\pagenumbering{roman}
    101100\linenumbers                                            % comment out to turn off line numbering
    … …  
    122121
    123122This document is a reference manual and rationale for \CFA, a polymorphic extension of the C programming language.
    124 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.
    125 It makes frequent reference to the \Celeven standard~\cite{C11}, and occasionally compares \CFA to \CC~\cite{C++}.
    126 Changes to the syntax and additional features are expected to be included in later revisions.
    127 
    128 The manual deliberately imitates the ordering of the \Celeven standard (although the section numbering differs).
    129 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.
     123It makes frequent reference to the {\c11} standard \cite{C11}, and occasionally compares \CFA to {\CC} \cite{C++}.
     124
     125The manual deliberately imitates the ordering of the {\c11} standard (although the section numbering differs).
     126Unfortunately, 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.
    130127For a simple introduction to \CFA, see the companion document ``An Overview of \CFA''
    131128\cite{Ditchfield96:Overview}.
    … …  
    142139\chapter{Terms, definitions, and symbols}
    143140
    144 Terms from the \Celeven standard used in this document have the same meaning as in the \Celeven standard.
     141Terms from the {\c11} standard used in this document have the same meaning as in the {\c11} standard.
    145142
    146143% No ``Conformance'' or ``Environment'' chapters yet.
    … …  
    152149
    153150\section{Notation}
    154 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.
     151The 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.
    155152
    156153
    … …  
    165162\begin{rationale}
    166163Hence, a \CFA program can declare an ©int v© and a ©float v© in the same scope;
    167 a \CC program can not.
     164a {\CC} program can not.
    168165\end{rationale}
    169166
    … …  
    288285
    289286\begin{rationale}
    290 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.
     287Note 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.
    291288\end{rationale}
    292289
    … …  
    373370\begin{rationale}
    374371As in C, there is an implicit conversion from ©void *© to any pointer type.
    375 This is clearly dangerous, and \CC does not have this implicit conversion.
     372This is clearly dangerous, and {\CC} does not have this implicit conversion.
    376373\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.
    377374\end{rationale}
    … …  
    611608
    612609There are two notable differences between \CFA's overload resolution rules and the rules for
    613 \CC defined in \cite{C++}.
     610{\CC} defined in \cite{C++}.
    614611First, the result type of a function plays a role.
    615 In \CC, a function call must be completely resolved based on the arguments to the call in most circumstances.
     612In {\CC}, a function call must be completely resolved based on the arguments to the call in most circumstances.
    616613In \CFA, a function call may have several interpretations, each with a different result type, and the interpretations of the containing context choose among them.
    617614Second, safe conversions are used to choose among interpretations of all sorts of functions;
    618 in \CC, the ``usual arithmetic conversions'' are a separate set of rules that apply only to the built-in operators.
     615in {\CC}, the ``usual arithmetic conversions'' are a separate set of rules that apply only to the built-in operators.
    619616\end{rationale}
    620617
    … …  
    640637
    641638\begin{rationale}
    642 Expression syntax is quoted from the \Celeven standard.
     639Expression syntax is quoted from the {\c11} standard.
    643640The syntax itself defines the precedence and associativity of operators.
    644641The sections are arranged in decreasing order of precedence, with all operators in a section having the same precedence.
    … …  
    668665The \Index{valid interpretation} of an \nonterm{identifier} are given by the visible\index{visible} declarations of the identifier.
    669666
    670 A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by \Celeven.
     667A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by {\c11}.
    671668The predefined integer identifiers ``©1©'' and ``©0©'' have the integer values 1 and 0, respectively.
    672669The 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.
    … …  
    11161113forall( otype T ) T restrict * ?++( T restrict *restrict volatile * );
    11171114\end{lstlisting} with ©T© inferred to be ©float *©.
    1118 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.
     1115This 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.
    11191116\end{enumerate}
    11201117\end{rationale}
    … …  
    14801477
    14811478\begin{rationale}
    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.
     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.
    14831480\end{rationale}
    14841481
    … …  
    15091506
    15101507\begin{rationale}
    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©.
     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©.
    15121509If ©s© is a ©short int©, ``©s *s©'' does not have type ©short int©;
    15131510it is treated as ``©( (int)s ) * ( (int)s )©'', and has type ©int©. \CFA matches that pattern;
    … …  
    15221519\end{lstlisting}
    15231520Since \CFA does not define a multiplication operator for ©short int©, ©square( s )© is treated as ©square( (int)s )©, and the result has type ©int©.
    1524 This is mildly surprising, but it follows the \Celeven operator pattern.
     1521This is mildly surprising, but it follows the {\c11} operator pattern.
    15251522
    15261523A more troubling example is
    … …  
    16201617©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.
    16211618It 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.
    1622 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.
     1619The {\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.
    16231620\end{rationale}
    16241621
    … …  
    19331930\end{lstlisting}
    19341931The logical expression calls the ©Rational© inequality operator, passing it ©*rp© and the ©Rational 0©, and getting a 1 or 0 as a result.
    1935 In contrast, \CC would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation.
     1932In contrast, {\CC} would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation.
    19361933The 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.
    19371934\end{rationale}
    … …  
    26292626\begin{itemize}
    26302627\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;
    2631 \item tags may be redeclared as specified in section 6.7.2.3 of the \Celeven standard.
     2628\item tags may be redeclared as specified in section 6.7.2.3 of the {\c11} standard.
    26322629\end{itemize}
    26332630\begin{rationale}
    2634 This constraint adds the phrase ``with compatible types'' to the \Celeven constraint, to allow overloading.
     2631This constraint adds the phrase ``with compatible types'' to the {\c11} constraint, to allow overloading.
    26352632\end{rationale}
    26362633
    26372634An identifier declared by a type declaration shall not be redeclared as a parameter in a function definition whose declarator includes an identifier list.
    26382635\begin{rationale}
    2639 This restriction echos \Celeven's ban on the redeclaration of typedef names as parameters.
     2636This restriction echos {\c11}'s ban on the redeclaration of typedef names as parameters.
    26402637This avoids an ambiguity between old-style function declarations and new-style function prototypes:
    26412638\begin{lstlisting}
    … …  
    26642661
    26652662\semantics
    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.
     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.
    26672664\begin{rationale}
    26682665This extension imitates an extension in the Plan 9 C compiler \cite{Thompson90new}.
    … …  
    28572854
    28582855\begin{rationale}
    2859 ©lvalue© provides some of the functionality of \CC's ``©T&©'' ( reference to object of type ©T©) type.
    2860 Reference types have four uses in \CC.
     2856©lvalue© provides some of the functionality of {\CC}'s ``©T&©'' ( reference to object of type ©T©) type.
     2857Reference types have four uses in {\CC}.
    28612858\begin{itemize}
    28622859\item
    … …  
    28652862\item
    28662863A 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.
    2867 The following \CC code gives an example.
     2864The following {\CC} code gives an example.
    28682865\begin{lstlisting}
    28692866{
    … …  
    28772874A reference parameter can be used to allow a function to modify an argument without forcing the caller to pass the address of the argument.
    28782875This is most useful for user-defined assignment operators.
    2879 In \CC, plain assignment is done by a function called ``©operator=©'', and the two expressions
     2876In {\CC}, plain assignment is done by a function called ``©operator=©'', and the two expressions
    28802877\begin{lstlisting}
    28812878a = b;
    … …  
    28902887\item
    28912888References to \Index{const-qualified} types can be used instead of value parameters.  Given the
    2892 \CC function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is
     2889{\CC} function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is
    28932890©Thing©, the type of ©fiddle© could be either of
    28942891\begin{lstlisting}
    … …  
    32193216The Simula class \cite{SIMULA87} is essentially a record type.
    32203217Since 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.
    3221 In \CC
     3218In {\CC}
    32223219\cite{C++}, operations on class instances include assignment and ``©&©'', which can be overloaded.
    32233220A ``scope resolution'' operator can be used inside the class to specify whether the abstract or implementation version of the operation should be used.
    … …  
    35513548\subsection{Predefined macro names}
    35523549
    3553 The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the \Celeven standard.
     3550The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the {\c11} standard.
    35543551It shall not define the macro name ©__STDC__©.
    35553552
    … …  
    36373634\subsection{Pointer and array types}
    36383635
    3639 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 )))©''.
     3636Array 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 )))©''.
    36403637Technically, 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.
    36413638Consequently, there is no need for a separate ``array type'' specification.
    … …  
    37153712Different operators often have related meanings;
    37163713for instance, in C, ``©+©'', ``©+=©'', and the two versions of ``©++©'' perform variations of addition.
    3717 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.
     3714Languages 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.
    37183715Completeness and consistency is left to the good taste and discretion of the programmer.
    37193716It 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.
    … …  
    38263823\end{theindex}
    38273824
    3828 
    38293825\end{document}
    38303826

  • doc/user/user.tex

    r2c6c893 r93684eb  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Jun  2 10:07:51 2017
    14 %% Update Count     : 2128
     13%% Last Modified On : Thu Jun  1 22:46:09 2017
     14%% Update Count     : 2126
    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 programmer reference-manual for the \CFA programming language.
    188 The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
    189 The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
    190 A 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.
     187This document is a user manual for the \CFA programming language, targeted at \CFA programmers.
    191188Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
     189In its current state, this document covers the intended core features of the language.
    192190Changes to the syntax and additional features are expected to be included in later revisions.
    193191
    … …  
    52755273\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    52765274// C unsafe allocation
    5277 extern "C" {
    5278 void * mallac( size_t size );§\indexc{memset}§
    5279 void * calloc( size_t dim, size_t size );§\indexc{calloc}§
    5280 void * realloc( void * ptr, size_t size );§\indexc{realloc}§
    5281 void * memalign( size_t align, size_t size );§\indexc{memalign}§
    5282 int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
    5283 }
     5275extern "C" { void * mallac( size_t size ); }§\indexc{memset}§
     5276extern "C" { void * calloc( size_t dim, size_t size ); }§\indexc{calloc}§
     5277extern "C" { void * realloc( void * ptr, size_t size ); }§\indexc{realloc}§
     5278extern "C" { void * memalign( size_t align, size_t size ); }§\indexc{memalign}§
     5279extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); }§\indexc{posix_memalign}§
    52845280
    52855281// §\CFA§ safe equivalents, i.e., implicit size specification
    … …  
    53065302
    53075303// C unsafe initialization/copy
    5308 extern "C" {
    5309 void * memset( void * dest, int c, size_t size );
    5310 void * memcpy( void * dest, const void * src, size_t size );
    5311 }
     5304extern "C" { void * memset( void * dest, int c, size_t size ); }
     5305extern "C" { void * memcpy( void * dest, const void * src, size_t size ); }
    53125306
    53135307// §\CFA§ safe initialization/copy

  • src/libcfa/stdlib

    r2c6c893 r93684eb  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun  2 15:51:03 2017
    13 // Update Count     : 218
     12// Last Modified On : Thu Jun  1 22:46:43 2017
     13// Update Count     : 216
    1414//
    1515
    … …  
    127127static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
    128128        //printf( "X19\n" );
    129         return (void *)memset( dest, c, dim * sizeof(T) );      // C memset
     129        return memset( dest, c, dim * sizeof(T) );
    130130} // memset
    131131static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {

  • src/tests/.expect/alloc.txt

    r2c6c893 r93684eb  
    13130x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    1414
    15 C   realloc
     15C   realloc 40
    16160xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
    17 CFA realloc
     17CFA realloc 88
    18180xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    1919
    20 CFA resize alloc
     20CFA resize alloc 40
    21210xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
    22 CFA resize array alloc
     22CFA resize array alloc 88
    23230xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    24 CFA resize array alloc
     24CFA resize array alloc 40
    25250xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
    26 CFA resize array alloc, fill
     26CFA resize array alloc 40, fill
    27270x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    28 CFA resize array alloc, fill
     28CFA resize array alloc 88, fill
    29290x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    30 CFA resize array alloc, fill
     30CFA resize array alloc 40, fill
    31310x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    3232

  • src/tests/alloc.c

    r2c6c893 r93684eb  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun  2 15:13:03 2017
    13 // Update Count     : 316
     12// Last Modified On : Thu Jun  1 21:33:49 2017
     13// Update Count     : 315
    1414//
    1515
    … …  
    8787    p = (void *)realloc( p, dim * sizeof(*p) );                 // C realloc
    8888        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    89         printf( "C   realloc\n" );
     89        printf( "C   realloc %ld\n", malloc_usable_size( p ) );
    9090        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    9191        printf( "\n" );
    … …  
    9393    p = realloc( p, 2 * dim * sizeof(*p) );                             // CFA realloc
    9494        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
    95         printf( "CFA realloc\n" );
     95        printf( "CFA realloc %ld\n", malloc_usable_size( p ) );
    9696        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    9797        printf( "\n" );
    … …  
    104104    p = alloc( p, dim );                                                                // CFA resize array alloc
    105105        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    106         printf( "CFA resize alloc\n" );
     106        printf( "CFA resize alloc %ld\n", malloc_usable_size( p ) );
    107107        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    108108        printf( "\n" );
    … …  
    110110    p = alloc( p, 2 * dim );                                                    // CFA resize array alloc
    111111        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
    112         printf( "CFA resize array alloc\n" );
     112        printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
    113113        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    114114        printf( "\n" );
    115115
    116116    p = alloc( p, dim );                                                                // CFA array alloc
    117         printf( "CFA resize array alloc\n" );
     117        printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
    118118        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    119119        printf( "\n" );
    … …  
    123123
    124124    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
    125         printf( "CFA resize array alloc, fill\n" );
     125        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
    126126        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    127127        printf( "\n" );
    128128
    129129    p = alloc( p, 2 * dim, fill );                                              // CFA array alloc, fill
    130         printf( "CFA resize array alloc, fill\n" );
     130        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
    131131        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    132132        printf( "\n" );
    133133
    134134    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
    135         printf( "CFA resize array alloc, fill\n" );
     135        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
    136136        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
    137137        printf( "\n" );
Note: See TracChangeset for help on using the changeset viewer.