Changeset 5ef4008


Ignore:
Timestamp:
Sep 13, 2024, 2:43:22 PM (4 weeks ago)
Author:
JiadaL <j82liang@…>
Branches:
master
Children:
8c79dc3c
Parents:
c494b84 (diff), 9739c56f (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

Files:
31 added
27 edited
3 moved

Legend:

Unmodified
Added
Removed

  • doc/uC++toCFA/uC++toCFA.tex

    rc494b84 r5ef4008  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sat Apr 13 11:11:39 2024
    14 %% Update Count     : 5969
     13%% Last Modified On : Fri Sep 13 07:48:54 2024
     14%% Update Count     : 5987
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    154154\begin{tabular}{@{}l|l@{}}
    155155\multicolumn{2}{@{}l}{\lstinline{       int x = 1, y = 2, * p1x = &x, * p1y = &y, ** p2i = &p1x,}} \\
    156 \multicolumn{2}{@{}l}{\lstinline{\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ && r1x = x, & r1y = y, && r2i = r1x;}} \\
     156\multicolumn{2}{@{}l}{\lstinline{\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ & r1x = x, & r1y = y, && r2i = r1x;}} \\
    157157\begin{uC++}
    158158**p2i = 3;
    … …  
    384384\multicolumn{2}{@{}l@{}}{\lstinline{string s1, s2;}} \\
    385385\begin{uC++}
    386 s1 = "hi";
     386s1 = "abcdefg";
    387387s2 = s1;
    388388s1 += s2;
    … …  
    393393s1.substr( 2 ); s1.substr( 2, 3 );
    394394s1.replace( 2, 5, s2 );
    395 s1.find( s2 ), s1.rfind( s2 );
     395s1.find( s2 ); s1.rfind( s2 );
    396396s1.find_first_of( s2 ); s1.find_last_of( s2 );
    397 s1.find_first_not_of(s2 ); s1.find_last_not_of( s2 );
     397s1.find_first_not_of( s2 ); s1.find_last_not_of( s2 );
    398398getline( cin, s1 );
    399399cout << s1 << endl;
    … …  
    401401&
    402402\begin{cfa}
    403 s1 = "hi";
     403s1 = "abcdefg";
    404404s2 = s1;
    405405s1 += s2;
    … …  
    409409s1[3];
    410410s1( 2 ); s1( 2, 3 );
    411 //s1.replace( 2, 5, s2 );
    412 find( s1, s2 ), rfind( s1, s2 );
    413 find_first_of( .substr, s2 ); s1.find_last_of( s2 );
    414 s1.find_first_not_of(s2 ); s1.find_last_not_of( s2 );
     411// replace( s1, 2, 5, s2 );
     412// find( s1, s2 ), rfind( s1, s2 );
     413// find_first_of( s2 ); find_last_of( s2 );
     414// find_first_not_of( s1, s2 ); find_last_not_of( s1, s2 );
    415415sin | getline( s1 );
    416416sout | s1;
    … …  
    451451
    452452
    453 \section{\texorpdfstring{\lstinline{uNoCtor}}{uNoCtor}}
     453\section{\texorpdfstring{\lstinline{uArray}}{uArray}}
    454454
    455455\begin{cquote}
    456456\begin{tabular}{@{}l|l@{}}
    457457\begin{uC++}
    458 
     458#include <iostream>
     459using namespace std;
    459460struct S {
    460461        int i;
    … …  
    464465int main() {
    465466        enum { N = 5 };
    466         @uNoCtor<S>@ s[N];   // no constructor calls
    467         for ( int i = 0; i < N; i += 1 ) @s[i].ctor( i )@;
     467        @uArray( S, s, N );@   // no constructor calls
     468        for ( int i = 0; i < N; i += 1 ) @s[i]( i )@; // constructor calls
    468469        for ( int i = 0; i < N; i += 1 ) cout << s[i]@->@i << endl;
    469470}
    … …  
    471472&
    472473\begin{cfa}
    473 #include @<raii.hfa>@          // uninit
     474#include <fstream.hfa>
     475#include <array.hfa>
    474476struct S {
    475477        int i;
    … …  
    479481int main() {
    480482        enum { N = 5 };
    481         @uninit(S)@ s[N];  // no constructor calls
    482         for ( i; N ) @s[i]{ i }@;
     483        @array( S, N ) s = { delay_init };@ // no constructor calls
     484        for ( i; N ) @s[i]{ i }@; // constructor calls
    483485        for ( i; N ) sout | s[i]@.@i;
    484486}
    … …  
    522524\end{cfa}
    523525\\
    524 \multicolumn{2}{l}{\lstinline{C c;}}
     526\multicolumn{2}{@{}l@{}}{\lstinline{C c;}}
    525527\end{tabular}
    526528\end{cquote}
    … …  
    594596\end{cfa}
    595597\\
    596 \multicolumn{2}{l}{\lstinline{M m;}}
     598\multicolumn{2}{@{}l@{}}{\lstinline{M m;}}
    597599\end{tabular}
    598600\end{cquote}
    … …  
    625627\end{cfa}
    626628\\
    627 \multicolumn{2}{l}{\lstinline{T t; // start thread in main routine}}
     629\multicolumn{2}{@{}l@{}}{\lstinline{T t; // start thread in main routine}}
    628630\end{tabular}
    629631\end{cquote}

  • libcfa/src/collections/array.hfa

    rc494b84 r5ef4008  
    156156//      other two.  This solution offers ?{}() that needs only ?{}(), and similar for ^?{}.
    157157
     158// skip initializing elements
     159//   array(float, 5) x = { delay_init };
     160enum () delay_init_t { delay_init };
     161forall( [N], S & | sized(S), Timmed &, Tbase & )
     162static inline void ?{}( arpk( N, S, Timmed, Tbase ) & this, delay_init_t ) {
     163        void ?{}( S (&)[N] ) {}
     164        ?{}(this.strides);
     165}
     166
     167// call default ctor on elements
     168//   array(float, 5) x;
    158169forall( [N], S & | sized(S), Timmed &, Tbase & | { void ?{}( Timmed & ); } )
    159170static inline void ?{}( arpk( N, S, Timmed, Tbase ) & this ) { 
    160         void ?{}( S (&)[N] ) {}
    161         ?{}(this.strides);
    162 
     171        ?{}( this, delay_init );
    163172        for (i; N) ?{}( (Timmed &)this.strides[i] );
    164173}
    … …  
    173182        }
    174183}
     184
    175185
    176186//

  • src/AST/BasicKind.hpp

    rc494b84 r5ef4008  
    99// Author           : Andrew Beach
    1010// Created On       : Thu Apr 18 14:00:00 2024
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thu Apr 18 14:00:00 2024
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Sep  9 20:51:13 2024
     13// Update Count     : 2
    1414//
    1515
    … …  
    3535        SignedInt128,
    3636        UnsignedInt128,
    37         uFloat16,
    38         uFloat16Complex,
    39         uFloat32,
    40         uFloat32Complex,
     37        Float16,
     38        Float16Complex,
     39        Float32,
     40        Float32Complex,
    4141        Float,
    4242        FloatComplex,
    43         uFloat32x,
    44         uFloat32xComplex,
    45         uFloat64,
    46         uFloat64Complex,
     43        Float32x,
     44        Float32xComplex,
     45        Float64,
     46        Float64Complex,
    4747        Double,
    4848        DoubleComplex,
    49         uFloat64x,
    50         uFloat64xComplex,
    51         uuFloat80,
    52         uFloat128,
    53         uFloat128Complex,
     49        Float64x,
     50        Float64xComplex,
     51        Float80,
     52        Float128,
     53        Float128Complex,
    5454        uuFloat128,
    5555        LongDouble,
    5656        LongDoubleComplex,
    57         uFloat128x,
    58         uFloat128xComplex,
     57        Float128x,
     58        Float128xComplex,
    5959        NUMBER_OF_BASIC_TYPES,
    6060        MAX_INTEGER_TYPE = UnsignedInt128,

  • src/BasicTypes-gen.cpp

    rc494b84 r5ef4008  
    99#include <assert.h>
    1010#include <string.h>                                                                             // strlen
    11 #include "config.h"                                                                     // configure info
     11#include "config.h"                                                                             // configure info
    1212
    1313enum Kind {
    … …  
    2626        SignedInt128,
    2727        UnsignedInt128,
    28         uFloat16,
    29         uFloat16Complex,
    30         uFloat32,
    31         uFloat32Complex,
     28        Float16,
     29        Float16Complex,
     30        Float32,
     31        Float32Complex,
    3232        Float,
    3333        FloatComplex,
    3434        // FloatImaginary,
    35         uFloat32x,
    36         uFloat32xComplex,
    37         uFloat64,
    38         uFloat64Complex,
     35        Float32x,
     36        Float32xComplex,
     37        Float64,
     38        Float64Complex,
    3939        Double,
    4040        DoubleComplex,
    4141        // DoubleImaginary,
    42         uFloat64x,
    43         uFloat64xComplex,
    44         uuFloat80,
    45         uFloat128,
    46         uFloat128Complex,
     42        Float64x,
     43        Float64xComplex,
     44        Float80,
     45        Float128,
     46        Float128Complex,
    4747        uuFloat128,
    4848        LongDouble,
    4949        LongDoubleComplex,
    5050        // LongDoubleImaginary,
    51         uFloat128x,
    52         uFloat128xComplex,
    53         NUMBER_OF_BASIC_TYPES
     51        Float128x,
     52        Float128xComplex,
     53        NUMBER_OF_BASIC_TYPES,
     54
     55        Float32x4,                                                                                      // ARM, gcc-14
     56        Float64x2,
     57        Svfloat32,
     58        Svfloat64,
     59        Svbool,
    5460};
    5561
    … …  
    8894        { LongLongUnsignedInt, "LongLongUnsignedInt", "LLUI", "unsigned long long int", "y", Unsigned, SignedInt128, UnsignedInt128, -1, 5 },
    8995
    90         { SignedInt128, "SignedInt128", "IB", "__int128", "n", Signed, UnsignedInt128, uFloat16, -1, 6 },
    91         { UnsignedInt128, "UnsignedInt128", "UIB", "unsigned __int128", "o", Unsigned, uFloat16, -1, -1, 6 },
    92 
    93         { uFloat16, "uFloat16", "_FH", "_Float16", "DF16_", Floating, uFloat32, uFloat16Complex, -1, 7 },
    94         { uFloat16Complex, "uFloat16Complex", "_FH", "_Float16 _Complex", "CDF16_", Floating, uFloat32Complex, -1, -1, 7 },
    95         { uFloat32, "uFloat32", "_F", "_Float32", "DF32_", Floating, Float, uFloat32Complex, -1, 8 },
    96         { uFloat32Complex, "uFloat32Complex", "_FC", "_Float32 _Complex", "CDF32_", Floating, FloatComplex, -1, -1, 8 },
    97         { Float, "Float", "F", "float", "f", Floating, uFloat32x, FloatComplex, -1, 9 },
    98         { FloatComplex, "FloatComplex", "FC", "float _Complex", "Cf", Floating, uFloat32xComplex, -1, -1, 9 },
     96        { SignedInt128, "SignedInt128", "IB", "__int128", "n", Signed, UnsignedInt128, Float16, -1, 6 },
     97        { UnsignedInt128, "UnsignedInt128", "UIB", "unsigned __int128", "o", Unsigned, Float16, -1, -1, 6 },
     98
     99        { Float16, "Float16", "_FH", "_Float16", "DF16_", Floating, Float32, Float16Complex, -1, 7 },
     100        { Float16Complex, "Float16Complex", "_FH", "_Float16 _Complex", "CDF16_", Floating, Float32Complex, -1, -1, 7 },
     101        { Float32, "Float32", "_F", "_Float32", "DF32_", Floating, Float, Float32Complex, -1, 8 },
     102        { Float32Complex, "Float32Complex", "_FC", "_Float32 _Complex", "CDF32_", Floating, FloatComplex, -1, -1, 8 },
     103        { Float, "Float", "F", "float", "f", Floating, Float32x, FloatComplex, -1, 9 },
     104        { FloatComplex, "FloatComplex", "FC", "float _Complex", "Cf", Floating, Float32xComplex, -1, -1, 9 },
    99105        // { FloatImaginary, "FloatImaginary", "FI", "float _Imaginary", "If", false, DoubleImaginary, FloatComplex, -1, 9 },
    100106
    101         { uFloat32x, "uFloat32x", "_FX", "_Float32x", "DF32x_", Floating, uFloat64, uFloat32xComplex, -1, 10 },
    102         { uFloat32xComplex, "uFloat32xComplex", "_FXC", "_Float32x _Complex", "CDF32x_", Floating, uFloat64Complex, -1, -1, 10 },
    103         { uFloat64, "uFloat64", "FD", "_Float64", "DF64_", Floating, Double, uFloat64Complex, -1, 11 },
    104         { uFloat64Complex, "uFloat64Complex", "_FDC", "_Float64 _Complex", "CDF64_", Floating, DoubleComplex, -1, -1, 11 },
    105         { Double, "Double", "D", "double", "d", Floating, uFloat64x, DoubleComplex, -1, 12 },
    106         { DoubleComplex, "DoubleComplex", "DC", "double _Complex", "Cd", Floating, uFloat64xComplex, -1, -1, 12 },
     107        { Float32x, "Float32x", "_FX", "_Float32x", "DF32x_", Floating, Float64, Float32xComplex, -1, 10 },
     108        { Float32xComplex, "Float32xComplex", "_FXC", "_Float32x _Complex", "CDF32x_", Floating, Float64Complex, -1, -1, 10 },
     109        { Float64, "Float64", "FD", "_Float64", "DF64_", Floating, Double, Float64Complex, -1, 11 },
     110        { Float64Complex, "Float64Complex", "_FDC", "_Float64 _Complex", "CDF64_", Floating, DoubleComplex, -1, -1, 11 },
     111        { Double, "Double", "D", "double", "d", Floating, Float64x, DoubleComplex, -1, 12 },
     112        { DoubleComplex, "DoubleComplex", "DC", "double _Complex", "Cd", Floating, Float64xComplex, -1, -1, 12 },
    107113        // { DoubleImaginary, "DoubleImaginary", "DI", "double _Imaginary", "Id", false, LongDoubleImaginary, DoubleComplex, -1, 12 },
    108114
    109         { uFloat64x, "uFloat64x", "F80X", "_Float64x", "DF64x_", Floating, uuFloat80, uFloat64xComplex, -1, 13 },
    110         { uFloat64xComplex, "uFloat64xComplex", "_FDXC", "_Float64x _Complex", "CDF64x_", Floating, uFloat128Complex, -1, -1, 13 },
    111         { uuFloat80, "uuFloat80", "F80", "__float80", "Dq", Floating, uFloat128, uFloat64xComplex, -1, 14 },
    112         { uFloat128, "uFloat128", "_FB", "_Float128", "DF128_", Floating, uuFloat128, uFloat128Complex, -1, 15 },
    113         { uFloat128Complex, "uFloat128Complex", "_FLDC", "_Float128 _Complex", "CDF128_", Floating, LongDoubleComplex, -1, -1, 15 },
    114         { uuFloat128, "uuFloat128", "FB", "__float128", "g", Floating, LongDouble, uFloat128Complex, -1, 16 },
    115         { LongDouble, "LongDouble", "LD", "long double", "e", Floating, uFloat128x, LongDoubleComplex, -1, 17 },
    116         { LongDoubleComplex, "LongDoubleComplex", "LDC", "long double _Complex", "Ce", Floating, uFloat128xComplex, -1, -1, 17 },
     115        { Float64x, "Float64x", "F80X", "_Float64x", "DF64x_", Floating, Float80, Float64xComplex, -1, 13 },
     116        { Float64xComplex, "Float64xComplex", "_FDXC", "_Float64x _Complex", "CDF64x_", Floating, Float128Complex, -1, -1, 13 },
     117        { Float80, "Float80", "F80", "__float80", "Dq", Floating, Float128, Float64xComplex, -1, 14 },
     118        { Float128, "Float128", "_FB", "_Float128", "DF128_", Floating, uuFloat128, Float128Complex, -1, 15 },
     119        { Float128Complex, "Float128Complex", "_FLDC", "_Float128 _Complex", "CDF128_", Floating, LongDoubleComplex, -1, -1, 15 },
     120        { uuFloat128, "uuFloat128", "FB", "__float128", "g", Floating, LongDouble, Float128Complex, -1, 16 },
     121        { LongDouble, "LongDouble", "LD", "long double", "e", Floating, Float128x, LongDoubleComplex, -1, 17 },
     122        { LongDoubleComplex, "LongDoubleComplex", "LDC", "long double _Complex", "Ce", Floating, Float128xComplex, -1, -1, 17 },
    117123        // { LongDoubleImaginary, "LongDoubleImaginary", "LDI", "long double _Imaginary", "Ie", false, LongDoubleComplex, -1, -1, 17 },
    118124
    119         { uFloat128x, "uFloat128x", "_FBX", "_Float128x", "DF128x_", Floating, uFloat128xComplex, -1, -1, 18 },
    120         { uFloat128xComplex, "uFloat128xComplex", "_FLDXC", "_Float128x _Complex", "CDF128x_", Floating, -1, -1, -1, 18 }
     125        { Float128x, "Float128x", "_FBX", "_Float128x", "DF128x_", Floating, Float128xComplex, -1, -1, 18 },
     126        { Float128xComplex, "Float128xComplex", "_FLDXC", "_Float128x _Complex", "CDF128x_", Floating, -1, -1, -1, 18 }
    121127}; // graph
    122128

  • src/ControlStruct/TranslateEnumRange.cpp

    rc494b84 r5ef4008  
    66namespace ControlStruct {
    77
    8 struct addInit {
    9     const ast::Stmt * postvisit( const ast::ForStmt * stmt );
     8namespace {
     9
     10struct TranslateEnumRangeCore {
     11        const ast::Stmt * postvisit( const ast::ForStmt * stmt );
    1012};
    1113
    12 struct translateEnumRangeCore {
    13     const ast::Stmt * postvisit( const ast::ForStmt * stmt );
    14 };
     14const ast::Stmt * TranslateEnumRangeCore::postvisit( const ast::ForStmt * stmt ) {
     15        if ( !stmt->range_over ) return stmt;
     16        auto mutStmt = ast::mutate( stmt );
     17        auto & location = mutStmt->location;
    1518
    16 const ast::Stmt* addInit::postvisit( const ast::ForStmt * stmt ) {
    17     if ( stmt->range_over ) {
    18         auto inits = stmt->inits;
    19         auto init = stmt->inits.front();
     19        if ( auto declStmt = mutStmt->inits.front().as<ast::DeclStmt>() ) {
     20                if ( auto objDecl = declStmt->decl.as<ast::ObjectDecl>() ) {
     21                        if ( !objDecl->init ) {
     22                                ast::SingleInit * newInit = new ast::SingleInit( location,
     23                                        ast::UntypedExpr::createCall( location,
     24                                                mutStmt->is_inc ? "lowerBound" : "upperBound", {} ),
     25                                        ast::ConstructFlag::MaybeConstruct
     26                                );
     27                                auto objDeclWithInit = ast::mutate_field( objDecl, &ast::ObjectDecl::init, newInit );
     28                                auto declWithInit = ast::mutate_field( declStmt, &ast::DeclStmt::decl, objDeclWithInit );
     29                                mutStmt->inits[0] = declWithInit;
     30                        }
     31                }
     32        }
    2033
    21         if (auto declStmt = init.as<ast::DeclStmt>()) {
    22             auto decl = declStmt->decl;
    23             if ( auto objDecl = decl.as<ast::ObjectDecl>()) {
    24                 if ( !objDecl->init ) {
    25                     auto location = stmt->location;
    26                     ast::SingleInit * newInit = new ast::SingleInit( location,
    27                         stmt->is_inc?
    28                         ast::UntypedExpr::createCall( location, "lowerBound", {} ):
    29                         ast::UntypedExpr::createCall( location, "upperBound", {} ),
    30                         ast::ConstructFlag::MaybeConstruct
    31                     );
    32                     auto objDeclWithInit = ast::mutate_field( objDecl, &ast::ObjectDecl::init, newInit );
    33                     auto declWithInit = ast::mutate_field( declStmt, &ast::DeclStmt::decl, objDeclWithInit );
    34                     stmt = ast::mutate_field_index( stmt, &ast::ForStmt::inits, 0, declWithInit );
    35                 }
    36             }
    37         }
    38     }
    39     return stmt;
     34        auto declStmt = mutStmt->inits.front().strict_as<ast::DeclStmt>();
     35        auto initDecl = declStmt->decl.strict_as<ast::ObjectDecl>();
     36        auto indexName = initDecl->name;
     37
     38        // Both inc and dec check if the current posn less than the number of enumerator
     39        // for dec, it keeps call pred until it passes 0 (the first enumerator) and underflow,
     40        // it wraps around and become unsigned max
     41        ast::UntypedExpr * condition = ast::UntypedExpr::createCall( location,
     42                mutStmt->is_inc ? "?<=?" : "?>=?",
     43                {
     44                        new ast::NameExpr( location, indexName ),
     45                        ast::UntypedExpr::createCall( location,
     46                                mutStmt->is_inc ? "upperBound" : "lowerBound", {} )
     47                } );
     48        auto increment = ast::UntypedExpr::createCall( location,
     49                mutStmt->is_inc ? "succ_unsafe" : "pred_unsafe",
     50                { new ast::NameExpr( location, indexName ) } );
     51        auto assig = ast::UntypedExpr::createAssign( location,
     52                new ast::NameExpr( location, indexName ), increment );
     53        mutStmt->cond = condition;
     54        mutStmt->inc = assig;
     55        return mutStmt;
    4056}
    4157
    42 const ast::Stmt* translateEnumRangeCore::postvisit( const ast::ForStmt * stmt ) {
    43     if ( !stmt->range_over ) return stmt;
    44     auto location = stmt->location;
    45     auto declStmt = stmt->inits.front().strict_as<ast::DeclStmt>();
    46     auto initDecl = declStmt->decl.strict_as<ast::ObjectDecl>();
    47     auto indexName = initDecl->name;
    48 
    49     // Both inc and dec check if the current posn less than the number of enumerator
    50     // for dec, it keeps call pred until it passes 0 (the first enumerator) and underflow,
    51     // it wraps around and become unsigned max
    52     ast::UntypedExpr * condition = ast::UntypedExpr::createCall( location,
    53         stmt->is_inc? "?<=?": "?>=?",
    54         {   new ast::NameExpr( location, indexName ),
    55             stmt->is_inc?
    56                 ast::UntypedExpr::createCall( location, "upperBound", {} ):
    57                 ast::UntypedExpr::createCall( location, "lowerBound", {} )
    58         });
    59     auto increment = ast::UntypedExpr::createCall( location,
    60         stmt->is_inc? "succ_unsafe": "pred_unsafe",
    61         { new ast::NameExpr( location, indexName ) });
    62     auto assig = ast::UntypedExpr::createAssign( location, new ast::NameExpr( location, indexName ), increment );
    63     auto mut = ast::mutate_field( stmt, &ast::ForStmt::cond, condition );
    64     mut = ast::mutate_field(stmt, &ast::ForStmt::inc, assig );
    65     return mut;
    66 } 
     58} // namespace
    6759
    6860void translateEnumRange( ast::TranslationUnit & translationUnit ) {
    69     ast::Pass<addInit>::run( translationUnit );
    70     ast::Pass<translateEnumRangeCore>::run( translationUnit );
     61        ast::Pass<TranslateEnumRangeCore>::run( translationUnit );
    7162}
    72 }
     63
     64} // namespace ControlStruct

  • src/Parser/ExpressionNode.cpp

    rc494b84 r5ef4008  
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat May 16 13:17:07 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Aug 23 10:22:00 2024
    13 // Update Count     : 1088
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Sep 12 22:40:35 2024
     13// Update Count     : 1090
    1414//
    1515
    … …  
    381381                const CodeLocation & location, string & str ) {
    382382        static const ast::BasicKind kind[2][12] = {
    383                 { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x },
    384                 { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex },
     383                { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::Float80, ast::BasicKind::uuFloat128, ast::BasicKind::Float16, ast::BasicKind::Float32, ast::BasicKind::Float32x, ast::BasicKind::Float64, ast::BasicKind::Float64x, ast::BasicKind::Float128, ast::BasicKind::Float128x },
     384                { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::Float16Complex, ast::BasicKind::Float32Complex, ast::BasicKind::Float32xComplex, ast::BasicKind::Float64Complex, ast::BasicKind::Float64xComplex, ast::BasicKind::Float128Complex, ast::BasicKind::Float128xComplex },
    385385        };
    386386
    … …  
    460460        return ret;
    461461} // build_constantChar
     462
     463static bool isoctal( char ch ) {
     464        return ('0' <= ch && ch <= '7');
     465}
     466
     467// A "sequence" is the series of characters in a character/string literal
     468// that becomes a single character value in the runtime value.
     469static size_t sequenceLength( const std::string & str, size_t pos ) {
     470        // Most "sequences" are just a single character, filter those out:
     471        if ( '\\' != str[pos] ) return 1;
     472        switch ( str[pos + 1] ) {
     473                // Simple Escape Sequence (\_ where _ is one of the following):
     474          case '\'': case '\"': case '?': case '\\':
     475          case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
     476                // GCC Escape Sequence (as simple, just some different letters):
     477          case 'e':
     478                return 2;
     479                // Numeric Escape Sequence (\___ where _ is 1-3 octal digits):
     480          case '0': case '1': case '2': case '3':
     481          case '4': case '5': case '6': case '7':
     482                return ( !isoctal( str[pos + 2] ) ) ? 2 :
     483                  ( !isoctal( str[pos + 3] ) ) ? 3 : 4;
     484                  // Numeric Escape Sequence (\x_ where _ is 1 or more hexadecimal digits):
     485          case 'x': {
     486                  size_t length = 2;
     487                  while ( isxdigit( str[pos + length] ) ) ++length;
     488                  return length;
     489          }
     490                // Universal Character Name (\u____ where _ is 4 decimal digits):
     491          case 'u':
     492                return 6;
     493                // Universal Character Name (\U________ where _ is 8 decimal digits):
     494          case 'U':
     495                return 10;
     496          default:
     497                assertf( false, "Unknown escape sequence (start %c).", str[pos] );
     498                return 1;
     499        }
     500}
    462501
    463502ast::Expr * build_constantStr(
    … …  
    485524                strtype = new ast::BasicType( ast::BasicKind::Char );
    486525        } // switch
     526
     527        // The dimension value of the type is equal to the number of "sequences"
     528        // not including the openning and closing quotes in the literal plus 1
     529        // for the implicit null terminator.
     530        size_t dimension = 1;
     531        for ( size_t pos = 1 ; pos < str.size() - 1 ;
     532                        pos += sequenceLength( str, pos ) ) {
     533                dimension += 1;
     534        }
     535
    487536        ast::ArrayType * at = new ast::ArrayType(
    488537                strtype,
    489                 // Length is adjusted: +1 for '\0' and -2 for '"'
    490                 ast::ConstantExpr::from_ulong( location, str.size() + 1 - 2 ),
     538                ast::ConstantExpr::from_ulong( location, dimension ),
    491539                ast::FixedLen,
    492540                ast::DynamicDim );

  • src/Parser/StatementNode.cpp

    rc494b84 r5ef4008  
    1111// Created On       : Sat May 16 14:59:41 2015
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Mon Sep  9 11:28:07 2024
    14 // Update Count     : 430
     13// Last Modified On : Mon Sep  9 21:49:15 2024
     14// Update Count     : 431
    1515//
    1616
    … …  
    184184
    185185ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
    186         std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
     186        std::vector<ast::ptr<ast::Stmt>> astinit;                       // maybe empty
    187187        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
    188188

  • src/Parser/TypeData.cpp

    rc494b84 r5ef4008  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 23 08:58:30 2024
    13 // Update Count     : 734
     12// Last Modified On : Thu Sep 12 22:43:59 2024
     13// Update Count     : 735
    1414//
    1515
    … …  
    11581158        case TypeData::Double:
    11591159        case TypeData::LongDouble:                                      // not set until below
    1160         case TypeData::uuFloat80:
     1160        case TypeData::Float80:
    11611161        case TypeData::uuFloat128:
    1162         case TypeData::uFloat16:
    1163         case TypeData::uFloat32:
    1164         case TypeData::uFloat32x:
    1165         case TypeData::uFloat64:
    1166         case TypeData::uFloat64x:
    1167         case TypeData::uFloat128:
    1168         case TypeData::uFloat128x:
     1162        case TypeData::Float16:
     1163        case TypeData::Float32:
     1164        case TypeData::Float32x:
     1165        case TypeData::Float64:
     1166        case TypeData::Float64x:
     1167        case TypeData::Float128:
     1168        case TypeData::Float128x:
    11691169                static ast::BasicKind floattype[2][12] = {
    1170                         { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex, },
    1171                         { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x, },
     1170                        { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::Float16Complex, ast::BasicKind::Float32Complex, ast::BasicKind::Float32xComplex, ast::BasicKind::Float64Complex, ast::BasicKind::Float64xComplex, ast::BasicKind::Float128Complex, ast::BasicKind::Float128xComplex, },
     1171                        { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::Float80, ast::BasicKind::uuFloat128, ast::BasicKind::Float16, ast::BasicKind::Float32, ast::BasicKind::Float32x, ast::BasicKind::Float64, ast::BasicKind::Float64x, ast::BasicKind::Float128, ast::BasicKind::Float128x, },
    11721172                };
    11731173
    … …  
    11851185                        genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
    11861186                } // if
    1187                 if ( (td->basictype == TypeData::uuFloat80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
     1187                if ( (td->basictype == TypeData::Float80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
    11881188                        genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
    11891189                } // if
    … …  
    12051205                const_cast<TypeData *>(td)->basictype = TypeData::Int;
    12061206                goto Integral;
     1207
     1208          case TypeData::Float32x4: case TypeData::Float64x2: case TypeData::Svfloat32: case TypeData:: Svfloat64: case TypeData::Svbool:
     1209                return nullptr;
    12071210        default:
    12081211                assertf( false, "unknown basic type" );
    … …  
    14831486                        ast::Expr * initValue;
    14841487                        if ( ret->isCfa && ret->base ) {
    1485                                 CodeLocation location = cur->enumeratorValue->location;
    1486                                 initValue = new ast::CastExpr( location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base );
     1488                                initValue = new ast::CastExpr( cur->enumeratorValue->location, maybeMoveBuild( cur->consume_enumeratorValue() ),
     1489                                                                                          ret->base );
    14871490                        } else {
    14881491                                initValue = maybeMoveBuild( cur->consume_enumeratorValue() );

  • src/Parser/TypeData.hpp

    rc494b84 r5ef4008  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 16:30:31 2024
    13 // Update Count     : 210
     12// Last Modified On : Fri Sep 13 08:13:01 2024
     13// Update Count     : 216
    1414//
    1515
    … …  
    2828        enum BasicType {
    2929                Void, Bool, Char, Int, Int128,
    30                 Float, Double, LongDouble, uuFloat80, uuFloat128,
    31                 uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x,
    32                 NoBasicType
     30                Float, Double, LongDouble, Float80, uuFloat128,
     31                Float16, Float32, Float32x, Float64, Float64x, Float128, Float128x,
     32                NoBasicType,
     33                Float32x4, Float64x2, Svfloat32, Svfloat64, Svbool,
    3334        };
    3435        static const char * basicTypeNames[];

  • src/Parser/lex.ll

    rc494b84 r5ef4008  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Jun 27 14:38:27 2024
    13  * Update Count     : 780
     12 * Last Modified On : Wed Sep 11 17:16:23 2024
     13 * Update Count     : 791
    1414 */
    1515
    … …  
    234234basetypeof              { KEYWORD_RETURN(BASETYPEOF); }                 // CFA
    235235_Bool                   { KEYWORD_RETURN(BOOL); }                               // C99
     236__SVBool_t              { KEYWORD_RETURN(SVBOOL); }                             // gcc (ARM)
    236237break                   { KEYWORD_RETURN(BREAK); }
    237238case                    { KEYWORD_RETURN(CASE); }
    … …  
    270271fixup                   { QKEYWORD_RETURN(FIXUP); }                             // CFA
    271272float                   { KEYWORD_RETURN(FLOAT); }
    272 __float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
    273 float80                 { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
     273__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
     274float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
    274275__float128              { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
    275276float128                { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
    276 _Float16                { FLOATXX(uFLOAT16); }                                  // GCC
    277 _Float32                { FLOATXX(uFLOAT32); }                                  // GCC
    278 _Float32x               { FLOATXX(uFLOAT32X); }                                 // GCC
    279 _Float64                { FLOATXX(uFLOAT64); }                                  // GCC
    280 _Float64x               { FLOATXX(uFLOAT64X); }                                 // GCC
    281 _Float128               { FLOATXX(uFLOAT128); }                                 // GCC
    282 _Float128x              { FLOATXX(uFLOAT128); }                                 // GCC
     277_Float16                { FLOATXX(FLOAT16); }                                   // GCC
     278_Float32                { FLOATXX(FLOAT32); }                                   // GCC
     279_Float32x               { FLOATXX(FLOAT32X); }                                  // GCC
     280_Float64                { FLOATXX(FLOAT64); }                                   // GCC
     281_Float64x               { FLOATXX(FLOAT64X); }                                  // GCC
     282_Float128               { FLOATXX(FLOAT128); }                                  // GCC
     283_Float128x              { FLOATXX(FLOAT128X); }                                 // GCC
     284__Float32x4_t   { FLOATXX(FLOAT32X4); }                                 // GCC (ARM)
     285__Float64x2_t   { FLOATXX(FLOAT64X2); }                                 // GCC (ARM)
     286__SVFloat32_t   { FLOATXX(SVFLOAT32); }                                 // GCC (ARM)
     287__SVFloat64_t   { FLOATXX(SVFLOAT64); }                                 // GCC (ARM)
    283288for                             { KEYWORD_RETURN(FOR); }
    284289forall                  { KEYWORD_RETURN(FORALL); }                             // CFA

  • src/Parser/parser.yy

    rc494b84 r5ef4008  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug 13 11:25:16 2024
    13 // Update Count     : 6740
     12// Last Modified On : Thu Sep 12 22:48:32 2024
     13// Update Count     : 6741
    1414//
    1515
    … …  
    366366%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
    367367%token BOOL COMPLEX IMAGINARY                                                   // C99
    368 %token INT128 UINT128 uuFLOAT80 uuFLOAT128                              // GCC
    369 %token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
     368%token INT128 UINT128 FLOAT80 uuFLOAT128                                // GCC
     369%token FLOAT16 FLOAT32 FLOAT32X FLOAT64 FLOAT64X FLOAT128 FLOAT128X // GCC
     370%token FLOAT32X4 FLOAT64X2 SVFLOAT32 SVFLOAT64 SVBOOL   // GCC (ARM)
    370371%token DECIMAL32 DECIMAL64 DECIMAL128                                   // GCC
    371372%token ZERO_T ONE_T                                                                             // CFA
    … …  
    23642365        | DOUBLE
    23652366                { $$ = build_basic_type( TypeData::Double ); }
    2366         | uuFLOAT80
    2367                 { $$ = build_basic_type( TypeData::uuFloat80 ); }
     2367        | FLOAT80
     2368                { $$ = build_basic_type( TypeData::Float80 ); }
    23682369        | uuFLOAT128
    23692370                { $$ = build_basic_type( TypeData::uuFloat128 ); }
    2370         | uFLOAT16
    2371                 { $$ = build_basic_type( TypeData::uFloat16 ); }
    2372         | uFLOAT32
    2373                 { $$ = build_basic_type( TypeData::uFloat32 ); }
    2374         | uFLOAT32X
    2375                 { $$ = build_basic_type( TypeData::uFloat32x ); }
    2376         | uFLOAT64
    2377                 { $$ = build_basic_type( TypeData::uFloat64 ); }
    2378         | uFLOAT64X
    2379                 { $$ = build_basic_type( TypeData::uFloat64x ); }
    2380         | uFLOAT128
    2381                 { $$ = build_basic_type( TypeData::uFloat128 ); }
     2371        | FLOAT16
     2372                { $$ = build_basic_type( TypeData::Float16 ); }
     2373        | FLOAT32
     2374                { $$ = build_basic_type( TypeData::Float32 ); }
     2375        | FLOAT32X
     2376                { $$ = build_basic_type( TypeData::Float32x ); }
     2377        | FLOAT64
     2378                { $$ = build_basic_type( TypeData::Float64 ); }
     2379        | FLOAT64X
     2380                { $$ = build_basic_type( TypeData::Float64x ); }
     2381        | FLOAT128
     2382                { $$ = build_basic_type( TypeData::Float128 ); }
     2383        | FLOAT128X
     2384                { $$ = build_basic_type( TypeData::Float128x ); }
     2385        | FLOAT32X4
     2386                { $$ = build_basic_type( TypeData::Float32x4 ); }
     2387        | FLOAT64X2
     2388                { $$ = build_basic_type( TypeData::Float64x2 ); }
     2389        | SVFLOAT32
     2390                { $$ = build_basic_type( TypeData::Svfloat32 ); }
     2391        | SVFLOAT64
     2392                { $$ = build_basic_type( TypeData::Svfloat64 ); }
     2393        | SVBOOL
     2394                { $$ = build_basic_type( TypeData::Svbool ); }
    23822395        | DECIMAL32
    23832396                { SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; }

  • src/ResolvExpr/CommonType.cpp

    rc494b84 r5ef4008  
    5252                /*      B */                BT Bool,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    5353                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    54                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    55                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    56                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    57                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     54                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     55                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     56                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     57                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    5858                                  },
    5959                                  {
    6060                /*      C */                BT Char,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    6161                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    62                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    63                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    64                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    65                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     62                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     63                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     64                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     65                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    6666                                  },
    6767                                  {
    6868                /*     SC */          BT SignedChar,          BT SignedChar,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    6969                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    70                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    71                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    72                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    73                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     70                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     71                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     72                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     73                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    7474                                  },
    7575                                  {
    7676                /*     UC */        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    7777                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    78                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    79                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    80                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    81                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     78                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     79                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     80                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     81                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    8282                                  },
    8383                                  {
    8484                /*     SI */      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,    BT ShortUnsignedInt,
    8585                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    86                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    87                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    88                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    89                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     86                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     87                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     88                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     89                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    9090                                  },
    9191                                  {
    9292                /*    SUI */    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,
    9393                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    94                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    95                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    96                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    97                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     94                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     95                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     96                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     97                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    9898                                  },
    9999                                  {
    100100                /*      I */           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,
    101101                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    102                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    103                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    104                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    105                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     102                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     103                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     104                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     105                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    106106                                  },
    107107                                  {
    108108                /*     UI */         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,
    109109                                           BT UnsignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    110                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    111                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    112                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    113                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     110                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     111                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     112                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     113                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    114114                                  },
    115115                                  {
    116116                /*     LI */       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,
    117117                                         BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    118                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    119                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    120                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    121                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     118                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     119                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     120                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     121                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    122122                                  },
    123123                                  {
    124124                /*    LUI */     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,
    125125                                       BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    126                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    127                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    128                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    129                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     126                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     127                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     128                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     129                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    130130                                  },
    131131                                  {
    132132                /*    LLI */   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,
    133133                                     BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    134                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    135                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    136                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    137                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     134                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     135                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     136                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     137                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    138138                                  },
    139139                                  {
    140140                /*   LLUI */ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
    141141                                   BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
    142                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    143                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    144                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    145                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     142                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     143                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     144                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     145                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    146146                                  },
    147147                                  {
    148148                /*     IB */        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
    149149                                          BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
    150                                           BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    151                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    152                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    153                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     150                                          BT SignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     151                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     152                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     153                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    154154                                  },
    155155                                  {
    156156                /*    UIB */      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
    157157                                        BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
    158                                         BT UnsignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    159                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    160                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    161                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    162                                   },
    163                                   {
    164                 /*    _FH */            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
    165                                               BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
    166                                               BT uFloat16,            BT uFloat16,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    167                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    168                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    169                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    170                                   },
    171                                   {
    172                 /*    _FH */     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
    173                                        BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
    174                                        BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    175                                           BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
    176                                          BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    177                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    178                                   },
    179                                   {
    180                 /*     _F */            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
    181                                               BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
    182                                               BT uFloat32,            BT uFloat32,            BT uFloat32,     BT uFloat32Complex,            BT uFloat32,     BT uFloat32Complex,
    183                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    184                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    185                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    186                                   },
    187                                   {
    188                 /*    _FC */     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    189                                        BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    190                                        BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    191                                           BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
    192                                          BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    193                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
     158                                        BT UnsignedInt128,      BT UnsignedInt128,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     159                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     160                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     161                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     162                                  },
     163                                  {
     164                /*    _FH */             BT Float16,             BT Float16,             BT Float16,             BT Float16,             BT Float16,             BT Float16,
     165                                               BT Float16,             BT Float16,             BT Float16,             BT Float16,             BT Float16,             BT Float16,
     166                                               BT Float16,             BT Float16,             BT Float16,      BT Float16Complex,             BT Float32,      BT Float32Complex,
     167                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     168                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     169                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     170                                  },
     171                                  {
     172                /*    _FH */      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,
     173                                        BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,
     174                                        BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float16Complex,      BT Float32Complex,      BT Float32Complex,
     175                                          BT FloatComplex,        BT FloatComplex,     BT Float32xComplex,     BT Float32xComplex,      BT Float64Complex,      BT Float64Complex,
     176                                         BT DoubleComplex,       BT DoubleComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     177                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
     178                                  },
     179                                  {
     180                /*     _F */             BT Float32,             BT Float32,             BT Float32,             BT Float32,             BT Float32,             BT Float32,
     181                                               BT Float32,             BT Float32,             BT Float32,             BT Float32,             BT Float32,             BT Float32,
     182                                               BT Float32,             BT Float32,             BT Float32,      BT Float32Complex,             BT Float32,      BT Float32Complex,
     183                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     184                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     185                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     186                                  },
     187                                  {
     188                /*    _FC */      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,
     189                                        BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,
     190                                        BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,      BT Float32Complex,
     191                                          BT FloatComplex,        BT FloatComplex,     BT Float32xComplex,     BT Float32xComplex,      BT Float64Complex,      BT Float64Complex,
     192                                         BT DoubleComplex,       BT DoubleComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     193                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
    194194                                  },
    195195                                  {
    … …  
    197197                                                 BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
    198198                                                 BT Float,               BT Float,               BT Float,        BT FloatComplex,               BT Float,        BT FloatComplex,
    199                                                  BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    200                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    201                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     199                                                 BT Float,        BT FloatComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     200                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     201                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    202202                                  },
    203203                                  {
    … …  
    205205                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
    206206                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
    207                                           BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
    208                                          BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    209                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    210                                   },
    211                                   {
    212                 /*    _FX */           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
    213                                              BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
    214                                              BT uFloat32x,           BT uFloat32x,           BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,
    215                                              BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
    216                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    217                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    218                                   },
    219                                   {
    220                 /*   _FXC */    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
    221                                       BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
    222                                       BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
    223                                       BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
    224                                          BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    225                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    226                                   },
    227                                   {
    228                 /*     FD */            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
    229                                               BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
    230                                               BT uFloat64,            BT uFloat64,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
    231                                               BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
    232                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    233                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    234                                   },
    235                                   {
    236                 /*   _FDC */     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    237                                        BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    238                                        BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    239                                        BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    240                                          BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    241                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
     207                                          BT FloatComplex,        BT FloatComplex,     BT Float32xComplex,     BT Float32xComplex,      BT Float64Complex,      BT Float64Complex,
     208                                         BT DoubleComplex,       BT DoubleComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     209                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
     210                                  },
     211                                  {
     212                /*    _FX */            BT Float32x,            BT Float32x,            BT Float32x,            BT Float32x,            BT Float32x,            BT Float32x,
     213                                              BT Float32x,            BT Float32x,            BT Float32x,            BT Float32x,            BT Float32x,            BT Float32x,
     214                                              BT Float32x,            BT Float32x,            BT Float32x,     BT Float32xComplex,            BT Float32x,     BT Float32xComplex,
     215                                              BT Float32x,     BT Float32xComplex,            BT Float32x,     BT Float32xComplex,             BT Float64,      BT Float64Complex,
     216                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     217                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     218                                  },
     219                                  {
     220                /*   _FXC */     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,
     221                                       BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,
     222                                       BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,
     223                                       BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,     BT Float32xComplex,      BT Float64Complex,      BT Float64Complex,
     224                                         BT DoubleComplex,       BT DoubleComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     225                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
     226                                  },
     227                                  {
     228                /*     FD */             BT Float64,             BT Float64,             BT Float64,             BT Float64,             BT Float64,             BT Float64,
     229                                               BT Float64,             BT Float64,             BT Float64,             BT Float64,             BT Float64,             BT Float64,
     230                                               BT Float64,             BT Float64,             BT Float64,      BT Float64Complex,             BT Float64,      BT Float64Complex,
     231                                               BT Float64,      BT Float64Complex,             BT Float64,      BT Float64Complex,             BT Float64,      BT Float64Complex,
     232                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     233                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     234                                  },
     235                                  {
     236                /*   _FDC */      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,
     237                                        BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,
     238                                        BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,
     239                                        BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,      BT Float64Complex,
     240                                         BT DoubleComplex,       BT DoubleComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     241                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
    242242                                  },
    243243                                  {
    … …  
    246246                                                BT Double,              BT Double,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
    247247                                                BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
    248                                                 BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    249                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     248                                                BT Double,       BT DoubleComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     249                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    250250                                  },
    251251                                  {
    … …  
    254254                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
    255255                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
    256                                          BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    257                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    258                                   },
    259                                   {
    260                 /*   F80X */           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
    261                                              BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
    262                                              BT uFloat64x,           BT uFloat64x,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
    263                                              BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
    264                                              BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    265                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    266                                   },
    267                                   {
    268                 /*  _FDXC */    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    269                                       BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    270                                       BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    271                                       BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    272                                       BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
    273                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    274                                   },
    275                                   {
    276                 /*    F80 */           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,
    277                                              BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,
    278                                              BT uuFloat80,           BT uuFloat80,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,
    279                                              BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,
    280                                              BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
    281                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    282                                   },
    283                                   {
    284                 /*    _FB */           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
    285                                              BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
    286                                              BT uFloat128,           BT uFloat128,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
    287                                              BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
    288                                              BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,           BT uFloat128,
    289                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
    290                                   },
    291                                   {
    292                 /*  _FLDC */    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    293                                       BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    294                                       BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    295                                       BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    296                                       BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    297                                       BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
     256                                         BT DoubleComplex,       BT DoubleComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     257                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
     258                                  },
     259                                  {
     260                /*   F80X */            BT Float64x,            BT Float64x,            BT Float64x,            BT Float64x,            BT Float64x,            BT Float64x,
     261                                              BT Float64x,            BT Float64x,            BT Float64x,            BT Float64x,            BT Float64x,            BT Float64x,
     262                                              BT Float64x,            BT Float64x,            BT Float64x,     BT Float64xComplex,            BT Float64x,     BT Float64xComplex,
     263                                              BT Float64x,     BT Float64xComplex,            BT Float64x,     BT Float64xComplex,            BT Float64x,     BT Float64xComplex,
     264                                              BT Float64x,     BT Float64xComplex,            BT Float64x,     BT Float64xComplex,             BT Float80,            BT Float128,
     265                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     266                                  },
     267                                  {
     268                /*  _FDXC */     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,
     269                                       BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,
     270                                       BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,
     271                                       BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,
     272                                       BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float64xComplex,     BT Float128Complex,
     273                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
     274                                  },
     275                                  {
     276                /*    F80 */             BT Float80,             BT Float80,             BT Float80,             BT Float80,             BT Float80,             BT Float80,
     277                                               BT Float80,             BT Float80,             BT Float80,             BT Float80,             BT Float80,             BT Float80,
     278                                               BT Float80,             BT Float80,             BT Float80,     BT Float64xComplex,             BT Float80,     BT Float64xComplex,
     279                                               BT Float80,     BT Float64xComplex,             BT Float80,     BT Float64xComplex,             BT Float80,     BT Float64xComplex,
     280                                               BT Float80,     BT Float64xComplex,             BT Float80,     BT Float64xComplex,             BT Float80,            BT Float128,
     281                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     282                                  },
     283                                  {
     284                /*    _FB */            BT Float128,            BT Float128,            BT Float128,            BT Float128,            BT Float128,            BT Float128,
     285                                              BT Float128,            BT Float128,            BT Float128,            BT Float128,            BT Float128,            BT Float128,
     286                                              BT Float128,            BT Float128,            BT Float128,     BT Float128Complex,            BT Float128,     BT Float128Complex,
     287                                              BT Float128,     BT Float128Complex,            BT Float128,     BT Float128Complex,            BT Float128,     BT Float128Complex,
     288                                              BT Float128,     BT Float128Complex,            BT Float128,     BT Float128Complex,            BT Float128,            BT Float128,
     289                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
     290                                  },
     291                                  {
     292                /*  _FLDC */     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,
     293                                       BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,
     294                                       BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,
     295                                       BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,
     296                                       BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,     BT Float128Complex,
     297                                       BT Float128Complex,     BT Float128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
    298298                                  },
    299299                                  {
    300300                /*     FB */          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
    301301                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
    302                                             BT uuFloat128,          BT uuFloat128,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
    303                                             BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
    304                                             BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,          BT uuFloat128,
    305                                       BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     302                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,     BT Float128Complex,          BT uuFloat128,     BT Float128Complex,
     303                                            BT uuFloat128,     BT Float128Complex,          BT uuFloat128,     BT Float128Complex,          BT uuFloat128,     BT Float128Complex,
     304                                            BT uuFloat128,     BT Float128Complex,          BT uuFloat128,     BT Float128Complex,          BT uuFloat128,          BT uuFloat128,
     305                                       BT Float128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    306306                                  },
    307307                                  {
    … …  
    311311                                            BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,
    312312                                            BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,
    313                                      BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
     313                                     BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,           BT Float128x,    BT Float128xComplex,
    314314                                  },
    315315                                  {
    … …  
    319319                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
    320320                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
    321                                      BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    322                                   },
    323                                   {
    324                 /*   _FBX */          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
    325                                             BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
    326                                             BT uFloat128x,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
    327                                             BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
    328                                             BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,          BT uFloat128x,
    329                                      BT uFloat128xComplex,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
    330                                   },
    331                                   {
    332                 /* _FLDXC */   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    333                                      BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    334                                      BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    335                                      BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    336                                      BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    337                                      BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
     321                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,    BT Float128xComplex,    BT Float128xComplex,
     322                                  },
     323                                  {
     324                /*   _FBX */           BT Float128x,           BT Float128x,           BT Float128x,           BT Float128x,           BT Float128x,           BT Float128x,
     325                                             BT Float128x,           BT Float128x,           BT Float128x,           BT Float128x,           BT Float128x,           BT Float128x,
     326                                             BT Float128x,           BT Float128x,           BT Float128x,    BT Float128xComplex,           BT Float128x,    BT Float128xComplex,
     327                                             BT Float128x,    BT Float128xComplex,           BT Float128x,    BT Float128xComplex,           BT Float128x,    BT Float128xComplex,
     328                                             BT Float128x,    BT Float128xComplex,           BT Float128x,    BT Float128xComplex,           BT Float128x,           BT Float128x,
     329                                      BT Float128xComplex,           BT Float128x,           BT Float128x,    BT Float128xComplex,           BT Float128x,    BT Float128xComplex,
     330                                  },
     331                                  {
     332                /* _FLDXC */    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,
     333                                      BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,
     334                                      BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,
     335                                      BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,
     336                                      BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,
     337                                      BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,    BT Float128xComplex,
    338338                                  },
    339339        }; // commonTypes

  • tests/Makefile.am

    rc494b84 r5ef4008  
    8181        avltree/avl-private.h \
    8282        avltree/avl.h \
    83         configs/.in/parseconfig-all.txt \
    84         configs/.in/parseconfig-errors.txt \
    85         configs/.in/parseconfig-missing.txt \
    8683        exceptions/except-io.hfa \
    8784        exceptions/with-threads.hfa \
    88         io/.in/io.data \
    89         io/.in/many_read.data \
    9085        meta/fork+exec.hfa \
    9186        concurrency/clib_tls.c \
    … …  
    10095        echo "Gathering test files"
    10196        for file in `${TEST_PY} --list-dist`; do \
    102                 if test -f ${srcdir}/$${file}; then \
     97                if ls ${srcdir}/$${file} > /dev/null 2>&1; then \
    10398                        ${MKDIR_P} $$(dirname ${distdir}/$${file}); \
    104                         cp -df ${srcdir}/$${file} ${distdir}/$${file}; \
     99                        cp -df ${srcdir}/$${file} $$(dirname ${distdir}/$${file}); \
    105100                fi; \
    106101        done

  • tests/array-collections/.expect/array-raii-c.txt

    rc494b84 r5ef4008  
    7070dtor 1
    7171dtor 0
    72 === uninit
     72=== uninit ( uNoCtor[] )
    7373 [1]
    7474before ctors

  • tests/array-collections/.expect/array-raii-cfa.txt

    rc494b84 r5ef4008  
    7070dtor 1
    7171dtor 0
    72 === uninit
     72=== uninit ( uNoCtor[] )
    7373 [1]
    7474before ctors
    … …  
    108108dtor 101
    109109dtor 100
     110=== uninit alt ( uArray )
     111 [1]
     112before ctors
     113ctor 0
     114ctor 999
     115ctor 888
     116ctor 3
     117ctor 4
     118func 0
     119func 999
     120func 888
     121func 3
     122func 4
     123dtor 4
     124dtor 3
     125dtor 888
     126dtor 999
     127dtor 0
     128 [2]
     129before ctors
     130ctor 100
     131ctor 101
     132ctor 102
     133ctor 110
     134ctor 999
     135ctor 888
     136func 100 at (0, 0)
     137func 101 at (0, 1)
     138func 102 at (0, 2)
     139func 110 at (1, 0)
     140func 999 at (1, 1)
     141func 888 at (1, 2)
     142dtor 888
     143dtor 999
     144dtor 110
     145dtor 102
     146dtor 101
     147dtor 100
     148=== uC++ cheat sheet
     149ctor 0
     150ctor 1
     151ctor 2
     152ctor 3
     153ctor 4
     1540
     1551
     1562
     1573
     1584
     159dtor 4
     160dtor 3
     161dtor 2
     162dtor 1
     163dtor 0

  • tests/array-collections/array-raii-c.cfa

    rc494b84 r5ef4008  
    2020
    2121#include "array-raii.hfa"
     22
     23void test_extras() {}

  • tests/array-collections/array-raii-cfa.cfa

    rc494b84 r5ef4008  
    1616// CFA array means like `array(float, 17) x;`
    1717
     18
     19#include <fstream.hfa>
    1820#include <collections/array.hfa>
    1921
    … …  
    2224
    2325#include "array-raii.hfa"
     26
     27void test_uninit_alt() {
     28    printf(" [1]\n");
     29    {
     30        array(thing, 5) a = { delay_init };
     31        printf("before ctors\n");
     32        for(i; 5) {
     33            if (i == 1)
     34                (a[i]){};  // no need for `emplace` bc no-arg ctor call means elem's real ctor
     35            else if (i == 2)
     36                (a[i]){888};
     37            else
     38                (a[i]){i};
     39        }
     40        for(i; 5) printf("func %d\n", a[i].mem);
     41    }
     42    printf(" [2]\n");
     43    {
     44        array(thing, 2, 3) a = { delay_init };
     45        printf("before ctors\n");
     46        for(i; 2) for(j; 3) {
     47            if (i == 1 && j == 1)
     48                (a[i][j]){};
     49            else if (i == 1 && j == 2)
     50                (a[i][j]){888};
     51            else
     52                (a[i][j]){100 + 10 * i + j};
     53        }
     54        for(i; 2) for(j; 3) {
     55            printf("func %d at (%d, %d)\n", a[i][j].mem, i, j);
     56        }
     57    }
     58}
     59
     60void test_uCxxCheatSheet() {
     61    struct S {
     62        int i;
     63    };
     64    void ?{}( S & s, int i ) { s.i = i; sout | "ctor" | s.i; }
     65    void ^?{}( S & s ) { sout | "dtor" | s.i; }
     66//  int main() {
     67        enum { N = 5 };
     68        array(S, N) s = { delay_init };   // no constructor calls
     69        for ( i; N ) s[i]{ i };
     70        for ( i; N ) sout | s[i].i;
     71//  }
     72}
     73
     74void test_extras() {
     75
     76    printf("=== uninit alt ( uArray )\n");
     77    test_uninit_alt();
     78
     79    printf("=== uC++ cheat sheet\n");
     80    test_uCxxCheatSheet();
     81}

  • tests/array-collections/array-raii.hfa

    rc494b84 r5ef4008  
    118118}
    119119
     120struct thing { int mem; };
     121void ?{}( thing & this, int i ) {
     122    (this.mem){ i };
     123    printf("ctor %d\n", this.mem);
     124}
     125void ?{}( thing & this ) {
     126    (this){ 999 };
     127}
     128void ^?{}( thing & this ) {
     129    printf("dtor %d\n", this.mem);
     130}
     131
    120132// Array of uninits sees explicit ctor calls (only), and implied dtor calls
    121133void test_uninit() {
    122     struct thing { int mem; };
    123     void ?{}( thing & this, int i ) {
    124         (this.mem){ i };
    125         printf("ctor %d\n", this.mem);
    126     }
    127     void ?{}( thing & this ) {
    128         (this){ 999 };
    129     }
    130     void ^?{}( thing & this ) {
    131         printf("dtor %d\n", this.mem);
    132     }
    133134    printf(" [1]\n");
    134135    {
    … …  
    163164}
    164165
     166void test_extras();
     167
    165168int main() {
    166169    printf("=== builtins\n");
    … …  
    170173    test_custom();
    171174
    172     printf("=== uninit\n");
     175    printf("=== uninit ( uNoCtor[] )\n");
    173176    test_uninit();
     177
     178    test_extras();
    174179}

  • tests/configs/parsebools.cfa

    rc494b84 r5ef4008  
    5050}
    5151
    52 int true_main( const char * path, char * env[] ) {
     52int true_main( const char * path, const char * env[] ) {
    5353        printf( "no arg:\n" );
    5454        if ( pid_t child = strict_fork(); child == 0 ) {

  • tests/configs/parseconfig.cfa

    rc494b84 r5ef4008  
    5050        sout | "Different types of destination addresses";
    5151
    52         parse_config( xstr(IN_DIR) "parseconfig-all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
     52        parse_config( xstr(IN_DIR) "parseconfig.all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
    5353
    5454    sout | "Stop cost: " | config_params.stop_cost;
    … …  
    7777        sout | "Missing_Config_Entries thrown when config file is missing entries we want";
    7878        try {
    79                 parse_config( xstr(IN_DIR) "parseconfig-missing.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
     79                parse_config( xstr(IN_DIR) "parseconfig.missing.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
    8080        } catch( Missing_Config_Entries * ex ) {
    8181                msg( ex );
    … …  
    9292
    9393        try {
    94                 parse_config( xstr(IN_DIR) "parseconfig-errors.txt", entry, 1, parse_tabular_config_format );
     94                parse_config( xstr(IN_DIR) "parseconfig.errors.txt", entry, 1, parse_tabular_config_format );
    9595        } catch( Parse_Failure * ex ) {
    9696                msg( ex );
    … …  
    106106
    107107        try {
    108                 parse_config( xstr(IN_DIR) "parseconfig-errors.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
     108                parse_config( xstr(IN_DIR) "parseconfig.errors.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
    109109        } catch( Validation_Failure * ex ) {
    110110                msg( ex );
    … …  
    115115        sout | "No error is thrown when validation succeeds";
    116116        config_params.stop_cost = -1; // Reset value
    117         parse_config( xstr(IN_DIR) "parseconfig-all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
     117        parse_config( xstr(IN_DIR) "parseconfig.all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
    118118        sout | "Stop cost: " | config_params.stop_cost;
    119119        sout | nl;
    … …  
    126126
    127127        config_params.stop_cost = -1; // Reset value
    128         parse_config( xstr(IN_DIR) "parseconfig-all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
     128        parse_config( xstr(IN_DIR) "parseconfig.all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
    129129
    130130        sout | "Stop cost: " | config_params.stop_cost;
    … …  
    139139
    140140        config_params.stop_cost = -1; // Reset value
    141         parse_config( xstr(IN_DIR) "parseconfig-all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
     141        parse_config( xstr(IN_DIR) "parseconfig.all.txt", entries, NUM_ENTRIES, parse_tabular_config_format );
    142142
    143143        sout | "Stop cost: " | config_params.stop_cost;

  • tests/configs/parsenums.cfa

    rc494b84 r5ef4008  
    6161}
    6262
    63 int true_main( const char * path, char * env[] ) {
     63int true_main( const char * path, const char * env[] ) {
    6464        printf( "no arg:\n" );
    6565        if ( pid_t child = strict_fork(); child == 0 ) {

  • tests/configs/usage.cfa

    rc494b84 r5ef4008  
    108108
    109109// no used
    110 static int true_main( const char * path, char * env[]) { return 0; }
     110static int true_main( const char * path, const char * env[]) { return 0; }

  • tests/meta/fork+exec.cfa

    rc494b84 r5ef4008  
    3232
    3333
    34 int true_main(const char * path, char * env[]) {
     34int true_main(const char * path, const char * env[]) {
    3535        printf("no arg:\n");
    3636        if(pid_t child = strict_fork(); child == 0) {

  • tests/meta/fork+exec.hfa

    rc494b84 r5ef4008  
    2828}
    2929
    30 static int true_main(const char * path, char * env[]);
     30static int true_main(const char * path, const char * env[]);
    3131
    3232static int do_wait(pid_t pid) {
    … …  
    7070        if(getenv("CFATEST_FORK_EXEC_TEXT")) return;
    7171
    72         char * env[] = { "CFATEST_FORK_EXEC_TEXT=1", 0p };
     72        const char * env[] = { "CFATEST_FORK_EXEC_TEXT=1", (char*)0 };
    7373        exit( true_main(path, env) );
    7474}

  • tests/pybin/test_run.py

    rc494b84 r5ef4008  
    2929                return os.path.normpath( os.path.join(settings.BUILDDIR, self.path, ".out"   , "%s.log" % self.name) )
    3030
     31        # one file that goes to the test's stdin
    3132        def input(self):
    3233                return os.path.normpath( os.path.join(settings.SRCDIR  , self.path, ".in"    , "%s.txt" % self.name) )
     34
     35        # several files available for this test to open
     36        def inputs_all(self):
     37                return os.path.normpath( os.path.join(settings.SRCDIR  , self.path, ".in"    , "%s.*" % self.name) )
    3338
    3439        def target_output(self):

  • tests/test.py

    rc494b84 r5ef4008  
    352352                for t in tests:
    353353                        print(os.path.relpath(t.expect(), settings.SRCDIR), end=' ')
    354                         print(os.path.relpath(t.input() , settings.SRCDIR), end=' ')
     354                        print(os.path.relpath(t.inputs_all() , settings.SRCDIR), end=' ')
    355355                        code, out, err = make_recon(t.target())
    356356
    … …  
    360360
    361361                        print(' '.join(re.findall(r'([^\s]+\.cfa)', out)), end=' ')
    362 
    363                 print('')
    364362
    365363                # done

  • tests/time.cfa

    rc494b84 r5ef4008  
    1010// Created On       : Tue Mar 27 17:24:56 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug 13 09:09:47 2024
    13 // Update Count     : 76
     12// Last Modified On : Fri Sep 13 00:57:15 2024
     13// Update Count     : 77
    1414//
    1515
    … …  
    1818#include <stdlib.h>                                                                             // putenv
    1919
    20 extern "C" size_t malloc_unfreed() { return 2048; }             // guess at unfreed storage from putenv/tzset
     20extern "C" size_t malloc_unfreed() { return 4096; }             // guess at unfreed storage from putenv/tzset
    2121
    2222int main() {
Note: See TracChangeset for help on using the changeset viewer.