source: src/examples/alloc.c @ 7937abf

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 7937abf was 7937abf, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

update examples with new keywords, more formatting changes in documentation

  • Property mode set to 100644
File size: 2.9 KB
Line 
1//                               -*- Mode: C -*-
2//
3// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
4//
5// The contents of this file are covered under the licence agreement in the
6// file "LICENCE" distributed with Cforall.
7//
8// alloc.c --
9//
10// Author           : Peter A. Buhr
11// Created On       : Wed Feb  3 07:56:22 2016
12// Last Modified By : Peter A. Buhr
13// Last Modified On : Fri Mar 11 17:42:08 2016
14// Update Count     : 59
15//
16
17forall( otype T ) T * malloc( char fill );
18forall( dtype T ) T *?=?( T **, void * );
19void *malloc( unsigned long int );
20#if 0
21#include <fstream>
22#include <stdlib>
23extern "C" {
24#include <stdlib.h>                                                                             // access C malloc, realloc
25#include <stdio.h>
26} // exten "C"
27
28int * foo( int * p, int c ) { return p; }
29int * bar( int * p, int c ) { return p; }
30int * baz( int * p, int c ) { return p; }
31#endif
32
33int main( void ) {
34#if 0
35    size_t size = 10;
36    int * p;
37    struct S { int x; double y; } * s;
38#endif
39
40#if 0
41    p = malloc( sizeof(*p) );                                                   // C malloc, type unsafe
42        printf( "here1\n" );
43    free( p );
44    p = malloc();                                                                               // CFA malloc, type safe
45        printf( "here2\n" );
46    free( p );
47#endif
48//    int * p;
49//    p = malloc( (char)'\0' );                                                                 // CFA malloc, type safe
50    (int *)malloc( (char)'\0' );                                                                        // CFA malloc, type safe
51    (void *)malloc( (char)'\0' );                                                                       // CFA malloc, type safe
52#if 0
53        printf( "here3\n" );
54    p = malloc( p, 1000 );                                                              // CFA remalloc, type safe
55        printf( "here4\n" );
56    free( p );
57    p = calloc( size, sizeof(*p) );                                             // C calloc, type unsafe
58        printf( "here5\n" );
59    free( p );
60    p = calloc( size );                                                                 // CFA calloc, type safe
61        printf( "here6\n" );
62    free( p );
63    p = calloc( size );                                                                 // CFA calloc, type safe
64    p = realloc( p, 1000 );                                                             // C realloc, type unsafe
65    p = realloc( p, 1000, '\0' );                                               // CFA realloc, type unsafe
66    p = memset( p );                                                                    // CFA memset, type unsafe
67        printf( "here7\n" );
68    free( p );
69    p = memalign( 16 );
70        printf( "here8\n" );
71    free( p );
72    posix_memalign( &p, 16 );
73        printf( "here9\n" );
74    free( p );
75
76    float * fp = malloc() + 1;
77    fprintf( stderr, "%p %p\n", fp, fp - 1 );
78    free( fp - 1 );
79    p = realloc( st1, size, '\0' );                                             // C realloc, type unsafe
80
81    double *y;
82    x = memset( st1, '\0' );                                                    // SHOULD FAIL!!
83
84    int *p;
85    p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
86    free( p );
87
88    struct St2 { int x; double y; };
89    struct St2 * st2;
90
91    y = malloc();
92    st1 = malloc();
93//    st1 = realloc( st2, 10, st1 );
94 
95    *y = 1.0;
96    printf("%f\n", *y);
97
98    st1->x = *x + 1;
99    st1->y = *y *1.5;
100    printf("{ %d, %f }\n", st1->x, st1->y);
101
102    free( y );
103 
104    x = malloc( 10 );
105    for ( int i = 0; i < 10; i += 1 ) {
106        x[i] = i * 10;
107    }
108    for ( int j = 0; j < 10; j += 1 ) {
109        printf( "x[%d] = %d\n", j, x[j] );
110    }
111    free( x );
112#endif
113}
114
115// Local Variables: //
116// tab-width: 4 //
117// compile-command: "cfa alloc.c" //
118// End: //
Note: See TracBrowser for help on using the repository browser.