Changes in / [a4248de1:95b1e28]

Location:

doc

Files:

• papers/general/Paper.tex (modified) (1 diff)
• user/user.tex (modified) (3 diffs)

doc/papers/general/Paper.tex

@@ -203 +203 @@
 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating-systems.
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
-Nevertheless, C, first standardized almost forty years ago, lacks many features that make programming in more modern languages safer and more productive.
+Nevertheless, C, first standardized almost thirty years ago, lacks many features that make programming in more modern languages safer and more productive.
 
 The goal of the \CFA project (pronounced ``C-for-all'') is to create an extension of C that provides modern safety and productivity features while still ensuring strong backwards compatibility with C and its programmers.

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Mon Jul  9 10:49:52 2018
-%% Update Count     : 3361
+%% Last Modified On : Thu Jul 26 17:29:05 2018
+%% Update Count     : 3366
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -5967 +5967 @@
 void * memalign( size_t align, size_t size );§\indexc{memalign}§
 int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
-}
-
-// §\CFA§ safe equivalents, i.e., implicit size specification
-forall( dtype T | sized(T) ) T * malloc( void );
-forall( dtype T | sized(T) ) T * calloc( size_t dim );
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
-forall( dtype T | sized(T) ) T * memalign( size_t align );
-forall( dtype T | sized(T) ) T * aligned_alloc( size_t align );
-forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align );
-
-// §\CFA§ safe general allocation, fill, resize, array
-forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§
-forall( dtype T | sized(T) ) T * alloc( char fill );
-forall( dtype T | sized(T) ) T * alloc( size_t dim );
-forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill );
-forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim );
-forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
-
-// §\CFA§ safe general allocation, align, fill, array
-forall( dtype T | sized(T) ) T * align_alloc( size_t align );
-forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill );
-forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim );
-forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill );
 
 // C unsafe initialization/copy
-extern "C" {
 void * memset( void * dest, int c, size_t size );
 void * memcpy( void * dest, const void * src, size_t size );
 }
 
+forall( dtype T | sized(T) ) {
+// §\CFA§ safe equivalents, i.e., implicit size specification
+        T * malloc( void );
+        T * calloc( size_t dim );
+        T * realloc( T * ptr, size_t size );
+        T * memalign( size_t align );
+        T * aligned_alloc( size_t align );
+        int posix_memalign( T ** ptr, size_t align );
+
+// §\CFA§ safe general allocation, fill, resize, array
+        T * alloc( void );§\indexc{alloc}§
+        T * alloc( char fill );
+        T * alloc( size_t dim );
+        T * alloc( size_t dim, char fill );
+        T * alloc( T ptr[], size_t dim );
+        T * alloc( T ptr[], size_t dim, char fill );
+
+// §\CFA§ safe general allocation, align, fill, array
+        T * align_alloc( size_t align );
+        T * align_alloc( size_t align, char fill );
+        T * align_alloc( size_t align, size_t dim );
+        T * align_alloc( size_t align, size_t dim, char fill );
+
 // §\CFA§ safe initialization/copy, i.e., implicit size specification
-forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§
-forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
+        T * memset( T * dest, char c );§\indexc{memset}§
+        T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
 
 // §\CFA§ safe initialization/copy array
-forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c );
-forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim );
+        T * amemset( T dest[], char c, size_t dim );
+        T * amemcpy( T dest[], const T src[], size_t dim );
+}
 
 // §\CFA§ allocation/deallocation and constructor/destructor
@@ -6063 +6063 @@
 forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dim );§\indexc{qsort}§
+
+forall( otype E | { int ?<?( E, E ); } ) {
+        E * bsearch( E key, const E * vals, size_t dim );§\indexc{bsearch}§     §\C{// location}§
+        size_t bsearch( E key, const E * vals, size_t dim );§\C{// position}§
+        E * bsearchl( E key, const E * vals, size_t dim );§\indexc{bsearchl}§
+        size_t bsearchl( E key, const E * vals, size_t dim );
+        E * bsearchu( E key, const E * vals, size_t dim );§\indexc{bsearchu}§
+        size_t bsearchu( E key, const E * vals, size_t dim );
+}
+
+forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
+        E * bsearch( K key, const E * vals, size_t dim );
+        size_t bsearch( K key, const E * vals, size_t dim );
+        E * bsearchl( K key, const E * vals, size_t dim );
+        size_t bsearchl( K key, const E * vals, size_t dim );
+        E * bsearchu( K key, const E * vals, size_t dim );
+        size_t bsearchu( K key, const E * vals, size_t dim );
+}
+
+forall( otype E | { int ?<?( E, E ); } ) {
+        void qsort( E * vals, size_t dim );§\indexc{qsort}§
+}
 \end{cfa}