Changeset 7a780ad


Ignore:
Timestamp:
Apr 18, 2024, 5:19:17 PM (14 months ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
master
Children:
38093ae
Parents:
60c5b6d
Message:

Moved ast::BasicType::Kind to ast::BasicKind? in its own hearder. This is more consistent with other utility enums (although we still use this as a enum class) and reduces what some files need to include. Also did a upgrade in a comment with MAX_INTEGER_TYPE, it is now part of the enum.

Location:
src
Files:
1 added
33 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Expr.cpp

    r60c5b6d r7a780ad  
    246246ConstantExpr * ConstantExpr::from_bool( const CodeLocation & loc, bool b ) {
    247247        return new ConstantExpr{
    248                 loc, new BasicType{ BasicType::Bool }, b ? "1" : "0", (unsigned long long)b };
     248                loc, new BasicType{ BasicKind::Bool }, b ? "1" : "0", (unsigned long long)b };
    249249}
    250250
    251251ConstantExpr * ConstantExpr::from_int( const CodeLocation & loc, int i ) {
    252252        return new ConstantExpr{
    253                 loc, new BasicType{ BasicType::SignedInt }, std::to_string( i ), (unsigned long long)i };
     253                loc, new BasicType{ BasicKind::SignedInt }, std::to_string( i ), (unsigned long long)i };
    254254}
    255255
    256256ConstantExpr * ConstantExpr::from_ulong( const CodeLocation & loc, unsigned long i ) {
    257257        return new ConstantExpr{
    258                 loc, new BasicType{ BasicType::LongUnsignedInt }, std::to_string( i ),
     258                loc, new BasicType{ BasicKind::LongUnsignedInt }, std::to_string( i ),
    259259                (unsigned long long)i };
    260260}
    261261
    262262ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & str ) {
    263         const Type * charType = new BasicType( BasicType::Char );
     263        const Type * charType = new BasicType( BasicKind::Char );
    264264        // Adjust the length of the string for the terminator.
    265265        const Expr * strSize = from_ulong( loc, str.size() + 1 );
    … …  
    277277
    278278SizeofExpr::SizeofExpr( const CodeLocation & loc, const Expr * e )
    279 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
     279: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
    280280
    281281SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * t )
    282 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
     282: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
    283283
    284284// --- AlignofExpr
    285285
    286286AlignofExpr::AlignofExpr( const CodeLocation & loc, const Expr * e )
    287 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
     287: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
    288288
    289289AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
    290 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
     290: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
    291291
    292292// --- OffsetofExpr
    293293
    294294OffsetofExpr::OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem )
    295 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), type( ty ), member( mem ) {
     295: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( ty ), member( mem ) {
    296296        assert( type );
    297297        assert( member );
    … …  
    302302OffsetPackExpr::OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty )
    303303: Expr( loc, new ArrayType{
    304         new BasicType{ BasicType::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
     304        new BasicType{ BasicKind::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
    305305), type( ty ) {
    306306        assert( type );
    … …  
    311311LogicalExpr::LogicalExpr(
    312312        const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia )
    313 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
     313: Expr( loc, new BasicType{ BasicKind::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
    314314
    315315// --- CommaExpr

  • src/AST/Pass.impl.hpp

    r60c5b6d r7a780ad  
    477477                                CodeLocation{}, "__func__",
    478478                                new ast::ArrayType{
    479                                         new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
     479                                        new ast::BasicType{ ast::BasicKind::Char, ast::CV::Const },
    480480                                        nullptr, VariableLen, DynamicDim
    481481                                },

  • src/AST/Type.hpp

    r60c5b6d r7a780ad  
    2222#include <vector>
    2323
     24#include "BasicKind.hpp"     // for BasicKind
    2425#include "CVQualifiers.hpp"
    2526#include "Decl.hpp"          // for AggregateDecl subclasses
    … …  
    114115class BasicType final : public Type {
    115116public:
    116         // GENERATED START, DO NOT EDIT
    117         // GENERATED BY BasicTypes-gen.cc
    118         enum Kind {
    119                 Bool,
    120                 Char,
    121                 SignedChar,
    122                 UnsignedChar,
    123                 ShortSignedInt,
    124                 ShortUnsignedInt,
    125                 SignedInt,
    126                 UnsignedInt,
    127                 LongSignedInt,
    128                 LongUnsignedInt,
    129                 LongLongSignedInt,
    130                 LongLongUnsignedInt,
    131                 SignedInt128,
    132                 UnsignedInt128,
    133                 uFloat16,
    134                 uFloat16Complex,
    135                 uFloat32,
    136                 uFloat32Complex,
    137                 Float,
    138                 FloatComplex,
    139                 uFloat32x,
    140                 uFloat32xComplex,
    141                 uFloat64,
    142                 uFloat64Complex,
    143                 Double,
    144                 DoubleComplex,
    145                 uFloat64x,
    146                 uFloat64xComplex,
    147                 uuFloat80,
    148                 uFloat128,
    149                 uFloat128Complex,
    150                 uuFloat128,
    151                 LongDouble,
    152                 LongDoubleComplex,
    153                 uFloat128x,
    154                 uFloat128xComplex,
    155                 NUMBER_OF_BASIC_TYPES
    156         } kind;
    157         // GENERATED END
    158 
    159         /// xxx -- MAX_INTEGER_TYPE should probably be in BasicTypes-gen.cc, rather than hardcoded here
    160         enum { MAX_INTEGER_TYPE = UnsignedInt128 };
     117        BasicKind kind;
    161118
    162119        /// string names of basic types; generated to match with Kind
    163120        static const char *typeNames[];
    164121
    165         BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
     122        BasicType( BasicKind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
    166123        : Type(q, std::move(as)), kind(k) {}
    167124
    168125        /// Check if this type represents an integer type
    169         bool isInteger() const { return (unsigned)kind <= (unsigned)MAX_INTEGER_TYPE; }
     126        bool isInteger() const { return kind <= MAX_INTEGER_TYPE; }
    170127
    171128        const Type * accept( Visitor & v ) const override { return v.visit( this ); }

  • src/AST/module.mk

    r60c5b6d r7a780ad  
    1818        AST/Attribute.cpp \
    1919        AST/Attribute.hpp \
     20        AST/BasicKind.hpp \
    2021        AST/Bitfield.hpp \
    2122        AST/Chain.hpp \

  • src/BasicTypes-gen.cc

    r60c5b6d r7a780ad  
    249249                } // for
    250250        } // for
     251        int lastInteger = NUMBER_OF_BASIC_TYPES;
    251252
    252253        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // perform breath-first traversal to generate cost graph
    … …  
    259260                } // for
    260261        } // for
     262
     263        // Find the last integer type.
     264        // Assumes at least 1, and all come before the floating types.
     265        for ( int i = 1 ; i < NUMBER_OF_BASIC_TYPES ; i += 1 ) {
     266                if ( Floating == graph[i].sign ) {
     267                        lastInteger = (i - 1);
     268                        break;
     269                }
     270        }
    261271
    262272        #define STARTMK "// GENERATED START, DO NOT EDIT"
    … …  
    272282        size_t start, end;
    273283
    274         #define TypeH_AST TOP_SRCDIR "src/AST/Type.hpp"
     284        #define TypeH_AST TOP_SRCDIR "src/AST/BasicKind.hpp"
    275285        resetInput( file, TypeH_AST, buffer, code, str );
    276286
    … …  
    279289        code << str.substr( 0, start );
    280290
    281         code << "\t" << BYMK << endl;
    282         code << "\tenum Kind {" << endl;
     291        code << BYMK << endl;
     292        code << "enum BasicKind {" << endl;
    283293        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
    284                 code << "\t\t" << graph[r].name << "," << endl;
    285         } // for
    286         code << "\t\tNUMBER_OF_BASIC_TYPES" << endl;
    287         code << "\t} kind;" << endl;
    288         code << "\t";                                                                           // indentation for end marker
     294                code << "\t" << graph[r].name << "," << endl;
     295        } // for
     296        code << "\tNUMBER_OF_BASIC_TYPES," << endl;
     297        code << "\tMAX_INTEGER_TYPE = " << graph[lastInteger].name << "," << endl;
     298        code << "};" << endl;
    289299
    290300        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
    … …  
    347357
    348358        code << "\t" << BYMK << endl;
    349         code << "\tstatic const int costMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
     359        code << "\tstatic const int costMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
    350360                 << "\t\t/*           ";
    351361        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
    … …  
    372382
    373383        code << "\t" << BYMK << endl;
    374         code << "\tstatic const int signMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
     384        code << "\tstatic const int signMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
    375385                 << "\t\t/*           ";
    376386        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
    … …  
    404414        enum { PER_ROW = 6 };
    405415        code << "\t" << BYMK << endl;
    406         code << "\t#define BT ast::BasicType::" << endl;
     416        code << "\t#define BT ast::BasicKind::" << endl;
    407417        code << "\tstatic const BT Kind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor" << endl
    408418             << "\t\t/*\t\t ";
    … …  
    460470                "//   - \"Ds\" char16_t\n";
    461471
    462         code << "const std::string basicTypes[ast::BasicType::NUMBER_OF_BASIC_TYPES] = {" << endl;
     472        code << "const std::string basicTypes[ast::BasicKind::NUMBER_OF_BASIC_TYPES] = {" << endl;
    463473        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
    464474                code << "\t\"" << graph[r].mangled << "\"," << setw(9 - strlen(graph[r].mangled)) << ' ' << "// " << graph[r].type << endl;

  • src/CodeGen/FixMain.cc

    r60c5b6d r7a780ad  
    5252ast::ObjectDecl * makeIntObj(){
    5353        return new ast::ObjectDecl( CodeLocation(), "",
    54                 new ast::BasicType( ast::BasicType::SignedInt ) );
     54                new ast::BasicType( ast::BasicKind::SignedInt ) );
    5555}
    5656
    … …  
    5959                new ast::PointerType(
    6060                        new ast::PointerType(
    61                                 new ast::BasicType( ast::BasicType::Char ) ) ) );
     61                                new ast::BasicType( ast::BasicKind::Char ) ) ) );
    6262}
    6363

  • src/CodeGen/GenType.cc

    r60c5b6d r7a780ad  
    8787
    8888void GenType::postvisit( ast::BasicType const * type ) {
    89         ast::BasicType::Kind kind = type->kind;
    90         assert( 0 <= kind && kind < ast::BasicType::NUMBER_OF_BASIC_TYPES );
     89        ast::BasicKind kind = type->kind;
     90        assert( 0 <= kind && kind < ast::BasicKind::NUMBER_OF_BASIC_TYPES );
    9191        result = std::string( ast::BasicType::typeNames[kind] ) + " " + result;
    9292        handleQualifiers( type );

  • src/Common/ResolvProtoDump.cpp

    r60c5b6d r7a780ad  
    229229        void previsit( const ast::EnumInstType * ) {
    230230                // TODO: Add the meaningful text representation of typed enum
    231                 ss << (int)ast::BasicType::SignedInt;
     231                ss << (int)ast::BasicKind::SignedInt;
    232232        }
    233233
    … …  
    255255        // TODO: Support 0 and 1 with their type names and conversions.
    256256        void previsit( const ast::ZeroType * ) {
    257                 ss << (int)ast::BasicType::SignedInt;
     257                ss << (int)ast::BasicKind::SignedInt;
    258258        }
    259259
    260260        void previsit( const ast::OneType * ) {
    261                 ss << (int)ast::BasicType::SignedInt;
     261                ss << (int)ast::BasicKind::SignedInt;
    262262        }
    263263
    … …  
    366366        // TODO: Extra expression to resolve argument.
    367367        void previsit( const ast::SizeofExpr * ) {
    368                 ss << (int)ast::BasicType::LongUnsignedInt;
     368                ss << (int)ast::BasicKind::LongUnsignedInt;
    369369                visit_children = false;
    370370        }
    371371        void previsit( const ast::AlignofExpr * ) {
    372                 ss << (int)ast::BasicType::LongUnsignedInt;
     372                ss << (int)ast::BasicKind::LongUnsignedInt;
    373373                visit_children = false;
    374374        }
    375375        void previsit( const ast::UntypedOffsetofExpr * ) {
    376                 ss << (int)ast::BasicType::LongUnsignedInt;
     376                ss << (int)ast::BasicKind::LongUnsignedInt;
    377377                visit_children = false;
    378378        }
    … …  
    753753                // &? Address of operator.
    754754                out << "#$ptr<T> $addr T" << std::endl;
    755                 const int intId = (int)ast::BasicType::SignedInt;
     755                const int intId = (int)ast::BasicKind::SignedInt;
    756756                // ?&&? ?||? ?: Logical operators.
    757757                out << intId << " $and " << intId << ' ' << intId << std::endl;

  • src/Concurrency/Corun.cpp

    r60c5b6d r7a780ad  
    130130                new ObjectDecl( loc,
    131131                    numProcsName,
    132                     new BasicType( BasicType::Kind::UnsignedInt ),
     132                    new BasicType( BasicKind::UnsignedInt ),
    133133                    new SingleInit( loc,
    134134                        new UntypedExpr( loc,
    … …  
    146146                new ObjectDecl( loc,
    147147                    currProcsName,
    148                     new BasicType( BasicType::Kind::UnsignedInt ),
     148                    new BasicType( BasicKind::UnsignedInt ),
    149149                    new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    150150                )

  • src/Concurrency/Waitfor.cpp

    r60c5b6d r7a780ad  
    244244        ast::ObjectDecl * flag = new ast::ObjectDecl( location,
    245245                namer_flg.newName(),
    246                 new ast::BasicType( ast::BasicType::Bool ),
     246                new ast::BasicType( ast::BasicKind::Bool ),
    247247                new ast::SingleInit( location,
    248248                        ast::ConstantExpr::from_ulong( location, 0 )
    … …  
    349349        ast::ObjectDecl * timeout = new ast::ObjectDecl( topLocation,
    350350                namer_tim.newName(),
    351                 new ast::BasicType( ast::BasicType::LongLongUnsignedInt ),
     351                new ast::BasicType( ast::BasicKind::LongLongUnsignedInt ),
    352352                new ast::SingleInit( topLocation,
    353353                        ast::ConstantExpr::from_int( topLocation, -1 )
    … …  
    397397        ast::ObjectDecl * index = new ast::ObjectDecl( location,
    398398                namer_idx.newName(),
    399                 new ast::BasicType( ast::BasicType::ShortSignedInt ),
     399                new ast::BasicType( ast::BasicKind::ShortSignedInt ),
    400400                new ast::SingleInit( location,
    401401                        ast::ConstantExpr::from_int( location, -1 )

  • src/Concurrency/Waituntil.cpp

    r60c5b6d r7a780ad  
    498498            rightExpr = genPredExpr( loc, currNode->right, idx, genLeaf );
    499499            return new LogicalExpr( loc,
    500                 new CastExpr( loc, leftExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
    501                 new CastExpr( loc, rightExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
     500                new CastExpr( loc, leftExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
     501                new CastExpr( loc, rightExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
    502502                LogicalFlag::AndExpr
    503503            );
    … …  
    507507            rightExpr = genPredExpr( loc, currNode->right, idx, genLeaf );
    508508            return new LogicalExpr( loc,
    509                 new CastExpr( loc, leftExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
    510                 new CastExpr( loc, rightExpr, new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast ),
     509                new CastExpr( loc, leftExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
     510                new CastExpr( loc, rightExpr, new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast ),
    511511                LogicalFlag::OrExpr );
    512512            break;
    … …  
    556556            new ObjectDecl( loc,
    557557                "clause_statuses",
    558                 new PointerType( new BasicType( BasicType::Kind::LongUnsignedInt ) )
     558                new PointerType( new BasicType( BasicKind::LongUnsignedInt ) )
    559559            )
    560560        },
    … …  
    562562            new ObjectDecl( loc,
    563563                "sat_ret",
    564                 new BasicType( BasicType::Kind::Bool )
     564                new BasicType( BasicKind::Bool )
    565565            )
    566566        },
    … …  
    766766                new ObjectDecl( loc,
    767767                    idxName,
    768                     new BasicType( BasicType::Kind::SignedInt ),
     768                    new BasicType( BasicKind::SignedInt ),
    769769                    new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    770770                )
    … …  
    893893                    new ObjectDecl( cLoc,
    894894                        currClause->whenName,
    895                         new BasicType( BasicType::Kind::Bool ),
     895                        new BasicType( BasicKind::Bool ),
    896896                        new SingleInit( cLoc, ast::deepCopy( stmt->clauses.at(i)->when_cond ) )
    897897                    )
    … …  
    915915                new ObjectDecl( stmt->else_cond->location,
    916916                    elseWhenName,
    917                     new BasicType( BasicType::Kind::Bool ),
     917                    new BasicType( BasicKind::Bool ),
    918918                    new SingleInit( stmt->else_cond->location, ast::deepCopy( stmt->else_cond ) )
    919919                )
    … …  
    945945                    new CastExpr( cLoc,
    946946                        new AddressExpr( cLoc, new NameExpr( cLoc, data.at(i)->nodeName ) ),
    947                         new BasicType( BasicType::Kind::LongUnsignedInt ), GeneratedFlag::ExplicitCast
     947                        new BasicType( BasicKind::LongUnsignedInt ), GeneratedFlag::ExplicitCast
    948948                    )
    949949                }
    … …  
    986986                    new CastExpr( cLoc,
    987987                        new NameExpr( cLoc, elseWhenName ),
    988                         new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     988                        new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    989989                    ),
    990990                    new CastExpr( cLoc,
    991991                        raceFnCall,
    992                         new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     992                        new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    993993                    ),
    994994                    LogicalFlag::AndExpr
    … …  
    10161016            new CastExpr( cLoc,
    10171017                new NameExpr( cLoc, data.at(idx)->whenName ),
    1018                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1018                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    10191019            ),
    10201020            new CastExpr( cLoc,
    10211021                baseCond,
    1022                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1022                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    10231023            ),
    10241024            LogicalFlag::AndExpr
    … …  
    10341034                        new NameExpr( cLoc, data.at(idx)->nodeName ),
    10351035                        new AddressExpr( cLoc, new NameExpr( cLoc, data.at(idx)->statusName ) ),
    1036                         ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicType::Kind::SignedInt ) ) )
     1036                        ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicKind::SignedInt ) ) )
    10371037                    }
    10381038                )
    … …  
    10961096        new ObjectDecl( loc,
    10971097            statusName,
    1098             new BasicType( BasicType::Kind::LongUnsignedInt ),
     1098            new BasicType( BasicKind::LongUnsignedInt ),
    10991099            new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    11001100        )
    … …  
    11141114            new NameExpr( cLoc, "?!=?" ),
    11151115            {
    1116                 ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicType::Kind::LongUnsignedInt ) ) ),
     1116                ConstantExpr::null( cLoc, new PointerType( new BasicType( BasicKind::LongUnsignedInt ) ) ),
    11171117                new UntypedExpr( cLoc,
    11181118                    new NameExpr( cLoc, "__get_clause_status" ),
    … …  
    11281128                new CastExpr( cLoc,
    11291129                    new NameExpr( cLoc, clauseData.at(i)->whenName ),
    1130                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1130                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11311131                ),
    11321132                new CastExpr( cLoc,
    11331133                    statusPtrCheck,
    1134                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1134                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11351135                ),
    11361136                LogicalFlag::AndExpr
    … …  
    11621162                new CastExpr( loc,
    11631163                    new NameExpr( loc, clauseData.at( whenIndices.at(i) )->whenName ),
    1164                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1164                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11651165                ),
    11661166                new CastExpr( loc,
    11671167                    lastExpr,
    1168                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1168                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    11691169                ),
    11701170                LogicalFlag::OrExpr
    … …  
    12201220        new ObjectDecl( loc,
    12211221            pCountName,
    1222             new BasicType( BasicType::Kind::SignedInt ),
     1222            new BasicType( BasicKind::SignedInt ),
    12231223            new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
    12241224        )
    … …  
    12291229        new ObjectDecl( loc,
    12301230            statusArrName,
    1231             new ArrayType( new BasicType( BasicType::Kind::LongUnsignedInt ), ConstantExpr::from_int( loc, numClauses ), LengthFlag::FixedLen, DimensionFlag::DynamicDim ),
     1231            new ArrayType( new BasicType( BasicKind::LongUnsignedInt ), ConstantExpr::from_int( loc, numClauses ), LengthFlag::FixedLen, DimensionFlag::DynamicDim ),
    12321232            new ListInit( loc,
    12331233                {
    … …  
    13311331            new CastExpr( cLoc,
    13321332                statusExpr,
    1333                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1333                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13341334            ),
    13351335            new CastExpr( cLoc,
    13361336                genSelectTraitCall( stmt->clauses.at(i), clauseData.at(i), "unregister_select" ),
    1337                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1337                new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13381338            ),
    13391339            LogicalFlag::AndExpr
    … …  
    13461346                new CastExpr( cLoc,
    13471347                    new NameExpr( cLoc, clauseData.at(i)->whenName ),
    1348                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1348                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13491349                ),
    13501350                new CastExpr( cLoc,
    13511351                    statusExpr,
    1352                     new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast
     1352                    new BasicType( BasicKind::Bool ), GeneratedFlag::ExplicitCast
    13531353                ),
    13541354                LogicalFlag::AndExpr

  • src/ControlStruct/ExceptDecl.cpp

    r60c5b6d r7a780ad  
    9999                createExceptionInstType( exceptionName, params ) ) );
    100100        type->returns.push_back( new ast::PointerType(
    101                 new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) ) );
     101                new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) ) );
    102102        return type;
    103103}
    … …  
    344344                                "",
    345345                                new ast::PointerType(
    346                                         new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) )
     346                                        new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) )
    347347                        ),
    348348                },

  • src/ControlStruct/ExceptTranslate.cpp

    r60c5b6d r7a780ad  
    182182                location,
    183183                "__handler_index",
    184                 new ast::BasicType( ast::BasicType::SignedInt )
     184                new ast::BasicType( ast::BasicKind::SignedInt )
    185185                );
    186186}
    … …  
    201201                location,
    202202                "__ret_bool",
    203                 new ast::BasicType( ast::BasicType::Bool ),
     203                new ast::BasicType( ast::BasicKind::Bool ),
    204204                nullptr, //init
    205205                ast::Storage::Classes{},
    … …  
    231231                location,
    232232                "__handler_index",
    233                 new ast::BasicType(ast::BasicType::SignedInt),
     233                new ast::BasicType( ast::BasicKind::SignedInt ),
    234234                nullptr,
    235235                ast::Storage::Classes{},

  • src/GenPoly/Box.cpp

    r60c5b6d r7a780ad  
    4343/// The layout type is used to represent sizes, alignments and offsets.
    4444ast::BasicType * makeLayoutType() {
    45         return new ast::BasicType( ast::BasicType::LongUnsignedInt );
     45        return new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    4646}
    4747
    4848/// Fixed version of layout type (just adding a 'C' in C++ style).
    4949ast::BasicType * makeLayoutCType() {
    50         return new ast::BasicType( ast::BasicType::LongUnsignedInt,
     50        return new ast::BasicType( ast::BasicKind::LongUnsignedInt,
    5151                ast::CV::Qualifiers( ast::CV::Const ) );
    5252}
    … …  
    16171617ast::Type * polyToMonoType( CodeLocation const & location,
    16181618                ast::Type const * declType ) {
    1619         auto charType = new ast::BasicType( ast::BasicType::Char );
     1619        auto charType = new ast::BasicType( ast::BasicKind::Char );
    16201620        auto size = new ast::NameExpr( location,
    16211621                sizeofName( Mangle::mangleType( declType ) ) );

  • src/InitTweak/FixInit.cpp

    r60c5b6d r7a780ad  
    847847
    848848                        // static bool __objName_uninitialized = true
    849                         auto boolType = new ast::BasicType( ast::BasicType::Kind::Bool );
     849                        auto boolType = new ast::BasicType( ast::BasicKind::Bool );
    850850                        auto boolInitExpr = new ast::SingleInit(loc, ast::ConstantExpr::from_int(loc, 1 ) );
    851851                        auto isUninitializedVar = new ast::ObjectDecl(loc, objDecl->mangleName + "_uninitialized", boolType, boolInitExpr, ast::Storage::Static, ast::Linkage::Cforall);

  • src/Makefile.am

    r60c5b6d r7a780ad  
    5353include Virtual/module.mk
    5454
    55 $(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/Type.hpp
     55$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/BasicKind.hpp
    5656
    57 $(srcdir)/AST/Type.hpp : BasicTypes-gen.cc
     57$(srcdir)/AST/BasicKind.hpp : BasicTypes-gen.cc
    5858        ${AM_V_GEN}${CXXCOMPILE} $< -o BasicTypes-gen -Wall -Wextra -Werror=return-type
    5959        @./BasicTypes-gen

  • src/Parser/ExpressionNode.cc

    r60c5b6d r7a780ad  
    2323#include <string>                  // for string, operator+, operator==
    2424
     25#include "AST/BasicKind.hpp"       // for BasicKind
    2526#include "AST/Expr.hpp"            // for NameExpr
    26 #include "AST/Type.hpp"            // for BaseType, SueInstType
     27#include "AST/Type.hpp"            // for Type, LengthFlag, DimentionFlag
    2728#include "Common/SemanticError.h"  // for SemanticError
    2829#include "Common/utility.h"        // for maybeMoveBuild, maybeBuild, CodeLo...
    … …  
    126127ast::Expr * build_constantInteger(
    127128                const CodeLocation & location, string & str ) {
    128         static const ast::BasicType::Kind kind[2][6] = {
     129        static const ast::BasicKind kind[2][6] = {
    129130                // short (h) must be before char (hh) because shorter type has the longer suffix
    130                 { ast::BasicType::ShortSignedInt, ast::BasicType::SignedChar, ast::BasicType::SignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ ast::BasicType::LongLongSignedInt, },
    131                 { ast::BasicType::ShortUnsignedInt, ast::BasicType::UnsignedChar, ast::BasicType::UnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ ast::BasicType::LongLongUnsignedInt, },
     131                { ast::BasicKind::ShortSignedInt, ast::BasicKind::SignedChar, ast::BasicKind::SignedInt, ast::BasicKind::LongSignedInt, ast::BasicKind::LongLongSignedInt, /* BasicKind::SignedInt128 */ ast::BasicKind::LongLongSignedInt, },
     132                { ast::BasicKind::ShortUnsignedInt, ast::BasicKind::UnsignedChar, ast::BasicKind::UnsignedInt, ast::BasicKind::LongUnsignedInt, ast::BasicKind::LongLongUnsignedInt, /* BasicKind::UnsignedInt128 */ ast::BasicKind::LongLongUnsignedInt, },
    132133        };
    133134
    … …  
    313314                if ( ltype == 6 ) {                                                             // int128, (int128)constant
    314315                        ret2 = new ast::ConstantExpr( location,
    315                                 new ast::BasicType( ast::BasicType::LongLongSignedInt ),
     316                                new ast::BasicType( ast::BasicKind::LongLongSignedInt ),
    316317                                str2,
    317318                                v2 );
    … …  
    379380ast::Expr * build_constantFloat(
    380381                const CodeLocation & location, string & str ) {
    381         static const ast::BasicType::Kind kind[2][12] = {
    382                 { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x },
    383                 { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex },
     382        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 },
    384385        };
    385386
    … …  
    447448
    448449        ast::Expr * ret = new ast::ConstantExpr( location,
    449                 new ast::BasicType( ast::BasicType::Char ),
     450                new ast::BasicType( ast::BasicKind::Char ),
    450451                str,
    451452                (unsigned long long int)(unsigned char)str[1] );
    … …  
    482483        Default:                                                                                        // char default string type
    483484        default:
    484                 strtype = new ast::BasicType( ast::BasicType::Char );
     485                strtype = new ast::BasicType( ast::BasicKind::Char );
    485486        } // switch
    486487        ast::ArrayType * at = new ast::ArrayType(
    … …  
    664665                member->name
    665666        );
    666         ret->result = new ast::BasicType( ast::BasicType::LongUnsignedInt );
     667        ret->result = new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    667668        delete member;
    668669        return ret;

  • src/Parser/TypeData.cc

    r60c5b6d r7a780ad  
    1919#include <ostream>                 // for operator<<, ostream, basic_ostream
    2020
     21#include "AST/Attribute.hpp"       // for Attribute
    2122#include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
    22 #include "AST/Attribute.hpp"       // for Attribute
    2323#include "AST/Init.hpp"            // for SingleInit, ListInit
    2424#include "AST/Print.hpp"           // for print
     25#include "AST/Type.hpp"            // for Type
    2526#include "Common/SemanticError.h"  // for SemanticError
    2627#include "Common/utility.h"        // for splice, spliceBegin
    … …  
    10101011                // fill in implicit int
    10111012                return new ast::BasicType(
    1012                         ast::BasicType::SignedInt,
     1013                        ast::BasicKind::SignedInt,
    10131014                        buildQualifiers( td )
    10141015                );
    … …  
    10951096
    10961097ast::Type * buildBasicType( const TypeData * td ) {
    1097         ast::BasicType::Kind ret;
     1098        ast::BasicKind ret;
    10981099
    10991100        switch ( td->basictype ) {
    … …  
    11161117                } // if
    11171118
    1118                 ret = ast::BasicType::Bool;
     1119                ret = ast::BasicKind::Bool;
    11191120                break;
    11201121
    … …  
    11231124                // character types. The implementation shall define char to have the same range, representation, and behavior as
    11241125                // either signed char or unsigned char.
    1125                 static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
     1126                static ast::BasicKind chartype[] = { ast::BasicKind::SignedChar, ast::BasicKind::UnsignedChar, ast::BasicKind::Char };
    11261127
    11271128                if ( td->length != TypeData::NoLength ) {
    … …  
    11331134
    11341135        case TypeData::Int:
    1135                 static ast::BasicType::Kind inttype[2][4] = {
    1136                         { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
    1137                         { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
     1136                static ast::BasicKind inttype[2][4] = {
     1137                        { ast::BasicKind::ShortSignedInt, ast::BasicKind::LongSignedInt, ast::BasicKind::LongLongSignedInt, ast::BasicKind::SignedInt },
     1138                        { ast::BasicKind::ShortUnsignedInt, ast::BasicKind::LongUnsignedInt, ast::BasicKind::LongLongUnsignedInt, ast::BasicKind::UnsignedInt },
    11381139                };
    11391140
    … …  
    11461147
    11471148        case TypeData::Int128:
    1148                 ret = td->signedness == TypeData::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
     1149                ret = td->signedness == TypeData::Unsigned ? ast::BasicKind::UnsignedInt128 : ast::BasicKind::SignedInt128;
    11491150                if ( td->length != TypeData::NoLength ) {
    11501151                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
    … …  
    11641165        case TypeData::uFloat128:
    11651166        case TypeData::uFloat128x:
    1166                 static ast::BasicType::Kind floattype[2][12] = {
    1167                         { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
    1168                         { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x, },
     1167                static ast::BasicKind floattype[2][12] = {
     1168                        { 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, },
     1169                        { 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, },
    11691170                };
    11701171
    … …  
    12131214
    12141215static ast::Type * buildDefaultType( const TypeData * td ) {
    1215         return ( td ) ? typebuild( td ) : new ast::BasicType( ast::BasicType::SignedInt );
     1216        return ( td ) ? typebuild( td ) : new ast::BasicType( ast::BasicKind::SignedInt );
    12161217} // buildDefaultType
    12171218
    … …  
    15791580                        td->location,
    15801581                        "",
    1581                         new ast::BasicType( ast::BasicType::SignedInt ),
     1582                        new ast::BasicType( ast::BasicKind::SignedInt ),
    15821583                        (ast::Init *)nullptr,
    15831584                        ast::Storage::Classes(),
    … …  
    16671668        } else {
    16681669                ft->returns.push_back(
    1669                         new ast::BasicType( ast::BasicType::SignedInt ) );
     1670                        new ast::BasicType( ast::BasicKind::SignedInt ) );
    16701671        } // if
    16711672        return ft;

  • src/Parser/TypeData.h

    r60c5b6d r7a780ad  
    2020#include <string>                                   // for string
    2121
    22 #include "AST/Type.hpp"                             // for Type
     22#include "AST/CVQualifiers.hpp"                     // for CV
     23#include "AST/Fwd.hpp"                              // for Type
    2324#include "DeclarationNode.h"                        // for DeclarationNode
    2425

  • src/Parser/parser.yy

    r60c5b6d r7a780ad  
    5555#include "TypedefTable.h"
    5656#include "TypeData.h"
     57#include "AST/Type.hpp"                                 // for BasicType, BasicKind
    5758#include "Common/SemanticError.h"                                               // error_str
    5859#include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
    … …  
    260261        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
    261262        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
    262                 type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicType::SignedInt ) ) );
     263                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::BasicKind::SignedInt ) ) );
    263264        } // if
    264265        DeclarationNode * initDecl = distAttr(

  • src/ResolvExpr/CandidateFinder.cpp

    r60c5b6d r7a780ad  
    21762176                        }
    21772177                ),
    2178                 new ast::BasicType( ast::BasicType::SignedInt )
     2178                new ast::BasicType( ast::BasicKind::SignedInt )
    21792179        );
    21802180}

  • src/ResolvExpr/CommonType.cc

    r60c5b6d r7a780ad  
    3838        // GENERATED START, DO NOT EDIT
    3939        // GENERATED BY BasicTypes-gen.cc
    40         #define BT ast::BasicType::
    41         static const BT Kind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
     40        #define BT ast::BasicKind::
     41        static const ast::BasicKind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
    4242                /*                                      B                       C                      SC                      UC                      SI                     SUI
    4343                                                        I                      UI                      LI                     LUI                     LLI                    LLUI
    … …  
    339339        // GENERATED END
    340340        static_assert(
    341                 sizeof(commonTypes)/sizeof(commonTypes[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
     341                sizeof(commonTypes)/sizeof(commonTypes[0][0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES * ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    342342                "Each basic type kind should have a corresponding row in the combined type matrix"
    343343        );
    … …  
    366366        void postvisit( const ast::BasicType * basic ) {
    367367                if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
    368                         ast::BasicType::Kind kind;
     368                        ast::BasicKind kind;
    369369                        if (basic->kind != basic2->kind && !widen.first && !widen.second) return;
    370370                        else if (!widen.first) kind = basic->kind; // widen.second
    … …  
    386386                        const ast::EnumDecl* enumDecl = enumInst->base;
    387387                        if ( !enumDecl->base ) {
    388                                 ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
     388                                ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
    389389                                if (
    390390                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
    … …  
    398398                } else if ( auto type2AsAttr = dynamic_cast< const ast::EnumAttrType * >( type2 ) ) {
    399399            if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
    400                             ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
     400                            ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
    401401                            if (
    402402                                    ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
    … …  
    649649        void postvisit( const ast::EnumInstType * enumInst ) {
    650650                if ( enumInst->base && !enumInst->base->base ) {
    651                         auto basicType = new ast::BasicType( ast::BasicType::UnsignedInt );
     651                        auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );
    652652                        result = commonType( basicType, type2, tenv, need, have, open, widen);
    653653                }
    … …  
    674674                } else if ( widen.second && dynamic_cast< const ast::OneType * >( type2 ) ) {
    675675                        result = new ast::BasicType{
    676                                 ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers };
     676                                ast::BasicKind::SignedInt, zero->qualifiers | type2->qualifiers };
    677677                } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
    678678                        const ast::EnumDecl * enumDecl = enumInst->base;
    … …  
    695695                } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) {
    696696                        result = new ast::BasicType{
    697                                 ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers };
     697                                ast::BasicKind::SignedInt, one->qualifiers | type2->qualifiers };
    698698                } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
    699699                        const ast::EnumDecl * enumDecl = enumInst->base;

  • src/ResolvExpr/ConversionCost.cc

    r60c5b6d r7a780ad  
    5959        // GENERATED START, DO NOT EDIT
    6060        // GENERATED BY BasicTypes-gen.cc
    61         static const int costMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
     61        static const int costMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
    6262                /*               B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
    6363                /*      B */ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  16,  18,  17, },
    … …  
    101101        // GENERATED END
    102102        static_assert(
    103                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
     103                sizeof(costMatrix)/sizeof(costMatrix[0][0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES * ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    104104                "Missing row in the cost matrix"
    105105        );
    … …  
    107107        // GENERATED START, DO NOT EDIT
    108108        // GENERATED BY BasicTypes-gen.cc
    109         static const int signMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
     109        static const int signMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
    110110                /*               B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
    111111                /*      B */ {   0,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    … …  
    148148        // GENERATED END
    149149        static_assert(
    150                 sizeof(signMatrix)/sizeof(signMatrix[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
     150                sizeof(signMatrix)/sizeof(signMatrix[0][0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES * ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    151151                "Missing row in the sign matrix"
    152152        );
    … …  
    279279                conversionCostFromBasicToBasic( basicType, dstAsBasic );
    280280        } else if ( dynamic_cast< const ast::EnumAttrType *>(dst) ) {
    281                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
     281                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
    282282                cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
    283283        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
    … …  
    383383                }
    384384                return;
    385         } 
    386         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
     385        }
     386        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
    387387        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
    388388        if ( cost < Cost::unsafe ) {
    … …  
    396396        if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Label ) {
    397397            cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
    398         } 
     398        }
    399399        // Add Conversion To String
    400400    } else if ( src->attr == ast::EnumAttribute::Value ) {
    … …  
    413413                    if ( cost < Cost::unsafe ) cost.incSafe();
    414414            } else {
    415                     static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
     415                    static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
    416416                    cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
    417417                    if ( cost < Cost::unsafe ) {
    … …  
    478478        } else if ( const ast::BasicType * dstAsBasic =
    479479                        dynamic_cast< const ast::BasicType * >( dst ) ) {
    480                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
     480                int tableResult = costMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ];
    481481                if ( -1 == tableResult ) {
    482482                        cost = Cost::unsafe;
    … …  
    484484                        cost = Cost::zero;
    485485                        cost.incSafe( tableResult + 1 );
    486                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
     486                        cost.incSign( signMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ] );
    487487                }
    488488                // this has the effect of letting any expr such as x+0, x+1 to be typed
    … …  
    510510        } else if ( const ast::BasicType * dstAsBasic =
    511511                        dynamic_cast< const ast::BasicType * >( dst ) ) {
    512                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
     512                int tableResult = costMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ];
    513513                if ( -1 == tableResult ) {
    514514                        cost = Cost::unsafe;
    … …  
    516516                        cost = Cost::zero;
    517517                        cost.incSafe( tableResult + 1 );
    518                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
     518                        cost.incSign( signMatrix[ ast::BasicKind::SignedInt ][ dstAsBasic->kind ] );
    519519                }
    520520        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {

  • src/ResolvExpr/PtrsCastable.cc

    r60c5b6d r7a780ad  
    100100                                result = 1;
    101101                        } else if ( auto bt = dynamic_cast< const ast::BasicType * >( dst ) ) {
    102                                 if ( bt->kind == ast::BasicType::SignedInt ) {
     102                                if ( bt->kind == ast::BasicKind::SignedInt ) {
    103103                                        result = 0;
    104104                                } else {

  • src/ResolvExpr/ResolveTypeof.cc

    r60c5b6d r7a780ad  
    6363                        if ( newType.as< ast::EnumInstType >() ) {
    6464                                newType = new ast::BasicType(
    65                                         ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) );
     65                                        ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
    6666                        }
    6767                        reset_qualifiers(
    … …  
    9191                auto mutType = mutate(arrayType);
    9292                auto globalSizeType = context.global.sizeType;
    93                 ast::ptr<ast::Type> sizetype = globalSizeType ? globalSizeType : new ast::BasicType(ast::BasicType::LongUnsignedInt);
     93                ast::ptr<ast::Type> sizetype = globalSizeType ? globalSizeType : new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    9494                mutType->dimension = findSingleExpression(arrayType->dimension, sizetype, context );
    9595

  • src/ResolvExpr/Resolver.cc

    r60c5b6d r7a780ad  
    351351        bool isCharType( const ast::Type * t ) {
    352352                if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
    353                         return bt->kind == ast::BasicType::Char
    354                                 || bt->kind == ast::BasicType::SignedChar
    355                                 || bt->kind == ast::BasicType::UnsignedChar;
     353                        return bt->kind == ast::BasicKind::Char
     354                                || bt->kind == ast::BasicKind::SignedChar
     355                                || bt->kind == ast::BasicKind::UnsignedChar;
    356356                }
    357357                return false;
    … …  
    458458                        if (attr->params.size() == 1) {
    459459                                auto arg = attr->params.front();
    460                                 auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicType::LongLongSignedInt ), context );
     460                                auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicKind::LongLongSignedInt ), context );
    461461                                auto result = eval(arg);
    462462
    … …  
    624624                        objectDecl = fixObjectType( objectDecl, context );
    625625                        currentObject = ast::CurrentObject{
    626                                 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
     626                                objectDecl->location, new ast::BasicType{ ast::BasicKind::SignedInt } };
    627627                }
    628628        } else {
    … …  
    10951095                // resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
    10961096                ast::ptr< ast::Type > target =
    1097                         new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
     1097                        new ast::BasicType{ ast::BasicKind::LongLongUnsignedInt };
    10981098                auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
    10991099                auto timeout_cond = findCondExpression( stmt->timeout_cond, context );

  • src/SymTab/GenImplicitCall.cpp

    r60c5b6d r7a780ad  
    133133
    134134        ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl(
    135                 loc, indexName.newName(), new ast::BasicType( ast::BasicType::SignedInt ),
     135                loc, indexName.newName(), new ast::BasicType( ast::BasicKind::SignedInt ),
    136136                new ast::SingleInit( loc, begin ) );
    137137        ast::ptr< ast::Expr > indexVar = new ast::VariableExpr( loc, index );

  • src/SymTab/Mangler.cc

    r60c5b6d r7a780ad  
    142142void Mangler::postvisit( const ast::BasicType * basicType ) {
    143143        printQualifiers( basicType );
    144         assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
     144        assertf( basicType->kind < ast::BasicKind::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
    145145        mangleName += Encoding::basicTypes[ basicType->kind ];
    146146}

  • src/SymTab/ManglerCommon.cc

    r60c5b6d r7a780ad  
    4141//   - "Di" char32_t
    4242//   - "Ds" char16_t
    43 const std::string basicTypes[ast::BasicType::NUMBER_OF_BASIC_TYPES] = {
     43const std::string basicTypes[ast::BasicKind::NUMBER_OF_BASIC_TYPES] = {
    4444        "b",        // _Bool
    4545        "c",        // char
    … …  
    8181// GENERATED END
    8282static_assert(
    83         sizeof(basicTypes) / sizeof(basicTypes[0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES,
     83        sizeof(basicTypes) / sizeof(basicTypes[0]) == ast::BasicKind::NUMBER_OF_BASIC_TYPES,
    8484        "Each basic type kind should have a corresponding mangler letter"
    8585);

  • src/Tuples/TupleExpansion.cpp

    r60c5b6d r7a780ad  
    106106                        assignUnq = commaExpr->arg1;
    107107                }
    108                 auto finished = new ast::ObjectDecl( loc, toString( "_unq", id, "_finished_" ), new ast::BasicType( ast::BasicType::Kind::Bool ),
     108                auto finished = new ast::ObjectDecl( loc, toString( "_unq", id, "_finished_" ), new ast::BasicType( ast::BasicKind::Bool ),
    109109                        new ast::SingleInit( loc, ast::ConstantExpr::from_int( loc, 0 ) ), {}, ast::Linkage::Cforall );
    110110                declsToAddBefore.push_back( finished );
    … …  
    175175                        new ast::ObjectDecl( location,
    176176                                "dummy",
    177                                 new ast::BasicType( ast::BasicType::SignedInt ),
     177                                new ast::BasicType( ast::BasicKind::SignedInt ),
    178178                                nullptr,
    179179                                ast::Storage::Classes(),

  • src/Validate/GenericParameter.cpp

    r60c5b6d r7a780ad  
    289289                return new ast::TypeExpr( expr->location,
    290290                        new ast::ArrayType(
    291                                 new ast::BasicType( ast::BasicType::Char ),
     291                                new ast::BasicType( ast::BasicKind::Char ),
    292292                                expr,
    293293                                ast::VariableLen,

  • src/Validate/ImplementEnumFunc.cpp

    r60c5b6d r7a780ad  
    311311        {new ast::ObjectDecl(
    312312            getLocation(), "_ret",
    313             new ast::PointerType(new ast::BasicType{ast::BasicType::Char}))});
     313            new ast::PointerType(new ast::BasicType{ast::BasicKind::Char}))});
    314314}
    315315
    … …  
    364364        attr == ast::EnumAttribute::Value
    365365            ? decl->base
    366             : new ast::PointerType(new ast::BasicType{ast::BasicType::Char}),
     366            : new ast::PointerType(new ast::BasicType{ast::BasicKind::Char}),
    367367        ast::ConstantExpr::from_int(decl->location, decl->members.size()),
    368368        ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim);

  • src/Validate/ReplaceTypedef.cpp

    r60c5b6d r7a780ad  
    349349                // Perhaps this should be a warning instead.
    350350                translationUnit.global.sizeType =
    351                         new ast::BasicType( ast::BasicType::LongUnsignedInt );
     351                        new ast::BasicType( ast::BasicKind::LongUnsignedInt );
    352352        }
    353353}
Note: See TracChangeset for help on using the changeset viewer.