Changeset 660665f for tests


Ignore:
Timestamp:
Jun 29, 2021, 5:35:19 PM (4 years ago)
Author:
caparsons <caparson@…>
Branches:
ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
dcad80a
Parents:
5a46e09 (diff), d02e547 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
tests
Files:
18 added
17 edited
1 moved

Legend:

Unmodified
Added
Removed

  • tests/.expect/forall.txt

    r5a46e09 r660665f  
    1 forall.cfa:216:25: warning: Compiled
     1forall.cfa:242:25: warning: Compiled

  • tests/.expect/typedefRedef-ERR1.txt

    r5a46e09 r660665f  
    1 typedefRedef.cfa:69:25: warning: Compiled
     1typedefRedef.cfa:75:25: warning: Compiled
    22typedefRedef.cfa:4:1 error: Cannot redefine typedef: Foo
    3 typedefRedef.cfa:59:1 error: Cannot redefine typedef: ARR
     3typedefRedef.cfa:65:1 error: Cannot redefine typedef: ARR

  • tests/.expect/typedefRedef.txt

    r5a46e09 r660665f  
    1 typedefRedef.cfa:69:25: warning: Compiled
     1typedefRedef.cfa:75:25: warning: Compiled

  • tests/array-container/array-basic.cfa

    r5a46e09 r660665f  
    6161forall( [Nw], [Nx], [Ny], [Nz] )
    6262void fillHelloData( array( float, Nw, Nx, Ny, Nz ) & wxyz ) {
    63     for (w; z(Nw))
    64     for (x; z(Nx))
    65     for (y; z(Ny))
    66     for (z; z(Nz))
     63    for (w; Nw)
     64    for (x; Nx)
     65    for (y; Ny)
     66    for (z; Nz)
    6767        wxyz[w][x][y][z] = getMagicNumber(w, x, y, z);
    6868}
    6969
    70 forall( [Zn]
     70forall( [N]
    7171      , S & | sized(S)
    7272      )
    73 float total1d_low( arpk(Zn, S, float, float ) & a ) {
     73float total1d_low( arpk(N, S, float, float ) & a ) {
    7474    float total = 0.0f;
    75     for (i; z(Zn))
     75    for (i; N)
    7676        total += a[i];
    7777    return total;
    … …  
    9898
    9999    expect = 0;
    100     for (i; z(Nw))
     100    for (i; Nw)
    101101        expect += getMagicNumber( i, slice_ix, slice_ix, slice_ix );
    102102    printf("expect Ws             = %f\n", expect);
    … …  
    105105    printf("result Ws [][][][] lo = %f\n", result);
    106106
    107     result = total1d_low( wxyz[[all, slice_ix, slice_ix, slice_ix]] );
     107    result = total1d_low( wxyz[all, slice_ix, slice_ix, slice_ix] );
    108108    printf("result Ws [,,,]    lo = %f\n", result);
    109109
    … …  
    111111    printf("result Ws [][][][] hi = %f\n", result);
    112112
    113     result = total1d_hi( wxyz[[all, slice_ix, slice_ix, slice_ix]] );
     113    result = total1d_hi( wxyz[all, slice_ix, slice_ix, slice_ix] );
    114114    printf("result Ws [,,,]    hi = %f\n", result);
    115115
    … …  
    117117
    118118    expect = 0;
    119     for (i; z(Nx))
     119    for (i; Nx)
    120120        expect += getMagicNumber( slice_ix, i, slice_ix, slice_ix );
    121121    printf("expect Xs             = %f\n", expect);
    … …  
    124124    printf("result Xs [][][][] lo = %f\n", result);
    125125
    126     result = total1d_low( wxyz[[slice_ix, all, slice_ix, slice_ix]] );
     126    result = total1d_low( wxyz[slice_ix, all, slice_ix, slice_ix] );
    127127    printf("result Xs [,,,]    lo = %f\n", result);
    128128
    … …  
    130130    printf("result Xs [][][][] hi = %f\n", result);
    131131
    132     result = total1d_hi( wxyz[[slice_ix, all, slice_ix, slice_ix]] );
     132    result = total1d_hi( wxyz[slice_ix, all, slice_ix, slice_ix] );
    133133    printf("result Xs [,,,]    hi = %f\n", result);
    134134

  • tests/array-container/array-md-sbscr-cases.cfa

    r5a46e09 r660665f  
    2020forall( [Nw], [Nx], [Ny], [Nz] )
    2121void fillHelloData( array( float, Nw, Nx, Ny, Nz ) & wxyz ) {
    22     for (w; z(Nw))
    23     for (x; z(Nx))
    24     for (y; z(Ny))
    25     for (z; z(Nz))
     22    for (w; Nw)
     23    for (x; Nx)
     24    for (y; Ny)
     25    for (z; Nz)
    2626        wxyz[w][x][y][z] = getMagicNumber(w, x, y, z);
    2727}
    … …  
    5353    // order wxyz, natural split (4-0 or 0-4, no intermediate to declare)
    5454
    55     assert(( wxyz[[iw, ix, iy, iz]] == valExpected ));
     55    assert(( wxyz[iw, ix, iy, iz] == valExpected ));
    5656
    5757    // order wxyz, unnatural split 1-3  (three ways declared)
    5858
    5959    typeof( wxyz[iw] ) xyz1 = wxyz[iw];
    60     assert(( xyz1[[ix, iy, iz]]  == valExpected ));
     60    assert(( xyz1[ix, iy, iz]  == valExpected ));
    6161
    6262    typeof( wxyz[iw] ) xyz2;
    6363    &xyz2 = &wxyz[iw];
    64     assert(( xyz2[[ix, iy, iz]] == valExpected ));
    65 
    66     assert(( wxyz[iw][[ix, iy, iz]] == valExpected ));
     64    assert(( xyz2[ix, iy, iz] == valExpected ));
     65
     66    assert(( wxyz[iw][ix, iy, iz] == valExpected ));
    6767
    6868    // order wxyz, unnatural split 2-2  (three ways declared)
    6969
    70     typeof( wxyz[[iw, ix]] ) yz1 = wxyz[[iw,ix]];
    71     assert(( yz1[[iy, iz]]  == valExpected ));
    72 
    73     typeof( wxyz[[iw, ix]] ) yz2;
    74     &yz2 = &wxyz[[iw, ix]];
    75     assert(( yz2[[iy, iz]]  == valExpected ));
    76 
    77     assert(( wxyz[[iw, ix]][[iy, iz]] == valExpected ));
     70    typeof( wxyz[iw, ix] ) yz1 = wxyz[iw,ix];
     71    assert(( yz1[iy, iz]  == valExpected ));
     72
     73    typeof( wxyz[iw, ix] ) yz2;
     74    &yz2 = &wxyz[iw, ix];
     75    assert(( yz2[iy, iz]  == valExpected ));
     76
     77    assert(( wxyz[iw, ix][iy, iz] == valExpected ));
    7878
    7979    // order wxyz, unnatural split 3-1  (three ways declared)
    8080
    81     typeof( wxyz[[iw, ix, iy]] ) z1 = wxyz[[iw, ix, iy]];
     81    typeof( wxyz[iw, ix, iy] ) z1 = wxyz[iw, ix, iy];
    8282    assert(( z1[iz]  == valExpected ));
    8383
    84     typeof( wxyz[[iw, ix, iy]] ) z2;
    85     &z2 = &wxyz[[iw, ix, iy]];
     84    typeof( wxyz[iw, ix, iy] ) z2;
     85    &z2 = &wxyz[iw, ix, iy];
    8686    assert(( z2[iz] == valExpected ));
    8787
    88     assert(( wxyz[[iw, ix, iy]][iz] == valExpected ));
     88    assert(( wxyz[iw, ix, iy][iz] == valExpected ));
    8989}
    9090
    … …  
    104104    // order wxyz (no intermediates to declare)
    105105
    106     assert(( wxyz[[iw  , ix  , iy  , iz  ]]       == valExpected ));
    107     assert(( wxyz[[iw-1, ix  , iy  , iz  ]]       != valExpected ));
     106    assert(( wxyz[iw  , ix  , iy  , iz  ]       == valExpected ));
     107    assert(( wxyz[iw-1, ix  , iy  , iz  ]       != valExpected ));
    108108
    109109    // order xyzw: *xyz, w
    110110
    111     assert(( wxyz[[all , ix  , iy  , iz  ]][iw  ] == valExpected ));
    112     assert(( wxyz[[all , ix-1, iy  , iz  ]][iw  ] != valExpected ));
    113     assert(( wxyz[[all , ix  , iy  , iz  ]][iw-1] != valExpected ));
     111    assert(( wxyz[all , ix  , iy  , iz  ][iw  ] == valExpected ));
     112    assert(( wxyz[all , ix-1, iy  , iz  ][iw  ] != valExpected ));
     113    assert(( wxyz[all , ix  , iy  , iz  ][iw-1] != valExpected ));
    114114
    115115    // order wyzx: w*yz, x
    116116
    117     assert(( wxyz[[iw  , all , iy  , iz  ]][ix  ] == valExpected ));
    118     assert(( wxyz[[iw  , all , iy-1, iz  ]][ix  ] != valExpected ));
    119     assert(( wxyz[[iw  , all , iy  , iz  ]][ix-1] != valExpected ));
     117    assert(( wxyz[iw  , all , iy  , iz  ][ix  ] == valExpected ));
     118    assert(( wxyz[iw  , all , iy-1, iz  ][ix  ] != valExpected ));
     119    assert(( wxyz[iw  , all , iy  , iz  ][ix-1] != valExpected ));
    120120
    121121    // order wxzy: wx*z, y
    122122  #if 0
    123123    // not working on 32-bit
    124     assert(( wxyz[[iw  , ix  , all , iz  ]][iy  ] == valExpected ));
    125     assert(( wxyz[[iw  , ix  , all , iz-1]][iy  ] != valExpected ));
    126     assert(( wxyz[[iw  , ix  , all , iz  ]][iy-1] != valExpected ));
     124    assert(( wxyz[iw  , ix  , all , iz  ][iy  ] == valExpected ));
     125    assert(( wxyz[iw  , ix  , all , iz-1][iy  ] != valExpected ));
     126    assert(( wxyz[iw  , ix  , all , iz  ][iy-1] != valExpected ));
    127127  #endif
    128128}
    … …  
    131131// The comments specify a covering set of orders, each in its most natural split.
    132132// Covering means that each edge on the lattice of dimesnions-provided is used.
    133 // Natural split means the arity of every -[[-,...]] tuple equals the dimensionality of its "this" operand, then that the fewest "all" subscripts are given.
     133// Natural split means the arity of every -[-,...] tuple equals the dimensionality of its "this" operand, then that the fewest "all" subscripts are given.
    134134// The commented-out test code shows cases that don't work.  We wish all the comment-coverd cases worked.
    135135forall( [Nw], [Nx], [Ny], [Nz] )
    … …  
    147147    // order wxyz (no intermediates to declare)
    148148
    149     assert(( wxyz[[iw, ix, iy, iz]] == valExpected ));
     149    assert(( wxyz[iw, ix, iy, iz] == valExpected ));
    150150
    151151    {
    … …  
    153153        assert( wxyz[iw][all][iy][all] [ix][iz] == valExpected );
    154154
    155         typeof( wxyz[[iw, all, iy, all]] ) xz1 = wxyz[[iw, all, iy, all]];
    156         assert(( xz1[[ix, iz]]  == valExpected ));
    157 
    158         typeof( wxyz[[iw, all, iy, all]] ) xz2;
    159         &xz2 = &wxyz[[iw, all, iy, all]];
    160         assert(( xz2[[ix, iz]]  == valExpected ));
    161 
    162         assert(( wxyz[[iw  , all, iy  , all]][[ix  , iz  ]] == valExpected ));
    163         assert(( wxyz[[iw-1, all, iy  , all]][[ix  , iz  ]] != valExpected ));
    164         assert(( wxyz[[iw  , all, iy-1, all]][[ix  , iz  ]] != valExpected ));
    165         assert(( wxyz[[iw  , all, iy  , all]][[ix-1, iz  ]] != valExpected ));
    166         assert(( wxyz[[iw  , all, iy  , all]][[ix  , iz-1]] != valExpected ));
     155        typeof( wxyz[iw, all, iy, all] ) xz1 = wxyz[iw, all, iy, all];
     156        assert(( xz1[ix, iz]  == valExpected ));
     157
     158        typeof( wxyz[iw, all, iy, all] ) xz2;
     159        &xz2 = &wxyz[iw, all, iy, all];
     160        assert(( xz2[ix, iz]  == valExpected ));
     161
     162        assert(( wxyz[iw  , all, iy  , all][ix  , iz  ] == valExpected ));
     163        assert(( wxyz[iw-1, all, iy  , all][ix  , iz  ] != valExpected ));
     164        assert(( wxyz[iw  , all, iy-1, all][ix  , iz  ] != valExpected ));
     165        assert(( wxyz[iw  , all, iy  , all][ix-1, iz  ] != valExpected ));
     166        assert(( wxyz[iw  , all, iy  , all][ix  , iz-1] != valExpected ));
    167167    }
    168168    {
    … …  
    170170        assert( wxyz[iw][all][all][iz] [ix][iy] == valExpected );
    171171
    172         // typeof( wxyz[[iw, all, all, iz]] ) xy1 = wxyz[[iw, all, all, iz]];
    173         // assert(( xy1[[ix, iy]]  == valExpected ));
    174 
    175         // typeof(  wxyz[[iw, all, all, iz]] ) xy2;
    176         // &xy2 = &wxyz[[iw, all, all, iz]];
    177         // assert(( xy2[[ix, iy]]  == valExpected ));
    178 
    179         // assert(( wxyz[[iw  , all, all, iz  ]][[ix  , iy  ]] == valExpected ));
    180         // assert(( wxyz[[iw-1, all, all, iz  ]][[ix  , iy  ]] != valExpected ));
    181         // assert(( wxyz[[iw  , all, all, iz-1]][[ix  , iy  ]] != valExpected ));
    182         // assert(( wxyz[[iw  , all, all, iz  ]][[ix-1, iy  ]] != valExpected ));
    183         // assert(( wxyz[[iw  , all, all, iz  ]][[ix  , iy-1]] != valExpected ));
     172        // typeof( wxyz[iw, all, all, iz] ) xy1 = wxyz[iw, all, all, iz];
     173        // assert(( xy1[ix, iy]  == valExpected ));
     174
     175        // typeof(  wxyz[iw, all, all, iz] ) xy2;
     176        // &xy2 = &wxyz[iw, all, all, iz];
     177        // assert(( xy2[ix, iy]  == valExpected ));
     178
     179        // assert(( wxyz[iw  , all, all, iz  ][ix  , iy  ] == valExpected ));
     180        // assert(( wxyz[iw-1, all, all, iz  ][ix  , iy  ] != valExpected ));
     181        // assert(( wxyz[iw  , all, all, iz-1][ix  , iy  ] != valExpected ));
     182        // assert(( wxyz[iw  , all, all, iz  ][ix-1, iy  ] != valExpected ));
     183        // assert(( wxyz[iw  , all, all, iz  ][ix  , iy-1] != valExpected ));
    184184    }
    185185    {
    … …  
    187187        assert( wxyz[all][ix][iy][all] [iw][iz] == valExpected );
    188188
    189         typeof( wxyz[[all, ix, iy, all]] ) wz1 = wxyz[[all, ix, iy, all]];
    190         assert(( wz1[[iw, iz]]  == valExpected ));
    191 
    192         assert(( wxyz[[all  , ix, iy  , all]][[iw  , iz  ]] == valExpected ));
     189        typeof( wxyz[all, ix, iy, all] ) wz1 = wxyz[all, ix, iy, all];
     190        assert(( wz1[iw, iz]  == valExpected ));
     191
     192        assert(( wxyz[all  , ix, iy  , all][iw  , iz  ] == valExpected ));
    193193    }
    194194    {
    … …  
    196196        assert( wxyz[all][ix][all][iz] [iw][iy] == valExpected );
    197197
    198         // assert(( wxyz[[all , ix  , all , iz  ]][[iw  , iy  ]] == valExpected ));
     198        // assert(( wxyz[all , ix  , all , iz  ][iw  , iy  ] == valExpected ));
    199199    }
    200200    {
    … …  
    202202        assert( wxyz[all][all][iy][iz] [iw][ix] == valExpected );
    203203
    204         // assert(( wxyz[[all , all , iy  , iz  ]][[iw  , ix  ]] == valExpected ));
     204        // assert(( wxyz[all , all , iy  , iz  ][iw  , ix  ] == valExpected ));
    205205    }
    206206    {
    … …  
    208208        assert( wxyz[all][ix][all][all] [iw][all][iz] [iy] == valExpected );
    209209
    210         typeof( wxyz[all][ix][all][all] ) wyz_workaround = wxyz[[all , ix , all  , all  ]];
    211         typeof( wyz_workaround[iw][all][iz] ) y_workaround = wyz_workaround[[iw , all , iz  ]];
     210        typeof( wxyz[all][ix][all][all] ) wyz_workaround = wxyz[all , ix , all  , all  ];
     211        typeof( wyz_workaround[iw][all][iz] ) y_workaround = wyz_workaround[iw , all , iz  ];
    212212        assert( y_workaround[iy] == valExpected );
    213213
    214         // assert(( wxyz[[all , ix , all  , all  ]][[iw  , all , iz  ]][iy  ] == valExpected ));
     214        // assert(( wxyz[all , ix , all  , all  ][iw  , all , iz  ][iy  ] == valExpected ));
    215215    }
    216216    {
    … …  
    239239    valExpected = getMagicNumber(2, 3, 4, 5);
    240240    assert(( wxyz [2] [3] [4] [5]  == valExpected ));
    241     assert(( wxyz[[2,  3]][4] [5]  == valExpected ));
    242     assert(( wxyz [2][[3,  4]][5]  == valExpected ));
    243     assert(( wxyz [2] [3][[4,  5]] == valExpected ));
    244     assert(( wxyz[[2,  3,  4]][5]  == valExpected ));
    245     assert(( wxyz [2][[3,  4,  5]] == valExpected ));
    246     assert(( wxyz[[2,  3,  4,  5]] == valExpected ));
    247 
    248     for ( i; z(Nw) ) {
    249         assert(( wxyz[[ i, 3, 4, 5 ]] == getMagicNumber(i, 3, 4, 5) ));
    250     }
    251 
    252     for ( i; z(Nx) ) {
    253         assert(( wxyz[[ 2, i, 4, 5 ]] == getMagicNumber(2, i, 4, 5) ));
    254     }
    255 
    256     for ( i; z(Ny) ) {
    257         assert(( wxyz[[ 2, 3, i, 5 ]] == getMagicNumber(2, 3, i, 5) ));
    258     }
    259 
    260     for ( i; z(Nz) ) {
    261         assert(( wxyz[[ 2, 3, 4, i ]] == getMagicNumber(2, 3, 4, i) ));
    262     }
    263 
    264     for ( i; z(Nw) ) {
    265         assert(( wxyz[[ i, all, 4, 5 ]][3] == getMagicNumber(i, 3, 4, 5) ));
    266     }
    267 
    268     for ( i; z(Nw) ) {
    269         assert(( wxyz[[ all, 3, 4, 5 ]][i] == getMagicNumber(i, 3, 4, 5) ));
     241    assert(( wxyz[2,  3][4] [5]  == valExpected ));
     242    assert(( wxyz [2][3,  4][5]  == valExpected ));
     243    assert(( wxyz [2] [3][4,  5] == valExpected ));
     244    assert(( wxyz[2,  3,  4][5]  == valExpected ));
     245    assert(( wxyz [2][3,  4,  5] == valExpected ));
     246    assert(( wxyz[2,  3,  4,  5] == valExpected ));
     247
     248    for ( i; Nw ) {
     249        assert(( wxyz[ i, 3, 4, 5 ] == getMagicNumber(i, 3, 4, 5) ));
     250    }
     251
     252    for ( i; Nx ) {
     253        assert(( wxyz[ 2, i, 4, 5 ] == getMagicNumber(2, i, 4, 5) ));
     254    }
     255
     256    for ( i; Ny ) {
     257        assert(( wxyz[ 2, 3, i, 5 ] == getMagicNumber(2, 3, i, 5) ));
     258    }
     259
     260    for ( i; Nz ) {
     261        assert(( wxyz[ 2, 3, 4, i ] == getMagicNumber(2, 3, 4, i) ));
     262    }
     263
     264    for ( i; Nw ) {
     265        assert(( wxyz[ i, all, 4, 5 ][3] == getMagicNumber(i, 3, 4, 5) ));
     266    }
     267
     268    for ( i; Nw ) {
     269        assert(( wxyz[ all, 3, 4, 5 ][i] == getMagicNumber(i, 3, 4, 5) ));
    270270    }
    271271}

  • tests/concurrent/signal/disjoint.cfa

    r5a46e09 r660665f  
    7777        wait( cond );
    7878        if( d.state != SIGNAL ) {
    79                 sout | "ERROR barging!";
     79                abort | "ERROR barging!";
    8080        }
    8181
    … …  
    113113        bool running = TEST(globals.data.counter < N) && globals.data.counter > 0;
    114114        if( globals.data.state != SIGNAL && running ) {
    115                 sout | "ERROR Eager signal" | globals.data.state;
     115                abort | "ERROR Eager signal" | globals.data.state;
    116116        }
    117117}

  • tests/coroutine/fibonacci.cfa

    r5a46e09 r660665f  
    3131}
    3232
    33 int next( Fibonacci & fib ) with( fib ) {
    34         resume( fib );                                                                          // restart last suspend
    35         return fn;
    36 }
    37 
    3833int main() {
    3934        Fibonacci f1, f2;
    4035        for ( 10 ) {                                                                            // print N Fibonacci values
    41                 sout | next( f1 ) | next( f2 );
     36                sout | resume( f1 ).fn | resume( f2 ).fn;
    4237        } // for
    4338}

  • tests/forall.cfa

    r5a46e09 r660665f  
    199199}
    200200
     201forall( T ) void check_otype() {
     202        T & tr = *0p;
     203        T * tp = 0p;
     204
     205        &tr += 1;
     206        tp += 1;
     207        T & tx = tp[1];
     208
     209        T t;
     210        T t2 = t;
     211}
     212
     213forall( T * ) void check_dstype() {
     214        T & tr = *0p;
     215        T * tp = 0p;
     216
     217        &tr += 1;
     218        tp += 1;
     219        T & tx = tp[1];
     220}
     221
     222forall( T & ) void check_dtype() {
     223        T & tr = *0p;
     224        T * tp = 0p;
     225}
     226
    201227//otype T1 | { void xxx( T1 ); };
    202228

  • tests/generator/fibonacci.cfa

    r5a46e09 r660665f  
    88//
    99// Author           : Thierry Delisle
    10 // Created On       : Mon Mar  1 16:54:23 2020
    11 // Last Modified By :
    12 // Last Modified On :
    13 // Update Count     :
     10// Created On       : Mon Mar 1 16:54:23 2020
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jun 10 21:54:14 2021
     13// Update Count     : 3
    1414//
     15
     16#include <fstream.hfa>
    1517
    1618generator Fib {
    … …  
    1820};
    1921
    20 void main(Fib & b) with (b) {
     22void main(Fib & fib) with (fib) {
    2123        [fn1, fn] = [1, 0];
    2224        for () {
    … …  
    2931        Fib f1, f2;
    3032        for ( 10 ) {
    31                 resume( f1 );
    32                 resume( f2 );
    33                 printf("%d %d\n", f1.fn, f2.fn);
     33                resume( f1 ); resume( f2 );
     34                sout | f1.fn | f2.fn;
     35                // sout | resume( f1 ).fn | resume( f2 ).fn; // compiler bug
    3436        }
    35 
    3637}
    3738

  • tests/generator/fmtLines.cfa

    r5a46e09 r660665f  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu Mar  5 16:09:08 2020
    11 // Last Modified By :
    12 // Last Modified On :
    13 // Update Count     :
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jun 10 21:56:22 2021
     13// Update Count     : 2
    1414//
    1515

  • tests/generator/suspend_then.cfa

    r5a46e09 r660665f  
    99// Author           : Peter A. Buhr
    1010// Created On       : Mon Apr 29 12:01:35 2019
    11 // Last Modified By :
    12 // Last Modified On :
    13 // Update Count     :
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jun 10 21:55:51 2021
     13// Update Count     : 1
    1414//
    1515

  • tests/literals.cfa

    r5a46e09 r660665f  
    1010// Created On       : Sat Sep  9 16:34:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 29 10:57:56 2020
    13 // Update Count     : 226
     12// Last Modified On : Sat Jun 19 15:47:49 2021
     13// Update Count     : 237
    1414//
    1515
    … …  
    6363        -0X0123456789ABCDEF;  -0X0123456789ABCDEFu;  -0X0123456789ABCDEFl;  -0X0123456789ABCDEFll;  -0X0123456789ABCDEFul;  -0X0123456789ABCDEFlu;  -0X0123456789ABCDEFull;  -0X0123456789ABCDEFllu;
    6464
     65// floating literals
     66
     67         0123456789.;   0123456789.f;   0123456789.d;   0123456789.l;   0123456789.F;   0123456789.D;   0123456789.L;
     68        +0123456789.;  +0123456789.f;  +0123456789.d;  +0123456789.l;  +0123456789.F;  +0123456789.D;  +0123456789.L;
     69        -0123456789.;  -0123456789.f;  -0123456789.d;  -0123456789.l;  -0123456789.F;  -0123456789.D;  -0123456789.L;
     70
     71         0123456789.e09;   0123456789.e09f;   0123456789.e09d;   0123456789.e09l;   0123456789.e09F;   0123456789.e09D;   0123456789.e09L;
     72        +0123456789.e09;  +0123456789.e09f;  +0123456789.e09d;  +0123456789.e09l;  +0123456789.e09F;  +0123456789.e09D;  +0123456789.e09L;
     73        -0123456789.e09;  -0123456789.e09f;  -0123456789.e09d;  -0123456789.e09l;  -0123456789.e09F;  -0123456789.e09D;  -0123456789.e09L;
     74                                                             
     75         0123456789.e+09;   0123456789.e+09f;   0123456789.e+09d;   0123456789.e+09l;   0123456789.e+09F;   0123456789.e+09D;   0123456789.e+09L;
     76        +0123456789.e+09;  +0123456789.e+09f;  +0123456789.e+09d;  +0123456789.e+09l;  +0123456789.e+09F;  +0123456789.e+09D;  +0123456789.e+09L;
     77        -0123456789.e+09;  -0123456789.e+09f;  -0123456789.e+09d;  -0123456789.e+09l;  -0123456789.e+09F;  -0123456789.e+09D;  -0123456789.e+09L;
     78                                                             
     79         0123456789.e-09;   0123456789.e-09f;   0123456789.e-09d;   0123456789.e-09l;   0123456789.e-09F;   0123456789.e-09D;   0123456789.e-09L;
     80        +0123456789.e-09;  +0123456789.e-09f;  +0123456789.e-09d;  +0123456789.e-09l;  +0123456789.e-09F;  +0123456789.e-09D;  +0123456789.e-09L;
     81        -0123456789.e-09;  -0123456789.e-09f;  -0123456789.e-09d;  -0123456789.e-09l;  -0123456789.e-09F;  -0123456789.e-09D;  -0123456789.e-09L;
     82
     83         .0123456789;   .0123456789f;   .0123456789d;   .0123456789l;   .0123456789F;   .0123456789D;   .0123456789L;
     84        +.0123456789;  +.0123456789f;  +.0123456789d;  +.0123456789l;  +.0123456789F;  +.0123456789D;  +.0123456789L;
     85        -.0123456789;  -.0123456789f;  -.0123456789d;  -.0123456789l;  -.0123456789F;  -.0123456789D;  -.0123456789L;
     86
     87         .0123456789e09;   .0123456789e09f;   .0123456789e09d;   .0123456789e09l;   .0123456789e09F;   .0123456789e09D;   .0123456789e09L;
     88        +.0123456789e09;  +.0123456789e09f;  +.0123456789e09d;  +.0123456789e09l;  +.0123456789e09F;  +.0123456789e09D;  +.0123456789e09L;
     89        -.0123456789e09;  -.0123456789e09f;  -.0123456789e09d;  -.0123456789e09l;  -.0123456789e09F;  -.0123456789e09D;  -.0123456789e09L;
     90                                                             
     91         .0123456789E+09;   .0123456789E+09f;   .0123456789E+09d;   .0123456789E+09l;   .0123456789E+09F;   .0123456789E+09D;   .0123456789E+09L;
     92        +.0123456789E+09;  +.0123456789E+09f;  +.0123456789E+09d;  +.0123456789E+09l;  +.0123456789E+09F;  +.0123456789E+09D;  +.0123456789E+09L;
     93        -.0123456789E+09;  -.0123456789E+09f;  -.0123456789E+09d;  -.0123456789E+09l;  -.0123456789E+09F;  -.0123456789E+09D;  -.0123456789E+09L;
     94                                                             
     95         .0123456789E-09;   .0123456789E-09f;   .0123456789E-09d;   .0123456789E-09l;   .0123456789E-09F;   .0123456789E-09D;   .0123456789E-09L;
     96        -.0123456789E-09;  -.0123456789E-09f;  -.0123456789E-09d;  -.0123456789E-09l;  -.0123456789E-09F;  -.0123456789E-09D;  -.0123456789E-09L;
     97        -.0123456789E-09;  -.0123456789E-09f;  -.0123456789E-09d;  -.0123456789E-09l;  -.0123456789E-09F;  -.0123456789E-09D;  -.0123456789E-09L;
     98
     99         0123456789.0123456789;   0123456789.0123456789f;   0123456789.0123456789d;   0123456789.0123456789l;   0123456789.0123456789F;   0123456789.0123456789D;   0123456789.0123456789L;
     100        +0123456789.0123456789;  +0123456789.0123456789f;  +0123456789.0123456789d;  +0123456789.0123456789l;  +0123456789.0123456789F;  +0123456789.0123456789D;  +0123456789.0123456789L;
     101        -0123456789.0123456789;  -0123456789.0123456789f;  -0123456789.0123456789d;  -0123456789.0123456789l;  -0123456789.0123456789F;  -0123456789.0123456789D;  -0123456789.0123456789L;
     102
     103         0123456789.0123456789E09;   0123456789.0123456789E09f;   0123456789.0123456789E09d;   0123456789.0123456789E09l;   0123456789.0123456789E09F;   0123456789.0123456789E09D;   0123456789.0123456789E09L;
     104        +0123456789.0123456789E09;  +0123456789.0123456789E09f;  +0123456789.0123456789E09d;  +0123456789.0123456789E09l;  +0123456789.0123456789E09F;  +0123456789.0123456789E09D;  +0123456789.0123456789E09L;
     105        -0123456789.0123456789E09;  -0123456789.0123456789E09f;  -0123456789.0123456789E09d;  -0123456789.0123456789E09l;  -0123456789.0123456789E09F;  -0123456789.0123456789E09D;  -0123456789.0123456789E09L;
     106                                                                                         
     107         0123456789.0123456789E+09;   0123456789.0123456789E+09f;   0123456789.0123456789E+09d;   0123456789.0123456789E+09l;   0123456789.0123456789E+09F;   0123456789.0123456789E+09D;   0123456789.0123456789E+09L;
     108        +0123456789.0123456789E+09;  +0123456789.0123456789E+09f;  +0123456789.0123456789E+09d;  +0123456789.0123456789E+09l;  +0123456789.0123456789E+09F;  +0123456789.0123456789E+09D;  +0123456789.0123456789E+09L;
     109        -0123456789.0123456789E+09;  -0123456789.0123456789E+09f;  -0123456789.0123456789E+09d;  -0123456789.0123456789E+09l;  -0123456789.0123456789E+09F;  -0123456789.0123456789E+09D;  -0123456789.0123456789E+09L;
     110                                                                                         
     111         0123456789.0123456789E-09;   0123456789.0123456789E-09f;   0123456789.0123456789E-09d;   0123456789.0123456789E-09l;   0123456789.0123456789E-09F;   0123456789.0123456789E-09D;   0123456789.0123456789E-09L;
     112        +0123456789.0123456789E-09;  +0123456789.0123456789E-09f;  +0123456789.0123456789E-09d;  +0123456789.0123456789E-09l;  +0123456789.0123456789E-09F;  +0123456789.0123456789E-09D;  +0123456789.0123456789E-09L;
     113        -0123456789.0123456789E-09;  -0123456789.0123456789E-09f;  -0123456789.0123456789E-09d;  -0123456789.0123456789E-09l;  -0123456789.0123456789E-09F;  -0123456789.0123456789E-09D;  -0123456789.0123456789E-09L;
     114
    65115// decimal floating literals
    66116
    67          0123456789.;   0123456789.f;   0123456789.l;   0123456789.F;   0123456789.L;   0123456789.DL;
    68         +0123456789.;  +0123456789.f;  +0123456789.l;  +0123456789.F;  +0123456789.L;  +0123456789.DL;
    69         -0123456789.;  -0123456789.f;  -0123456789.l;  -0123456789.F;  -0123456789.L;  -0123456789.DL;
    70 
    71          0123456789.e09;   0123456789.e09f;   0123456789.e09l;   0123456789.e09F;   0123456789.e09L;   0123456789.e09DL;
    72         +0123456789.e09;  +0123456789.e09f;  +0123456789.e09l;  +0123456789.e09F;  +0123456789.e09L;  +0123456789.e09DL;
    73         -0123456789.e09;  -0123456789.e09f;  -0123456789.e09l;  -0123456789.e09F;  -0123456789.e09L;  -0123456789.e09DL;
    74 
    75          0123456789.e+09;   0123456789.e+09f;   0123456789.e+09l;   0123456789.e+09F;   0123456789.e+09L;   0123456789.e+09DL;
    76         +0123456789.e+09;  +0123456789.e+09f;  +0123456789.e+09l;  +0123456789.e+09F;  +0123456789.e+09L;  +0123456789.e+09DL;
    77         -0123456789.e+09;  -0123456789.e+09f;  -0123456789.e+09l;  -0123456789.e+09F;  -0123456789.e+09L;  -0123456789.e+09DL;
    78 
    79          0123456789.e-09;   0123456789.e-09f;   0123456789.e-09l;   0123456789.e-09F;   0123456789.e-09L;   0123456789.e-09DL;
    80         +0123456789.e-09;  +0123456789.e-09f;  +0123456789.e-09l;  +0123456789.e-09F;  +0123456789.e-09L;  +0123456789.e-09DL;
    81         -0123456789.e-09;  -0123456789.e-09f;  -0123456789.e-09l;  -0123456789.e-09F;  -0123456789.e-09L;  -0123456789.e-09DL;
    82 
    83          .0123456789;   .0123456789f;   .0123456789l;   .0123456789F;   .0123456789L;   .0123456789DL;
    84         +.0123456789;  +.0123456789f;  +.0123456789l;  +.0123456789F;  +.0123456789L;  +.0123456789DL;
    85         -.0123456789;  -.0123456789f;  -.0123456789l;  -.0123456789F;  -.0123456789L;  -.0123456789DL;
    86 
    87          .0123456789e09;   .0123456789e09f;   .0123456789e09l;   .0123456789e09F;   .0123456789e09L;   .0123456789e09DL;
    88         +.0123456789e09;  +.0123456789e09f;  +.0123456789e09l;  +.0123456789e09F;  +.0123456789e09L;  +.0123456789e09DL;
    89         -.0123456789e09;  -.0123456789e09f;  -.0123456789e09l;  -.0123456789e09F;  -.0123456789e09L;  -.0123456789e09DL;
    90 
    91          .0123456789E+09;   .0123456789E+09f;   .0123456789E+09l;   .0123456789E+09F;   .0123456789E+09L;   .0123456789E+09DL;
    92         +.0123456789E+09;  +.0123456789E+09f;  +.0123456789E+09l;  +.0123456789E+09F;  +.0123456789E+09L;  +.0123456789E+09DL;
    93         -.0123456789E+09;  -.0123456789E+09f;  -.0123456789E+09l;  -.0123456789E+09F;  -.0123456789E+09L;  -.0123456789E+09DL;
    94 
    95          .0123456789E-09;   .0123456789E-09f;   .0123456789E-09l;   .0123456789E-09F;   .0123456789E-09L;   .0123456789E-09DL;
    96         -.0123456789E-09;  -.0123456789E-09f;  -.0123456789E-09l;  -.0123456789E-09F;  -.0123456789E-09L;  -.0123456789E-09DL;
    97         -.0123456789E-09;  -.0123456789E-09f;  -.0123456789E-09l;  -.0123456789E-09F;  -.0123456789E-09L;  -.0123456789E-09DL;
    98 
    99          0123456789.0123456789;   0123456789.0123456789f;   0123456789.0123456789l;   0123456789.0123456789F;   0123456789.0123456789L;   0123456789.0123456789DL;
    100         +0123456789.0123456789;  +0123456789.0123456789f;  +0123456789.0123456789l;  +0123456789.0123456789F;  +0123456789.0123456789L;  +0123456789.0123456789DL;
    101         -0123456789.0123456789;  -0123456789.0123456789f;  -0123456789.0123456789l;  -0123456789.0123456789F;  -0123456789.0123456789L;  -0123456789.0123456789DL;
    102 
    103          0123456789.0123456789E09;   0123456789.0123456789E09f;   0123456789.0123456789E09l;   0123456789.0123456789E09F;   0123456789.0123456789E09L;   0123456789.0123456789E09DL;
    104         +0123456789.0123456789E09;  +0123456789.0123456789E09f;  +0123456789.0123456789E09l;  +0123456789.0123456789E09F;  +0123456789.0123456789E09L;  +0123456789.0123456789E09DL;
    105         -0123456789.0123456789E09;  -0123456789.0123456789E09f;  -0123456789.0123456789E09l;  -0123456789.0123456789E09F;  -0123456789.0123456789E09L;  -0123456789.0123456789E09DL;
    106 
    107          0123456789.0123456789E+09;   0123456789.0123456789E+09f;   0123456789.0123456789E+09l;   0123456789.0123456789E+09F;   0123456789.0123456789E+09L;   0123456789.0123456789E+09DL;
    108         +0123456789.0123456789E+09;  +0123456789.0123456789E+09f;  +0123456789.0123456789E+09l;  +0123456789.0123456789E+09F;  +0123456789.0123456789E+09L;  +0123456789.0123456789E+09DL;
    109         -0123456789.0123456789E+09;  -0123456789.0123456789E+09f;  -0123456789.0123456789E+09l;  -0123456789.0123456789E+09F;  -0123456789.0123456789E+09L;  -0123456789.0123456789E+09DL;
    110 
    111          0123456789.0123456789E-09;   0123456789.0123456789E-09f;   0123456789.0123456789E-09l;   0123456789.0123456789E-09F;   0123456789.0123456789E-09L;   0123456789.0123456789E-09DL;
    112         +0123456789.0123456789E-09;  +0123456789.0123456789E-09f;  +0123456789.0123456789E-09l;  +0123456789.0123456789E-09F;  +0123456789.0123456789E-09L;  +0123456789.0123456789E-09DL;
    113         -0123456789.0123456789E-09;  -0123456789.0123456789E-09f;  -0123456789.0123456789E-09l;  -0123456789.0123456789E-09F;  -0123456789.0123456789E-09L;  -0123456789.0123456789E-09DL;
     117#if ! defined( __aarch64__ )                                                    // unsupported on ARM after gcc-9
     118         0123456789.df;   0123456789.dd;   0123456789.dl;   0123456789.DF;   0123456789.DD;   0123456789.DL;
     119        +0123456789.df;  +0123456789.dd;  +0123456789.dl;  +0123456789.DF;  +0123456789.DD;  +0123456789.DL;
     120        -0123456789.df;  -0123456789.dd;  -0123456789.dl;  -0123456789.DF;  -0123456789.DD;  -0123456789.DL;
     121
     122         0123456789.e09df;   0123456789.e09dd;   0123456789.e09dl;   0123456789.e09DF;   0123456789.e09DD;   0123456789.e09DL;
     123        +0123456789.e09df;  +0123456789.e09dd;  +0123456789.e09dl;  +0123456789.e09DF;  +0123456789.e09DD;  +0123456789.e09DL;
     124        -0123456789.e09df;  -0123456789.e09dd;  -0123456789.e09dl;  -0123456789.e09DF;  -0123456789.e09DD;  -0123456789.e09DL;
     125                                                                     
     126         0123456789.e+09df;   0123456789.e+09dd;  0123456789.e+09dl;   0123456789.e+09DF;   0123456789.e+09DD;   0123456789.e+09DL;
     127        +0123456789.e+09df;  +0123456789.e+09dd; +0123456789.e+09dl;  +0123456789.e+09DF;  +0123456789.e+09DD;  +0123456789.e+09DL;
     128        -0123456789.e+09df;  -0123456789.e+09dd; -0123456789.e+09dl;  -0123456789.e+09DF;  -0123456789.e+09DD;  -0123456789.e+09DL;
     129                                                                     
     130         0123456789.e-09df;   0123456789.e-09dd;  0123456789.e-09dl;   0123456789.e-09DF;   0123456789.e-09DD;   0123456789.e-09DL;
     131        +0123456789.e-09df;  +0123456789.e-09dd; +0123456789.e-09dl;  +0123456789.e-09DF;  +0123456789.e-09DD;  +0123456789.e-09DL;
     132        -0123456789.e-09df;  -0123456789.e-09dd; -0123456789.e-09dl;  -0123456789.e-09DF;  -0123456789.e-09DD;  -0123456789.e-09DL;
     133
     134         .0123456789df;   .0123456789dd;   .0123456789dl;   .0123456789DF;   .0123456789DD;   .0123456789DL;
     135        +.0123456789df;  +.0123456789dd;  +.0123456789dl;  +.0123456789DF;  +.0123456789DD;  +.0123456789DL;
     136        -.0123456789df;  -.0123456789dd;  -.0123456789dl;  -.0123456789DF;  -.0123456789DD;  -.0123456789DL;
     137
     138         .0123456789e09df;   .0123456789e09dd;   .0123456789e09dl;   .0123456789e09DF;   .0123456789e09DD;   .0123456789e09DL;
     139        +.0123456789e09df;  +.0123456789e09dd;  +.0123456789e09dl;  +.0123456789e09DF;  +.0123456789e09DD;  +.0123456789e09DL;
     140        -.0123456789e09df;  -.0123456789e09dd;  -.0123456789e09dl;  -.0123456789e09DF;  -.0123456789e09DD;  -.0123456789e09DL;
     141                                                               
     142         .0123456789E+09df;   .0123456789E+09dd;   .0123456789E+09dl;   .0123456789E+09DF;   .0123456789E+09DD;   .0123456789E+09DL;
     143        +.0123456789E+09df;  +.0123456789E+09dd;  +.0123456789E+09dl;  +.0123456789E+09DF;  +.0123456789E+09DD;  +.0123456789E+09DL;
     144        -.0123456789E+09df;  -.0123456789E+09dd;  -.0123456789E+09dl;  -.0123456789E+09DF;  -.0123456789E+09DD;  -.0123456789E+09DL;
     145                                                               
     146         .0123456789E-09df;   .0123456789E-09dd;   .0123456789E-09dl;   .0123456789E-09DF;   .0123456789E-09DD;   .0123456789E-09DL;
     147        -.0123456789E-09df;  -.0123456789E-09dd;  -.0123456789E-09dl;  -.0123456789E-09DF;  -.0123456789E-09DD;  -.0123456789E-09DL;
     148        -.0123456789E-09df;  -.0123456789E-09dd;  -.0123456789E-09dl;  -.0123456789E-09DF;  -.0123456789E-09DD;  -.0123456789E-09DL;
     149
     150         0123456789.0123456789df;   0123456789.0123456789dd;   0123456789.0123456789dl;   0123456789.0123456789DF;   0123456789.0123456789DD;   0123456789.0123456789DL;
     151        +0123456789.0123456789df;  +0123456789.0123456789dd;  +0123456789.0123456789dl;  +0123456789.0123456789DF;  +0123456789.0123456789DD;  +0123456789.0123456789DL;
     152        -0123456789.0123456789df;  -0123456789.0123456789dd;  -0123456789.0123456789dl;  -0123456789.0123456789DF;  -0123456789.0123456789DD;  -0123456789.0123456789DL;
     153
     154         0123456789.0123456789E09df;   0123456789.0123456789E09dd;   0123456789.0123456789E09dl;   0123456789.0123456789E09DF;   0123456789.0123456789E09DD;   0123456789.0123456789E09DL;
     155        +0123456789.0123456789E09df;  +0123456789.0123456789E09dd;  +0123456789.0123456789E09dl;  +0123456789.0123456789E09DF;  +0123456789.0123456789E09DD;  +0123456789.0123456789E09DL;
     156        -0123456789.0123456789E09df;  -0123456789.0123456789E09dd;  -0123456789.0123456789E09dl;  -0123456789.0123456789E09DF;  -0123456789.0123456789E09DD;  -0123456789.0123456789E09DL;
     157                                                                                               
     158         0123456789.0123456789E+09df;   0123456789.0123456789E+09dd;   0123456789.0123456789E+09dl;   0123456789.0123456789E+09DF;   0123456789.0123456789E+09DD;   0123456789.0123456789E+09DL;
     159        +0123456789.0123456789E+09df;  +0123456789.0123456789E+09dd;  +0123456789.0123456789E+09dl;  +0123456789.0123456789E+09DF;  +0123456789.0123456789E+09DD;  +0123456789.0123456789E+09DL;
     160        -0123456789.0123456789E+09df;  -0123456789.0123456789E+09dd;  -0123456789.0123456789E+09dl;  -0123456789.0123456789E+09DF;  -0123456789.0123456789E+09DD;  -0123456789.0123456789E+09DL;
     161                                                                                               
     162         0123456789.0123456789E-09df;   0123456789.0123456789E-09dd;   0123456789.0123456789E-09dl;   0123456789.0123456789E-09DF;   0123456789.0123456789E-09DD;   0123456789.0123456789E-09DL;
     163        +0123456789.0123456789E-09df;  +0123456789.0123456789E-09dd;  +0123456789.0123456789E-09dl;  +0123456789.0123456789E-09DF;  +0123456789.0123456789E-09DD;  +0123456789.0123456789E-09DL;
     164        -0123456789.0123456789E-09df;  -0123456789.0123456789E-09dd;  -0123456789.0123456789E-09dl;  -0123456789.0123456789E-09DF;  -0123456789.0123456789E-09DD;  -0123456789.0123456789E-09DL;
     165#endif // ! __aarch64__
    114166
    115167// hexadecimal floating literals, must have exponent

  • tests/math.cfa

    r5a46e09 r660665f  
    1010// Created On       : Fri Apr 22 14:59:21 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 13 21:04:48 2021
    13 // Update Count     : 123
     12// Last Modified On : Fri Jun 18 17:02:44 2021
     13// Update Count     : 124
    1414//
    1515
    … …  
    4040
    4141        sout | "exp:" | exp( 1.0F ) | exp( 1.0D ) | exp( 1.0L ) | nonl;
    42         sout | exp( 1.0F+1.0FI ) | exp( 1.0D+1.0DI ) | exp( 1.0DL+1.0LI );
     42        sout | exp( 1.0F+1.0FI ) | exp( 1.0D+1.0DI ) | exp( 1.0L+1.0LI );
    4343        sout | "exp2:" | exp2( 1.0F ) | exp2( 1.0D ) | exp2( 1.0L );
    4444        sout | "expm1:" | expm1( 1.0F ) | expm1( 1.0D ) | expm1( 1.0L );
    4545        sout | "pow:" | pow( 1.0F, 1.0F ) | pow( 1.0D, 1.0D ) | pow( 1.0L, 1.0L ) | nonl;
    46         sout | pow( 1.0F+1.0FI, 1.0F+1.0FI ) | pow( 1.0D+1.0DI, 1.0D+1.0DI ) | pow( 1.5DL+1.5LI, 1.5DL+1.5LI );
     46        sout | pow( 1.0F+1.0FI, 1.0F+1.0FI ) | pow( 1.0D+1.0DI, 1.0D+1.0DI ) | pow( 1.5L+1.5LI, 1.5L+1.5LI );
    4747
    4848        int b = 4;
    … …  
    6868
    6969        sout | "log:" | log( 1.0F ) | log( 1.0D ) | log( 1.0L ) | nonl;
    70         sout | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0DL+1.0LI );
     70        sout | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0L+1.0LI );
    7171        sout | "log2:" | log2( 1024 ) | log2( 2 \ 17u ) | log2( 2 \ 23u );
    7272        sout | "log2:" | log2( 1024l ) | log2( 2l \ 17u ) | log2( 2l \ 23u );
    … …  
    8282
    8383        sout | "sqrt:" | sqrt( 1.0F ) | sqrt( 1.0D ) | sqrt( 1.0L ) | nonl;
    84         sout | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0DL+1.0LI );
     84        sout | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0L+1.0LI );
    8585        sout | "cbrt:" | cbrt( 27.0F ) | cbrt( 27.0D ) | cbrt( 27.0L );
    8686        sout | "hypot:" | hypot( 1.0F, -1.0F ) | hypot( 1.0D, -1.0D ) | hypot( 1.0L, -1.0L );
    … …  
    8989
    9090        sout | "sin:" | sin( 1.0F ) | sin( 1.0D ) | sin( 1.0L ) | nonl;
    91         sout | sin( 1.0F+1.0FI ) | sin( 1.0D+1.0DI ) | sin( 1.0DL+1.0LI );
     91        sout | sin( 1.0F+1.0FI ) | sin( 1.0D+1.0DI ) | sin( 1.0L+1.0LI );
    9292        sout | "cos:" | cos( 1.0F ) | cos( 1.0D ) | cos( 1.0L ) | nonl;
    93         sout | cos( 1.0F+1.0FI ) | cos( 1.0D+1.0DI ) | cos( 1.0DL+1.0LI );
     93        sout | cos( 1.0F+1.0FI ) | cos( 1.0D+1.0DI ) | cos( 1.0L+1.0LI );
    9494        sout | "tan:" | tan( 1.0F ) | tan( 1.0D ) | tan( 1.0L ) | nonl;
    95         sout | tan( 1.0F+1.0FI ) | tan( 1.0D+1.0DI ) | tan( 1.0DL+1.0LI );
     95        sout | tan( 1.0F+1.0FI ) | tan( 1.0D+1.0DI ) | tan( 1.0L+1.0LI );
    9696        sout | "asin:" | asin( 1.0F ) | asin( 1.0D ) | asin( 1.0L ) | nonl;
    97         sout | asin( 1.0F+1.0FI ) | asin( 1.0D+1.0DI ) | asin( 1.0DL+1.0LI );
     97        sout | asin( 1.0F+1.0FI ) | asin( 1.0D+1.0DI ) | asin( 1.0L+1.0LI );
    9898        sout | "acos:" | acos( 1.0F ) | acos( 1.0D ) | acos( 1.0L ) | nonl;
    99         sout | acos( 1.0F+1.0FI ) | acos( 1.0D+1.0DI ) | acos( 1.0DL+1.0LI );
     99        sout | acos( 1.0F+1.0FI ) | acos( 1.0D+1.0DI ) | acos( 1.0L+1.0LI );
    100100        sout | "atan:" | atan( 1.0F ) | atan( 1.0D ) | atan( 1.0L ) | nonl;
    101         sout | atan( 1.0F+1.0FI ) | atan( 1.0D+1.0DI ) | atan( 1.0DL+1.0LI );
     101        sout | atan( 1.0F+1.0FI ) | atan( 1.0D+1.0DI ) | atan( 1.0L+1.0LI );
    102102        sout | "atan2:" | atan2( 1.0F, 1.0F ) | atan2( 1.0D, 1.0D ) | atan2( 1.0L, 1.0L ) | nonl;
    103103        sout | "atan:" | atan( 1.0F, 1.0F ) | atan( 1.0D, 1.0D ) | atan( 1.0L, 1.0L );
    … …  
    106106
    107107        sout | "sinh:" | sinh( 1.0F ) | sinh( 1.0D ) | sinh( 1.0L ) | nonl;
    108         sout | sinh( 1.0F+1.0FI ) | sinh( 1.0D+1.0DI ) | sinh( 1.0DL+1.0LI );
     108        sout | sinh( 1.0F+1.0FI ) | sinh( 1.0D+1.0DI ) | sinh( 1.0L+1.0LI );
    109109        sout | "cosh:" | cosh( 1.0F ) | cosh( 1.0D ) | cosh( 1.0L ) | nonl;
    110         sout | cosh( 1.0F+1.0FI ) | cosh( 1.0D+1.0DI ) | cosh( 1.0DL+1.0LI );
     110        sout | cosh( 1.0F+1.0FI ) | cosh( 1.0D+1.0DI ) | cosh( 1.0L+1.0LI );
    111111        sout | "tanh:" | tanh( 1.0F ) | tanh( 1.0D ) | tanh( 1.0L ) | nonl;
    112         sout | tanh( 1.0F+1.0FI ) | tanh( 1.0D+1.0DI ) | tanh( 1.0DL+1.0LI );
     112        sout | tanh( 1.0F+1.0FI ) | tanh( 1.0D+1.0DI ) | tanh( 1.0L+1.0LI );
    113113        sout | "acosh:" | acosh( 1.0F ) | acosh( 1.0D ) | acosh( 1.0L ) | nonl;
    114         sout | acosh( 1.0F+1.0FI ) | acosh( 1.0D+1.0DI ) | acosh( 1.0DL+1.0LI );
     114        sout | acosh( 1.0F+1.0FI ) | acosh( 1.0D+1.0DI ) | acosh( 1.0L+1.0LI );
    115115        sout | "asinh:" | asinh( 1.0F ) | asinh( 1.0D ) | asinh( 1.0L ) | nonl;
    116         sout | asinh( 1.0F+1.0FI ) | asinh( 1.0D+1.0DI ) | asinh( 1.0DL+1.0LI );
     116        sout | asinh( 1.0F+1.0FI ) | asinh( 1.0D+1.0DI ) | asinh( 1.0L+1.0LI );
    117117        sout | "atanh:" | atanh( 1.0F ) | atanh( 1.0D ) | atanh( 1.0L ) | nonl;
    118         sout | atanh( 1.0F+1.0FI ) | atanh( 1.0D+1.0DI ) | atanh( 1.0DL+1.0LI );
     118        sout | atanh( 1.0F+1.0FI ) | atanh( 1.0D+1.0DI ) | atanh( 1.0L+1.0LI );
    119119
    120120        //---------------------- Error / Gamma ----------------------

  • tests/pybin/tools.py

    r5a46e09 r660665f  
    376376                return 1, "ERR No core dump"
    377377
    378         return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output_file=subprocess.PIPE)
     378        try:
     379                return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output_file=subprocess.PIPE)
     380        except:
     381                return 1, "ERR Could not read core with gdb"
    379382
    380383def core_archive(dst, name, exe):

  • tests/test.py

    r5a46e09 r660665f  
    1313
    1414import os
    15 import psutil
    1615import signal
    1716

  • tests/typedefRedef.cfa

    r5a46e09 r660665f  
    4545typedef int X2;
    4646
     47X2 value  __attribute__((aligned(4 * sizeof(X2))));
     48
     49__attribute__((aligned(4 * sizeof(X2)))) struct rseq_cs {
     50        int foo;
     51};
     52
    4753// xxx - this doesn't work yet due to parsing problems with generic types
    4854// #ifdef __CFA__

  • tests/unified_locking/fast.cfa

    r5a46e09 r660665f  
    2222uint32_t cs() {
    2323        $thread * me = active_thread();
    24         uint32_t value = (uint32_t)me;
     24        uint32_t value;
    2525        lock(mo.l);
    2626        {
    … …  
    2828                mo.id = me;
    2929                yield(random(5));
     30                value = ((uint32_t)random()) ^ ((uint32_t)me);
    3031                if(mo.id != me) sout | "Intruder!";
    3132                mo.sum = tsum + value;
Note: See TracChangeset for help on using the changeset viewer.