Changes in doc/user/user.tex [e10537a9:d92ff4a]

File:

• doc/user/user.tex (modified) (9 diffs)

doc/user/user.tex

@@ -1 +1 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%
+%% 
 %% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 %%
 %% The contents of this file are covered under the licence agreement in the
 %% file "LICENCE" distributed with Cforall.
-%%
-%% user.tex --
-%%
+%% 
+%% user.tex -- 
+%% 
 %% Author           : Peter A. Buhr
 %% 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
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -72 +72 @@
 
 % Names used in the document.
-\newcommand{\Version}{\input{build/version}}
+\newcommand{\Version}{\input{../../version}}
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
@@ -430 +430 @@
 #endif
 \end{cfa}
-which conditionally includes the correct header file, if the program is compiled using \Indexc{gcc} or \Indexc{cfa}.
+which conditionally includes the correct header file, if the program is compiled using \Indexc{gcc} or \Indexc{cfa}. 
 
 
@@ -1447 +1447 @@
 \end{cfa}
 Algol68 infers the following dereferencing ©*p2 = *p1 + x©, because adding the arbitrary integer value in ©x© to the address of ©p1© and storing the resulting address into ©p2© is an unlikely operation.
-Unfortunately, automatic dereferencing does not work in all cases, and so some mechanism is necessary to fix incorrect choices.
+Unfortunately, automatic dereferencing does not work in all cases, and so some mechanism is necessary to fix incorrect choices. 
 
 Rather than inferring dereference, most programming languages pick one implicit dereferencing semantics, and the programmer explicitly indicates the other to resolve address-duality.
@@ -2282 +2282 @@
         struct T t;
 } s;
-
+        
 
 
@@ -2354 +2354 @@
 }
 \end{cfa}
-because
+because 
 
 Currently, there are no \Index{lambda} expressions, \ie unnamed routines because routine names are very important to properly select the correct routine.
@@ -3394 +3394 @@
         sout | sepDisable | 1 | 2 | 3 | endl;           // globally turn off implicit separator
         sout | sepEnable | 1 | 2 | 3 | endl;            // globally turn on implicit separator
-
+        
         sout | 1 | sepOff | 2 | 3 | endl;                       // locally turn on implicit separator
         sout | sepDisable | 1 | sepOn | 2 | 3 | endl; // globally turn off implicit separator
@@ -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}