Changeset 7a780ad for src/AST

Timestamp:

Apr 18, 2024, 5:19:17 PM (3 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/AST

Files:

• BasicKind.hpp (added)
• Expr.cpp (modified) (4 diffs)
• Pass.impl.hpp (modified) (1 diff)
• Type.hpp (modified) (2 diffs)
• module.mk (modified) (1 diff)

src/AST/Expr.cpp

@@ -246 +246 @@
 ConstantExpr * ConstantExpr::from_bool( const CodeLocation & loc, bool b ) {
         return new ConstantExpr{
-                loc, new BasicType{ BasicType::Bool }, b ? "1" : "0", (unsigned long long)b };
+                loc, new BasicType{ BasicKind::Bool }, b ? "1" : "0", (unsigned long long)b };
 }
 
 ConstantExpr * ConstantExpr::from_int( const CodeLocation & loc, int i ) {
         return new ConstantExpr{
-                loc, new BasicType{ BasicType::SignedInt }, std::to_string( i ), (unsigned long long)i };
+                loc, new BasicType{ BasicKind::SignedInt }, std::to_string( i ), (unsigned long long)i };
 }
 
 ConstantExpr * ConstantExpr::from_ulong( const CodeLocation & loc, unsigned long i ) {
         return new ConstantExpr{
-                loc, new BasicType{ BasicType::LongUnsignedInt }, std::to_string( i ),
+                loc, new BasicType{ BasicKind::LongUnsignedInt }, std::to_string( i ),
                 (unsigned long long)i };
 }
 
 ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & str ) {
-        const Type * charType = new BasicType( BasicType::Char );
+        const Type * charType = new BasicType( BasicKind::Char );
         // Adjust the length of the string for the terminator.
         const Expr * strSize = from_ulong( loc, str.size() + 1 );
@@ -277 +277 @@
 
 SizeofExpr::SizeofExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
 
 SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
 
 // --- AlignofExpr
 
 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
 
 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
 
 // --- OffsetofExpr
 
 OffsetofExpr::OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), type( ty ), member( mem ) {
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( ty ), member( mem ) {
         assert( type );
         assert( member );
@@ -302 +302 @@
 OffsetPackExpr::OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty )
 : Expr( loc, new ArrayType{
-        new BasicType{ BasicType::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
+        new BasicType{ BasicKind::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
 ), type( ty ) {
         assert( type );
@@ -311 +311 @@
 LogicalExpr::LogicalExpr(
         const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia )
-: Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
+: Expr( loc, new BasicType{ BasicKind::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
 
 // --- CommaExpr

src/AST/Pass.impl.hpp

@@ -477 +477 @@
                                 CodeLocation{}, "__func__",
                                 new ast::ArrayType{
-                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
+                                        new ast::BasicType{ ast::BasicKind::Char, ast::CV::Const },
                                         nullptr, VariableLen, DynamicDim
                                 },

src/AST/Type.hpp

@@ -22 +22 @@
 #include <vector>
 
+#include "BasicKind.hpp"     // for BasicKind
 #include "CVQualifiers.hpp"
 #include "Decl.hpp"          // for AggregateDecl subclasses
@@ -114 +115 @@
 class BasicType final : public Type {
 public:
-        // GENERATED START, DO NOT EDIT
-        // GENERATED BY BasicTypes-gen.cc
-        enum Kind {
-                Bool,
-                Char,
-                SignedChar,
-                UnsignedChar,
-                ShortSignedInt,
-                ShortUnsignedInt,
-                SignedInt,
-                UnsignedInt,
-                LongSignedInt,
-                LongUnsignedInt,
-                LongLongSignedInt,
-                LongLongUnsignedInt,
-                SignedInt128,
-                UnsignedInt128,
-                uFloat16,
-                uFloat16Complex,
-                uFloat32,
-                uFloat32Complex,
-                Float,
-                FloatComplex,
-                uFloat32x,
-                uFloat32xComplex,
-                uFloat64,
-                uFloat64Complex,
-                Double,
-                DoubleComplex,
-                uFloat64x,
-                uFloat64xComplex,
-                uuFloat80,
-                uFloat128,
-                uFloat128Complex,
-                uuFloat128,
-                LongDouble,
-                LongDoubleComplex,
-                uFloat128x,
-                uFloat128xComplex,
-                NUMBER_OF_BASIC_TYPES
-        } kind;
-        // GENERATED END
-
-        /// xxx -- MAX_INTEGER_TYPE should probably be in BasicTypes-gen.cc, rather than hardcoded here
-        enum { MAX_INTEGER_TYPE = UnsignedInt128 };
+        BasicKind kind;
 
         /// string names of basic types; generated to match with Kind
         static const char *typeNames[];
 
-        BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        BasicType( BasicKind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : Type(q, std::move(as)), kind(k) {}
 
         /// Check if this type represents an integer type
-        bool isInteger() const { return (unsigned)kind <= (unsigned)MAX_INTEGER_TYPE; }
+        bool isInteger() const { return kind <= MAX_INTEGER_TYPE; }
 
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/module.mk

@@ -18 +18 @@
         AST/Attribute.cpp \
         AST/Attribute.hpp \
+        AST/BasicKind.hpp \
         AST/Bitfield.hpp \
         AST/Chain.hpp \