Index: libcfa/src/exception.c =================================================================== --- libcfa/src/exception.c (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ libcfa/src/exception.c (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -85,14 +85,16 @@ __cfadbg_print_safe(exception, "Throwing resumption exception\n"); - __attribute__((cleanup(reset_top_resume))) - struct __cfaehm_try_resume_node * original_head = context->top_resume; - struct __cfaehm_try_resume_node * current = context->top_resume; - - for ( ; current ; current = current->next) { - context->top_resume = current->next; - if (current->handler(except)) { - return; + { + __attribute__((cleanup(reset_top_resume))) + struct __cfaehm_try_resume_node * original_head = context->top_resume; + struct __cfaehm_try_resume_node * current = context->top_resume; + + for ( ; current ; current = current->next) { + context->top_resume = current->next; + if (current->handler(except)) { + return; + } } - } + } // End the search and return to the top of the stack. // No handler found, fall back to the default operation. Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ libcfa/src/iostream.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jun 19 16:15:34 2020 -// Update Count : 1019 +// Last Modified On : Mon Jul 6 08:49:48 2020 +// Update Count : 1064 // @@ -30,5 +30,5 @@ } // extern "C" -#include // fms +#include // high1 @@ -168,5 +168,5 @@ static void base10_128( ostype & os, unsigned int128 val ) { - if ( val > UINT64_MAX ) { + if ( val > P10_UINT64 ) { base10_128( os, val / P10_UINT64 ); // recursive fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) ); @@ -455,5 +455,5 @@ // Default prefix for non-decimal prints is 0b, 0, 0x. -#define IntegralFMTImpl( T, CODE, IFMTNP, IFMTP ) \ +#define IntegralFMTImpl( T, IFMTNP, IFMTP ) \ forall( dtype ostype | ostream( ostype ) ) { \ ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ @@ -506,5 +506,5 @@ if ( f.flags.left && spaces > 0 ) fmt( os, "%*s", spaces, " " ); \ return os; \ - } /* if */ \ + } /* if */ \ \ char fmtstr[sizeof(IFMTP)]; /* sizeof includes '\0' */ \ @@ -516,5 +516,5 @@ if ( ! f.flags.nobsdp ) { fmtstr[star] = '#'; star -= 1; } \ if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; } \ - if ( f.flags.sign && f.base == CODE ) { fmtstr[star] = '+'; star -= 1; } \ + if ( f.flags.sign ) { fmtstr[star] = '+'; star -= 1; } \ if ( f.flags.pad0 && ! f.flags.pc ) { fmtstr[star] = '0'; star -= 1; } \ fmtstr[star] = '%'; \ @@ -522,9 +522,9 @@ if ( ! f.flags.pc ) { /* no precision */ \ fmtstr[sizeof(IFMTNP)-2] = f.base; /* sizeof includes '\0' */ \ - /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \ + /* printf( "%s %c\n", &fmtstr[star], f.base ); */ \ fmt( os, &fmtstr[star], f.wd, f.val ); \ } else { /* precision */ \ fmtstr[sizeof(IFMTP)-2] = f.base; /* sizeof includes '\0' */ \ - /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \ + /* printf( "%s %c\n", &fmtstr[star], f.base ); */ \ fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \ } /* if */ \ @@ -534,16 +534,16 @@ } // distribution -IntegralFMTImpl( signed char, 'd', "% *hh ", "% *.*hh " ) -IntegralFMTImpl( unsigned char, 'u', "% *hh ", "% *.*hh " ) -IntegralFMTImpl( signed short int, 'd', "% *h ", "% *.*h " ) -IntegralFMTImpl( unsigned short int, 'u', "% *h ", "% *.*h " ) -IntegralFMTImpl( signed int, 'd', "% * ", "% *.* " ) -IntegralFMTImpl( unsigned int, 'u', "% * ", "% *.* " ) -IntegralFMTImpl( signed long int, 'd', "% *l ", "% *.*l " ) -IntegralFMTImpl( unsigned long int, 'u', "% *l ", "% *.*l " ) -IntegralFMTImpl( signed long long int, 'd', "% *ll ", "% *.*ll " ) -IntegralFMTImpl( unsigned long long int, 'u', "% *ll ", "% *.*ll " ) - - +IntegralFMTImpl( signed char, "% *hh ", "% *.*hh " ) +IntegralFMTImpl( unsigned char, "% *hh ", "% *.*hh " ) +IntegralFMTImpl( signed short int, "% *h ", "% *.*h " ) +IntegralFMTImpl( unsigned short int, "% *h ", "% *.*h " ) +IntegralFMTImpl( signed int, "% * ", "% *.* " ) +IntegralFMTImpl( unsigned int, "% * ", "% *.* " ) +IntegralFMTImpl( signed long int, "% *l ", "% *.*l " ) +IntegralFMTImpl( unsigned long int, "% *l ", "% *.*l " ) +IntegralFMTImpl( signed long long int, "% *ll ", "% *.*ll " ) +IntegralFMTImpl( unsigned long long int, "% *ll ", "% *.*ll " ) + +#if 0 #if defined( __SIZEOF_INT128__ ) // Default prefix for non-decimal prints is 0b, 0, 0x. @@ -663,4 +663,93 @@ IntegralFMTImpl128( unsigned int128, unsigned, 'u', "% *ll ", "% *.*ll " ) #endif // __SIZEOF_INT128__ +#endif // 0 + +#if 1 +#if defined( __SIZEOF_INT128__ ) +// Default prefix for non-decimal prints is 0b, 0, 0x. +forall( dtype ostype | ostream( ostype ) ) +static inline void base_128( ostype & os, unsigned int128 val, unsigned int128 power, _Ostream_Manip(uint64_t) & f, unsigned int maxdig, unsigned int bits, unsigned int cnt = 0 ) { + int wd = 1; // f.wd is never 0 because 0 implies left-pad + if ( val > power ) { // subdivide value into printable 64-bit values + base_128( os, val / power, power, f, maxdig, bits, cnt + 1 ); // recursive + f.val = val % power; + if ( cnt == 1 && f.flags.left ) { wd = f.wd; f.wd = maxdig; } // copy f.wd and reset for printing middle chunk + (ostype &)(os | f); + if ( cnt == 1 ) { + if ( f.flags.left ) { wd -= maxdig; f.wd = wd < 0 ? 1 : wd; } // update and restore f.wd for printing end chunk + sepOff( os ); // no seperator between chunks + } // if + } else { // print start chunk + f.val = val; + // f.pc is unsigned => use wd + if ( f.flags.pc && f.pc > maxdig * cnt ) { wd = f.pc - maxdig * cnt; f.pc = wd < 0 ? 0 : wd; } + else { f.flags.pc = false; f.pc = 0; } + + if ( ! f.flags.left ) { // right justify + wd = f.wd - maxdig * cnt; + f.wd = wd < 0 ? 1 : wd; + wd = maxdig; + } else { // left justify + if ( cnt != 0 ) { // value >= 2^64 ? + unsigned int dig, bs = 0; + // compute size of prefix digits and base + if ( f.base == 'd' || f.base == 'u' ) { // no base prefix + dig = ceil( log10( f.val ) ); // use floating-point + if ( f.base == 'd' && (f.flags.neg || f.flags.sign) ) bs = 1; // sign ? + } else { + dig = ceiling( high1( f.val ), bits ); + if ( ! f.flags.nobsdp ) { // base prefix ? + if ( f.base == 'o' ) { + // 0 prefix for octal is not added for precision with leading zero + if ( f.pc <= dig ) bs = 1; // 1 character prefix + } else bs = 2; // 2 character prefix + } // if + } // if + wd = f.wd - (f.pc > dig ? f.pc : dig) - bs; // precision > leading digits ? + if ( wd < 0 ) wd = 1; + f.wd = 1; + } // if + // all manipulators handled implicitly for value < 2^64 + } // if + // prior checks ensure wd not negative + + if ( f.flags.neg ) f.val = -f.val; + (ostype &)(os | f); + + // remaining middle and end chunks are padded with 0s on the left + if ( ! f.flags.left ) { f.flags.pad0 = true; f.flags.pc = false; } // left pad with 0s + else { f.pc = maxdig; f.flags.pc = true; } // left pad with precision + + if ( cnt != 0 ) sepOff( os ); // no seperator between chunks + f.wd = wd; // reset f.wd for next chunk + f.flags.sign = false; // no leading +/- sign + f.flags.nobsdp = true; // no leading base prefix + } // if +} // base_128 + +#define IntegralFMTImpl128( T ) \ +forall( dtype ostype | ostream( ostype ) ) { \ + ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \ + _Ostream_Manip(uint64_t) fmt; \ + fmt.[wd, pc, base, all] = f.[wd, pc, base, all]; \ + if ( f.base == 'b' | f.base == 'B' ) { \ + base_128( os, f.val, (unsigned int128)1 << 64, fmt, 64, 1 ); \ + } else if ( f.base == 'o' ) { \ + base_128( os, f.val, (unsigned int128)1 << 63, fmt, 21, 3 ); \ + } else if ( f.base == 'd' || f.base == 'u' ) { \ + if ( f.base == 'd' && f.val < 0 ) { f.val = -f.val; fmt.flags.neg = true; } \ + base_128( os, f.val, (unsigned int128)10_000_000_000_000_000_000UL, fmt, 19, 0 ); \ + } else { \ + base_128( os, f.val, (unsigned int128)1 << 64, fmt, 16, 4 ); \ + } /* if */ \ + return os; \ + } /* ?|? */ \ + void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \ +} // distribution + +IntegralFMTImpl128( int128 ) +IntegralFMTImpl128( unsigned int128 ) +#endif // __SIZEOF_INT128__ +#endif // 0 // *********************************** floating point *********************************** Index: libcfa/src/iostream.hfa =================================================================== --- libcfa/src/iostream.hfa (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ libcfa/src/iostream.hfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jun 19 16:15:56 2020 -// Update Count : 338 +// Last Modified On : Sat Jul 4 18:31:48 2020 +// Update Count : 343 // @@ -166,4 +166,5 @@ unsigned char all; struct { + unsigned char neg:1; // val is negative unsigned char pc:1; // precision specified unsigned char left:1; // left justify @@ -370,10 +371,10 @@ static inline { - _Istream_Char ignore( const char c ) { return (_Istream_Char)@{ true }; } + _Istream_Char ignore( const char ) { return (_Istream_Char)@{ true }; } _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; } } // distribution forall( dtype istype | istream( istype ) ) istype & ?|?( istype & is, _Istream_Char f ); -forall( otype T ) +forall( dtype T | sized( T ) ) struct _Istream_Manip { T & val; // polymorphic base-type Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ src/GenPoly/Specialize.cc (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Fri Dec 13 23:40:49 2019 -// Update Count : 32 +// Last Modified By : Andrew Beach +// Last Modified On : Thr Jul 2 17:42:00 2020 +// Update Count : 33 // @@ -42,5 +42,6 @@ namespace GenPoly { - struct Specialize final : public WithConstTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef { + struct Specialize final : public WithConstTypeSubstitution, + public WithDeclsToAdd, public WithVisitorRef { Expression * postmutate( ApplicationExpr *applicationExpr ); Expression * postmutate( CastExpr *castExpr ); @@ -248,16 +249,20 @@ } // if - // handle any specializations that may still be present - std::string oldParamPrefix = paramPrefix; - paramPrefix += "p"; - // save stmtsToAddBefore in oldStmts - std::list< Statement* > oldStmts; - oldStmts.splice( oldStmts.end(), stmtsToAddBefore ); - appExpr->acceptMutator( *visitor ); - paramPrefix = oldParamPrefix; - // write any statements added for recursive specializations into the thunk body - thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore ); - // restore oldStmts into stmtsToAddBefore - stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts ); + // Handle any specializations that may still be present. + { + std::string oldParamPrefix = paramPrefix; + paramPrefix += "p"; + std::list< Declaration * > oldDecls; + oldDecls.splice( oldDecls.end(), declsToAddBefore ); + + appExpr->acceptMutator( *visitor ); + // Write recursive specializations into the thunk body. + for ( Declaration * decl : declsToAddBefore ) { + thunkFunc->statements->kids.push_back( new DeclStmt( decl ) ); + } + + declsToAddBefore = std::move( oldDecls ); + paramPrefix = oldParamPrefix; + } // add return (or valueless expression) to the thunk @@ -270,6 +275,6 @@ thunkFunc->statements->kids.push_back( appStmt ); - // add thunk definition to queue of statements to add - stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) ); + // Add the thunk definition (converted to DeclStmt if appproprate). + declsToAddBefore.push_back( thunkFunc ); // return address of thunk function as replacement expression return new AddressExpr( new VariableExpr( thunkFunc ) ); Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ src/Parser/ParseNode.h (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 7 17:56:02 2020 -// Update Count : 891 +// Last Modified On : Mon Jul 6 09:33:32 2020 +// Update Count : 892 // @@ -86,5 +86,5 @@ class InitializerNode : public ParseNode { public: - InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); + InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); InitializerNode( bool isDelete ); Index: tests/.expect/global-monomorph.txt =================================================================== --- tests/.expect/global-monomorph.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/.expect/global-monomorph.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,1 @@ +Compilation Successful. Index: tests/.expect/manipulatorsOutput3.x64.txt =================================================================== --- tests/.expect/manipulatorsOutput3.x64.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/.expect/manipulatorsOutput3.x64.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,262 @@ +-1208907372870555465220095 +-1208907372870555465220095 ++1208907372870555465220095 + +0b11111111111111110000000000000000000000000000000000000000000000001111111111111111 +0B11111111111111110000000000000000000000000000000000000000000000001111111111111111 +11111111111111110000000000000000000000000000000000000000000000001111111111111111 + 0B11111111111111110000000000000000000000000000000000000000000000001111111111111111 + 0B000000000011111111111111110000000000000000000000000000000000000000000000001111111111111111 +0X0000000000FFFF000000000000FFFF + +0000000123 +0000000123 +0377776000000000000000177777 +377776000000000000000177777 + 0123 + 0000000000000000000000000000000000000123 +000000000000000000000000000000000000000000123 + 0377776000000000000000177777 + 0000000000000377776000000000000000177777 +000000000000000000377776000000000000000177777 +0123 X +0377776000000000000000177777 X +05000000000000000000123 X +0000000000000000000000000000000000000123 X +0000000000000377776000000000000000177777 X +0000000000000000005000000000000000000123 X +000000000000000000000000000000000000000000123X +000000000000000000377776000000000000000177777X +000000000000000000000005000000000000000000123X +0000000123X +0000000123X +0000000123 X +0000000123 X +0377776000000000000000177777 X +05000000000000000000123 X +0000000000000000000000000000000000000123X +0000000000000377776000000000000000177777X +0000000000000000005000000000000000000123X +0000000000000000000000000000000000000000001234567X +03777777777777777777777777777777777776543211Y +03777777777777777777777777777777777776543211Y + +0xffff000000000000ffff +0XFFFF000000000000FFFF +ffff000000000000ffff + 0XFFFF000000000000FFFF + 0X00000000000000000000FFFF000000000000FFFF +0X00000000000000000000000000000FFFF000000000000FFFF +0XFFFF000000000000FFFF X +0X00000000000000000000FFFF000000000000FFFF X +0X00000000000000000000000000000FFFF000000000000FFFFX + +base 2 +0b1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 + +base 8 +0113166530623714330436400000 + 0113166530623714330436400000 + 0113166530623714330436400000 + 00000000000113166530623714330436400000 + 000113166530623714330436400000 + 00000000000113166530623714330436400000 + +base 10 +355272055279601493606400 +355272055279601493606400 +355272055279601493606400 +355272055279601493606400 +355272055279601493606400 + 355272055279601493606400 + 355272055279601493606400 + 355272055279601493606400 + 000000355272055279601493606400 + 00000000000000355272055279601493606400 +0000000000000000355272055279601493606400 +0000000000000000355272055279601493606400 ++000000000000000355272055279601493606400 + +base 16 +0X4B3B56327CC6C47A0000 + 0X4B3B56327CC6C47A0000 + 0X4B3B56327CC6C47A0000 +0X0000000000000000004B3B56327CC6C47A0000 + 0X00000000004B3B56327CC6C47A0000 +0X0000000000000000004B3B56327CC6C47A0000 + +extras +0b1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0B1001011001110110101011000110010011111001100011011000100011110100000000000000000 +0113166530623714330436400000 +0x4b3b56327cc6c47a0000 +0X4B3B56327CC6C47A0000 +1001011001110110101011000110010011111001100011011000100011110100000000000000000 113166530623714330436400000 4b3b56327cc6c47a0000 ++355272055279601493606400 +-355272055279601493606400 +-355272055279601493606400 +355272055279601493606400 +355272055279601493606400 +355272055279601493606400 X ++355272055279601493606400 X ++0000000000000000355272055279601493606400X ++0000000000000000000000000000000123456789X +-10 0xfffffffffffffffffffffffffffffff6 03777777777777777777777777777777777777777766 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110110 +-9 0xfffffffffffffffffffffffffffffff7 03777777777777777777777777777777777777777767 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110111 +-8 0xfffffffffffffffffffffffffffffff8 03777777777777777777777777777777777777777770 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000 +-7 0xfffffffffffffffffffffffffffffff9 03777777777777777777777777777777777777777771 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111001 +-6 0xfffffffffffffffffffffffffffffffa 03777777777777777777777777777777777777777772 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111010 +-5 0xfffffffffffffffffffffffffffffffb 03777777777777777777777777777777777777777773 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111011 +-4 0xfffffffffffffffffffffffffffffffc 03777777777777777777777777777777777777777774 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 +-3 0xfffffffffffffffffffffffffffffffd 03777777777777777777777777777777777777777775 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101 +-2 0xfffffffffffffffffffffffffffffffe 03777777777777777777777777777777777777777776 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 +-1 0xffffffffffffffffffffffffffffffff 03777777777777777777777777777777777777777777 +0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 ++0 0 0 +0b0 ++1 0x1 01 +0b1 ++2 0x2 02 +0b10 ++3 0x3 03 +0b11 ++4 0x4 04 +0b100 ++5 0x5 05 +0b101 ++6 0x6 06 +0b110 ++7 0x7 07 +0b111 ++8 0x8 010 +0b1000 ++9 0x9 011 +0b1001 ++10 0xa 012 +0b1010 ++11 0xb 013 +0b1011 ++12 0xc 014 +0b1100 ++13 0xd 015 +0b1101 ++14 0xe 016 +0b1110 + +170141183460469231731687303715884105722 ++170141183460469231731687303715884105722 0x7ffffffffffffffffffffffffffffffa 01777777777777777777777777777777777777777772 +0b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111010 +170141183460469231731687303715884105723 ++170141183460469231731687303715884105723 0x7ffffffffffffffffffffffffffffffb 01777777777777777777777777777777777777777773 +0b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111011 +170141183460469231731687303715884105724 ++170141183460469231731687303715884105724 0x7ffffffffffffffffffffffffffffffc 01777777777777777777777777777777777777777774 +0b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 +170141183460469231731687303715884105725 ++170141183460469231731687303715884105725 0x7ffffffffffffffffffffffffffffffd 01777777777777777777777777777777777777777775 +0b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101 +170141183460469231731687303715884105726 ++170141183460469231731687303715884105726 0x7ffffffffffffffffffffffffffffffe 01777777777777777777777777777777777777777776 +0b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 +170141183460469231731687303715884105727 ++170141183460469231731687303715884105727 0x7fffffffffffffffffffffffffffffff 01777777777777777777777777777777777777777777 +0b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 +-170141183460469231731687303715884105728 +-170141183460469231731687303715884105728 0x80000000000000000000000000000000 02000000000000000000000000000000000000000000 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +-170141183460469231731687303715884105727 +-170141183460469231731687303715884105727 0x80000000000000000000000000000001 02000000000000000000000000000000000000000001 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 +-170141183460469231731687303715884105726 +-170141183460469231731687303715884105726 0x80000000000000000000000000000002 02000000000000000000000000000000000000000002 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010 +-170141183460469231731687303715884105725 +-170141183460469231731687303715884105725 0x80000000000000000000000000000003 02000000000000000000000000000000000000000003 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011 +-170141183460469231731687303715884105724 +-170141183460469231731687303715884105724 0x80000000000000000000000000000004 02000000000000000000000000000000000000000004 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100 +-170141183460469231731687303715884105723 +-170141183460469231731687303715884105723 0x80000000000000000000000000000005 02000000000000000000000000000000000000000005 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101 +-170141183460469231731687303715884105722 +-170141183460469231731687303715884105722 0x80000000000000000000000000000006 02000000000000000000000000000000000000000006 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000110 +-170141183460469231731687303715884105721 +-170141183460469231731687303715884105721 0x80000000000000000000000000000007 02000000000000000000000000000000000000000007 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111 +-170141183460469231731687303715884105720 +-170141183460469231731687303715884105720 0x80000000000000000000000000000008 02000000000000000000000000000000000000000010 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000 +-170141183460469231731687303715884105719 +-170141183460469231731687303715884105719 0x80000000000000000000000000000009 02000000000000000000000000000000000000000011 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001001 +-170141183460469231731687303715884105718 +-170141183460469231731687303715884105718 0x8000000000000000000000000000000a 02000000000000000000000000000000000000000012 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001010 +-170141183460469231731687303715884105717 +-170141183460469231731687303715884105717 0x8000000000000000000000000000000b 02000000000000000000000000000000000000000013 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001011 +-170141183460469231731687303715884105716 +-170141183460469231731687303715884105716 0x8000000000000000000000000000000c 02000000000000000000000000000000000000000014 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001100 +-170141183460469231731687303715884105715 +-170141183460469231731687303715884105715 0x8000000000000000000000000000000d 02000000000000000000000000000000000000000015 +0b10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001101 + +170141183460469231731687303715884105722 +170141183460469231731687303715884105723 +170141183460469231731687303715884105724 +170141183460469231731687303715884105725 +170141183460469231731687303715884105726 +170141183460469231731687303715884105727 +170141183460469231731687303715884105728 +170141183460469231731687303715884105729 +170141183460469231731687303715884105730 +170141183460469231731687303715884105731 +170141183460469231731687303715884105732 +170141183460469231731687303715884105733 +170141183460469231731687303715884105734 +170141183460469231731687303715884105735 +170141183460469231731687303715884105736 +170141183460469231731687303715884105737 +170141183460469231731687303715884105738 +170141183460469231731687303715884105739 +170141183460469231731687303715884105740 +170141183460469231731687303715884105741 + +340282366920938463463374607431768211450 +340282366920938463463374607431768211451 +340282366920938463463374607431768211452 +340282366920938463463374607431768211453 +340282366920938463463374607431768211454 +340282366920938463463374607431768211455 +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 Index: tests/bugs/.expect/10.txt =================================================================== --- tests/bugs/.expect/10.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/10.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,1 @@ +bugs/10.cfa:10:53: error: ‘_sizeof_Y1T’ undeclared here (not in a function) Index: tests/bugs/.expect/194.txt =================================================================== --- tests/bugs/.expect/194.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/194.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,40 @@ +bugs/194.cfa:13:1 error: Cannot choose between 2 alternatives for expression +Applying untyped: + Name: foo +...to: + Alternatives are: +Cost ( 0, 0, 0, 0, 1, 0, 0 ): Application of + Variable Expression: foo: forall + T: sized data type + function + ... returning + _retval_foo: reference to instance of type T (not function type) + ... with attributes: + Attribute with name: unused + + + + (types: + reference to instance of type _79_5_T (not function type) + ) + Environment: -> pointer to signed int + + +Cost ( 0, 0, 0, 0, 1, 0, 0 ): Application of + Variable Expression: foo: forall + T: sized data type + function + ... returning + _retval_foo: pointer to instance of type T (not function type) + ... with attributes: + Attribute with name: unused + + + + (types: + pointer to instance of type _79_6_T (not function type) + ) + Environment: -> signed int (no widening) + + + Index: tests/bugs/.expect/20.txt =================================================================== --- tests/bugs/.expect/20.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/20.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,6 @@ +error: No reasonable alternatives for expression Untyped Init Expression + constant expression (0 0: zero_t) InitAlternative: instance of struct foo with body 1 +bugs/20.cfa:15:1 error: No reasonable alternatives for expression Applying untyped: + Name: bar +...to: + Index: tests/bugs/.expect/44.txt =================================================================== --- tests/bugs/.expect/44.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/44.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,6 @@ +bugs/44.cfa:9:1 error: No reasonable alternatives for expression Applying untyped: + Name: ?=? +...to: + Name: x + Name: f + Index: tests/bugs/.expect/46.txt =================================================================== --- tests/bugs/.expect/46.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/46.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,4 @@ +bugs/46.cfa: In function ‘_X4mainFi___1’: +bugs/46.cfa:10:100: error: lvalue required as unary ‘&’ operand + 3 ? x[2] : val; + ^ Index: tests/bugs/.expect/5.txt =================================================================== --- tests/bugs/.expect/5.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/5.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,8 @@ +bugs/5.cfa: In function ‘_X4mainFi___1’: +bugs/5.cfa:8:43: error: ‘_unq0_finished_’ undeclared (first use in this function) + foo(bar()); + ^ +bugs/5.cfa:8:43: note: each undeclared identifier is reported only once for each function it appears in +bugs/5.cfa:8:225: warning: left-hand operand of comma expression has no effect [-Wunused-value] + foo(bar()); + ^ Index: tests/bugs/.expect/66.txt =================================================================== --- tests/bugs/.expect/66.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/66.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,69 @@ +bugs/66.cfa:11:1 error: Cannot choose between 2 alternatives for expression +Applying untyped: + Name: ?!=? +...to: + Name: next + constant expression (0 0: zero_t) + Alternatives are: +Cost ( 0, 2, 17, 0, 1, -2, 0 ): Application of + Variable Expression: ?!=?: forall + FT: function type + function + ... with parameters + intrinsic pointer to instance of type FT ( function type) + intrinsic pointer to instance of type FT ( function type) + ... returning + _retval__operator_notequal: signed int + ... with attributes: + Attribute with name: unused + + + ... to arguments + Variable Expression: next: function + accepting unspecified arguments + ... returning nothing + + Generated Cast of: + constant expression (0 0: zero_t) + ... to: + pointer to function + accepting unspecified arguments + ... returning nothing + + + (types: + signed int + ) + Environment: -> function + accepting unspecified arguments + ... returning nothing + (no widening) + + +Cost ( 0, 2, 17, 0, 1, -2, 0 ): Application of + Variable Expression: ?!=?: forall + DT: data type + function + ... with parameters + intrinsic pointer to instance of type DT (not function type) + intrinsic pointer to instance of type DT (not function type) + ... returning + _retval__operator_notequal: signed int + ... with attributes: + Attribute with name: unused + + + ... to arguments + Variable Expression: next: pointer to signed int + Generated Cast of: + constant expression (0 0: zero_t) + ... to: + pointer to signed int + + (types: + signed int + ) + Environment: -> signed int (no widening) + + + Index: tests/bugs/.expect/91.txt =================================================================== --- tests/bugs/.expect/91.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/91.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,2 @@ +error: No reasonable alternatives for expression Untyped Init Expression + Name: f InitAlternative: _Bool Index: tests/bugs/.expect/92.txt =================================================================== --- tests/bugs/.expect/92.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/92.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,16 @@ +bugs/92.cfa:6:1 error: No reasonable alternatives for expression Applying untyped: + Name: ?{} +...to: + Generated Cast of: + Variable Expression: _ret: instance of struct superFred with body 1 + ... to: + reference to instance of struct superFred with body 1 + Generated Cast of: + Variable Expression: _dst: reference to instance of struct superFred with body 1 + ... to: + instance of struct superFred with body 1 + ... with environment: + Types: + Non-types: + + Index: tests/bugs/.expect/95.txt =================================================================== --- tests/bugs/.expect/95.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/.expect/95.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,1 @@ +bugs/95.cfa:8:1 error: List of mutex member is currently unimplemented. Index: tests/bugs/10.cfa =================================================================== --- tests/bugs/10.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/10.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,9 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/10 + +forall(otype T) +struct result { + union { + T value; + }; +}; Index: tests/bugs/104.cfa =================================================================== --- tests/bugs/104.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/104.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,11 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/104 + +[ float, float ] modf_( float x ); + +forall(otype T | { [T, T] modf_(T); }) +void modf(T); + +int main() { + modf(7.0f); +} Index: tests/bugs/194.cfa =================================================================== --- tests/bugs/194.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/194.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,14 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/194 + +forall( dtype T | sized(T) ) T * foo( void ) { + printf( "foo1\n" ); + return (T *)0; +} +forall( dtype T | sized(T) ) T & foo( void ) { + printf( "foo2\n" ); + return (T &)*(T *)0; +} +int main( void ) { + int * i = foo(); +} Index: tests/bugs/20.cfa =================================================================== --- tests/bugs/20.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/20.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,16 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/20 + +struct foo { + int i; +}; + +void ?{}( foo & this, zero_t zero ) { + this.i = zero; +} + +extern void bar( foo this = 0 ); + +int main() { + bar(); +} Index: tests/bugs/44.cfa =================================================================== --- tests/bugs/44.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/44.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,10 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/44 + +typedef void (*fptr_t)(); +void f(int); + +int main() { + fptr_t x; + x = f; +} Index: tests/bugs/46.cfa =================================================================== --- tests/bugs/46.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/46.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,11 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/46 + +enum E { + val +}; + +int main() { + E x[3]; + 3 ? x[2] : val; +} Index: tests/bugs/5.cfa =================================================================== --- tests/bugs/5.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/5.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,9 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/5 + +[int, int] bar() { return [3, 4]; } +[void] foo([int] x, [int] y) {} + +int main() { + foo(bar()); +} Index: tests/bugs/66.cfa =================================================================== --- tests/bugs/66.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/66.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,12 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/66 + +void next() {} + +int main() { + int * next = (void*)0; + if( next ) { + return 1; + } + return 0; +} Index: tests/bugs/7.cfa =================================================================== --- tests/bugs/7.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/7.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,41 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/7 + +#include +extern "C" { +#include +} + +// (Bug 1 unresolved as of this test.) +forall(otype T) +struct stack_node; + +forall(otype T) +struct stack_node { + stack_node(T) * next; + T item; +}; + +forall(otype T) +struct stack { + stack_node(T) * head; +}; + +trait stack_errors(otype T) { + T emptyStackHandler (stack(T) * this); +}; + +forall(otype T | stack_errors(T)) +T pop (stack(T) * this) { + return (T){}; +} + +int emptyStackHandler (stack(int) * this) { + return 0; +} + +int main (int argc, char * argv[]) { + stack(int) stackOfInts; + pop(&stackOfInts); + return 0; +} Index: tests/bugs/91.cfa =================================================================== --- tests/bugs/91.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/91.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,13 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/91 + +#include + +struct fred {}; +bool ?!=?(const fred & this, zero_t) { return true; } + +void foo() { + fred f; + if(f) {} + bool test = f; +} Index: tests/bugs/92.cfa =================================================================== --- tests/bugs/92.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/92.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,17 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/92 + +struct fred{}; + +void ?{}(fred & this, int count = 1); +void ?{}(fred & this, fred & other) = void; +void ^?{}(fred & this); +fred ?=?(fred & this, const fred & other) = void; + +struct superFred { + fred f; +}; + +void foo() { + superFred f; +} Index: tests/bugs/95.cfa =================================================================== --- tests/bugs/95.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/bugs/95.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,9 @@ +// Trac ticket +// https://cforall.uwaterloo.ca/trac/ticket/95 + +#include +monitor M { condition e; } m; +void rtn( M & mutex m ); +void bar( M & mutex m ) { + waitfor( rtn, m ); // not ambiguous, select parameter +} Index: tests/copyfile.cfa =================================================================== --- tests/copyfile.cfa (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/copyfile.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -10,6 +10,6 @@ // Created On : Fri Jun 19 13:44:05 2020 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jun 19 17:58:03 2020 -// Update Count : 4 +// Last Modified On : Sun Jul 5 11:27:43 2020 +// Update Count : 5 // @@ -22,10 +22,10 @@ try { - choose ( argc ) { + choose ( argc ) { // terminate if command-line errors case 2, 3: open( in, argv[1] ); // open input file first as output creates file if ( argc == 3 ) open( out, argv[2] ); // do not create output unless input opens case 1: ; // use default files - default: + default: // wrong number of options exit | "Usage" | argv[0] | "[ input-file (default stdin) [ output-file (default stdout) ] ]"; } // choose Index: tests/exceptions/.expect/defaults.txt =================================================================== --- tests/exceptions/.expect/defaults.txt (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/exceptions/.expect/defaults.txt (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -3,2 +3,8 @@ jump default handler. Catch unhandled_exception. +cross terminate throw +cross terminate default +cross terminate catch +cross resume throw +cross resume default +cross resume catch Index: tests/exceptions/defaults.cfa =================================================================== --- tests/exceptions/defaults.cfa (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/exceptions/defaults.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -30,5 +30,5 @@ throwResume (log_message){(char *)"Should be printed.\n"}; } catchResume (log_message * this) { - printf(this->virtual_table->msg(this)); + printf("%s", this->virtual_table->msg(this)); } // But we don't have to: @@ -69,7 +69,33 @@ } +TRIVIAL_EXCEPTION(second); + +void cross_test(void) { + void defaultTerminationHandler(first &) { + printf("cross terminate default\n"); + throw (second){}; + } + void defaultResumptionHandler(first &) { + printf("cross resume default\n"); + throwResume (second){}; + } + try { + printf("cross terminate throw\n"); + throw (first){}; + } catch (second *) { + printf("cross terminate catch\n"); + } + try { + printf("cross resume throw\n"); + throwResume (first){}; + } catchResume (second *) { + printf("cross resume catch\n"); + } +} + int main(int argc, char * argv[]) { log_test(); jump_test(); unhandled_test(); + cross_test(); } Index: tests/global-monomorph.cfa =================================================================== --- tests/global-monomorph.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) +++ tests/global-monomorph.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -0,0 +1,37 @@ +// Crea + +#include +#include + +forall(dtype T) +void poly0(T &) {} + +forall(dtype T | sized(T)) +void poly1(T &) {} + +forall(otype T) +void poly2(T &) {} + +struct wrapper { + void (*mono)(int &); +}; + +/* These are failing (#193): +void (*mono0)(int &) = poly0; +void (*mono1)(int &) = poly1; +void (*mono2)(int &) = poly2; +struct wrapper mono0w = { poly0 }; +struct wrapper mono1w = { poly1 }; +struct wrapper mono2w = { poly2 }; +*/ +void (*mono0c)(int &) @= poly0; +void (*mono1c)(int &) @= poly1; +void (*mono2c)(int &) @= poly2; +struct wrapper mono0wc @= { poly0 }; +struct wrapper mono1wc @= { poly1 }; +struct wrapper mono2wc @= { poly2 }; + +int main(void) { + printf("Compilation Successful.\n"); + return 0; +} Index: tests/manipulatorsOutput3.cfa =================================================================== --- tests/manipulatorsOutput3.cfa (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/manipulatorsOutput3.cfa (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -13,5 +13,5 @@ sout | sign(x); sout | nl; -#if 1 + sout | bin(x); sout | upcase(bin(x)); @@ -124,5 +124,7 @@ sout | nl; - + + // extras + sout | "extras"; sout | bin(divisor); sout | upcase(bin(divisor)); @@ -140,4 +142,45 @@ sout | left(sign(wd(0,40, divisor))) | 'X'; printf( "%-+1.40dX\n", 123456789 ); -#endif // 0 + + int128 i128; + unsigned int128 ui128; + + i128 = -10; + for ( 25 ) { + sout | left( sign( wd( 20, i128 ) ) ) | left( wd( 20, hex( i128 ) ) ) | left( wd( 20, oct( i128 ) ) ); + sout | left( wd( 20, bin( i128 ) ) ); + i128 += 1; + } + sout | nl; + + i128 = 0x7fffffffffffffff; + i128 <<= 64; + i128 += 0xfffffffffffffffa; + + for ( 20 ) { + sout | i128; + sout | left( sign( wd( 45, i128 ) ) ) | left( wd( 45, hex( i128 ) ) ) | left( wd( 45, oct( i128 ) ) ); + sout | left( wd( 45, bin( i128 ) ) ); + i128 += 1; + } + sout | nl; + + ui128 = 0x7fffffffffffffff; + ui128 <<= 64; + ui128 += 0xfffffffffffffffa; + + for ( 20 ) { + sout | ui128; + ui128 += 1; + } + sout | nl; + + ui128 = 0xffffffffffffffff; + ui128 <<= 64; + ui128 += 0xfffffffffffffffa; + + for ( 20 ) { + sout | ui128; + ui128 += 1; + } } Index: tests/pybin/test_run.py =================================================================== --- tests/pybin/test_run.py (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/pybin/test_run.py (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -69,13 +69,4 @@ else : text = "FAILED with code %d" % retcode - text += " C%s - R%s" % (cls.fmtDur(duration[0]), cls.fmtDur(duration[1])) + text += " C%s - R%s" % (fmtDur(duration[0]), fmtDur(duration[1])) return text - - @staticmethod - def fmtDur( duration ): - if duration : - hours, rem = divmod(duration, 3600) - minutes, rem = divmod(rem, 60) - seconds, millis = divmod(rem, 1) - return "%2d:%02d.%03d" % (minutes, seconds, millis * 1000) - return " n/a" Index: tests/pybin/tools.py =================================================================== --- tests/pybin/tools.py (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/pybin/tools.py (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -387,2 +387,10 @@ while True: yield i.next(max(expire - time.time(), 0)) + +def fmtDur( duration ): + if duration : + hours, rem = divmod(duration, 3600) + minutes, rem = divmod(rem, 60) + seconds, millis = divmod(rem, 1) + return "%2d:%02d.%03d" % (minutes, seconds, millis * 1000) + return " n/a" Index: tests/test.py =================================================================== --- tests/test.py (revision 732b406caee356d13ed484758bd2ab40a2f63e22) +++ tests/test.py (revision 3a32b3ae8496c5197e67965c7a5c54f2eeb7d823) @@ -361,34 +361,35 @@ # for each build configurations, run the test - for arch, debug, install in itertools.product(settings.all_arch, settings.all_debug, settings.all_install): - settings.arch = arch - settings.debug = debug - settings.install = install - - # filter out the tests for a different architecture - # tests are the same across debug/install - local_tests = settings.arch.filter( tests ) - options.jobs, forceJobs = job_count( options, local_tests ) - settings.update_make_cmd(forceJobs, options.jobs) - - # check the build configuration works - settings.validate() - - # print configuration - print('%s %i tests on %i cores (%s:%s)' % ( - 'Regenerating' if settings.generating else 'Running', - len(local_tests), - options.jobs, - settings.arch.string, - settings.debug.string - )) - - # otherwise run all tests and make sure to return the correct error code - failed = run_tests(local_tests, options.jobs) - if failed: - result = 1 - if not settings.continue_: - break - - + with Timed() as total_dur: + for arch, debug, install in itertools.product(settings.all_arch, settings.all_debug, settings.all_install): + settings.arch = arch + settings.debug = debug + settings.install = install + + # filter out the tests for a different architecture + # tests are the same across debug/install + local_tests = settings.arch.filter( tests ) + options.jobs, forceJobs = job_count( options, local_tests ) + settings.update_make_cmd(forceJobs, options.jobs) + + # check the build configuration works + settings.validate() + + # print configuration + print('%s %i tests on %i cores (%s:%s)' % ( + 'Regenerating' if settings.generating else 'Running', + len(local_tests), + options.jobs, + settings.arch.string, + settings.debug.string + )) + + # otherwise run all tests and make sure to return the correct error code + failed = run_tests(local_tests, options.jobs) + if failed: + result = 1 + if not settings.continue_: + break + + print('Tests took %s' % fmtDur( total_dur.duration )) sys.exit( failed )