Changeset f94ca7e


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

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

Files:
16 edited

Legend:

Unmodified
Added
Removed
  • doc/bibliography/cfa.bib

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

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

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

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

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

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

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

    r2164637 rf94ca7e  
    114114// __builtin_eh_return_data_regno(^) ^=[0..3]? gives index.
    115115
     116// Locally we also seem to have:
     117_Unwind_Word _Unwind_GetCFA (struct _Unwind_Context *);
    116118
    117119// GCC (Dwarf2 ?) Frame Layout Macros
    118 // https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html
     120// See: https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html
     121// Include from: ???
    119122
    120123FIRST_PARAM_OFFSET(fundecl)
  • src/Common/PassVisitor.impl.h

    r2164637 rf94ca7e  
    11#pragma once
     2
     3#define VISIT_START( node )  \
     4        call_previsit( node ); \
     5
     6#define VISIT_END( node )                \
     7        return call_postvisit( node ); \
    28
    39#define MUTATE_START( node )  \
    410        call_premutate( node ); \
    511
    6 
    712#define MUTATE_END( type, node )                \
    813        return call_postmutate< type * >( node ); \
     
    1015
    1116#define VISIT_BODY( node )    \
    12         call_previsit( node );  \
     17        VISIT_START( node );  \
    1318        Visitor::visit( node ); \
    14         call_postvisit( node ); \
     19        VISIT_END( node ); \
    1520
    1621
     
    3944                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
    4045                try {
    41                         *i = (*i)->accept( *this );
     46                        (*i)->accept( *this );
    4247                } catch ( SemanticError &e ) {
    4348                        errors.append( e );
     
    7883        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    7984
    80         Statement *newStmt = maybeVisit( stmt, *this );
     85        maybeAccept( stmt, *this );
    8186
    8287        StmtList_t* beforeStmts = get_beforeStmts();
    8388        StmtList_t* afterStmts  = get_afterStmts();
    8489
    85         if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
     90        if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; }
    8691
    8792        CompoundStmt *compound = new CompoundStmt( noLabels );
    8893        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
    89         compound->get_kids().push_back( newStmt );
     94        compound->get_kids().push_back( stmt );
    9095        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
    9196        return compound;
     
    187192}
    188193
     194//--------------------------------------------------------------------------
     195// CompoundStmt
    189196template< typename pass_type >
    190197void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
    191         VISIT_BODY( node );
     198        VISIT_START( node );
     199        call_beginScope();
     200
     201        visitStatementList( node->get_kids() );
     202
     203        call_endScope();
     204        VISIT_END( node );
    192205}
    193206
     
    203216}
    204217
     218//--------------------------------------------------------------------------
     219// ExprStmt
    205220template< typename pass_type >
    206221void PassVisitor< pass_type >::visit( ExprStmt * node ) {
    207         VISIT_BODY( node );
     222        VISIT_START( node );
     223        call_beginScope();
     224
     225        visitExpression( node->get_expr() );
     226
     227        call_endScope();
     228        VISIT_END( node );
    208229}
    209230
     
    222243}
    223244
     245//--------------------------------------------------------------------------
     246// IfStmt
    224247template< typename pass_type >
    225248void PassVisitor< pass_type >::visit( IfStmt * node ) {
    226         VISIT_BODY( node );
     249        VISIT_START( node );
     250
     251        visitExpression( node->get_condition() );
     252        node->set_thenPart ( visitStatement( node->get_thenPart() ) );
     253        node->set_elsePart ( visitStatement( node->get_elsePart() ) );
     254
     255        VISIT_END( node );
    227256}
    228257
     
    238267}
    239268
     269//--------------------------------------------------------------------------
     270// WhileStmt
    240271template< typename pass_type >
    241272void PassVisitor< pass_type >::visit( WhileStmt * node ) {
    242         VISIT_BODY( node );
     273        VISIT_START( node );
     274
     275        visitExpression( node->get_condition() );
     276        node->set_body( visitStatement( node->get_body() ) );
     277
     278        VISIT_END( node );
    243279}
    244280
     
    253289}
    254290
    255 
     291//--------------------------------------------------------------------------
     292// WhileStmt
    256293template< typename pass_type >
    257294void PassVisitor< pass_type >::visit( ForStmt * node ) {
    258         VISIT_BODY( node );
     295        VISIT_START( node );
     296
     297        acceptAll( node->get_initialization(), *this );
     298        visitExpression( node->get_condition() );
     299        visitExpression( node->get_increment() );
     300        node->set_body( visitStatement( node->get_body() ) );
     301
     302        VISIT_END( node );
    259303}
    260304
     
    264308
    265309        mutateAll( node->get_initialization(), *this );
    266         node->set_condition(  mutateExpression( node->get_condition() ) );
    267         node->set_increment(  mutateExpression( node->get_increment() ) );
    268         node->set_body(  mutateStatement( node->get_body() ) );
     310        node->set_condition( mutateExpression( node->get_condition() ) );
     311        node->set_increment( mutateExpression( node->get_increment() ) );
     312        node->set_body( mutateStatement( node->get_body() ) );
    269313
    270314        MUTATE_END( Statement, node );
    271315}
    272316
     317//--------------------------------------------------------------------------
     318// SwitchStmt
    273319template< typename pass_type >
    274320void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
    275         VISIT_BODY( node );
     321        VISIT_START( node );
     322
     323        visitExpression( node->get_condition() );
     324        visitStatementList( node->get_statements() );
     325
     326        VISIT_END( node );
    276327}
    277328
     
    286337}
    287338
     339//--------------------------------------------------------------------------
     340// SwitchStmt
    288341template< typename pass_type >
    289342void PassVisitor< pass_type >::visit( CaseStmt * node ) {
    290         VISIT_BODY( node );
     343        VISIT_START( node );
     344       
     345        visitExpression( node->get_condition() );
     346        visitStatementList( node->get_statements() );
     347       
     348        VISIT_END( node );
    291349}
    292350
     
    306364}
    307365
     366//--------------------------------------------------------------------------
     367// ReturnStmt
    308368template< typename pass_type >
    309369void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
    310         VISIT_BODY( node );
     370        VISIT_START( node );
     371
     372        visitExpression( node->get_expr() );
     373
     374        VISIT_END( node );
    311375}
    312376
     
    320384}
    321385
     386//--------------------------------------------------------------------------
     387// TryStmt
    322388template< typename pass_type >
    323389void PassVisitor< pass_type >::visit( TryStmt * node ) {
    324         VISIT_BODY( node );
     390        VISIT_START( node );
     391
     392        maybeAccept( node->get_block(), *this );
     393        acceptAll( node->get_catchers(), *this );
     394
     395        VISIT_END( node );
    325396}
    326397
     
    335406}
    336407
     408//--------------------------------------------------------------------------
     409// CatchStmt
    337410template< typename pass_type >
    338411void PassVisitor< pass_type >::visit( CatchStmt * node ) {
    339         VISIT_BODY( node );
     412        VISIT_START( node );
     413
     414        node->set_body( visitStatement( node->get_body() ) );
     415        maybeAccept( node->get_decl(), *this );
     416
     417        VISIT_END( node );
    340418}
    341419
     
    375453}
    376454
     455//--------------------------------------------------------------------------
     456// UntypedExpr
    377457template< typename pass_type >
    378458void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
    379         VISIT_BODY( node );
     459        VISIT_START( node );
     460
     461        for ( auto expr : node->get_args() ) {
     462                visitExpression( expr );
     463        }
     464
     465        VISIT_END( node );
    380466}
    381467
     
    536622}
    537623
     624//--------------------------------------------------------------------------
     625// UntypedExpr
    538626template< typename pass_type >
    539627void PassVisitor< pass_type >::visit( StmtExpr * node ) {
    540         VISIT_BODY( node );
     628        VISIT_START( node );
     629
     630        // don't want statements from outer CompoundStmts to be added to this StmtExpr
     631        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
     632        ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
     633        ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
     634
     635        Visitor::visit( node );
     636
     637        VISIT_END( node );
    541638}
    542639
     
    640737}
    641738
     739//--------------------------------------------------------------------------
     740// UntypedExpr
    642741template< typename pass_type >
    643742void PassVisitor< pass_type >::visit( SingleInit * node ) {
    644         VISIT_BODY( node );
     743        VISIT_START( node );
     744
     745        visitExpression( node->get_value() );
     746
     747        VISIT_END( node );
    645748}
    646749
  • src/Makefile.am

    r2164637 rf94ca7e  
    4343driver_cfa_cpp_SOURCES = ${SRC}
    4444driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    45 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
     45driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
    4646driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
    4747
  • src/Makefile.in

    r2164637 rf94ca7e  
    447447driver_cfa_cpp_SOURCES = ${SRC}
    448448driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    449 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
     449driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
    450450driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
    451451all: $(BUILT_SOURCES)
  • src/Parser/lex.ll

    r2164637 rf94ca7e  
    55 * file "LICENCE" distributed with Cforall.
    66 *
    7  * lex.l --
     7 * lex.ll --
    88 *
    99 * Author           : Peter A. Buhr
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Mon May 22 07:46:30 2017
    13  * Update Count     : 525
     12 * Last Modified On : Tue May 30 22:00:48 2017
     13 * Update Count     : 527
    1414 */
    1515
     
    235235long                    { KEYWORD_RETURN(LONG); }
    236236lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
    237 monitor         { KEYWORD_RETURN(MONITOR); }                    // CFA
     237monitor                 { KEYWORD_RETURN(MONITOR); }                    // CFA
    238238mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
    239239_Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
  • src/libcfa/stdlib

    r2164637 rf94ca7e  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 30 09:07:35 2017
    13 // Update Count     : 164
     12// Last Modified On : Fri Jun  2 15:51:03 2017
     13// Update Count     : 218
    1414//
    1515
     
    2828//---------------------------------------
    2929
    30 extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
    31 
    3230// allocation, non-array types
    3331static inline forall( dtype T | sized(T) ) T * malloc( void ) {
     
    3533        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
    3634} // malloc
    37 static inline forall( dtype T | sized(T) ) T * malloc( char fill ) {
     35
     36extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
     37static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
    3838        //printf( "X2\n" );
     39        return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
     40}
     41
     42extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void *
     43static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
     44        //printf( "X3\n" );
     45        return (T *)(void *)realloc( (void *)ptr, size );
     46}
     47
     48extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
     49static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) {
     50        //printf( "X4\n" );
     51        return (T *)memalign( align, sizeof(T) );
     52} // memalign
     53
     54static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) {
     55        //printf( "X5\n" );
     56        return (T *)memalign( align, sizeof(T) );
     57} // aligned_alloc
     58
     59extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void *
     60static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) {
     61        //printf( "X6\n" );
     62        return posix_memalign( (void **)ptr, align, sizeof(T) );
     63} // posix_memalign
     64
     65
     66extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
     67
     68static inline forall( dtype T | sized(T) ) T * alloc( void ) {
     69        //printf( "X7\n" );
     70        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
     71} // alloc
     72static inline forall( dtype T | sized(T) ) T * alloc( char fill ) {
     73        //printf( "X8\n" );
    3974        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
    4075    return memset( ptr, (int)fill, sizeof(T) );                 // initial with fill value
    41 } // malloc
    42 
    43 // allocation, array types
    44 extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void *
    45 static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
    46         //printf( "X3\n" );
    47         return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
    48 }
    49 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name
    50         //printf( "X4\n" );
     76} // alloc
     77
     78static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) {
     79        //printf( "X9\n" );
    5180        return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    52 } // amalloc
    53 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name
    54         //printf( "X5\n" );
     81} // alloc
     82static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) {
     83        //printf( "X10\n" );
    5584        T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    5685    return memset( ptr, (int)fill, dim * sizeof(T) );
    57 } // amalloc
    58 
    59 // resize, non-array types
    60 extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
    61 static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
    62         //printf( "X5.5\n" );
    63         return (T *)(void *)realloc( (void *)ptr, size );
    64 }
    65 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
    66 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name
    67         //printf( "X7\n" );
    68         return realloc( ptr, size );
    69 } // malloc
    70 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name
    71         //printf( "X8\n" );
    72         return realloc( ptr, size, fill );
    73 } // malloc
    74 
    75 // resize, array types
    76 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) {
    77         //printf( "X9\n" );
    78         return malloc( ptr, dim * (size_t)sizeof(T) );
    79 } // amalloc
    80 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) {
    81         //printf( "X10\n" );
    82         return malloc( ptr, dim * (size_t)sizeof(T), fill );
    83 } // amalloc
    84 
    85 // alignment, non-array types
    86 extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void *
    87 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
     86} // alloc
     87
     88static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
    8889        //printf( "X11\n" );
    89         return (T *)memalign( alignment, sizeof(T) );
    90 } // memalign
    91 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) {
    92         //printf( "X12\n" );
    93     T * ptr = (T *)memalign( alignment, sizeof(T) );
     90        return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
     91} // alloc
     92forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     93
     94static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
     95        //printf( "X13\n" );
     96        return (T *)memalign( align, sizeof(T) );
     97} // align_alloc
     98static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
     99        //printf( "X14\n" );
     100    T * ptr = (T *)memalign( align, sizeof(T) );
    94101    return memset( ptr, (int)fill, sizeof(T) );
    95 } // memalign
    96 static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) {
    97         //printf( "X13\n" );
    98         return (T *)memalign( alignment, sizeof(T) );
    99 } // aligned_alloc
    100 extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void *
    101 static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
    102         //printf( "X14\n" );
    103         return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    104 } // posix_memalign
    105 
    106 // alignment, array types
    107 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) {
     102} // align_alloc
     103
     104static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
    108105        //printf( "X15\n" );
    109         return (T *)memalign( alignment, dim * sizeof(T) );
    110 } // amemalign
    111 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) {
     106        return (T *)memalign( align, dim * sizeof(T) );
     107} // align_alloc
     108static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
    112109        //printf( "X16\n" );
    113     T * ptr = (T *)memalign( alignment, dim * sizeof(T) );
     110    T * ptr = (T *)memalign( align, dim * sizeof(T) );
    114111    return memset( ptr, (int)fill, dim * sizeof(T) );
    115 } // amemalign
     112} // align_alloc
     113
    116114
    117115// data, non-array types
     
    127125
    128126// data, array types
    129 static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) {
     127static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
    130128        //printf( "X19\n" );
    131         return memset( dest, c, dim * sizeof(T) );
    132 } // amemset
    133 static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) {
     129        return (void *)memset( dest, c, dim * sizeof(T) );      // C memset
     130} // memset
     131static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
    134132        //printf( "X20\n" );
    135         return memcpy( dest, src, dim * sizeof(T) );
    136 } // amemcpy
    137 
    138 // allocation/deallocation and constructor/destructor
    139 forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
     133        return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
     134} // memcpy
     135
     136// allocation/deallocation and constructor/destructor, non-array types
     137forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );
    140138forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
    141139forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
     140
     141// allocation/deallocation and constructor/destructor, array types
     142forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );
     143forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );
     144forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
    142145
    143146//---------------------------------------
  • src/libcfa/stdlib.c

    r2164637 rf94ca7e  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 30 09:07:56 2017
    13 // Update Count     : 237
     12// Last Modified On : Thu Jun  1 21:52:57 2017
     13// Update Count     : 280
    1414//
    1515
     
    2828
    2929// resize, non-array types
    30 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value
    31         //printf( "X6\n" );
     30forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
    3231        size_t olen = malloc_usable_size( ptr );                        // current allocation
    33     char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc
     32    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
    3433        size_t nlen = malloc_usable_size( nptr );                       // new allocation
    3534        if ( nlen > olen ) {                                                            // larger ?
     
    3736        } //
    3837    return (T *)nptr;
    39 } // realloc
    40 
    41 // allocation/deallocation and constructor/destructor
    42 forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } )
     38} // alloc
     39
     40// allocation/deallocation and constructor/destructor, non-array types
     41forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
    4342T * new( Params p ) {
    44         return ((T *)malloc()){ p };
     43        return (malloc()){ p };                                                         // run constructor
    4544} // new
    4645
    4746forall( dtype T | { void ^?{}( T * ); } )
    4847void delete( T * ptr ) {
    49         if ( ptr ) {
     48        if ( ptr ) {                                                                            // ignore null
    5049                ^ptr{};                                                                                 // run destructor
    5150                free( ptr );
     
    5554forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
    5655void delete( T * ptr, Params rest ) {
    57         if ( ptr ) {
     56        if ( ptr ) {                                                                            // ignore null
    5857                ^ptr{};                                                                                 // run destructor
    5958                free( ptr );
     
    6160        delete( rest );
    6261} // delete
     62
     63
     64// allocation/deallocation and constructor/destructor, array types
     65forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
     66T * anew( size_t dim, Params p ) {
     67        T *arr = alloc( dim );
     68        for ( unsigned int i = 0; i < dim; i += 1 ) {
     69                (&arr[i]){ p };                                                                 // run constructor
     70        } // for
     71        return arr;
     72} // anew
     73
     74forall( dtype T | sized(T) | { void ^?{}( T * ); } )
     75void adelete( size_t dim, T arr[] ) {
     76        if ( arr ) {                                                                            // ignore null
     77                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
     78                        ^(&arr[i]){};                                                           // run destructor
     79                } // for
     80                free( arr );
     81        } // if
     82} // adelete
     83
     84forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
     85void adelete( size_t dim, T arr[], Params rest ) {
     86        if ( arr ) {                                                                            // ignore null
     87                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
     88                        ^(&arr[i]){};                                                           // run destructor
     89                } // for
     90                free( arr );
     91        } // if
     92        adelete( rest );
     93} // adelete
    6394
    6495//---------------------------------------
  • src/tests/.expect/alloc.txt

    r2164637 rf94ca7e  
    1 C   malloc deadbeef
    2 CFA malloc 0
    3 CFA malloc, fill 01010101
     1C   malloc 0xdeadbeef
     2CFA malloc 0xdeadbeef
     3CFA alloc 0xdeadbeef
     4CFA alloc, fill 01010101
    45
    5 C   calloc
     6C   array calloc, fill 0
    670 0 0 0 0 0 0 0 0 0
    7 CFA calloc
     8CFA array calloc, fill 0
    890 0 0 0 0 0 0 0 0 0
    9 CFA array malloc
    10 0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    11 CFA array malloc
    12 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
     10CFA array alloc, no fill
     110xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     12CFA array alloc, fill 0x1
     130x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    1314
    1415C   realloc
    15 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     160xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
    1617CFA realloc
    17 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0
    18 CFA realloc
    19 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    20 CFA resize malloc
    21 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    22 CFA resize malloc, fill
    23 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
    24 CFA resize malloc, fill
    25 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     180xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    2619
    27 CFA resize array malloc
    28 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0
    29 CFA resize array malloc
    30 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    31 CFA resize array malloc, fill
    32 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
    33 CFA resize array malloc, fill
    34 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     20CFA resize alloc
     210xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     22CFA resize array alloc
     230xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     24CFA resize array alloc
     250xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     26CFA resize array alloc, fill
     270x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     28CFA resize array alloc, fill
     290x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     30CFA resize array alloc, fill
     310x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    3532
    36 CFA aligned_alloc 42 42.5
     33C   memalign 42 42.5
    3734CFA memalign 42 42.5
    3835CFA posix_memalign 42 42.5
    39 CFA memalign fill 16843009 7.7486e-304
     36CFA posix_memalign 42 42.5
     37CFA aligned_alloc 42 42.5
     38CFA align_alloc 42 42.5
     39CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007
    4040
    41 CFA memalign array
    42 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,
    43 CFA memalign array
    44 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,
     41CFA array align_alloc
     4242 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,
     43CFA array align_alloc, fill
     440x1010101 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,
    4545
    46 CFA memset ffffffff -nan
    47 CFA memcpy ffffffff -nan
     46CFA memset 0x1010101 0x1.1010101010101p-1007
     47CFA memcpy 0x1010101 0x1.1010101010101p-1007
    4848
    4949CFA array memset
    50 ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan,
     500x1010101 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,
    5151CFA memcpy
    52 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,
     520x1010101 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,
     53
     54CFA new initialize
     5542 42.5 42 42.5
     56CFA array new initialize
     5742 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,
     5842 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,
     59
    5360pointer arithmetic 0
    54 CFA deep malloc deadbeef
     61CFA deep malloc 0xdeadbeef
    5562
    5663SHOULD FAIL
  • src/tests/alloc.c

    r2164637 rf94ca7e  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 29 11:33:15 2017
    13 // Update Count     : 228
     12// Last Modified On : Fri Jun  2 15:13:03 2017
     13// Update Count     : 316
    1414//
    1515
     
    1818#include <malloc.h>                                                                             // malloc_usable_size
    1919#include <stdint.h>                                                                             // uintptr_t
     20#include <stdlib.h>                                                                             // posix_memalign
    2021} // extern
    2122#include <fstream>
     
    2829int main( void ) {
    2930    size_t dim = 10;
    30     struct S { int x; double y; } * s;
    3131    int * p;
     32        char fill = '\1';
    3233
    3334        // allocation, non-array types
     
    3536    p = (void *)malloc( sizeof(*p) );                                   // C malloc, type unsafe
    3637        *p = 0xdeadbeef;
    37         printf( "C   malloc %x\n", *p );
     38        printf( "C   malloc %#x\n", *p );
    3839    free( p );
    3940
    4041    p = malloc();                                                                               // CFA malloc, type safe
    41         printf( "CFA malloc %d\n", *p );
    42     free( p );
    43 
    44     p = malloc( '\1' );                                                                 // CFA malloc, fill
    45         printf( "CFA malloc, fill %08x\n", *p );
     42        *p = 0xdeadbeef;
     43        printf( "CFA malloc %#x\n", *p );
     44    free( p );
     45
     46    p = alloc();                                                                                // CFA alloc, type safe
     47        *p = 0xdeadbeef;
     48        printf( "CFA alloc %#x\n", *p );
     49    free( p );
     50
     51    p = alloc( fill );                                                                  // CFA alloc, fill
     52        printf( "CFA alloc, fill %08x\n", *p );
    4653
    4754
     
    5057
    5158    p = calloc( dim, sizeof( *p ) );                                    // C array calloc, type unsafe
    52         printf( "C   calloc\n" );
    53         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     59        printf( "C   array calloc, fill 0\n" );
     60        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    5461        printf( "\n" );
    5562    free( p );
    5663
    5764    p = calloc( dim );                                                                  // CFA array calloc, type safe
    58         printf( "CFA calloc\n" );
    59         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    60         printf( "\n" );
    61     free( p );
    62 
    63     p = amalloc( dim );                                                                 // CFA array malloc, type safe
    64         printf( "CFA array malloc\n" );
    65         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    66         printf( "\n" );
    67     free( p );
    68 
    69     p = amalloc( 2 * dim, '\1' );                                               // CFA array malloc, fill
    70         printf( "CFA array malloc\n" );
    71         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     65        printf( "CFA array calloc, fill 0\n" );
     66        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     67        printf( "\n" );
     68    free( p );
     69
     70    p = alloc( dim );                                                                   // CFA array alloc, type safe
     71        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     72        printf( "CFA array alloc, no fill\n" );
     73        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     74        printf( "\n" );
     75    free( p );
     76
     77    p = alloc( 2 * dim, fill );                                                 // CFA array alloc, fill
     78        printf( "CFA array alloc, fill %#x\n", fill );
     79        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    7280        printf( "\n" );
    7381        // do not free
     
    7785        printf( "\n" );
    7886
    79     p = (void *)realloc( p, dim * sizeof(*p) );                 // CFA realloc
     87    p = (void *)realloc( p, dim * sizeof(*p) );                 // C realloc
     88        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    8089        printf( "C   realloc\n" );
    81         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     90        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    8291        printf( "\n" );
    8392
    8493    p = realloc( p, 2 * dim * sizeof(*p) );                             // CFA realloc
     94        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
    8595        printf( "CFA realloc\n" );
    86         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    87         printf( "\n" );
    88 
    89     p = realloc( p, dim * sizeof(*p), '\1' );                   // CFA realloc
    90         printf( "CFA realloc\n" );
    91         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    92         printf( "\n" );
    93 
    94     p = malloc( p, dim * sizeof(*p) );                                  // CFA malloc
    95         printf( "CFA resize malloc\n" );
    96         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    97         printf( "\n" );
    98 
    99     p = malloc( p, 2 * dim * sizeof(*p), '\1' );                // CFA malloc, fill
    100         printf( "CFA resize malloc, fill\n" );
    101         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    102         printf( "\n" );
    103 
    104     p = malloc( p, dim * sizeof(*p), '\1' );                    // CFA malloc, fill
    105         printf( "CFA resize malloc, fill\n" );
    106         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     96        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    10797        printf( "\n" );
    10898        // do not free
     
    112102        printf( "\n" );
    113103
    114     p = amalloc( p, 2 * dim );                                                  // CFA array malloc
    115         printf( "CFA resize array malloc\n" );
    116         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    117         printf( "\n" );
    118 
    119     p = amalloc( p, dim );                                                              // CFA array malloc
    120         printf( "CFA resize array malloc\n" );
    121         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    122         printf( "\n" );
    123 
    124     p = amalloc( p, 2 * dim, '\1' );                                    // CFA array malloc, fill
    125         printf( "CFA resize array malloc, fill\n" );
    126         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    127         printf( "\n" );
    128 
    129     p = amalloc( p, dim, '\1' );                                                // CFA array malloc, fill
    130         printf( "CFA resize array malloc, fill\n" );
    131         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     104    p = alloc( p, dim );                                                                // CFA resize array alloc
     105        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     106        printf( "CFA resize alloc\n" );
     107        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     108        printf( "\n" );
     109
     110    p = alloc( p, 2 * dim );                                                    // CFA resize array alloc
     111        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     112        printf( "CFA resize array alloc\n" );
     113        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     114        printf( "\n" );
     115
     116    p = alloc( p, dim );                                                                // CFA array alloc
     117        printf( "CFA resize array alloc\n" );
     118        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     119        printf( "\n" );
     120
    132121        free( p );
    133         printf( "\n" );
     122        p = 0;
     123
     124    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     125        printf( "CFA resize array alloc, fill\n" );
     126        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     127        printf( "\n" );
     128
     129    p = alloc( p, 2 * dim, fill );                                              // CFA array alloc, fill
     130        printf( "CFA resize array alloc, fill\n" );
     131        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     132        printf( "\n" );
     133
     134    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     135        printf( "CFA resize array alloc, fill\n" );
     136        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
     137        printf( "\n" );
     138        free( p );
     139
    134140
    135141    struct Struct { int x; double y; };
    136     Struct st, st1, sta[dim], sta1[dim], * stp;
    137 
     142    Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
    138143
    139144        // alignment, non-array types
    140145        printf( "\n" );
    141 
    142146        enum { Alignment = 128 };
    143     stp = aligned_alloc( Alignment );                                   // CFA aligned_alloc
     147
     148    stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
     149        assert( (uintptr_t)stp % Alignment == 0 );
     150        printf( "C   memalign %d %g\n", stp->x, stp->y );
     151    free( stp );
     152
     153    stp = (memalign( Alignment )){ 42, 42.5 };                  // CFA memalign
     154        assert( (uintptr_t)stp % Alignment == 0 );
     155        printf( "CFA memalign %d %g\n", stp->x, stp->y );
     156    free( stp );
     157
     158    posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
    144159        *stp = (Struct){ 42, 42.5 };
    145160        assert( (uintptr_t)stp % Alignment == 0 );
    146         printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
    147     free( stp );
    148 
    149     stp = memalign( Alignment );                                                // CFA memalign
    150         *stp = (Struct){ 42, 42.5 };
    151         assert( (uintptr_t)stp % Alignment == 0 );
    152         printf( "CFA memalign %d %g\n", stp->x, stp->y );
     161        printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
    153162    free( stp );
    154163
     
    159168    free( stp );
    160169
    161     stp = memalign( Alignment, '\1' );                                  // CFA memalign, fill
    162         assert( (uintptr_t)stp % Alignment == 0 );
    163         printf( "CFA memalign fill %d %g\n", stp->x, stp->y );
     170    stp = (aligned_alloc( Alignment )){ 42, 42.5 };             // CFA aligned_alloc
     171        assert( (uintptr_t)stp % Alignment == 0 );
     172        printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
     173    free( stp );
     174
     175    stp = (align_alloc( Alignment )){ 42, 42.5 };               // CFA align_alloc
     176        assert( (uintptr_t)stp % Alignment == 0 );
     177        printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
     178    free( stp );
     179
     180    stp = align_alloc( Alignment, fill );                               // CFA memalign, fill
     181        assert( (uintptr_t)stp % Alignment == 0 );
     182        printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
    164183    free( stp );
    165184
     
    168187        printf( "\n" );
    169188
    170     stp = amemalign( Alignment, 2 * dim );                              // CFA array memalign
    171         assert( (uintptr_t)stp % Alignment == 0 );
    172         printf( "CFA memalign array\n" );
    173         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; }
    174         printf( "\n" );
    175     free( stp );
    176 
    177     stp = amemalign( Alignment, dim, '\1' );                    // CFA array memalign, fill
    178         assert( (uintptr_t)stp % Alignment == 0 );
    179         printf( "CFA memalign array\n" );
    180         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; }
     189    stp = align_alloc( Alignment, dim );                                // CFA array memalign
     190        assert( (uintptr_t)stp % Alignment == 0 );
     191        for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
     192        printf( "CFA array align_alloc\n" );
     193        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     194        printf( "\n" );
     195    free( stp );
     196
     197    stp = align_alloc( Alignment, dim, fill );                  // CFA array memalign, fill
     198        assert( (uintptr_t)stp % Alignment == 0 );
     199        printf( "CFA array align_alloc, fill\n" );
     200        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
    181201        printf( "\n" );
    182202    free( stp );
     
    186206        printf( "\n" );
    187207
    188     stp = memset( &st, '\xff' );                                                // CFA memset, type safe
    189         printf( "CFA memset %x %g\n", st.x, st.y );
    190     stp = memcpy( &st1, &st );                                                  // CFA memcpy, type safe
    191         printf( "CFA memcpy %x %g\n", st1.x, st1.y );
     208    memset( &st, fill );                                                                // CFA memset, type safe
     209        printf( "CFA memset %#x %a\n", st.x, st.y );
     210    memcpy( &st1, &st );                                                                // CFA memcpy, type safe
     211        printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
    192212
    193213
     
    195215        printf( "\n" );
    196216
    197     stp = amemset( sta, dim, '\xff' );                                  // CFA array memset, type safe
     217    memset( sta, dim, fill );                                                   // CFA array memset, type safe
    198218        printf( "CFA array memset\n" );
    199         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; }
    200         printf( "\n" );
    201 
    202     stp = amemcpy( sta1, sta, dim );                                    // CFA array memcpy, type safe
     219        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
     220        printf( "\n" );
     221
     222    memcpy( sta1, sta, dim );                                                   // CFA array memcpy, type safe
    203223        printf( "CFA memcpy\n" );
    204         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; }
     224        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
     225        printf( "\n" );
     226
     227
     228        // new, non-array types
     229        printf( "\n" );
     230
     231        stp = new( 42, 42.5 );
     232        stp1 = new( 42, 42.5 );
     233        printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
     234        delete( stp, stp1 );
     235
     236        // new, array types
     237        stp = anew( dim, 42, 42.5 );
     238        printf( "CFA array new initialize\n" );
     239        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     240        printf( "\n" );
     241        stp1 = anew( dim, 42, 42.5 );
     242        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
     243        printf( "\n" );
     244        adelete( dim, stp, dim, stp1 );
     245
     246        // extras
    205247        printf( "\n" );
    206248
     
    211253    p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    212254        *p = 0xdeadbeef;
    213         printf( "CFA deep malloc %x\n", *p );
     255        printf( "CFA deep malloc %#x\n", *p );
    214256    free( p );
    215257
    216258        stp = malloc();
    217259        printf( "\nSHOULD FAIL\n" );
    218     p = malloc( stp, dim * sizeof(*stp) );
     260    p = alloc( stp, dim * sizeof(*stp) );
    219261    p = memset( stp, 10 );
    220262    p = memcpy( &st1, &st );
Note: See TracChangeset for help on using the changeset viewer.