Changeset bd85400 for src/examples/alloc.c

Timestamp:

Feb 5, 2016, 5:09:04 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, 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, string, with_gc

Children:

52f85e0, 6ed1d4b, d41280e, d63eeb0

Parents:

4789f44

Message:

remove offsetof keyword, parser 0/1 names as structure fields, update examples to new stdlib, rename algorithms to stdlib, extend stdlib, use correct type for box parameters

File:

• src/examples/alloc.c (modified) (2 diffs)

src/examples/alloc.c

@@ -1 @@
-#if 0
+//                               -*- Mode: C -*- 
+// 
+// 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.
+//
+// alloc.c -- 
+// 
+// Author           : Peter A. Buhr
+// Created On       : Wed Feb  3 07:56:22 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  3 16:32:04 2016
+// Update Count     : 38
+// 
+
+#include <fstream>
+#include <stdlib>
 extern "C" {
-    typedef long unsigned int size_t;
-    void *malloc( size_t size );
-    void *calloc( size_t nmemb, size_t size );
-    void *realloc( void *ptr, size_t size );
-    void *memset( void *s, int c, size_t n );
-    void free( void * ptr );
-    int printf( const char *, ... );
-}
+#include <stdlib.h>                                                                             // access C malloc, realloc
+#include <stdio.h>
+} // exten "C"
 
-forall( type T ) T * malloc( void ) {
-    return (T *)malloc( sizeof(T) );
-}
-forall( type T ) T * calloc( size_t size ) {
-    return (T *)calloc( size, sizeof(T) );
-}
-#endif
-typedef int size_t;
-forall( type T ) T * realloc( T *ptr, size_t n ) {
-//    return (T *)(void *)realloc( ptr, sizeof(T) );
-}
-//forall( type T ) T * realloc( T *ptr, size_t n, T c ) {
-//    return (T *)realloc( ptr, n );
-//}
-
-//int *foo( int *p, int c );
-//int *bar( int *p, int c );
-//int *baz( int *p, int c );
+int * foo( int * p, int c ) { return p; }
+int * bar( int * p, int c ) { return p; }
+int * baz( int * p, int c ) { return p; }
 
 int main( void ) {
-    // size_t size = 10;
-    //int * x = malloc();
-    int * x;
-    // x = malloc();
-    // x = calloc( 10 );                                        // calloc: array set to 0
-    // x = realloc( x, 10 );
-    // x = realloc( x, 10, '\0' );
-    // x = malloc( 5 );
-    // float *fp = malloc() + 1;
+    ofstream * sout = ofstream_stdout();
 
-    struct St1 { int x; double y; };
-    struct St1 * st1;
-//    double *y;
-    x = realloc( st1, 10 );                             // SHOULD FAIL!!
+    size_t size = 10;
+    int * p;
+    struct S { int x; double y; } * s;
+
+    p = malloc( sizeof(*p) );                                                   // C malloc, type unsafe
+        printf( "here1\n" );
+    free( p );
+    p = malloc();                                                                               // CFA malloc, type safe
+        printf( "here2\n" );
+    free( p );
+    p = malloc( (char)'\0' );                                                                   // CFA malloc, type safe
+        printf( "here3\n" );
+    p = malloc( p, 1000 );                                                              // CFA remalloc, type safe
+        printf( "here4\n" );
+    free( p );
+    p = calloc( size, sizeof(*p) );                                             // C calloc, type unsafe
+        printf( "here5\n" );
+    free( p );
+    p = calloc( size );                                                                 // CFA calloc, type safe
+        printf( "here6\n" );
+    free( p );
+    p = calloc( size );                                                                 // CFA calloc, type safe
+    p = realloc( p, 1000 );                                                             // C realloc, type unsafe
+    p = realloc( p, 1000, '\0' );                                               // CFA realloc, type unsafe
+    p = memset( p );                                                                    // CFA memset, type unsafe
+        printf( "here7\n" );
+    free( p );
+    p = memalign( 16 );
+        printf( "here8\n" );
+    free( p );
+    posix_memalign( &p, 16 );
+        printf( "here9\n" );
+    free( p );
 #if 0
+    float * fp = malloc() + 1;
+    fprintf( stderr, "%p %p\n", fp, fp - 1 );
+    free( fp - 1 );
+    p = realloc( st1, size, '\0' );                                             // C realloc, type unsafe
+
+    double *y;
+    x = memset( st1, '\0' );                                                    // SHOULD FAIL!!
+
     int *p;
     p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
@@ -74 +100 @@
     free( x );
 #endif
+    free( sout );
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa alloc.c" //
+// End: //