Changeset 90be0cf for src


Ignore:
Timestamp:
Oct 24, 2024, 12:50:14 PM (11 months ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
master
Children:
d031f7f
Parents:
12c4a5f
Message:

Moved some methods out of EnumDecl. These were calculations and the ast types are supposed to be data focused so they should either go with utility functions or to their use site. I tried the use site.

Location:
src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Decl.cpp

    r12c4a5f r90be0cf  
    169169}
    170170
    171 const std::string EnumDecl::getUnmangeldArrayName( const ast::EnumAttribute attr ) const {
    172         switch( attr ) {
    173                 case ast::EnumAttribute::Value: return "values_" + name ;
    174                 case ast::EnumAttribute::Label: return "labels_" + name;
    175                 default: /* Posn does not generate array */
    176                         return "";
    177         }
    178 }
    179 
    180 unsigned EnumDecl::calChildOffset(const std::string & target) const{
    181         unsigned offset = 0;
    182         for (auto childEnum: inlinedDecl) {
    183                 auto childDecl = childEnum->base;
    184                 if (childDecl->name == target) {
    185                         return offset;
    186                 }
    187                 offset += childDecl->members.size();
    188         }
    189     std::cerr << "Cannot find the target enum" << std::endl;
    190         return 0;
    191 }
    192 
    193 unsigned EnumDecl::calChildOffset(const ast::EnumInstType * target) const{
    194         return calChildOffset(target->base->name);
    195 }
    196 
    197 bool EnumDecl::isSubTypeOf(const ast::EnumDecl * other) const {
    198         if (name == other->name) return true;
    199         for (auto inlined: other->inlinedDecl) {
    200                 if (isSubTypeOf(inlined->base)) return true;
    201         }
    202         return false;
    203 }
    204 
    205171bool EnumDecl::isTyped() const { return base; }
    206172

  • src/AST/Decl.hpp

    r12c4a5f r90be0cf  
    302302};
    303303
     304/// Enumeration attribute kind.
    304305enum class EnumAttribute{ Value, Posn, Label };
     306
    305307/// enum declaration `enum Foo { ... };`
    306308class EnumDecl final : public AggregateDecl {
    … …  
    328330        const char * typeString() const override { return aggrString( Enum ); }
    329331
    330         const std::string getUnmangeldArrayName( const EnumAttribute attr ) const;
    331 
    332         unsigned calChildOffset(const std::string & childEnum) const;
    333         unsigned calChildOffset(const ast::EnumInstType * childEnum) const;
    334 
    335         bool isSubTypeOf(const ast::EnumDecl *) const;
    336332        bool isTyped() const;
    337333        bool isOpaque() const;

  • src/ResolvExpr/CandidateFinder.cpp

    r12c4a5f r90be0cf  
    21362136}
    21372137
     2138/// If the target enum is a child, get the offset from the base to the target.
     2139static unsigned findChildOffset(
     2140                const ast::EnumDecl * decl, const ast::EnumDecl * target ) {
     2141        unsigned offset = 0;
     2142        for ( auto inlined : decl->inlinedDecl ) {
     2143                auto childDecl = inlined->base;
     2144                if ( childDecl == target ) {
     2145                        return offset;
     2146                }
     2147                offset += childDecl->members.size();
     2148        }
     2149        SemanticError( decl, "Cannot find the target enum." );
     2150}
     2151
    21382152const ast::Expr * CandidateFinder::makeEnumOffsetCast( const ast::EnumInstType * src,
    21392153        const ast::EnumInstType * dst, const ast::Expr * expr, Cost minCost ) {
    … …  
    21472161                ast::CastExpr * castToDst;
    21482162                if (c<minCost) {
    2149                         unsigned offset = dstDecl->calChildOffset(dstChild.get());
     2163                        unsigned offset = findChildOffset( dstDecl, dstChild.get()->base );
    21502164                        if (offset > 0) {
    21512165                                auto untyped = ast::UntypedExpr::createCall(
    2152                                         expr->location, 
    2153                                         "?+?", 
     2166                                        expr->location,
     2167                                        "?+?",
    21542168                                        { new ast::CastExpr( expr->location,
    21552169                                                expr,

  • src/ResolvExpr/CommonType.cpp

    r12c4a5f r90be0cf  
    636636        void postvisit( const ast::UnionInstType * ) {}
    637637
     638        /// Is the target enum a child of the base enum?
     639        static bool isChildEnum(
     640                        const ast::EnumDecl * decl, const ast::EnumDecl * target ) {
     641                if ( decl == target ) return true;
     642                for ( auto inlined : decl->inlinedDecl ) {
     643                        if ( isChildEnum( inlined->base, target ) ) return true;
     644                }
     645                return false;
     646        }
     647
    638648        void postvisit( const ast::EnumInstType * param ) {
    639649                auto argAsEnumInst = dynamic_cast<const ast::EnumInstType *>(type2);
    … …  
    641651                        const ast::EnumDecl* paramDecl = param->base;
    642652                        const ast::EnumDecl* argDecl = argAsEnumInst->base;
    643                         if (argDecl->isSubTypeOf(paramDecl)) result = param;
     653                        if ( isChildEnum( paramDecl, argDecl ) ) {
     654                                result = param;
     655                        }
    644656                } else if ( param->base && !param->base->isCfa ) {
    645657                        auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );

  • src/Validate/ImplementEnumFunc.cpp

    r12c4a5f r90be0cf  
    7878        std::vector<ast::ptr<ast::Init>> genValueInit() const;
    7979        ast::ObjectDecl* genAttrArrayProto(
    80                 const ast::EnumAttribute attr, const CodeLocation& location,
    81                 std::vector<ast::ptr<ast::Init>>& inits) const;
     80                const CodeLocation& location, const std::string& prefix,
     81                const ast::Type * type, std::vector<ast::ptr<ast::Init>>& inits ) const;
    8282};
    8383
    … …  
    351351
    352352ast::ObjectDecl* EnumAttrFuncGenerator::genAttrArrayProto(
    353         const ast::EnumAttribute attr, const CodeLocation& location,
    354         std::vector<ast::ptr<ast::Init>>& inits) const {
     353                const CodeLocation& location, const std::string& prefix,
     354                const ast::Type * type, std::vector<ast::ptr<ast::Init>>& inits ) const {
    355355        ast::ArrayType* arrT = new ast::ArrayType(
    356                 attr == ast::EnumAttribute::Value
    357                         ? decl->base
    358                         : new ast::PointerType(
    359                                 new ast::BasicType(ast::BasicKind::Char, ast::CV::Const)),
     356                type,
    360357                ast::ConstantExpr::from_int(decl->location, decl->members.size()),
    361358                ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim);
    … …  
    363360        ast::ObjectDecl* objDecl =
    364361                new ast::ObjectDecl(
    365                         decl->location, decl->getUnmangeldArrayName( attr ),
     362                        decl->location, prefix + decl->name,
    366363                        arrT, new ast::ListInit( location, std::move( inits ) ),
    367364                        ast::Storage::Static, ast::Linkage::AutoGen );
    … …  
    417414void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) {
    418415        if (attr == ast::EnumAttribute::Value) {
    419                 if (decl->isTyped()) {
    420                         // TypedEnum's backing arrays
    421                         std::vector<ast::ptr<ast::Init>> inits = genValueInit();
    422                         ast::ObjectDecl* arrayProto =
    423                                 genAttrArrayProto(attr, getLocation(), inits);
    424                         forwards.push_back(arrayProto);
    425 
    426                         ast::FunctionDecl* funcProto = genValueProto();
    427                         produceForwardDecl(funcProto);
    428                         genValueOrLabelBody(funcProto, arrayProto);
    429                         produceDecl(funcProto);
    430                 } 
    431                 // else {
    432                 //      ast::FunctionDecl* funcProto = genQuasiValueProto();
    433                 //      produceForwardDecl(funcProto);
    434                 //      // genQuasiValueBody(funcProto);
    435                 //      produceDecl(funcProto);
    436                 // }
     416                if ( !decl->isTyped() ) return;
     417                std::vector<ast::ptr<ast::Init>> inits = genValueInit();
     418                ast::ObjectDecl* arrayProto =
     419                        genAttrArrayProto( getLocation(), "values_", decl->base, inits );
     420                forwards.push_back(arrayProto);
     421
     422                ast::FunctionDecl* funcProto = genValueProto();
     423                produceForwardDecl(funcProto);
     424                genValueOrLabelBody(funcProto, arrayProto);
     425                produceDecl(funcProto);
    437426        } else if (attr == ast::EnumAttribute::Label) {
    438427                std::vector<ast::ptr<ast::Init>> inits = genLabelInit();
     428                const ast::Type * type = new ast::PointerType(
     429                        new ast::BasicType( ast::BasicKind::Char, ast::CV::Const ) );
    439430                ast::ObjectDecl* arrayProto =
    440                         genAttrArrayProto(attr, getLocation(), inits);
     431                        genAttrArrayProto( getLocation(), "labels_", type, inits );
    441432                forwards.push_back(arrayProto);
    442433                ast::FunctionDecl* funcProto = genLabelProto();
    … …  
    445436                produceDecl(funcProto);
    446437        } else {
     438                assert( attr == ast::EnumAttribute::Posn );
    447439                ast::FunctionDecl* funcProto = genPosnProto();
    448440                produceForwardDecl(funcProto);
Note: See TracChangeset for help on using the changeset viewer.