source: tests/zero_one.cfa @ 62b5940

#include <fstream.hfa>

void foo(zero_t)
{
        sout | "It's a Zero!";
}

void foo(one_t)
{
        sout | "It's a One!";
}

void foo(int)
{
        sout | "It's a Number!";
}

void testOverloads()
{
        foo(0);
        foo(1);
        foo(2);
}

struct S { int i, j; };
void ?{}( S & s, zero_t ) { s.[i,j] = 0; }                              // constructors
void ?{}( S & s, one_t ) { s.[i,j] = 1; }
S ?=?( S & dst, zero_t ) { dst.[i,j] = 0; return dst; } // assignment
S ?=?( S & dst, one_t ) { dst.[i,j] = 1; return dst; }
S ?+=?( S & s, one_t ) { s.[i,j] += 1; return s; }              // increment/decrement each field
S ?-=?( S & s, one_t ) { s.[i,j] -= 1; return s; }
int ?!=?( S s, zero_t ) { return s.i != 0 && s.j != 0; } // comparison
void testInitAssignQueryIncrement() {
        S s = 0;                                                                                        // initialization
        s = 0;                                                                                          // assignments
        s = 1;
        if ( s ) ++s;                                                                           // special, unary ++/-\,- come from +=/-=
        sout | s.i | s.j;
}

void testCompats() {
    zero_t zero = 0;
    one_t one = 1;

    int x = 0;
        int xx = zero;

        sout | x | xx;

        x = xx = 42;
        sout | x | xx;

        x = 0;
        xx = zero;
        sout | x | xx;

        int y = 1;
        int yy = one;

        sout | y | yy;

        y = yy = 42;
        sout | y | yy;

        y = 1;
        yy = one;
        sout | y | yy;

        void z_helper( int * p, zero_t z ) {
                p = z;  // expect z not reported unused here; expect no missing cast from -Wint-conversion
                sout | "zero" | (bool) (p == 0);
        }

        void z_call( int * p, zero_t z ) {
                z_helper(p, z);
        }

        void o_helper( int * p, one_t o ) {
          #ifdef ERR1
                p = o;
          #else
                (void) x;  (void) o;
          #endif
                sout | "one" | (bool) (p == 0);
        }

        void o_call( int * p, one_t o ) {
                o_helper(p, o);
        }

        z_call( &x, 0 );
        z_call( &x, zero );

        o_call( &x, 1 );
        o_call( &x, one );
}

int main() {
        testOverloads();
        testInitAssignQueryIncrement();
        testCompats();
        return 0;
}