rv4p.c

用于进行gcc测试

                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_2578(a))           == 2> t1;
    sa<sizeof(sink_4_2578(ca))          == 2> t2;
    sa<sizeof(sink_4_2578(va))          == 7> t3;
    sa<sizeof(sink_4_2578(cva))         == 8> t4;
    sa<sizeof(sink_4_2578(source()))    == 5> t5;
    sa<sizeof(sink_4_2578(c_source()))  == 8> t6;
    sa<sizeof(sink_4_2578(v_source()))  == 7> t7;
    sa<sizeof(sink_4_2578(cv_source())) == 8> t8;
    return 0;
}

two   sink_4_2678(const          A&);
six   sink_4_2678(const          A&&);
seven sink_4_2678(volatile       A&&);
eight sink_4_2678(const volatile A&&);

int test4_2678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_2678(a))           == 2> t1;
    sa<sizeof(sink_4_2678(ca))          == 2> t2;
    sa<sizeof(sink_4_2678(va))          == 7> t3;
    sa<sizeof(sink_4_2678(cva))         == 8> t4;
    sa<sizeof(sink_4_2678(c_source()))  == 6> t6;
    sa<sizeof(sink_4_2678(v_source()))  == 7> t7;
    sa<sizeof(sink_4_2678(cv_source())) == 8> t8;
    return 0;
}

three sink_4_3456(volatile       A&);
four  sink_4_3456(const volatile A&);
five  sink_4_3456(               A&&);
six   sink_4_3456(const          A&&);

int test4_3456()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3456(a))           == 3> t1;
    sa<sizeof(sink_4_3456(ca))          == 4> t2;
    sa<sizeof(sink_4_3456(va))          == 3> t3;
    sa<sizeof(sink_4_3456(cva))         == 4> t4;
    sa<sizeof(sink_4_3456(source()))    == 5> t5;
    sa<sizeof(sink_4_3456(c_source()))  == 6> t6;
    return 0;
}

three sink_4_3457(volatile       A&);
four  sink_4_3457(const volatile A&);
five  sink_4_3457(               A&&);
seven sink_4_3457(volatile       A&&);

int test4_3457()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3457(a))           == 3> t1;
    sa<sizeof(sink_4_3457(ca))          == 4> t2;
    sa<sizeof(sink_4_3457(va))          == 3> t3;
    sa<sizeof(sink_4_3457(cva))         == 4> t4;
    sa<sizeof(sink_4_3457(source()))    == 5> t5;
    sa<sizeof(sink_4_3457(v_source()))  == 7> t7;
    return 0;
}

three sink_4_3458(volatile       A&);
four  sink_4_3458(const volatile A&);
five  sink_4_3458(               A&&);
eight sink_4_3458(const volatile A&&);

int test4_3458()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3458(a))           == 3> t1;
    sa<sizeof(sink_4_3458(ca))          == 4> t2;
    sa<sizeof(sink_4_3458(va))          == 3> t3;
    sa<sizeof(sink_4_3458(cva))         == 4> t4;
    sa<sizeof(sink_4_3458(source()))    == 5> t5;
    sa<sizeof(sink_4_3458(c_source()))  == 8> t6;
    sa<sizeof(sink_4_3458(v_source()))  == 8> t7;
    sa<sizeof(sink_4_3458(cv_source())) == 8> t8;
    return 0;
}

three sink_4_3467(volatile       A&);
four  sink_4_3467(const volatile A&);
six   sink_4_3467(const          A&&);
seven sink_4_3467(volatile       A&&);

int test4_3467()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3467(a))           == 3> t1;
    sa<sizeof(sink_4_3467(ca))          == 4> t2;
    sa<sizeof(sink_4_3467(va))          == 3> t3;
    sa<sizeof(sink_4_3467(cva))         == 4> t4;
    sa<sizeof(sink_4_3467(c_source()))  == 6> t6;
    sa<sizeof(sink_4_3467(v_source()))  == 7> t7;
    return 0;
}

three sink_4_3468(volatile       A&);
four  sink_4_3468(const volatile A&);
six   sink_4_3468(const          A&&);
eight sink_4_3468(const volatile A&&);

int test4_3468()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3468(a))           == 3> t1;
    sa<sizeof(sink_4_3468(ca))          == 4> t2;
    sa<sizeof(sink_4_3468(va))          == 3> t3;
    sa<sizeof(sink_4_3468(cva))         == 4> t4;
    sa<sizeof(sink_4_3468(source()))    == 6> t5;
    sa<sizeof(sink_4_3468(c_source()))  == 6> t6;
    sa<sizeof(sink_4_3468(v_source()))  == 8> t7;
    sa<sizeof(sink_4_3468(cv_source())) == 8> t8;
    return 0;
}

three sink_4_3478(volatile       A&);
four  sink_4_3478(const volatile A&);
seven sink_4_3478(volatile       A&&);
eight sink_4_3478(const volatile A&&);

int test4_3478()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3478(a))           == 3> t1;
    sa<sizeof(sink_4_3478(ca))          == 4> t2;
    sa<sizeof(sink_4_3478(va))          == 3> t3;
    sa<sizeof(sink_4_3478(cva))         == 4> t4;
    sa<sizeof(sink_4_3478(source()))    == 7> t5;
    sa<sizeof(sink_4_3478(c_source()))  == 8> t6;
    sa<sizeof(sink_4_3478(v_source()))  == 7> t7;
    sa<sizeof(sink_4_3478(cv_source())) == 8> t8;
    return 0;
}

three sink_4_3567(volatile       A&);
five  sink_4_3567(               A&&);
six   sink_4_3567(const          A&&);
seven sink_4_3567(volatile       A&&);

int test4_3567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3567(a))           == 3> t1;
    sa<sizeof(sink_4_3567(ca))          == 6> t2;
    sa<sizeof(sink_4_3567(va))          == 3> t3;
    sa<sizeof(sink_4_3567(source()))    == 5> t5;
    sa<sizeof(sink_4_3567(c_source()))  == 6> t6;
    sa<sizeof(sink_4_3567(v_source()))  == 7> t7;
    return 0;
}

three sink_4_3568(volatile       A&);
five  sink_4_3568(               A&&);
six   sink_4_3568(const          A&&);
eight sink_4_3568(const volatile A&&);

int test4_3568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3568(a))           == 3> t1;
    sa<sizeof(sink_4_3568(ca))          == 6> t2;
    sa<sizeof(sink_4_3568(va))          == 3> t3;
    sa<sizeof(sink_4_3568(cva))         == 8> t4;
    sa<sizeof(sink_4_3568(source()))    == 5> t5;
    sa<sizeof(sink_4_3568(c_source()))  == 6> t6;
    sa<sizeof(sink_4_3568(v_source()))  == 8> t7;
    sa<sizeof(sink_4_3568(cv_source())) == 8> t8;
    return 0;
}

three sink_4_3578(volatile       A&);
five  sink_4_3578(               A&&);
seven sink_4_3578(volatile       A&&);
eight sink_4_3578(const volatile A&&);

int test4_3578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3578(a))           == 3> t1;
    sa<sizeof(sink_4_3578(ca))          == 8> t2;
    sa<sizeof(sink_4_3578(va))          == 3> t3;
    sa<sizeof(sink_4_3578(cva))         == 8> t4;
    sa<sizeof(sink_4_3578(source()))    == 5> t5;
    sa<sizeof(sink_4_3578(c_source()))  == 8> t6;
    sa<sizeof(sink_4_3578(v_source()))  == 7> t7;
    sa<sizeof(sink_4_3578(cv_source())) == 8> t8;
    return 0;
}

three sink_4_3678(volatile       A&);
six   sink_4_3678(const          A&&);
seven sink_4_3678(volatile       A&&);
eight sink_4_3678(const volatile A&&);

int test4_3678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_3678(a))           == 3> t1;
    sa<sizeof(sink_4_3678(ca))          == 6> t2;
    sa<sizeof(sink_4_3678(va))          == 3> t3;
    sa<sizeof(sink_4_3678(cva))         == 8> t4;
    sa<sizeof(sink_4_3678(c_source()))  == 6> t6;
    sa<sizeof(sink_4_3678(v_source()))  == 7> t7;
    sa<sizeof(sink_4_3678(cv_source())) == 8> t8;
    return 0;
}

four  sink_4_4567(const volatile A&);
five  sink_4_4567(               A&&);
six   sink_4_4567(const          A&&);
seven sink_4_4567(volatile       A&&);

int test4_4567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_4567(a))           == 4> t1;
    sa<sizeof(sink_4_4567(ca))          == 4> t2;
    sa<sizeof(sink_4_4567(va))          == 4> t3;
    sa<sizeof(sink_4_4567(cva))         == 4> t4;
    sa<sizeof(sink_4_4567(source()))    == 5> t5;
    sa<sizeof(sink_4_4567(c_source()))  == 6> t6;
    sa<sizeof(sink_4_4567(v_source()))  == 7> t7;
    return 0;
}

four  sink_4_4568(const volatile A&);
five  sink_4_4568(               A&&);
six   sink_4_4568(const          A&&);
eight sink_4_4568(const volatile A&&);

int test4_4568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_4568(a))           == 4> t1;
    sa<sizeof(sink_4_4568(ca))          == 4> t2;
    sa<sizeof(sink_4_4568(va))          == 4> t3;
    sa<sizeof(sink_4_4568(cva))         == 4> t4;
    sa<sizeof(sink_4_4568(source()))    == 5> t5;
    sa<sizeof(sink_4_4568(c_source()))  == 6> t6;
    sa<sizeof(sink_4_4568(v_source()))  == 8> t7;
    sa<sizeof(sink_4_4568(cv_source())) == 8> t8;
    return 0;
}

four  sink_4_4578(const volatile A&);
five  sink_4_4578(               A&&);
seven sink_4_4578(volatile       A&&);
eight sink_4_4578(const volatile A&&);

int test4_4578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_4578(a))           == 4> t1;
    sa<sizeof(sink_4_4578(ca))          == 4> t2;
    sa<sizeof(sink_4_4578(va))          == 4> t3;
    sa<sizeof(sink_4_4578(cva))         == 4> t4;
    sa<sizeof(sink_4_4578(source()))    == 5> t5;
    sa<sizeof(sink_4_4578(c_source()))  == 8> t6;
    sa<sizeof(sink_4_4578(v_source()))  == 7> t7;
    sa<sizeof(sink_4_4578(cv_source())) == 8> t8;
    return 0;
}

four  sink_4_4678(const volatile A&);
six   sink_4_4678(const          A&&);
seven sink_4_4678(volatile       A&&);
eight sink_4_4678(const volatile A&&);

int test4_4678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_4678(a))           == 4> t1;
    sa<sizeof(sink_4_4678(ca))          == 4> t2;
    sa<sizeof(sink_4_4678(va))          == 4> t3;
    sa<sizeof(sink_4_4678(cva))         == 4> t4;
    sa<sizeof(sink_4_4678(c_source()))  == 6> t6;
    sa<sizeof(sink_4_4678(v_source()))  == 7> t7;
    sa<sizeof(sink_4_4678(cv_source())) == 8> t8;
    return 0;
}

five  sink_4_5678(               A&&);
six   sink_4_5678(const          A&&);
seven sink_4_5678(volatile       A&&);
eight sink_4_5678(const volatile A&&);

int test4_5678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_4_5678(a))           == 5> t1;
    sa<sizeof(sink_4_5678(ca))          == 6> t2;
    sa<sizeof(sink_4_5678(va))          == 7> t3;
    sa<sizeof(sink_4_5678(cva))         == 8> t4;
    sa<sizeof(sink_4_5678(source()))    == 5> t5;
    sa<sizeof(sink_4_5678(c_source()))  == 6> t6;
    sa<sizeof(sink_4_5678(v_source()))  == 7> t7;
    sa<sizeof(sink_4_5678(cv_source())) == 8> t8;
    return 0;
}

int main()
{
    return test4_1234() + test4_1235() + test4_1236() + test4_1237() + test4_1238() +
           test4_1245() + test4_1246() + test4_1247() + test4_1248() + test4_1256() +
           test4_1257() + test4_1258() + test4_1267() + test4_1268() + test4_1278() +
           test4_1345() + test4_1346() + test4_1347() + test4_1348() + test4_1356() +
           test4_1357() + test4_1358() + test4_1367() + test4_1368() + test4_1378() +
           test4_1456() + test4_1457() + test4_1458() + test4_1467() + test4_1468() +
           test4_1478() + test4_1567() + test4_1568() + test4_1578() + test4_1678() +
           test4_2345() + test4_2346() + test4_2347() + test4_2348() + test4_2356() +
           test4_2357() + test4_2358() + test4_2367() + test4_2368() + test4_2378() +
           test4_2456() + test4_2457() + test4_2458() + test4_2467() + test4_2468() +
           test4_2478() + test4_2567() + test4_2568() + test4_2578() + test4_2678() +
           test4_3456() + test4_3457() + test4_3458() + test4_3467() + test4_3468() +
           test4_3478() + test4_3567() + test4_3568() + test4_3578() + test4_3678() +
           test4_4567() + test4_4568() + test4_4578() + test4_4678() + test4_5678();
}