Index: doc/bibliography/cfa.bib =================================================================== --- doc/bibliography/cfa.bib (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/bibliography/cfa.bib (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -4424,10 +4424,10 @@ keywords = {Plan 9}, contributer = {pabuhr@plg}, - title = {A New C Compiler}, + title = {A New {C} Compiler}, author = {Ken Thompson}, booktitle = {Proceedings of the Summer 1990 UKUUG Conference}, year = 1990, pages = {41--51}, - url = {http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf} + 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}}, } Index: doc/refrat/Makefile =================================================================== --- doc/refrat/Makefile (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/refrat/Makefile (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -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 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/refrat/refrat.bib (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -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 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/refrat/refrat.tex (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -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} Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/user/user.tex (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Tue May 30 11:45:46 2017 -%% Update Count : 2098 +%% Last Modified On : Fri Jun 2 10:07:51 2017 +%% Update Count : 2128 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -185,7 +185,9 @@ While 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}). -This document is a user manual for the \CFA programming language, targeted at \CFA programmers. +This document is a programmer reference-manual for the \CFA programming language. +The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature. +The manual does not teach programming, i.e., how to combine the new constructs to build complex programs. +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. Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics. -In its current state, this document covers the intended core features of the language. Changes to the syntax and additional features are expected to be included in later revisions. @@ -5242,77 +5244,90 @@ \begin{description} \item[fill] -after allocation the storage is or is not filled with a specified character. +after allocation the storage is filled with a specified character. \item[resize] an existing allocation is decreased or increased in size. In 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. -For an increase in storage size, new storage after the copied data may or may not be filled. +For an increase in storage size, new storage after the copied data may be filled. \item[alignment] an allocation starts on a specified memory boundary, e.g., an address multiple of 64 or 128 for cache-line purposes. \item[array] the allocation size is scaled to the specified number of array elements. -An array may or not be filled, resized, or aligned. +An array may be filled, resized, or aligned. \end{description} - -The following table show the allocation routines supporting different combinations of storage-management capabilities: +The table shows allocation routines supporting different combinations of storage-management capabilities: \begin{center} -\begin{tabular}{@{}r|l|l|l|l@{}} - & fill & resize & alignment & array \\ +\begin{tabular}{@{}lr|l|l|l|l@{}} + & & \multicolumn{1}{c|}{fill} & resize & alignment & array \\ \hline -©malloc© & no/yes & no/yes & no & no \\ -©amalloc© & no/copy data/yes & no/yes & no & yes \\ -©calloc© & yes (0 only) & no & no & yes \\ -©realloc© & no/copy data & yes & no & no \\ -©memalign© & no/yes & no & yes & no \\ -©amemalign© & no/yes & no & yes & yes \\ -©align_alloc© & no & no & yes & no \\ -©posix_memalign© & no & no & yes & no \\ +C & ©malloc© & no & no & no & no \\ + & ©calloc© & yes (0 only) & no & no & yes \\ + & ©realloc© & no/copy & yes & no & no \\ + & ©memalign© & no & no & yes & no \\ + & ©posix_memalign© & no & no & yes & no \\ +C11 & ©aligned_alloc© & no & no & yes & no \\ +\CFA & ©alloc© & no/copy/yes & no/yes & no & yes \\ + & ©align_alloc© & no/yes & no & yes & yes \\ \end{tabular} \end{center} -% When ©amalloc© resizes and fills, the space after the copied data from the source is set to the fill character. It 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. \leavevmode \begin{cfa}[aboveskip=0pt,belowskip=0pt] -// allocation, non-array types -forall( dtype T | sized(T) ) T * malloc( void );§\indexc{malloc}§ -forall( dtype T | sized(T) ) T * malloc( char fill ); - -// allocation, array types -forall( dtype T | sized(T) ) T * calloc( size_t dim );§\indexc{cmalloc}§ -forall( dtype T | sized(T) ) T * amalloc( size_t dim );§\indexc{amalloc}§ // alternate name for calloc -forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ); - -// resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );§\indexc{realloc}§ -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ); // alternate name for realloc -forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ); - -// resize, array types -forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ); -forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ); - -// alignment, non-array types -forall( dtype T | sized(T) ) T * memalign( size_t alignment );§\indexc{memalign}§ -forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ); -forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );§\indexc{aligned_alloc}§ -forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );§\indexc{posix_memalign}§ - -// alignment, array types -forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim );§\indexc{amemalign}§ -forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ); - -// data, non-array types +// C unsafe allocation +extern "C" { +void * mallac( size_t size );§\indexc{memset}§ +void * calloc( size_t dim, size_t size );§\indexc{calloc}§ +void * realloc( void * ptr, size_t size );§\indexc{realloc}§ +void * memalign( size_t align, size_t size );§\indexc{memalign}§ +int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§ +} + +// §\CFA§ safe equivalents, i.e., implicit size specification +forall( dtype T | sized(T) ) T * malloc( void ); +forall( dtype T | sized(T) ) T * calloc( size_t dim ); +forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ); +forall( dtype T | sized(T) ) T * memalign( size_t align ); +forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ); +forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ); + +// §\CFA§ safe general allocation, fill, resize, array +forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§ +forall( dtype T | sized(T) ) T * alloc( char fill ); +forall( dtype T | sized(T) ) T * alloc( size_t dim ); +forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +// §\CFA§ safe general allocation, align, fill, array +forall( dtype T | sized(T) ) T * align_alloc( size_t align ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ); +forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ); + +// C unsafe initialization/copy +extern "C" { +void * memset( void * dest, int c, size_t size ); +void * memcpy( void * dest, const void * src, size_t size ); +} + +// §\CFA§ safe initialization/copy forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§ forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§ -// data, array types -forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c );§\indexc{amemset}§ -forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim );§\indexc{amemcpy}§ - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );§\indexc{new}§ +// §\CFA§ safe initialization/copy array +forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ); +forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ); + +// §\CFA§ allocation/deallocation and constructor/destructor +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§ forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§ -forall( dtype T, ttype Params | { void ^?{}( T * ); void delete(Params); } ) void delete( T * ptr, Params rest ); +forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) + void delete( T * ptr, Params rest ); + +// §\CFA§ allocation/deallocation and constructor/destructor, array +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§ +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§ +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) + void adelete( size_t dim, T arr[], Params rest ); \end{cfa} Index: doc/working/exception/impl/except.c =================================================================== --- doc/working/exception/impl/except.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/working/exception/impl/except.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -4,4 +4,10 @@ #include "lsda.h" + +// This macro should be the only thing that needs to change across machines. +// struct _Unwind_Context * -> _Unwind_Reason_Code(*)() +#define MATCHER_FROM_CONTEXT(ptr_to_context) \ + (*(_Unwind_Reason_Code(**)())(_Unwind_GetCFA(ptr_to_context) + 8)) + //Global which defines the current exception @@ -17,4 +23,6 @@ struct _Unwind_Exception* unwind_exception, struct _Unwind_Context* context) { + printf("CFA: 0x%lx\n", _Unwind_GetCFA(context)); + //DEBUG printf("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context); @@ -111,5 +119,8 @@ //Get a function pointer from the relative offset and call it - _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; + // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; + + _Unwind_Reason_Code (*matcher)() = + MATCHER_FROM_CONTEXT(context); _Unwind_Reason_Code ret = matcher(); Index: doc/working/exception/impl/main.c =================================================================== --- doc/working/exception/impl/main.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/working/exception/impl/main.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -1,4 +1,6 @@ #include #include "except.h" + +// Requires -fexceptions to work. #define EXCEPTION 2 @@ -26,5 +28,6 @@ extern int this_exception; _Unwind_Reason_Code foo_try_match() { - return this_exception == 3 ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND; + printf(" (foo_try_match called)"); + return this_exception == EXCEPTION ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND; } @@ -34,6 +37,10 @@ //for details __attribute__((noinline)) -void try( void (*try_block)(), void (*catch_block)() ) +void try( void (*try_block)(), void (*catch_block)(), + _Unwind_Reason_Code (*match_block)() ) { + volatile int xy = 0; + printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy); + //Setup statments //These 2 statments won't actually result in any code, @@ -95,6 +102,4 @@ " .uleb128 .CATCH-try\n" //Hanlder landing pad adress (relative to start of function) " .uleb128 1\n" //Action code, gcc seems to use always 0 - //Beyond this point we don't match gcc data' - " .uleb128 foo_try_match-try\n" //Handler routine to check if the exception is matched ".LLSDACSECFA2:\n" //BODY end " .text\n" //TABLE footer @@ -122,13 +127,64 @@ //Actual call to the try block - try( foo_try_block, foo_catch_block ); + try( foo_try_block, foo_catch_block, foo_try_match ); printf( "Foo exited normally\n" ); } +// Not in main.cfa +void fy() { + // Currently not destroyed if the exception is caught in fee. + raii_t a = { "Fy dtor" }; + + void fy_try_block() { + raii_t b = { "Fy try dtor" }; + + throw( 3 ); + } + + void fy_catch_block() { + printf("Fy caught exception\n"); + } + + _Unwind_Reason_Code fy_match_block() { + return this_exception == 2 ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND; + } + + try(fy_try_block, fy_catch_block, fy_match_block); + + printf( "Fy exited normally\n" ); +} + +void fee() { + raii_t a = { "Fee dtor" }; + + void fee_try_block() { + raii_t b = { "Fee try dtor" }; + + fy(); + + printf("fy returned\n"); + } + + void fee_catch_block() { + printf("Fee caught exception\n"); + } + + _Unwind_Reason_Code fee_match_block() { + return this_exception == 3 ? _URC_HANDLER_FOUND : _URC_CONTINUE_UNWIND; + } + + try(fee_try_block, fee_catch_block, fee_match_block); + + printf( "Fee exited normally\n" ); +} +// End not in main.cfa + int main() { raii_t a = { "Main dtor" }; - for (unsigned int i = 0 ; i < 100000000 ; ++i) foo(); + //for (unsigned int i = 0 ; i < 100000000 ; ++i) + foo(); + fee(); printf("End of program reached\n"); Index: doc/working/exception/reference.c =================================================================== --- doc/working/exception/reference.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ doc/working/exception/reference.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -114,7 +114,10 @@ // __builtin_eh_return_data_regno(^) ^=[0..3]? gives index. +// Locally we also seem to have: +_Unwind_Word _Unwind_GetCFA (struct _Unwind_Context *); // GCC (Dwarf2 ?) Frame Layout Macros -// https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html +// See: https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html +// Include from: ??? FIRST_PARAM_OFFSET(fundecl) Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Common/PassVisitor.impl.h (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -1,8 +1,13 @@ #pragma once + +#define VISIT_START( node ) \ + call_previsit( node ); \ + +#define VISIT_END( node ) \ + return call_postvisit( node ); \ #define MUTATE_START( node ) \ call_premutate( node ); \ - #define MUTATE_END( type, node ) \ return call_postmutate< type * >( node ); \ @@ -10,7 +15,7 @@ #define VISIT_BODY( node ) \ - call_previsit( node ); \ + VISIT_START( node ); \ Visitor::visit( node ); \ - call_postvisit( node ); \ + VISIT_END( node ); \ @@ -39,5 +44,5 @@ if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); } try { - *i = (*i)->accept( *this ); + (*i)->accept( *this ); } catch ( SemanticError &e ) { errors.append( e ); @@ -78,14 +83,14 @@ ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); - Statement *newStmt = maybeVisit( stmt, *this ); + maybeAccept( stmt, *this ); StmtList_t* beforeStmts = get_beforeStmts(); StmtList_t* afterStmts = get_afterStmts(); - if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; } + if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; } CompoundStmt *compound = new CompoundStmt( noLabels ); if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); } - compound->get_kids().push_back( newStmt ); + compound->get_kids().push_back( stmt ); if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); } return compound; @@ -187,7 +192,15 @@ } +//-------------------------------------------------------------------------- +// CompoundStmt template< typename pass_type > void PassVisitor< pass_type >::visit( CompoundStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + call_beginScope(); + + visitStatementList( node->get_kids() ); + + call_endScope(); + VISIT_END( node ); } @@ -203,7 +216,15 @@ } +//-------------------------------------------------------------------------- +// ExprStmt template< typename pass_type > void PassVisitor< pass_type >::visit( ExprStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + call_beginScope(); + + visitExpression( node->get_expr() ); + + call_endScope(); + VISIT_END( node ); } @@ -222,7 +243,15 @@ } +//-------------------------------------------------------------------------- +// IfStmt template< typename pass_type > void PassVisitor< pass_type >::visit( IfStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + node->set_thenPart ( visitStatement( node->get_thenPart() ) ); + node->set_elsePart ( visitStatement( node->get_elsePart() ) ); + + VISIT_END( node ); } @@ -238,7 +267,14 @@ } +//-------------------------------------------------------------------------- +// WhileStmt template< typename pass_type > void PassVisitor< pass_type >::visit( WhileStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + node->set_body( visitStatement( node->get_body() ) ); + + VISIT_END( node ); } @@ -253,8 +289,16 @@ } - +//-------------------------------------------------------------------------- +// WhileStmt template< typename pass_type > void PassVisitor< pass_type >::visit( ForStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + acceptAll( node->get_initialization(), *this ); + visitExpression( node->get_condition() ); + visitExpression( node->get_increment() ); + node->set_body( visitStatement( node->get_body() ) ); + + VISIT_END( node ); } @@ -264,14 +308,21 @@ mutateAll( node->get_initialization(), *this ); - node->set_condition( mutateExpression( node->get_condition() ) ); - node->set_increment( mutateExpression( node->get_increment() ) ); - node->set_body( mutateStatement( node->get_body() ) ); + node->set_condition( mutateExpression( node->get_condition() ) ); + node->set_increment( mutateExpression( node->get_increment() ) ); + node->set_body( mutateStatement( node->get_body() ) ); MUTATE_END( Statement, node ); } +//-------------------------------------------------------------------------- +// SwitchStmt template< typename pass_type > void PassVisitor< pass_type >::visit( SwitchStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + visitStatementList( node->get_statements() ); + + VISIT_END( node ); } @@ -286,7 +337,14 @@ } +//-------------------------------------------------------------------------- +// SwitchStmt template< typename pass_type > void PassVisitor< pass_type >::visit( CaseStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + visitStatementList( node->get_statements() ); + + VISIT_END( node ); } @@ -306,7 +364,13 @@ } +//-------------------------------------------------------------------------- +// ReturnStmt template< typename pass_type > void PassVisitor< pass_type >::visit( ReturnStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_expr() ); + + VISIT_END( node ); } @@ -320,7 +384,14 @@ } +//-------------------------------------------------------------------------- +// TryStmt template< typename pass_type > void PassVisitor< pass_type >::visit( TryStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + maybeAccept( node->get_block(), *this ); + acceptAll( node->get_catchers(), *this ); + + VISIT_END( node ); } @@ -335,7 +406,14 @@ } +//-------------------------------------------------------------------------- +// CatchStmt template< typename pass_type > void PassVisitor< pass_type >::visit( CatchStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + node->set_body( visitStatement( node->get_body() ) ); + maybeAccept( node->get_decl(), *this ); + + VISIT_END( node ); } @@ -375,7 +453,15 @@ } +//-------------------------------------------------------------------------- +// UntypedExpr template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedExpr * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + for ( auto expr : node->get_args() ) { + visitExpression( expr ); + } + + VISIT_END( node ); } @@ -536,7 +622,18 @@ } +//-------------------------------------------------------------------------- +// UntypedExpr template< typename pass_type > void PassVisitor< pass_type >::visit( StmtExpr * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + // don't want statements from outer CompoundStmts to be added to this StmtExpr + ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); + ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() ); + ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); + + Visitor::visit( node ); + + VISIT_END( node ); } @@ -640,7 +737,13 @@ } +//-------------------------------------------------------------------------- +// UntypedExpr template< typename pass_type > void PassVisitor< pass_type >::visit( SingleInit * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_value() ); + + VISIT_END( node ); } Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Makefile.am (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -43,5 +43,5 @@ driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Makefile.in (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -447,5 +447,5 @@ driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic all: $(BUILT_SOURCES) Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Parser/lex.ll (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -5,11 +5,11 @@ * file "LICENCE" distributed with Cforall. * - * lex.l -- + * lex.ll -- * * Author : Peter A. Buhr * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Mon May 22 07:46:30 2017 - * Update Count : 525 + * Last Modified On : Tue May 30 22:00:48 2017 + * Update Count : 527 */ @@ -235,5 +235,5 @@ long { KEYWORD_RETURN(LONG); } lvalue { KEYWORD_RETURN(LVALUE); } // CFA -monitor { KEYWORD_RETURN(MONITOR); } // CFA +monitor { KEYWORD_RETURN(MONITOR); } // CFA mutex { KEYWORD_RETURN(MUTEX); } // CFA _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/libcfa/stdlib (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:35 2017 -// Update Count : 164 +// Last Modified On : Fri Jun 2 15:51:03 2017 +// Update Count : 218 // @@ -28,6 +28,4 @@ //--------------------------------------- -extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * - // allocation, non-array types static inline forall( dtype T | sized(T) ) T * malloc( void ) { @@ -35,83 +33,83 @@ return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc } // malloc -static inline forall( dtype T | sized(T) ) T * malloc( char fill ) { + +extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine +static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { //printf( "X2\n" ); + return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc +} + +extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void * +static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { + //printf( "X3\n" ); + return (T *)(void *)realloc( (void *)ptr, size ); +} + +extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) { + //printf( "X4\n" ); + return (T *)memalign( align, sizeof(T) ); +} // memalign + +static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) { + //printf( "X5\n" ); + return (T *)memalign( align, sizeof(T) ); +} // aligned_alloc + +extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) { + //printf( "X6\n" ); + return posix_memalign( (void **)ptr, align, sizeof(T) ); +} // posix_memalign + + +extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * + +static inline forall( dtype T | sized(T) ) T * alloc( void ) { + //printf( "X7\n" ); + return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( char fill ) { + //printf( "X8\n" ); T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, sizeof(T) ); // initial with fill value -} // malloc - -// allocation, array types -extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { - //printf( "X3\n" ); - return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc -} -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name - //printf( "X4\n" ); +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) { + //printf( "X9\n" ); return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name - //printf( "X5\n" ); +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) { + //printf( "X10\n" ); T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amalloc - -// resize, non-array types -extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { - //printf( "X5.5\n" ); - return (T *)(void *)realloc( (void *)ptr, size ); -} -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name - //printf( "X7\n" ); - return realloc( ptr, size ); -} // malloc -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name - //printf( "X8\n" ); - return realloc( ptr, size, fill ); -} // malloc - -// resize, array types -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) { - //printf( "X9\n" ); - return malloc( ptr, dim * (size_t)sizeof(T) ); -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) { - //printf( "X10\n" ); - return malloc( ptr, dim * (size_t)sizeof(T), fill ); -} // amalloc - -// alignment, non-array types -extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) { +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) { //printf( "X11\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) { - //printf( "X12\n" ); - T * ptr = (T *)memalign( alignment, sizeof(T) ); + return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc +} // alloc +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) { + //printf( "X13\n" ); + return (T *)memalign( align, sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) { + //printf( "X14\n" ); + T * ptr = (T *)memalign( align, sizeof(T) ); return memset( ptr, (int)fill, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { - //printf( "X13\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // aligned_alloc -extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) { - //printf( "X14\n" ); - return posix_memalign( (void **)ptr, alignment, sizeof(T) ); -} // posix_memalign - -// alignment, array types -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) { +} // align_alloc + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) { //printf( "X15\n" ); - return (T *)memalign( alignment, dim * sizeof(T) ); -} // amemalign -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) { + return (T *)memalign( align, dim * sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) { //printf( "X16\n" ); - T * ptr = (T *)memalign( alignment, dim * sizeof(T) ); + T * ptr = (T *)memalign( align, dim * sizeof(T) ); return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amemalign +} // align_alloc + // data, non-array types @@ -127,17 +125,22 @@ // data, array types -static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) { +static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) { //printf( "X19\n" ); - return memset( dest, c, dim * sizeof(T) ); -} // amemset -static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) { + return (void *)memset( dest, c, dim * sizeof(T) ); // C memset +} // memset +static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) { //printf( "X20\n" ); - return memcpy( dest, src, dim * sizeof(T) ); -} // amemcpy - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); + return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy +} // memcpy + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); //--------------------------------------- Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/libcfa/stdlib.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:56 2017 -// Update Count : 237 +// Last Modified On : Thu Jun 1 21:52:57 2017 +// Update Count : 280 // @@ -28,8 +28,7 @@ // resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value - //printf( "X6\n" ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) { size_t olen = malloc_usable_size( ptr ); // current allocation - char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc + char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc size_t nlen = malloc_usable_size( nptr ); // new allocation if ( nlen > olen ) { // larger ? @@ -37,15 +36,15 @@ } // return (T *)nptr; -} // realloc - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) +} // alloc + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ) { - return ((T *)malloc()){ p }; + return (malloc()){ p }; // run constructor } // new forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -55,5 +54,5 @@ forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -61,4 +60,36 @@ delete( rest ); } // delete + + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +T * anew( size_t dim, Params p ) { + T *arr = alloc( dim ); + for ( unsigned int i = 0; i < dim; i += 1 ) { + (&arr[i]){ p }; // run constructor + } // for + return arr; +} // anew + +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) +void adelete( size_t dim, T arr[] ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if +} // adelete + +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) +void adelete( size_t dim, T arr[], Params rest ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if + adelete( rest ); +} // adelete //--------------------------------------- Index: src/tests/.expect/alloc.txt =================================================================== --- src/tests/.expect/alloc.txt (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/tests/.expect/alloc.txt (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -1,56 +1,63 @@ -C malloc deadbeef -CFA malloc 0 -CFA malloc, fill 01010101 +C malloc 0xdeadbeef +CFA malloc 0xdeadbeef +CFA alloc 0xdeadbeef +CFA alloc, fill 01010101 -C calloc +C array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA calloc +CFA array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA array malloc -0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA array malloc -1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 +CFA array alloc, no fill +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA array alloc, fill 0x1 +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 C realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +CFA resize alloc +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA aligned_alloc 42 42.5 +C memalign 42 42.5 CFA memalign 42 42.5 CFA posix_memalign 42 42.5 -CFA memalign fill 16843009 7.7486e-304 +CFA posix_memalign 42 42.5 +CFA aligned_alloc 42 42.5 +CFA align_alloc 42 42.5 +CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007 -CFA memalign array -0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, -CFA memalign array -1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, +CFA array align_alloc +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, +CFA array align_alloc, fill +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, -CFA memset ffffffff -nan -CFA memcpy ffffffff -nan +CFA memset 0x1010101 0x1.1010101010101p-1007 +CFA memcpy 0x1010101 0x1.1010101010101p-1007 CFA array memset -ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, CFA memcpy -deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, +0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, + +CFA new initialize +42 42.5 42 42.5 +CFA array new initialize +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, +42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, + pointer arithmetic 0 -CFA deep malloc deadbeef +CFA deep malloc 0xdeadbeef SHOULD FAIL Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/tests/alloc.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -10,6 +10,6 @@ // Created On : Wed Feb 3 07:56:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 29 11:33:15 2017 -// Update Count : 228 +// Last Modified On : Fri Jun 2 15:13:03 2017 +// Update Count : 316 // @@ -18,4 +18,5 @@ #include // malloc_usable_size #include // uintptr_t +#include // posix_memalign } // extern #include @@ -28,6 +29,6 @@ int main( void ) { size_t dim = 10; - struct S { int x; double y; } * s; int * p; + char fill = '\1'; // allocation, non-array types @@ -35,13 +36,19 @@ p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; - printf( "C malloc %x\n", *p ); + printf( "C malloc %#x\n", *p ); free( p ); p = malloc(); // CFA malloc, type safe - printf( "CFA malloc %d\n", *p ); - free( p ); - - p = malloc( '\1' ); // CFA malloc, fill - printf( "CFA malloc, fill %08x\n", *p ); + *p = 0xdeadbeef; + printf( "CFA malloc %#x\n", *p ); + free( p ); + + p = alloc(); // CFA alloc, type safe + *p = 0xdeadbeef; + printf( "CFA alloc %#x\n", *p ); + free( p ); + + p = alloc( fill ); // CFA alloc, fill + printf( "CFA alloc, fill %08x\n", *p ); @@ -50,24 +57,25 @@ p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe - printf( "C calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "C array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); free( p ); p = calloc( dim ); // CFA array calloc, type safe - printf( "CFA calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( dim ); // CFA array malloc, type safe - printf( "CFA array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "CFA array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( dim ); // CFA array alloc, type safe + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA array alloc, no fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA array alloc, fill %#x\n", fill ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -77,32 +85,14 @@ printf( "\n" ); - p = (void *)realloc( p, dim * sizeof(*p) ); // CFA realloc + p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "C realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } printf( "CFA realloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = realloc( p, dim * sizeof(*p), '\1' ); // CFA realloc - printf( "CFA realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p) ); // CFA malloc - printf( "CFA resize malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, 2 * dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -112,43 +102,62 @@ printf( "\n" ); - p = amalloc( p, 2 * dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + p = alloc( p, dim ); // CFA resize array alloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA resize alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim ); // CFA resize array alloc + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } + printf( "CFA resize array alloc\n" ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim ); // CFA array alloc + printf( "CFA resize array alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); - printf( "\n" ); + p = 0; + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc, fill\n" ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; } + printf( "\n" ); + free( p ); + struct Struct { int x; double y; }; - Struct st, st1, sta[dim], sta1[dim], * stp; - + Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; // alignment, non-array types printf( "\n" ); - enum { Alignment = 128 }; - stp = aligned_alloc( Alignment ); // CFA aligned_alloc + + stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "C memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = memalign( Alignment ); // CFA memalign - *stp = (Struct){ 42, 42.5 }; - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign %d %g\n", stp->x, stp->y ); + printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); free( stp ); @@ -159,7 +168,17 @@ free( stp ); - stp = memalign( Alignment, '\1' ); // CFA memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign fill %d %g\n", stp->x, stp->y ); + stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = align_alloc( Alignment, fill ); // CFA memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y ); free( stp ); @@ -168,15 +187,16 @@ printf( "\n" ); - stp = amemalign( Alignment, 2 * dim ); // CFA array memalign - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; } - printf( "\n" ); - free( stp ); - - stp = amemalign( Alignment, dim, '\1' ); // CFA array memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; } + stp = align_alloc( Alignment, dim ); // CFA array memalign + assert( (uintptr_t)stp % Alignment == 0 ); + for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; } + printf( "CFA array align_alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + free( stp ); + + stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA array align_alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); } printf( "\n" ); free( stp ); @@ -186,8 +206,8 @@ printf( "\n" ); - stp = memset( &st, '\xff' ); // CFA memset, type safe - printf( "CFA memset %x %g\n", st.x, st.y ); - stp = memcpy( &st1, &st ); // CFA memcpy, type safe - printf( "CFA memcpy %x %g\n", st1.x, st1.y ); + memset( &st, fill ); // CFA memset, type safe + printf( "CFA memset %#x %a\n", st.x, st.y ); + memcpy( &st1, &st ); // CFA memcpy, type safe + printf( "CFA memcpy %#x %a\n", st1.x, st1.y ); @@ -195,12 +215,34 @@ printf( "\n" ); - stp = amemset( sta, dim, '\xff' ); // CFA array memset, type safe + memset( sta, dim, fill ); // CFA array memset, type safe printf( "CFA array memset\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta[i].x, sta[i].y ); sta[i].x = 0Xdeadbeef, sta[i].y = -17.2; } - printf( "\n" ); - - stp = amemcpy( sta1, sta, dim ); // CFA array memcpy, type safe + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); } + printf( "\n" ); + + memcpy( sta1, sta, dim ); // CFA array memcpy, type safe printf( "CFA memcpy\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta1[i].x, sta1[i].y ); sta1[i].x = 0Xdeadbeef, sta1[i].y = -17.2; } + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); } + printf( "\n" ); + + + // new, non-array types + printf( "\n" ); + + stp = new( 42, 42.5 ); + stp1 = new( 42, 42.5 ); + printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y ); + delete( stp, stp1 ); + + // new, array types + stp = anew( dim, 42, 42.5 ); + printf( "CFA array new initialize\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + stp1 = anew( dim, 42, 42.5 ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); } + printf( "\n" ); + adelete( dim, stp, dim, stp1 ); + + // extras printf( "\n" ); @@ -211,10 +253,10 @@ p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); *p = 0xdeadbeef; - printf( "CFA deep malloc %x\n", *p ); + printf( "CFA deep malloc %#x\n", *p ); free( p ); stp = malloc(); printf( "\nSHOULD FAIL\n" ); - p = malloc( stp, dim * sizeof(*stp) ); + p = alloc( stp, dim * sizeof(*stp) ); p = memset( stp, 10 ); p = memcpy( &st1, &st );