Changeset 6e50a6b


Ignore:
Timestamp:
Jun 18, 2021, 12:20:59 PM (6 weeks ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
master
Children:
c7d8696a
Parents:
dcbfcbc
Message:

Implementing language-provided syntax for (array) dimensions.

Former z(i) and Z(N) macros are eliminated.

Files:
2 added
25 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/containers/array.hfa

    rdcbfcbc r6e50a6b  
    11
    22
    3 // a type whose size is n
    4 #define Z(n) char[n]
    5 
    6 // the inverse of Z(-)
    7 #define z(N) sizeof(N)
    8 
    9 forall( T & ) struct tag {};
     3forall( __CFA_tysys_id_only_X & ) struct tag {};
    104#define ttag(T) ((tag(T)){})
    11 #define ztag(n) ttag(Z(n))
     5#define ztag(n) ttag(n)
    126
    137
     
    1812forall( [N], S & | sized(S), Timmed &, Tbase & ) {
    1913    struct arpk {
    20         S strides[z(N)];
     14        S strides[N];
    2115    };
    2216
     
    5650
    5751    static inline size_t ?`len( arpk(N, S, Timmed, Tbase) & a ) {
    58         return z(N);
     52        return N;
    5953    }
    6054
    6155    // workaround #226 (and array relevance thereof demonstrated in mike102/otype-slow-ndims.cfa)
    6256    static inline void ?{}( arpk(N, S, Timmed, Tbase) & this ) {
    63         void ?{}( S (&inner)[z(N)] ) {}
     57        void ?{}( S (&inner)[N] ) {}
    6458        ?{}(this.strides);
    6559    }
    6660    static inline void ^?{}( arpk(N, S, Timmed, Tbase) & this ) {
    67         void ^?{}( S (&inner)[z(N)] ) {}
     61        void ^?{}( S (&inner)[N] ) {}
    6862        ^?{}(this.strides);
    6963    }
  • src/AST/Convert.cpp

    rdcbfcbc r6e50a6b  
    24152415        }
    24162416
     2417        virtual void visit( const DimensionExpr * old ) override final {
     2418                // DimensionExpr gets desugared away in Validate.
     2419                // As long as new-AST passes don't use it, this cheap-cheerful error
     2420                // detection helps ensure that these occurrences have been compiled
     2421                // away, as expected.  To move the DimensionExpr boundary downstream
     2422                // or move the new-AST translation boundary upstream, implement
     2423                // DimensionExpr in the new AST and implement a conversion.
     2424                (void) old;
     2425                assert(false && "DimensionExpr should not be present at new-AST boundary");
     2426        }
     2427
    24172428        virtual void visit( const AsmExpr * old ) override final {
    24182429                this->node = visitBaseExpr( old,
  • src/AST/Decl.cpp

    rdcbfcbc r6e50a6b  
    7878
    7979const char * TypeDecl::typeString() const {
    80         static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized array length type" };
     80        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized length value" };
    8181        static_assert( sizeof(kindNames) / sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
    8282        assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
  • src/AST/Decl.hpp

    rdcbfcbc r6e50a6b  
    175175class TypeDecl final : public NamedTypeDecl {
    176176  public:
    177         enum Kind { Dtype, DStype, Otype, Ftype, Ttype, ALtype, NUMBER_OF_KINDS };
     177        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, Dimension, NUMBER_OF_KINDS };
    178178
    179179        Kind kind;
  • src/CodeGen/CodeGenerator.cc

    rdcbfcbc r6e50a6b  
    589589                        output << nameExpr->get_name();
    590590                } // if
     591        }
     592
     593        void CodeGenerator::postvisit( DimensionExpr * dimensionExpr ) {
     594                extension( dimensionExpr );
     595                output << "/*non-type*/" << dimensionExpr->get_name();
    591596        }
    592597
  • src/CodeGen/CodeGenerator.h

    rdcbfcbc r6e50a6b  
    9292                void postvisit( TupleIndexExpr * tupleExpr );
    9393                void postvisit( TypeExpr *typeExpr );
     94                void postvisit( DimensionExpr *dimensionExpr );
    9495                void postvisit( AsmExpr * );
    9596                void postvisit( StmtExpr * );
  • src/Common/PassVisitor.h

    rdcbfcbc r6e50a6b  
    167167        virtual void visit( TypeExpr * typeExpr ) override final;
    168168        virtual void visit( const TypeExpr * typeExpr ) override final;
     169        virtual void visit( DimensionExpr * dimensionExpr ) override final;
     170        virtual void visit( const DimensionExpr * dimensionExpr ) override final;
    169171        virtual void visit( AsmExpr * asmExpr ) override final;
    170172        virtual void visit( const AsmExpr * asmExpr ) override final;
     
    309311        virtual Expression * mutate( CommaExpr * commaExpr ) override final;
    310312        virtual Expression * mutate( TypeExpr * typeExpr ) override final;
     313        virtual Expression * mutate( DimensionExpr * dimensionExpr ) override final;
    311314        virtual Expression * mutate( AsmExpr * asmExpr ) override final;
    312315        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override final;
     
    542545class WithIndexer {
    543546protected:
    544         WithIndexer() {}
     547        WithIndexer( bool trackIdentifiers = true ) : indexer(trackIdentifiers) {}
    545548        ~WithIndexer() {}
    546549
  • src/Common/PassVisitor.impl.h

    rdcbfcbc r6e50a6b  
    25192519
    25202520//--------------------------------------------------------------------------
     2521// DimensionExpr
     2522template< typename pass_type >
     2523void PassVisitor< pass_type >::visit( DimensionExpr * node ) {
     2524        VISIT_START( node );
     2525
     2526        indexerScopedAccept( node->result, *this );
     2527
     2528        VISIT_END( node );
     2529}
     2530
     2531template< typename pass_type >
     2532void PassVisitor< pass_type >::visit( const DimensionExpr * node ) {
     2533        VISIT_START( node );
     2534
     2535        indexerScopedAccept( node->result, *this );
     2536
     2537        VISIT_END( node );
     2538}
     2539
     2540template< typename pass_type >
     2541Expression * PassVisitor< pass_type >::mutate( DimensionExpr * node ) {
     2542        MUTATE_START( node );
     2543
     2544        indexerScopedMutate( node->env   , *this );
     2545        indexerScopedMutate( node->result, *this );
     2546
     2547        MUTATE_END( Expression, node );
     2548}
     2549
     2550//--------------------------------------------------------------------------
    25212551// AsmExpr
    25222552template< typename pass_type >
     
    31573187
    31583188        maybeAccept_impl( node->forall, *this );
    3159         // xxx - should PointerType visit/mutate dimension?
     3189        maybeAccept_impl( node->dimension, *this );
    31603190        maybeAccept_impl( node->base, *this );
    31613191
     
    31683198
    31693199        maybeAccept_impl( node->forall, *this );
    3170         // xxx - should PointerType visit/mutate dimension?
     3200        maybeAccept_impl( node->dimension, *this );
    31713201        maybeAccept_impl( node->base, *this );
    31723202
     
    31793209
    31803210        maybeMutate_impl( node->forall, *this );
    3181         // xxx - should PointerType visit/mutate dimension?
     3211        maybeMutate_impl( node->dimension, *this );
    31823212        maybeMutate_impl( node->base, *this );
    31833213
  • src/Parser/DeclarationNode.cc

    rdcbfcbc r6e50a6b  
    10761076        if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
    10771077                // otype is internally converted to dtype + otype parameters
    1078                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::DStype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dtype };
     1078                static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::DStype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dimension };
    10791079                static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
    10801080                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1081                 TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype || variable.tyClass == TypeDecl::ALtype, variable.initializer ? variable.initializer->buildType() : nullptr );
     1081                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype, variable.initializer ? variable.initializer->buildType() : nullptr );
    10821082                buildList( variable.assertions, ret->get_assertions() );
    10831083                return ret;
  • src/Parser/ExpressionNode.cc

    rdcbfcbc r6e50a6b  
    509509} // build_varref
    510510
     511DimensionExpr * build_dimensionref( const string * name ) {
     512        DimensionExpr * expr = new DimensionExpr( *name );
     513        delete name;
     514        return expr;
     515} // build_varref
    511516// TODO: get rid of this and OperKinds and reuse code from OperatorTable
    512517static const char * OperName[] = {                                              // must harmonize with OperKinds
  • src/Parser/ParseNode.h

    rdcbfcbc r6e50a6b  
    183183
    184184NameExpr * build_varref( const std::string * name );
     185DimensionExpr * build_dimensionref( const std::string * name );
    185186
    186187Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
  • src/Parser/TypedefTable.cc

    rdcbfcbc r6e50a6b  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 15 20:56:47 2021
    13 // Update Count     : 260
     12// Last Modified On : Wed May 19 08:30:14 2021
     13// Update Count     : 262
    1414//
    1515
     
    3131        switch ( kind ) {
    3232          case IDENTIFIER: return "identifier";
     33          case TYPEDIMname: return "typedim";
    3334          case TYPEDEFname: return "typedef";
    3435          case TYPEGENname: return "typegen";
  • src/Parser/parser.yy

    rdcbfcbc r6e50a6b  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Apr 26 18:41:54 2021
    13 // Update Count     : 4990
     12// Last Modified On : Wed May 19 14:20:36 2021
     13// Update Count     : 5022
    1414//
    1515
     
    287287
    288288// names and constants: lexer differentiates between identifier and typedef names
    289 %token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDEFname             TYPEGENname
     289%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDIMname             TYPEDEFname             TYPEGENname
    290290%token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
    291291%token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
     
    586586        | quasi_keyword
    587587                { $$ = new ExpressionNode( build_varref( $1 ) ); }
     588        | TYPEDIMname                                                                           // CFA, generic length argument
     589                // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
     590                // { $$ = new ExpressionNode( build_varref( $1 ) ); }
     591                { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
    588592        | tuple
    589593        | '(' comma_expression ')'
     
    25352539        | '[' identifier_or_type_name ']'
    25362540                {
    2537                         typedefTable.addToScope( *$2, TYPEDEFname, "9" );
    2538                         $$ = DeclarationNode::newTypeParam( TypeDecl::ALtype, $2 );
     2541                        typedefTable.addToScope( *$2, TYPEDIMname, "9" );
     2542                        $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
    25392543                }
    25402544        // | type_specifier identifier_parameter_declarator
     
    25902594                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
    25912595        | assignment_expression
    2592                 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $1->build()) ); $$ = nullptr; }
    25932596        | type_list ',' type
    25942597                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
    25952598        | type_list ',' assignment_expression
    2596                 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $3->build()) ); $$ = nullptr; }
    2597                 // { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
     2599                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
    25982600        ;
    25992601
  • src/SymTab/Indexer.cc

    rdcbfcbc r6e50a6b  
    7474        }
    7575
    76         Indexer::Indexer()
     76        Indexer::Indexer( bool trackIdentifiers )
    7777        : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
    78           prevScope(), scope( 0 ), repScope( 0 ) { ++* stats().count; }
     78          prevScope(), scope( 0 ), repScope( 0 ), trackIdentifiers( trackIdentifiers ) { ++* stats().count; }
    7979
    8080        Indexer::~Indexer() {
     
    110110
    111111        void Indexer::lookupId( const std::string & id, std::list< IdData > &out ) const {
     112                assert( trackIdentifiers );
     113
    112114                ++* stats().lookup_calls;
    113115                if ( ! idTable ) return;
     
    434436                        const Declaration * deleteStmt ) {
    435437                ++* stats().add_calls;
     438                if ( ! trackIdentifiers ) return;
    436439                const std::string &name = decl->name;
    437440                if ( name == "" ) return;
  • src/SymTab/Indexer.h

    rdcbfcbc r6e50a6b  
    3131        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
    3232        public:
    33                 explicit Indexer();
     33                explicit Indexer( bool trackIdentifiers = true );
    3434                virtual ~Indexer();
    3535
     
    180180                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
    181181                bool hasIncompatibleCDecl( const std::string & id, const std::string & mangleName ) const;
     182
     183            bool trackIdentifiers;
    182184        };
    183185} // namespace SymTab
  • src/SymTab/Validate.cc

    rdcbfcbc r6e50a6b  
    105105
    106106        struct FixQualifiedTypes final : public WithIndexer {
     107                FixQualifiedTypes() : WithIndexer(false) {}
    107108                Type * postmutate( QualifiedType * );
    108109        };
     
    174175        };
    175176
     177        /// Does early resolution on the expressions that give enumeration constants their values
     178        struct ResolveEnumInitializers final : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveEnumInitializers>, public WithShortCircuiting {
     179                ResolveEnumInitializers( const Indexer * indexer );
     180                void postvisit( EnumDecl * enumDecl );
     181
     182          private:
     183                const Indexer * local_indexer;
     184
     185        };
     186
    176187        /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
    177188        struct ForallPointerDecay_old final {
     
    260271                void previsit( StructInstType * inst );
    261272                void previsit( UnionInstType * inst );
     273        };
     274
     275        /// desugar declarations and uses of dimension paramaters like [N],
     276        /// from type-system managed values, to tunnneling via ordinary types,
     277        /// as char[-] in and sizeof(-) out
     278        struct TranslateDimensionGenericParameters : public WithIndexer, public WithGuards {
     279                static void translateDimensions( std::list< Declaration * > &translationUnit );
     280                TranslateDimensionGenericParameters();
     281
     282                bool nextVisitedNodeIsChildOfSUIT = false; // SUIT = Struct or Union -Inst Type
     283                bool visitingChildOfSUIT = false;
     284                void changeState_ChildOfSUIT( bool newVal );
     285                void premutate( StructInstType * sit );
     286                void premutate( UnionInstType * uit );
     287                void premutate( BaseSyntaxNode * node );
     288
     289                TypeDecl * postmutate( TypeDecl * td );
     290                Expression * postmutate( DimensionExpr * de );
     291                Expression * postmutate( Expression * e );
    262292        };
    263293
     
    307337                PassVisitor<EnumAndPointerDecay_old> epc;
    308338                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
     339                PassVisitor<ResolveEnumInitializers> rei( nullptr );
    309340                PassVisitor<ForallPointerDecay_old> fpd;
    310341                PassVisitor<CompoundLiteral> compoundliteral;
     
    326357                        Stats::Heap::newPass("validate-B");
    327358                        Stats::Time::BlockGuard guard("validate-B");
    328                         Stats::Time::TimeBlock("Link Reference To Types", [&]() {
    329                                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
    330                         });
    331                         Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
    332                                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
    333                         });
    334                         Stats::Time::TimeBlock("Hoist Structs", [&]() {
    335                                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
    336                         });
    337                         Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
    338                                 EliminateTypedef::eliminateTypedef( translationUnit ); //
    339                         });
     359                        acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
     360                        mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
     361                        HoistStruct::hoistStruct( translationUnit );
     362                        EliminateTypedef::eliminateTypedef( translationUnit );
    340363                }
    341364                {
    342365                        Stats::Heap::newPass("validate-C");
    343366                        Stats::Time::BlockGuard guard("validate-C");
    344                         acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
    345                         ReturnChecker::checkFunctionReturns( translationUnit );
    346                         InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
     367                        Stats::Time::TimeBlock("Validate Generic Parameters", [&]() {
     368                                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old; observed failing when attempted before eliminateTypedef
     369                        });
     370                        Stats::Time::TimeBlock("Translate Dimensions", [&]() {
     371                                TranslateDimensionGenericParameters::translateDimensions( translationUnit );
     372                        });
     373                        Stats::Time::TimeBlock("Resolve Enum Initializers", [&]() {
     374                                acceptAll( translationUnit, rei ); // must happen after translateDimensions because rei needs identifier lookup, which needs name mangling
     375                        });
     376                        Stats::Time::TimeBlock("Check Function Returns", [&]() {
     377                                ReturnChecker::checkFunctionReturns( translationUnit );
     378                        });
     379                        Stats::Time::TimeBlock("Fix Return Statements", [&]() {
     380                                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
     381                        });
    347382                }
    348383                {
     
    644679        }
    645680
    646         LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) {
     681        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) : WithIndexer( false ) {
    647682                if ( other_indexer ) {
    648683                        local_indexer = other_indexer;
     
    664699        }
    665700
    666         void checkGenericParameters( ReferenceToType * inst ) {
    667                 for ( Expression * param : inst->parameters ) {
    668                         if ( ! dynamic_cast< TypeExpr * >( param ) ) {
    669                                 SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
    670                         }
    671                 }
    672         }
    673 
    674701        void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
    675702                const StructDecl * st = local_indexer->lookupStruct( structInst->name );
     
    682709                        forwardStructs[ structInst->name ].push_back( structInst );
    683710                } // if
    684                 checkGenericParameters( structInst );
    685711        }
    686712
     
    695721                        forwardUnions[ unionInst->name ].push_back( unionInst );
    696722                } // if
    697                 checkGenericParameters( unionInst );
    698723        }
    699724
     
    807832                                forwardEnums.erase( fwds );
    808833                        } // if
    809 
    810                         for ( Declaration * member : enumDecl->members ) {
    811                                 ObjectDecl * field = strict_dynamic_cast<ObjectDecl *>( member );
    812                                 if ( field->init ) {
    813                                         // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
    814                                         SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
    815                                         ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
    816                                 }
    817                         }
    818834                } // if
    819835        }
     
    878894                                typeInst->set_isFtype( typeDecl->kind == TypeDecl::Ftype );
    879895                        } // if
     896                } // if
     897        }
     898
     899        ResolveEnumInitializers::ResolveEnumInitializers( const Indexer * other_indexer ) : WithIndexer( true ) {
     900                if ( other_indexer ) {
     901                        local_indexer = other_indexer;
     902                } else {
     903                        local_indexer = &indexer;
     904                } // if
     905        }
     906
     907        void ResolveEnumInitializers::postvisit( EnumDecl * enumDecl ) {
     908                if ( enumDecl->body ) {
     909                        for ( Declaration * member : enumDecl->members ) {
     910                                ObjectDecl * field = strict_dynamic_cast<ObjectDecl *>( member );
     911                                if ( field->init ) {
     912                                        // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
     913                                        SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
     914                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
     915                                }
     916                        }
    880917                } // if
    881918        }
     
    12231260        }
    12241261
     1262        // Test for special name on a generic parameter.  Special treatment for the
     1263        // special name is a bootstrapping hack.  In most cases, the worlds of T's
     1264        // and of N's don't overlap (normal treamtemt).  The foundations in
     1265        // array.hfa use tagging for both types and dimensions.  Tagging treats
     1266        // its subject parameter even more opaquely than T&, which assumes it is
     1267        // possible to have a pointer/reference to such an object.  Tagging only
     1268        // seeks to identify the type-system resident at compile time.  Both N's
     1269        // and T's can make tags.  The tag definition uses the special name, which
     1270        // is treated as "an N or a T."  This feature is not inteded to be used
     1271        // outside of the definition and immediate uses of a tag.
     1272        static inline bool isReservedTysysIdOnlyName( const std::string & name ) {
     1273                // name's prefix was __CFA_tysys_id_only, before it got wrapped in __..._generic
     1274                int foundAt = name.find("__CFA_tysys_id_only");
     1275                if (foundAt == 0) return true;
     1276                if (foundAt == 2 && name[0] == '_' && name[1] == '_') return true;
     1277                return false;
     1278        }
     1279
    12251280        template< typename Aggr >
    12261281        void validateGeneric( Aggr * inst ) {
     
    12391294                        TypeSubstitution sub;
    12401295                        auto paramIter = params->begin();
    1241                         for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
    1242                                 if ( i < args.size() ) {
    1243                                         TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( * std::next( args.begin(), i ) );
    1244                                         sub.add( (* paramIter)->get_name(), expr->get_type()->clone() );
    1245                                 } else if ( i == args.size() ) {
     1296                        auto argIter = args.begin();
     1297                        for ( ; paramIter != params->end(); ++paramIter, ++argIter ) {
     1298                                if ( argIter != args.end() ) {
     1299                                        TypeExpr * expr = dynamic_cast< TypeExpr * >( * argIter );
     1300                                        if ( expr ) {
     1301                                                sub.add( (* paramIter)->get_name(), expr->get_type()->clone() );
     1302                                        }
     1303                                } else {
    12461304                                        Type * defaultType = (* paramIter)->get_init();
    12471305                                        if ( defaultType ) {
    12481306                                                args.push_back( new TypeExpr( defaultType->clone() ) );
    12491307                                                sub.add( (* paramIter)->get_name(), defaultType->clone() );
     1308                                                argIter = std::prev(args.end());
     1309                                        } else {
     1310                                                SemanticError( inst, "Too few type arguments in generic type " );
    12501311                                        }
    12511312                                }
     1313                                assert( argIter != args.end() );
     1314                                bool typeParamDeclared = (*paramIter)->kind != TypeDecl::Kind::Dimension;
     1315                                bool typeArgGiven;
     1316                                if ( isReservedTysysIdOnlyName( (*paramIter)->name ) ) {
     1317                                        // coerce a match when declaration is reserved name, which means "either"
     1318                                        typeArgGiven = typeParamDeclared;
     1319                                } else {
     1320                                        typeArgGiven = dynamic_cast< TypeExpr * >( * argIter );
     1321                                }
     1322                                if ( ! typeParamDeclared &&   typeArgGiven ) SemanticError( inst, "Type argument given for value parameter: " );
     1323                                if (   typeParamDeclared && ! typeArgGiven ) SemanticError( inst, "Expression argument given for type parameter: " );
    12521324                        }
    12531325
    12541326                        sub.apply( inst );
    1255                         if ( args.size() < params->size() ) SemanticError( inst, "Too few type arguments in generic type " );
    12561327                        if ( args.size() > params->size() ) SemanticError( inst, "Too many type arguments in generic type " );
    12571328                }
     
    12641335        void ValidateGenericParameters::previsit( UnionInstType * inst ) {
    12651336                validateGeneric( inst );
     1337        }
     1338
     1339        void TranslateDimensionGenericParameters::translateDimensions( std::list< Declaration * > &translationUnit ) {
     1340                PassVisitor<TranslateDimensionGenericParameters> translator;
     1341                mutateAll( translationUnit, translator );
     1342        }
     1343
     1344        TranslateDimensionGenericParameters::TranslateDimensionGenericParameters() : WithIndexer( false ) {}
     1345
     1346        // Declaration of type variable:           forall( [N] )          ->  forall( N & | sized( N ) )
     1347        TypeDecl * TranslateDimensionGenericParameters::postmutate( TypeDecl * td ) {
     1348                if ( td->kind == TypeDecl::Dimension ) {
     1349                        td->kind = TypeDecl::Dtype;
     1350                        if ( ! isReservedTysysIdOnlyName( td->name ) ) {
     1351                                td->sized = true;
     1352                        }
     1353                }
     1354                return td;
     1355        }
     1356
     1357        // Situational awareness:
     1358        // array( float, [[currentExpr]]     )  has  visitingChildOfSUIT == true
     1359        // array( float, [[currentExpr]] - 1 )  has  visitingChildOfSUIT == false
     1360        // size_t x =    [[currentExpr]]        has  visitingChildOfSUIT == false
     1361        void TranslateDimensionGenericParameters::changeState_ChildOfSUIT( bool newVal ) {
     1362                GuardValue( nextVisitedNodeIsChildOfSUIT );
     1363                GuardValue( visitingChildOfSUIT );
     1364                visitingChildOfSUIT = nextVisitedNodeIsChildOfSUIT;
     1365                nextVisitedNodeIsChildOfSUIT = newVal;
     1366        }
     1367        void TranslateDimensionGenericParameters::premutate( StructInstType * sit ) {
     1368                (void) sit;
     1369                changeState_ChildOfSUIT(true);
     1370        }
     1371        void TranslateDimensionGenericParameters::premutate( UnionInstType * uit ) {
     1372                (void) uit;
     1373                changeState_ChildOfSUIT(true);
     1374        }
     1375        void TranslateDimensionGenericParameters::premutate( BaseSyntaxNode * node ) {
     1376                (void) node;
     1377                changeState_ChildOfSUIT(false);
     1378        }
     1379
     1380        // Passing values as dimension arguments:  array( float,     7 )  -> array( float, char[             7 ] )
     1381        // Consuming dimension parameters:         size_t x =    N - 1 ;  -> size_t x =          sizeof(N) - 1   ;
     1382        // Intertwined reality:                    array( float, N     )  -> array( float,              N        )
     1383        //                                         array( float, N - 1 )  -> array( float, char[ sizeof(N) - 1 ] )
     1384        // Intertwined case 1 is not just an optimization.
     1385        // Avoiding char[sizeof(-)] is necessary to enable the call of f to bind the value of N, in:
     1386        //   forall([N]) void f( array(float, N) & );
     1387        //   array(float, 7) a;
     1388        //   f(a);
     1389
     1390        Expression * TranslateDimensionGenericParameters::postmutate( DimensionExpr * de ) {
     1391                // Expression de is an occurrence of N in LHS of above examples.
     1392                // Look up the name that de references.
     1393                // If we are in a struct body, then this reference can be to an entry of the stuct's forall list.
     1394                // Whether or not we are in a struct body, this reference can be to an entry of a containing function's forall list.
     1395                // If we are in a struct body, then the stuct's forall declarations are innermost (functions don't occur in structs).
     1396                // Thus, a potential struct's declaration is highest priority.
     1397                // A struct's forall declarations are already renamed with _generic_ suffix.  Try that name variant first.
     1398
     1399                std::string useName = "__" + de->name + "_generic_";
     1400                TypeDecl * namedParamDecl = const_cast<TypeDecl *>( strict_dynamic_cast<const TypeDecl *, nullptr >( indexer.lookupType( useName ) ) );
     1401
     1402                if ( ! namedParamDecl ) {
     1403                        useName = de->name;
     1404                        namedParamDecl = const_cast<TypeDecl *>( strict_dynamic_cast<const TypeDecl *, nullptr >( indexer.lookupType( useName ) ) );
     1405                }
     1406
     1407                // Expect to find it always.  A misspelled name would have been parsed as an identifier.
     1408                assert( namedParamDecl && "Type-system-managed value name not found in symbol table" );
     1409
     1410                delete de;
     1411
     1412                TypeInstType * refToDecl = new TypeInstType( 0, useName, namedParamDecl );
     1413
     1414                if ( visitingChildOfSUIT ) {
     1415                        // As in postmutate( Expression * ), topmost expression needs a TypeExpr wrapper
     1416                        // But avoid ArrayType-Sizeof
     1417                        return new TypeExpr( refToDecl );
     1418                } else {
     1419                        // the N occurrence is being used directly as a runtime value,
     1420                        // if we are in a type instantiation, then the N is within a bigger value computation
     1421                        return new SizeofExpr( refToDecl );
     1422                }
     1423        }
     1424
     1425        Expression * TranslateDimensionGenericParameters::postmutate( Expression * e ) {
     1426                if ( visitingChildOfSUIT ) {
     1427                        // e is an expression used as an argument to instantiate a type
     1428                        if (! dynamic_cast< TypeExpr * >( e ) ) {
     1429                                // e is a value expression
     1430                                // but not a DimensionExpr, which has a distinct postmutate
     1431                                Type * typeExprContent = new ArrayType( 0, new BasicType( 0, BasicType::Char ), e, true, false );
     1432                                TypeExpr * result = new TypeExpr( typeExprContent );
     1433                                return result;
     1434                        }
     1435                }
     1436                return e;
    12661437        }
    12671438
  • src/SynTree/Declaration.h

    rdcbfcbc r6e50a6b  
    201201        typedef NamedTypeDecl Parent;
    202202  public:
    203         enum Kind { Dtype, DStype, Otype, Ftype, Ttype, ALtype, NUMBER_OF_KINDS };
     203        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, Dimension, NUMBER_OF_KINDS };
    204204
    205205        Kind kind;
  • src/SynTree/Expression.h

    rdcbfcbc r6e50a6b  
    587587};
    588588
     589/// DimensionExpr represents a type-system provided value used in an expression ( forrall([N]) ... N + 1 )
     590class DimensionExpr : public Expression {
     591  public:
     592        std::string name;
     593
     594        DimensionExpr( std::string name );
     595        DimensionExpr( const DimensionExpr & other );
     596        virtual ~DimensionExpr();
     597
     598        const std::string & get_name() const { return name; }
     599        void set_name( std::string newValue ) { name = newValue; }
     600
     601        virtual DimensionExpr * clone() const override { return new DimensionExpr( * this ); }
     602        virtual void accept( Visitor & v ) override { v.visit( this ); }
     603        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     604        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     605        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     606};
     607
    589608/// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
    590609class AsmExpr : public Expression {
  • src/SynTree/Mutator.h

    rdcbfcbc r6e50a6b  
    8080        virtual Expression * mutate( CommaExpr * commaExpr ) = 0;
    8181        virtual Expression * mutate( TypeExpr * typeExpr ) = 0;
     82        virtual Expression * mutate( DimensionExpr * dimensionExpr ) = 0;
    8283        virtual Expression * mutate( AsmExpr * asmExpr ) = 0;
    8384        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
  • src/SynTree/SynTree.h

    rdcbfcbc r6e50a6b  
    8585class CommaExpr;
    8686class TypeExpr;
     87class DimensionExpr;
    8788class AsmExpr;
    8889class ImplicitCopyCtorExpr;
  • src/SynTree/TypeDecl.cc

    rdcbfcbc r6e50a6b  
    3333
    3434const char * TypeDecl::typeString() const {
    35         static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized array length type" };
     35        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized length value" };
    3636        static_assert( sizeof(kindNames) / sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
    3737        assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
  • src/SynTree/TypeExpr.cc

    rdcbfcbc r6e50a6b  
    3535}
    3636
     37DimensionExpr::DimensionExpr( std::string name ) : Expression(), name(name) {
     38        assertf(name != "0", "Zero is not a valid name");
     39        assertf(name != "1", "One is not a valid name");
     40}
     41
     42DimensionExpr::DimensionExpr( const DimensionExpr & other ) : Expression( other ), name( other.name ) {
     43}
     44
     45DimensionExpr::~DimensionExpr() {}
     46
     47void DimensionExpr::print( std::ostream & os, Indenter indent ) const {
     48        os << "Type-Sys Value: " << get_name();
     49        Expression::print( os, indent );
     50}
    3751// Local Variables: //
    3852// tab-width: 4 //
  • src/SynTree/Visitor.h

    rdcbfcbc r6e50a6b  
    135135        virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
    136136        virtual void visit( const TypeExpr * typeExpr ) = 0;
     137        virtual void visit( DimensionExpr * node ) { visit( const_cast<const DimensionExpr *>(node) ); }
     138        virtual void visit( const DimensionExpr * typeExpr ) = 0;
    137139        virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
    138140        virtual void visit( const AsmExpr * asmExpr ) = 0;
  • tests/array-container/array-basic.cfa

    rdcbfcbc r6e50a6b  
    6161forall( [Nw], [Nx], [Ny], [Nz] )
    6262void fillHelloData( array( float, Nw, Nx, Ny, Nz ) & wxyz ) {
    63     for (w; z(Nw))
    64     for (x; z(Nx))
    65     for (y; z(Ny))
    66     for (z; z(Nz))
     63    for (w; Nw)
     64    for (x; Nx)
     65    for (y; Ny)
     66    for (z; Nz)
    6767        wxyz[w][x][y][z] = getMagicNumber(w, x, y, z);
    6868}
    6969
    70 forall( [Zn]
     70forall( [N]
    7171      , S & | sized(S)
    7272      )
    73 float total1d_low( arpk(Zn, S, float, float ) & a ) {
     73float total1d_low( arpk(N, S, float, float ) & a ) {
    7474    float total = 0.0f;
    75     for (i; z(Zn))
     75    for (i; N)
    7676        total += a[i];
    7777    return total;
     
    9898
    9999    expect = 0;
    100     for (i; z(Nw))
     100    for (i; Nw)
    101101        expect += getMagicNumber( i, slice_ix, slice_ix, slice_ix );
    102102    printf("expect Ws             = %f\n", expect);
     
    117117
    118118    expect = 0;
    119     for (i; z(Nx))
     119    for (i; Nx)
    120120        expect += getMagicNumber( slice_ix, i, slice_ix, slice_ix );
    121121    printf("expect Xs             = %f\n", expect);
  • tests/array-container/array-md-sbscr-cases.cfa

    rdcbfcbc r6e50a6b  
    2020forall( [Nw], [Nx], [Ny], [Nz] )
    2121void fillHelloData( array( float, Nw, Nx, Ny, Nz ) & wxyz ) {
    22     for (w; z(Nw))
    23     for (x; z(Nx))
    24     for (y; z(Ny))
    25     for (z; z(Nz))
     22    for (w; Nw)
     23    for (x; Nx)
     24    for (y; Ny)
     25    for (z; Nz)
    2626        wxyz[w][x][y][z] = getMagicNumber(w, x, y, z);
    2727}
     
    246246    assert(( wxyz[[2,  3,  4,  5]] == valExpected ));
    247247
    248     for ( i; z(Nw) ) {
     248    for ( i; Nw ) {
    249249        assert(( wxyz[[ i, 3, 4, 5 ]] == getMagicNumber(i, 3, 4, 5) ));
    250250    }
    251251
    252     for ( i; z(Nx) ) {
     252    for ( i; Nx ) {
    253253        assert(( wxyz[[ 2, i, 4, 5 ]] == getMagicNumber(2, i, 4, 5) ));
    254254    }
    255255
    256     for ( i; z(Ny) ) {
     256    for ( i; Ny ) {
    257257        assert(( wxyz[[ 2, 3, i, 5 ]] == getMagicNumber(2, 3, i, 5) ));
    258258    }
    259259
    260     for ( i; z(Nz) ) {
     260    for ( i; Nz ) {
    261261        assert(( wxyz[[ 2, 3, 4, i ]] == getMagicNumber(2, 3, 4, i) ));
    262262    }
    263263
    264     for ( i; z(Nw) ) {
     264    for ( i; Nw ) {
    265265        assert(( wxyz[[ i, all, 4, 5 ]][3] == getMagicNumber(i, 3, 4, 5) ));
    266266    }
    267267
    268     for ( i; z(Nw) ) {
     268    for ( i; Nw ) {
    269269        assert(( wxyz[[ all, 3, 4, 5 ]][i] == getMagicNumber(i, 3, 4, 5) ));
    270270    }
Note: See TracChangeset for help on using the changeset viewer.