source: tests/array.cfa@ d7a2de1

//                               -*- 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.
//
// array.cfa -- test array declarations
//
// Author           : Peter A. Buhr
// Created On       : Tue Feb 19 21:18:06 2019
// Last Modified By : Peter A. Buhr
// Last Modified On : Sat Jun  5 10:05:51 2021
// Update Count     : 5
//

// Tests syntax.  Comments explain semantics.  Test does not show semantics.
// Mostly illustrates facts about C (with which CFA is being tested to agree).
// Is a test oracle under `gcc -x c`.

#ifdef ERR1
#define E1(...) __VA_ARGS__
#else
#define E1(...)
#endif

#ifdef ERR2
#define E2(...) __VA_ARGS__
#else
#define E2(...)
#endif

#ifdef ERR3
#define E3(...) __VA_ARGS__
#else
#define E3(...)
#endif

    int ga1[0];
E1( int ga2[*];       )
                                                        #ifndef __cforall
E1( int ga3[3.0];  )                                  // BUG 275: CFA accepts but should reject
                                                        #endif

    int m1[0][3];
E1( int m2[*][*];    )
    int m4[3][3];

    typedef int T;

    void fred(int n) {
E1(     int a1[];   )
E1(     int a2[*];  )
        int a4[3];      (void) a4;
        int T[3];       (void) T;
        int a5[n];      (void) a5;
    }

    void fred2(int n,
        int a1[],
E1(     int a2[*],  )
        int a4[3],
        int T[3]        __attribute__((unused)),
        int a5[n]
    ) {
        // FIX ME: Replace attribute-unused on T with void cast, once Trac 297 is fixed.
        // This parameter should be in scope and usable within the body.

        (void) a1;
E1(     (void) a2;  )
        (void) a4;
//      (void) T;
        (void) a5;
    }

    void mary(
        int T[3]        __attribute__((unused)),  // same as: int *T
        int p1[const 3],                          // same as: int const *p1
        int p2[static 3],                         // same as T, but length >=3 checked
        int p3[static const 3]                    // both above: 3 is static, p3 is const
    ) {
        // FIX ME: Replace attribute-unused on T with void cast, once Trac 297 is fixed.
        // This parameter should be in scope and usable within the body.

//      (void) T;
        (void) p1;
        (void) p2;
        (void) p3;
    }

    // function taking (), returning pointer to array of ints
    int (*tom())[3] {
        return 0p;
    }

    // function taking (), returning pointer to function of same type as mary
    int (*(jane)())( int T[3],
                     int p1[const 3],
                     int p2[static 3],
                     int p3[static const 3]
        ) {
        return 0p;
    }

    // functions returning same exotic pointers, in CFA's non-onion syntax
    #ifdef __cforall
    [ * [3] int ] toms_twin(...) {
        return 0p;
    }
    [ * [int]( [3] int T,
               [const 3] int p1,
               [static 3] int p2,
               [static const 3] int p3
             )
    ] janes_twin(...) {
        return 0p;
    }
    #endif

    // GCC 11+ gives a false warning (-Wvla-parameter) on the valid (C11 ARM p134-135) combination:
    // declare with type int[*], define with type int[n].
    // https://gcc.gnu.org/bugzilla//show_bug.cgi?id=100420 suggests the internal representation of
    // of a[*] is the same as a[0].
    // https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wno-vla-parameter explains
    // the purpose of -Wvla-parameter is to report conflicts between int[] and int[n], which would
    // understandably also include those between int[42] and int[n].
    // https://stackoverflow.com/questions/17371645/why-use-an-asterisk-instead-of-an-integer-for-a-vla-array-parameter-of-a-f
    // explains the declare-*, define-n pattern.

    // To work around the false warning, and keep to this test's purpose of exercising CFA's
    // handling of exotic C array syntax, what would ideally be demonstrated as a declaration of
    // fm1, followed by its definition, is instead split into fm1x and fm1y.  And similarly for
    // fm5.

    void fm1x( int, int, int[][*] );
    void fm1y( int r, int c, int m[][c] ) { (void) r; (void) c; (void) m; }
    void fm2( int r, int c, int (*m)[c] ) { (void) r; (void) c; (void) m; }             // same as fm1
E2( void fm3( int r, int c, int m[][static c] ) {}  )    // that's not static
E3( void fm4( int r, int c, int m[][] );            )    // m's immediate element type is incomplete
    void fm5x( int, int, int[*][*] );                    // alt syntax for fm1 decl
    void fm5y( int r, int c, int m[r][c] ) { (void) r; (void) c; (void) m; }            // alt syntax for fm1 defn



int main() {
    printf("done\n");
}

// Local Variables: //
// tab-width: 4 //
// compile-command: "cfa array.cfa" //
// End: //