Changeset 7937abf

Timestamp:

May 4, 2016, 1:58:35 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1b7ea43, 7b937575

Parents:

0638c44

Message:

update examples with new keywords, more formatting changes in documentation

Files:

• doc/LaTeXmacros/common.tex (modified) (4 diffs)
• doc/refrat/refrat.tex (modified) (35 diffs)
• src/examples/abstype.c (modified) (2 diffs)
• src/examples/alloc.c (modified) (4 diffs)
• src/examples/includes.c (modified) (4 diffs)

doc/LaTeXmacros/common.tex

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue May  3 07:59:41 2016
-%% Update Count     : 44
+%% Last Modified On : Wed May  4 08:01:10 2016
+%% Update Count     : 54
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -132 +132 @@
 % blocks and titles
 \newcommand{\define}[1]{\emph{#1\/}\index{#1}}
-\newcommand{\rewrite}{\(\Rightarrow\)}
 \newcommand{\rewriterules}{\paragraph{Rewrite Rules}~\par\noindent}
 \newcommand{\examples}{\paragraph{Examples}~\par\noindent}
@@ -144 +143 @@
 \newcommand{\lhs}[1]{\par{\emph{#1:}}\index{#1@{\emph{#1}}|italic}}
 \newcommand{\rhs}{\hfil\break\hbox{\hskip1in}}
-\newcommand{\oldlhs}[1]{\emph{#1: \ldots}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\oldlhs}[1]{\emph{#1: \dots}\index{#1@{\emph{#1}}|italic}}
 \newcommand{\nonterm}[1]{\emph{#1\/}\index{#1@{\emph{#1}}|italic}}
 \newcommand{\opt}{$_{opt}$\ }
@@ -200 +199 @@
 belowskip=2pt,
 moredelim=**[is][\color{red}]{®}{®}, % red highlighting
-% moredelim=**[is][\color{blue}]{©}{©}, % blue highlighting
+% moredelim=**[is][\color{blue}]{¢}{¢}, % blue highlighting
 moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
 % literate={\\`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}1, % escape \`, otherwise used for red highlighting
+literate={...}{{$\dots$}}1 {<-}{{$\leftarrow$}}1 {=>}{{$\Rightarrow$}}1,
 }%
 

doc/refrat/refrat.tex

@@ -10 +10 @@
 %% Created On       : Wed Apr  6 14:52:25 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue May  3 09:23:43 2016
-%% Update Count     : 52
+%% Last Modified On : Tue May  3 18:00:28 2016
+%% Update Count     : 64
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -139 +139 @@
 \subsection{Scopes of identifiers}\index{scopes}
 
-\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may overload\index{overloading} outer declarations of lexically identical identifiers in the same
-\Index{name space}, instead of hiding them.
+\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may overload\index{overloading} outer declarations of lexically identical identifiers in the same \Index{name space}, instead of hiding them.
 The outer declaration is hidden if the two declarations have \Index{compatible type}, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type, or if one declaration is a ©type©\use{type} or ©typedef©\use{typedef} declaration and the other is not.
 The outer declaration becomes \Index{visible} when the scope of the inner declaration terminates.
@@ -153 +152 @@
 
 \CFA's linkage rules differ from C's in only one respect: instances of a particular identifier with external or internal linkage do not necessarily denote the same object or function.
-Instead, in the set of translation units and libraries that constitutes an entire program, any two instances of a particular identifier with \Index{external linkage} denote the same object or function if they have
-\Index{compatible type}s, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type.
+Instead, in the set of translation units and libraries that constitutes an entire program, any two instances of a particular identifier with \Index{external linkage} denote the same object or function if they have \Index{compatible type}s, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type.
 Within one translation unit, each instance of an identifier with \Index{internal linkage} denotes the same object or function in the same circumstances.
 Identifiers with \Index{no linkage} always denote unique entities.
@@ -229 +227 @@
 \CFA defines situations where values of one type are automatically converted to another type.
 These conversions are called \define{implicit conversion}s.
-The programmer can request
-\define{explicit conversion}s using cast expressions.
+The programmer can request \define{explicit conversion}s using cast expressions.
 
 
@@ -281 +278 @@
 \label{anon-conv}
 
-If an expression's type is a pointer to a structure or union type that has a member that is an
-\Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's type.
+If an expression's type is a pointer to a structure or union type that has a member that is an \Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's type.
 The result of the conversion is a pointer to the member.
 
@@ -708 +704 @@
 \rewriterules
 \begin{lstlisting}
-a[b] §\rewrite§ ?[?]( b, a ) // if a has integer type§\use{?[?]}§
-a[b] §\rewrite§ ?[?]( a, b ) // otherwise
-a( §\emph{arguments}§ ) §\rewrite§ ?()( a, §\emph{arguments}§ )§\use{?()}§
-a++ §\rewrite§ ?++(&( a ))§\use{?++}§
-a-- §\rewrite§ ?--(&( a ))§\use{?--}§
+a[b] => ?[?]( b, a ) // if a has integer type§\use{?[?]}§
+a[b] => ?[?]( a, b ) // otherwise
+a( §\emph{arguments}§ ) => ?()( a, §\emph{arguments}§ )§\use{?()}§
+a++ => ?++(&( a ))§\use{?++}§
+a-- => ?--(&( a ))§\use{?--}§
 \end{lstlisting}
 
@@ -744 +740 @@
 Subscript expressions are rewritten as function calls that pass the first parameter by value.
 This is somewhat unfortunate, since array-like types tend to be large.
-The alternative is to use the rewrite rule ``©a[b]© \rewrite ©?[?](&(a), b)©''.
+The alternative is to use the rewrite rule ``©a[b] => ?[?](&(a), b)©''.
 However, C semantics forbid this approach: the ©a© in ``©a[b]©'' can be an arbitrary pointer value, which does not have an address.
 
@@ -771 +767 @@
 The type of the valid interpretation is the return type of the function designator.
 
-For those combinations where the interpretation of the \nonterm{postfix-expression} is a
-\Index{polymorphic function} designator and the function designator accepts the number of arguments given, there shall be at least one set of \define{implicit argument}s for the implicit parameters such that
+For those combinations where the interpretation of the \nonterm{postfix-expression} is a \Index{polymorphic function} designator and the function designator accepts the number of arguments given, there shall be at least one set of \define{implicit argument}s for the implicit parameters such that
 \begin{itemize}
 \item
@@ -798 +793 @@
 For instance, it should be possible to replace a function ``©int f( int );©'' with ``©forall( otype T ) T f( T );©'' without affecting any calls of ©f©.
 
-\CFA\index{deficiencies!generalizability} does not fully possess this property, because
-\Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
+\CFA\index{deficiencies!generalizability} does not fully possess this property, because \Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
 Consider
 \begin{lstlisting}
@@ -1123 +1117 @@
 \rewriterules
 \begin{lstlisting}
-*a      §\rewrite§ *?( a ) §\use{*?}§
-+a      §\rewrite§ +?( a ) §\use{+?}§
--a      §\rewrite§ -?( a ) §\use{-?}§
-~a      §\rewrite§ ~?( a ) §\use{~?}§
-!a      §\rewrite§ !?( a ) §\use{"!?}§
-++a     §\rewrite§ ++?(&( a )) §\use{++?}§
---a     §\rewrite§ --?(&( a )) §\use{--?}§
+*a      => *?( a )§\use{*?}§
++a      => +?( a )§\use{+?}§
+-a      => -?( a )§\use{-?}§
+~a      => ~?( a )§\use{~?}§
+!a      => !?( a )§\use{"!?}§
+++a     => ++?(&( a ))§\use{++?}§
+--a     => --?(&( a ))§\use{--?}§
 \end{lstlisting}
 
@@ -1270 +1264 @@
 
 \constraints
-The operand of the unary ``©&©'' operator shall have exactly one
-\Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
+The operand of the unary ``©&©'' operator shall have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
 
 \semantics
@@ -1317 +1310 @@
 long int li;
 void eat_double( double );§\use{eat_double}§
-eat_double(-li ); // §\rewrite§ eat_double( -?( li ) );
+eat_double(-li ); // => eat_double( -?( li ) );
 \end{lstlisting}
 The valid interpretations of ``©-li©'' (assuming no extended integer types exist) are
@@ -1425 +1418 @@
 \rewriterules
 \begin{lstlisting}
-a * b §\rewrite§ ?*?( a, b )§\use{?*?}§
-a / b §\rewrite§ ?/?( a, b )§\use{?/?}§
-a % b §\rewrite§ ?%?( a, b )§\use{?%?}§
+a * b => ?*?( a, b )§\use{?*?}§
+a / b => ?/?( a, b )§\use{?/?}§
+a % b => ?%?( a, b )§\use{?%?}§
 \end{lstlisting}
 
@@ -1461 +1454 @@
 
 \begin{rationale}
-{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the
-\Index{usual arithmetic conversion}s.  Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern.
+{\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.
 \end{rationale}
 
@@ -1536 +1528 @@
 \rewriterules
 \begin{lstlisting}
-a + b §\rewrite§ ?+?( a, b )§\use{?+?}§
-a - b §\rewrite§ ?-?( a, b )§\use{?-?}§
+a + b => ?+?( a, b )§\use{?+?}§
+a - b => ?-?( a, b )§\use{?-?}§
 \end{lstlisting}
 
@@ -1615 +1607 @@
 \end{syntax}
 
-\rewriterules \use{?>>?}%use{?<<?}
-\begin{lstlisting}
-a << b §\rewrite§ ?<<?( a, b )
-a >> b §\rewrite§ ?>>?( a, b )
+\rewriterules
+\begin{lstlisting}
+a << b => ?<<?( a, b )§\use{?<<?}§
+a >> b => ?>>?( a, b )§\use{?>>?}§
 \end{lstlisting}
 
@@ -1656 +1648 @@
 \end{syntax}
 
-\rewriterules\use{?>?}\use{?>=?}%use{?<?}%use{?<=?}
-\begin{lstlisting}
-a < b §\rewrite§ ?<?( a, b )
-a > b §\rewrite§ ?>?( a, b )
-a <= b §\rewrite§ ?<=?( a, b )
-a >= b §\rewrite§ ?>=?( a, b )
+\rewriterules
+\begin{lstlisting}
+a < b => ?<?( a, b )§\use{?<?}§
+a > b => ?>?( a, b )§\use{?>?}§
+a <= b => ?<=?( a, b )§\use{?<=?}§
+a >= b => ?>=?( a, b )§\use{?>=?}§
 \end{lstlisting}
 
@@ -1717 +1709 @@
 \rewriterules
 \begin{lstlisting}
-a == b §\rewrite§ ?==?( a, b )§\use{?==?}§
-a != b §\rewrite§ ?!=?( a, b )§\use{?"!=?}§
+a == b => ?==?( a, b )§\use{?==?}§
+a != b => ?!=?( a, b )§\use{?"!=?}§
 \end{lstlisting}
 
@@ -1805 +1797 @@
 \rewriterules
 \begin{lstlisting}
-a & b §\rewrite§ ?&?( a, b )§\use{?&?}§
+a & b => ?&?( a, b )§\use{?&?}§
 \end{lstlisting}
 
@@ -1837 +1829 @@
 \rewriterules
 \begin{lstlisting}
-a ^ b §\rewrite§ ?^?( a, b )§\use{?^?}§
+a ^ b => ?^?( a, b )§\use{?^?}§
 \end{lstlisting}
 
@@ -1867 +1859 @@
 \end{syntax}
 
-\rewriterules\use{?"|?}
-\begin{lstlisting}
-a | b §\rewrite§ ?|?( a, b )
+\rewriterules
+\begin{lstlisting}
+a | b => ?|?( a, b )§\use{?"|?}§
 \end{lstlisting}
 
@@ -2024 +2016 @@
          \nonterm{assignment-expression}
 \lhs{assignment-operator} one of
-\rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \  
-         ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
+\rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \ ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
 \end{syntax}
 
 \rewriterules
-Let ``\(\leftarrow\)'' be any of the assignment operators.
+Let ``©<-©'' be any of the assignment operators.
 Then
-\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}
-\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
-\begin{lstlisting}
-a §$\leftarrow$§ b §\rewrite§ ?§$\leftarrow$§?( &( a ), b )
+\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
+\begin{lstlisting}
+a <- b => ?<-?( &( a ), b )
 \end{lstlisting}
 
@@ -2709 +2699 @@
 D( §\normalsize\nonterm{parameter-type-list}§ )
 \end{lstlisting} then a type identifier declared by one of the \nonterm{forall-specifier}s is an \define{inferred parameter} of the function declarator if and only if it is not an inferred parameter of a function declarator in ©D©, and it is used in the type of a parameter in the following
-\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a
-\Index{specification} in one of the \nonterm{forall-specifier}s.
+\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a \Index{specification} in one of the \nonterm{forall-specifier}s.
 The identifiers declared by assertions that use an inferred parameter of a function declarator are \Index{assertion parameter}s of that function declarator.
 
@@ -2732 +2721 @@
 
 If a function declarator is part of a function definition, its inferred parameters and assertion parameters have \Index{block scope};
-otherwise, identifiers declared by assertions have a
-\define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
+otherwise, identifiers declared by assertions have a \define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
 
 A function type that has at least one inferred parameter is a \define{polymorphic function} type.
@@ -2742 +2730 @@
 Let $f$ and $g$ be two polymorphic function types with the same number of inferred parameters, and let $f_i$ and $g_i$ be the inferred parameters of $f$ and $g$ in their order of occurance in the function types' \nonterm{parameter-type-list}s.
 Let $f'$ be $f$ with every occurrence of $f_i$ replaced by $g_i$, for all $i$.
-Then $f$ and $g$ are
-\Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same identifier and compatible type, and vice versa.
+Then $f$ and $g$ are \Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same identifier and compatible type, and vice versa.
 
 \examples
@@ -2960 +2947 @@
 
 \semantics
-An \define{assertion} is a declaration of a collection of objects and functions, called
-\define{assertion parameters}.
+An \define{assertion} is a declaration of a collection of objects and functions, called \define{assertion parameters}.
 
 The assertion parameters produced by an assertion that applies the name of a specification to type arguments are found by taking the declarations specified in the specification and treating each of the specification's parameters as a synonym for the corresponding \nonterm{type-name} argument.
@@ -3040 +3026 @@
 
 A type declaration without an \Index{initializer} and without a \Index{storage-class specifier} or with storage-class specifier ©static©\use{static} defines an \Index{incomplete type}.
-If a
-\Index{translation unit} or \Index{block} contains one or more such declarations for an identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block, which would define a new type known only within that block).
+If a \Index{translation unit} or \Index{block} contains one or more such declarations for an identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block, which would define a new type known only within that block).
 \begin{rationale}
 Incomplete type declarations allow compact mutually-recursive types.
@@ -3059 +3044 @@
 
 A type declaration without an initializer and with \Index{storage-class specifier} ©extern©\use{extern} is an \define{opaque type declaration}.
-Opaque types are
-\Index{object type}s.
+Opaque types are \Index{object type}s.
 An opaque type is not a \nonterm{constant-expression};
-neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.  Every other
-\Index{object type} is a \nonterm{constant-expression}.
+neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.
+Every other \Index{object type} is a \nonterm{constant-expression}.
 Objects with static storage duration shall be declared with a type that is a \nonterm{constant-expression}.
 \begin{rationale}
@@ -3075 +3059 @@
 An \Index{incomplete type} which is not a qualified version\index{qualified type} of a type is a value of \Index{type-class} ©dtype©.
 An object type\index{object types} which is not a qualified version of a type is a value of type-classes ©type© and ©dtype©.
-A
-\Index{function type} is a value of type-class ©ftype©.
+A \Index{function type} is a value of type-class ©ftype©.
 \begin{rationale}
 Syntactically, a type value is a \nonterm{type-name}, which is a declaration for an object which omits the identifier being declared.
@@ -3128 +3111 @@
 //  File a.c:
         extern type t1;
-        type t2 = struct { t1 f1; ... } // illegal 
+        type t2 = struct { t1 f1; ... } // illegal 
 //  File b.c:
         extern type t2;
-        type t1 = struct { t2 f2; ... } // illegal 
+        type t1 = struct { t2 f2; ... } // illegal 
 \end{lstlisting}
 \end{rationale}
@@ -3154 +3137 @@
 #include <stdlib.h>
 T * new( otype T ) { return ( T * )malloc( sizeof( T) ); };
-§\ldots§ int * ip = new( int );
+... int * ip = new( int );
 \end{lstlisting}
 This looks sensible, but \CFA's declaration-before-use rules mean that ``©T©'' in the function body refers to the parameter, but the ``©T©'' in the return type refers to the meaning of ©T© in the scope that contains ©new©;
@@ -3239 +3222 @@
 
 A definition\index{type definition} of a type identifier ©T© with \Index{implementation type} ©I© and type-class ©type© implicitly defines a default assignment function.
-A definition\index{type definition} of a type identifier ©T© with implementation type ©I© and an assertion list implicitly defines \define{default function}s and
-\define{default object}s as declared by the assertion declarations.
+A definition\index{type definition} of a type identifier ©T© with implementation type ©I© and an assertion list implicitly defines \define{default function}s and \define{default object}s as declared by the assertion declarations.
 The default objects and functions have the same \Index{scope} and \Index{linkage} as the identifier ©T©.
 Their values are determined as follows:
@@ -3296 +3278 @@
 Default functions and objects are subject to the normal scope rules.
 \begin{lstlisting}
-otype T = §\ldots§;
-T a_T = §\ldots§;               // Default assignment used. 
+otype T = ...;
+T a_T = ...;            // Default assignment used. 
 T ?=?( T *, T );
-T a_T = §\ldots§;               // Programmer-defined assignment called. 
+T a_T = ...;            // Programmer-defined assignment called. 
 \end{lstlisting}
 \begin{rationale}
@@ -3421 +3403 @@
 The statement 
 \begin{lstlisting}
-for ( a; b; c ) §\ldots§
+for ( a; b; c ) ...
 \end{lstlisting} is treated as
 \begin{lstlisting}
@@ -3581 +3563 @@
 \end{lstlisting}
 
-The various flavors of ©char© and ©int© and the enumerated types make up the
-\define{integral types}.
+The various flavors of ©char© and ©int© and the enumerated types make up the \define{integral types}.
 \begin{lstlisting}
 trait integral( otype T | arithmetic( T ) ) {§\impl{integral}§§\use{arithmetic}§

src/examples/abstype.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May 27 18:10:01 2015
-// Update Count     : 4
+// Last Modified On : Wed Apr  6 22:16:08 2016
+// Update Count     : 8
 //
 
-type T | { T x( T ); };
+otype T | { T x( T ); };
 
 T y( T t ) {
@@ -21 +21 @@
 }
 
-forall(type T) lvalue T *?( T* );
-int ?++( int *);
-int ?=?( int*, int );
-forall(dtype DT) DT* ?=?( DT **, DT* );
+forall( otype T ) lvalue T *?( T* );
+int ?++( int * );
+int ?=?( int *, int );
+forall( dtype DT ) DT * ?=?( DT **, DT* );
 
-type U = int*;
+otype U = int *;
 
 U x( U u ) {

src/examples/alloc.c

@@ -11 +11 @@
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 11:43:23 2016
-// Update Count     : 40
+// Last Modified On : Fri Mar 11 17:42:08 2016
+// Update Count     : 59
 // 
 
+forall( otype T ) T * malloc( char fill );
+forall( dtype T ) T *?=?( T **, void * );
+void *malloc( unsigned long int );
+#if 0
 #include <fstream>
 #include <stdlib>
@@ -25 +29 @@
 int * bar( int * p, int c ) { return p; }
 int * baz( int * p, int c ) { return p; }
+#endif
 
 int main( void ) {
+#if 0
     size_t size = 10;
     int * p;
     struct S { int x; double y; } * s;
+#endif
 
+#if 0
     p = malloc( sizeof(*p) );                                                   // C malloc, type unsafe
         printf( "here1\n" );
@@ -37 +45 @@
         printf( "here2\n" );
     free( p );
-    p = malloc( (char)'\0' );                                                                   // CFA malloc, type safe
+#endif
+//    int * p;
+//    p = malloc( (char)'\0' );                                                                 // CFA malloc, type safe
+    (int *)malloc( (char)'\0' );                                                                        // CFA malloc, type safe
+    (void *)malloc( (char)'\0' );                                                                       // CFA malloc, type safe
+#if 0
         printf( "here3\n" );
     p = malloc( p, 1000 );                                                              // CFA remalloc, type safe
@@ -60 +73 @@
         printf( "here9\n" );
     free( p );
-#if 0
+
     float * fp = malloc() + 1;
     fprintf( stderr, "%p %p\n", fp, fp - 1 );

src/examples/includes.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 23:28:02 2016
-// Update Count     : 328
+// Last Modified On : Wed Apr 13 22:30:02 2016
+// Update Count     : 370
 //
 
@@ -24 +24 @@
 #if 1
 #define _GNU_SOURCE
-#include <aio.h>
-#include <a.out.h>
-#include <aliases.h>
-#include <alloca.h>
-#include <ansidecl.h>
-#include <ar.h>
-#include <argp.h>
+//#include <aio.h>
+//#include <a.out.h>
+//#include <aliases.h>
+//#include <alloca.h>
+//#include <ansidecl.h>
+//#include <ar.h>
+//#include <argp.h>
 #include <argz.h>
-#include <assert.h>
+//#include <assert.h>
 #include <bfd.h>
+#if 0
 #include <bfdlink.h>
 #include <byteswap.h>
@@ -56 +57 @@
 #include <err.h>
 #include <errno.h>
-#if 0
 #include <error.h>
-#endif
 #include <eti.h>
 #include <evdns.h>
 #include <event.h>
 #include <evhttp.h>
+#endif
 #if 0
 #include <evrpc.h>
@@ -129 +129 @@
 
 //#define _GNU_SOURCE
-#include <error.h>
+#include <bfd.h>
+//#include <error.h>
 
 #endif // 0