Changeset 515a037 for src/Parser


Ignore:
Timestamp:
Dec 12, 2018, 3:52:19 PM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum
Children:
1b8f13f0
Parents:
cdc02f2 (diff), 85acec94 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into shared_library

Location:
src/Parser
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/DeclarationNode.cc

    rcdc02f2 r515a037  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 20 14:56:54 2018
    13 // Update Count     : 1107
     12// Last Modified On : Thu Nov  1 20:54:26 2018
     13// Update Count     : 1108
    1414//
    1515
    … …  
    402402}
    403403
    404 DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
    405         DeclarationNode * newnode = new DeclarationNode;
    406         newnode->type = new TypeData( TypeData::Typeof );
     404DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr, bool basetypeof ) {
     405        DeclarationNode * newnode = new DeclarationNode;
     406        newnode->type = new TypeData( basetypeof ? TypeData::Basetypeof : TypeData::Typeof );
    407407        newnode->type->typeexpr = expr;
    408408        return newnode;

  • src/Parser/ParseNode.h

    rcdc02f2 r515a037  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug  4 09:39:40 2018
    13 // Update Count     : 853
     12// Last Modified On : Thu Nov  1 20:54:53 2018
     13// Update Count     : 854
    1414//
    1515
    … …  
    249249        static DeclarationNode * newBitfield( ExpressionNode * size );
    250250        static DeclarationNode * newTuple( DeclarationNode * members );
    251         static DeclarationNode * newTypeof( ExpressionNode * expr );
     251        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
    252252        static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
    253253        static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes

  • src/Parser/TypeData.cc

    rcdc02f2 r515a037  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 20 14:39:31 2018
    13 // Update Count     : 622
     12// Last Modified On : Fri Nov  2 07:54:26 2018
     13// Update Count     : 624
    1414//
    1515
    … …  
    9696                break;
    9797          case Typeof:
     98          case Basetypeof:
    9899                // typeexpr = new Typeof_t;
    99100                typeexpr = nullptr;
    … …  
    166167                break;
    167168          case Typeof:
     169          case Basetypeof:
    168170                // delete typeexpr->expr;
    169171                delete typeexpr;
    … …  
    245247                break;
    246248          case Typeof:
     249          case Basetypeof:
    247250                newtype->typeexpr = maybeClone( typeexpr );
    248251                break;
    … …  
    419422                } // if
    420423                break;
     424          case Basetypeof:
     425                os << "base-";
     426                #if defined(__GNUC__) && __GNUC__ >= 7
     427                        __attribute__((fallthrough));
     428                #endif
    421429          case Typeof:
    422430                os << "type-of expression ";
    … …  
    457465          case Tuple:
    458466          case Typeof:
     467          case Basetypeof:
    459468          case Builtin:
    460469                assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
    … …  
    513522        switch ( td->kind ) {
    514523          case TypeData::Unknown:
    515                 // fill in implicit int
    516                 return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
     524                        // fill in implicit int
     525                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
    517526          case TypeData::Basic:
    518                 return buildBasicType( td );
     527                        return buildBasicType( td );
    519528          case TypeData::Pointer:
    520                 return buildPointer( td );
     529                        return buildPointer( td );
    521530          case TypeData::Array:
    522                 return buildArray( td );
     531                        return buildArray( td );
    523532          case TypeData::Reference:
    524                 return buildReference( td );
     533                        return buildReference( td );
    525534          case TypeData::Function:
    526                 return buildFunction( td );
     535                        return buildFunction( td );
    527536          case TypeData::AggregateInst:
    528                 return buildAggInst( td );
     537                        return buildAggInst( td );
    529538          case TypeData::EnumConstant:
    530                 // the name gets filled in later -- by SymTab::Validate
    531                 return new EnumInstType( buildQualifiers( td ), "" );
     539                        // the name gets filled in later -- by SymTab::Validate
     540                        return new EnumInstType( buildQualifiers( td ), "" );
    532541          case TypeData::SymbolicInst:
    533                 return buildSymbolicInst( td );
     542                        return buildSymbolicInst( td );
    534543          case TypeData::Tuple:
    535                 return buildTuple( td );
     544                        return buildTuple( td );
    536545          case TypeData::Typeof:
    537                 return buildTypeof( td );
     546          case TypeData::Basetypeof:
     547                        return buildTypeof( td );
    538548          case TypeData::Builtin:
    539                 if(td->builtintype == DeclarationNode::Zero) {
    540                         return new ZeroType( noQualifiers );
    541                 }
    542                 else if(td->builtintype == DeclarationNode::One) {
    543                         return new OneType( noQualifiers );
    544                 }
    545                 else {
    546                         return new VarArgsType( buildQualifiers( td ) );
    547                 }
     549                        if (td->builtintype == DeclarationNode::Zero) {
     550                                return new ZeroType( noQualifiers );
     551                        }
     552                        else if (td->builtintype == DeclarationNode::One) {
     553                                return new OneType( noQualifiers );
     554                        }
     555                        else {
     556                                return new VarArgsType( buildQualifiers( td ) );
     557                        }
    548558          case TypeData::GlobalScope:
    549                 return new GlobalScopeType();
     559                        return new GlobalScopeType();
    550560                case TypeData::Qualified:
    551                 return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
     561                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
    552562          case TypeData::Symbolic:
    553563          case TypeData::Enum:
    554564          case TypeData::Aggregate:
    555                 assert( false );
     565                        assert( false );
    556566        } // switch
    557567
    … …  
    929939
    930940TypeofType * buildTypeof( const TypeData * td ) {
    931         assert( td->kind == TypeData::Typeof );
     941        assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
    932942        assert( td->typeexpr );
    933943        // assert( td->typeexpr->expr );
    934         return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
     944        return new TypeofType{
     945                buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
    935946} // buildTypeof
    936947

  • src/Parser/TypeData.h

    rcdc02f2 r515a037  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 20 13:56:40 2018
    13 // Update Count     : 195
     12// Last Modified On : Thu Nov  1 20:56:46 2018
     13// Update Count     : 196
    1414//
    1515
    … …  
    2727struct TypeData {
    2828        enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
    29                                 SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Qualified, Unknown };
     29                                SymbolicInst, Tuple, Typeof, Basetypeof, Builtin, GlobalScope, Qualified, Unknown };
    3030
    3131        struct Aggregate_t {

  • src/Parser/lex.ll

    rcdc02f2 r515a037  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Sat Oct 20 09:42:45 2018
     12 * Last Modified On : Thu Nov  1 20:57:35 2018
    1313 * Update Count     : 687
    1414 */

  • src/Parser/parser.yy

    rcdc02f2 r515a037  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Oct 21 08:27:29 2018
    13 // Update Count     : 4045
     12// Last Modified On : Thu Nov  8 18:08:23 2018
     13// Update Count     : 4052
    1414//
    1515
    … …  
    187187
    188188ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    189         ConstantExpr *constant = dynamic_cast<ConstantExpr *>(type->get_expr());
     189        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
    190190        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
    191191        type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
    192192        } // if
    193193        return new ForCtrl(
    194                 distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
     194                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
    195195                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
    196196                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
    197197                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
     198<<<<<<< HEAD
     199=======
     200} // forCtrl
     201
     202ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
     203        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
     204                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
     205        } else {
     206                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
     207        } // if
     208>>>>>>> master
    198209} // forCtrl
    199210
    … …  
    11321143        | FOR '(' push for_control_expression ')' statement pop
    11331144                { $$ = new StatementNode( build_for( $4, $6 ) ); }
     1145        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
     1146                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
    11341147        ;
    11351148
    11361149for_control_expression:
     1150<<<<<<< HEAD
    11371151        comma_expression_opt                                                            // CFA
    11381152                {
    … …  
    11441158                        } // if
    11451159                }
     1160=======
     1161        comma_expression                                                                        // CFA
     1162                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
     1163                                                OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1164>>>>>>> master
    11461165        | constant_expression inclexcl constant_expression      // CFA
    11471166                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    11481167        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
    11491168                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
     1169<<<<<<< HEAD
    11501170        | comma_expression_opt ';' comma_expression                     // CFA
    11511171                {
    … …  
    11881208                }
    11891209        | comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
     1210=======
     1211        | comma_expression ';' comma_expression                         // CFA
     1212                { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
     1213                                                OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1214        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
     1215                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
     1216        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
     1217                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
     1218        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
     1219>>>>>>> master
    11901220                { $$ = new ForCtrl( $1, $3, $5 ); }
     1221        | ';' comma_expression_opt ';' comma_expression_opt
     1222                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
    11911223        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
    11921224                { $$ = new ForCtrl( $1, $2, $4 ); }
    … …  
    18501882
    18511883indirect_type:
    1852         TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
     1884        TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
    18531885                { $$ = $3; }
    1854         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
     1886        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
    18551887                { $$ = DeclarationNode::newTypeof( $3 ); }
     1888<<<<<<< HEAD
    18561889        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof(x) y;
    18571890                { $$ = $3; }
    … …  
    18591892                { $$ = DeclarationNode::newTypeof( $3 ); }
    18601893        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
     1894=======
     1895        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
     1896                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
     1897        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
     1898                { $$ = DeclarationNode::newTypeof( $3, true ); }
     1899        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
     1900>>>>>>> master
    18611901                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    1862         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
     1902        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
    18631903                { $$ = DeclarationNode::newAttr( $1, $3 ); }
    18641904        | ZERO_T                                                                                        // CFA
Note: See TracChangeset for help on using the changeset viewer.