Changeset 6a1dfda


Ignore:
Timestamp:
Jun 13, 2019, 8:41:11 PM (2 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
c36298d
Parents:
dc5072f (diff), 6896548 (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.
git-author:
Peter A. Buhr <pabuhr@…> (06/13/19 20:39:34)
git-committer:
Peter A. Buhr <pabuhr@…> (06/13/19 20:41:11)
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    rdc5072f r6a1dfda  
    733733        const ast::Expr * visit( const ast::VariableExpr * node ) override final {
    734734                auto expr = new VariableExpr();
     735                expr->var = get<DeclarationWithType>().accept1(node->var);
    735736                visitBaseExpr( node, expr );
    736                 expr->var = get<DeclarationWithType>().accept1(node->var);
    737                 Type * type = expr->var->get_type()->clone();
    738                 if(FunctionType * ft = dynamic_cast<FunctionType*>(type)) {
    739                         if(node->result.as<ast::PointerType>()) {
    740                                 type = new PointerType({}, ft);
    741                         }
    742                 }
    743 
    744                 type->set_lvalue( true );
    745                 expr->result = type ;
    746737                this->node = expr;
    747738                return nullptr;
     
    766757                        break;
    767758                case ast::ConstantExpr::String:
    768                         rslt = new ConstantExpr{Constant{
    769                                 get<Type>().accept1( node->result ),
    770                                 node->rep,
    771                                 (long long unsigned int)0
    772                         }};
     759                        // Old world:   two types: rslt->constant.type, rslt->result
     760                        // New workd:   one type: node->result
     761                        // Both worlds: the outer, expression-level type can change during resolution
     762                        //              in case of string, that's char[k] before-resolve and char * after
     763                        // Old world:   the inner Constant type stays what it was built with
     764                        //              in case of string, that's char[k]
     765                        // Both worlds: the "rep" field of a string constant is the string value it was initialized from, wrapped in quotes, but not otherwise escaped
     766                        ast::ptr<ast::Type> charType = nullptr;
     767                        if (const ast::ArrayType *arrRslt = node->result.as<ast::ArrayType>()) {
     768                                charType = arrRslt->base;
     769                        } else {
     770                                const ast::PointerType *ptrRslt = node->result.as<ast::PointerType>();
     771                                assert(ptrRslt);
     772                                charType = ptrRslt->base;
     773                        }
     774                        rslt = new ConstantExpr(Constant::from_string(
     775                                node->rep, get<Type>().accept1(charType)));          // rslt->result is char[k]
     776                        rslt->set_result( get<Type>().accept1( node->result ) ); // rslt->result is [[ node->rsult ]]
    773777                        break;
    774778                }
     
    21522156                );
    21532157
    2154                 visitBaseExpr_SkipResultType( old,
    2155                         expr
    2156                 );
    2157 
    21582158                expr->var = GET_ACCEPT_1(var, DeclWithType);
    2159                 expr->result = expr->var->get_type();
    2160                 if(const ast::FunctionType * ft = expr->result.as<ast::FunctionType>()) {
    2161                         if(dynamic_cast<PointerType *>(old->result)) {
    2162                                 expr->result = new ast::PointerType(ft);
    2163                         }
    2164                 }
    2165                 add_qualifiers( expr->result, ast::CV::Lvalue );
     2159                visitBaseExpr( old, expr );
     2160
    21662161                this->node = expr;
    21672162        }
     
    22142209                        rslt = new ast::ConstantExpr(
    22152210                                old->location,
    2216                                 GET_ACCEPT_1(result, Type),
     2211                                GET_ACCEPT_1(result, Type), // preserve the expression-level type (old->result, not old->constant.type); see new-to-old
    22172212                                old->constant.get_value(),
    22182213                                0,
  • src/AST/Expr.cpp

    rdc5072f r6a1dfda  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May 15 17:00:00 2019
    11 // Last Modified By : Aaron B. Moss
    12 // Created On       : Wed May 15 17:00:00 2019
    13 // Update Count     : 1
     11// Last Modified By : Andrew Beach
     12// Created On       : Thr Jun 13 13:38:00 2019
     13// Update Count     : 2
    1414//
    1515
     
    238238}
    239239
    240 ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & s ) {
    241         return new ConstantExpr{
    242                 loc,
    243                 new ArrayType{
    244                         new BasicType{ BasicType::Char, CV::Const },
    245                         ConstantExpr::from_int( loc, s.size() + 1 /* null terminator */ ),
    246                         FixedLen, DynamicDim },
    247                 std::string{"\""} + s + "\"",
    248                 (unsigned long long)0,
    249                 ConstantExpr::String };
    250 }
    251 
    252240ConstantExpr * ConstantExpr::null( const CodeLocation & loc, const Type * ptrType ) {
    253241        return new ConstantExpr{
     
    382370
    383371UniqueExpr::UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i )
    384 : Expr( loc, e->result ), id( i ) {
     372: Expr( loc, e->result ), expr( e ), id( i ) {
    385373        assert( expr );
    386374        if ( id == -1ull ) {
  • src/AST/Expr.hpp

    rdc5072f r6a1dfda  
    381381        /// generates a floating point constant of the given double
    382382        static ConstantExpr * from_double( const CodeLocation & loc, double d );
    383         /// generates an array of chars constant of the given string
    384         static ConstantExpr * from_string( const CodeLocation & loc, const std::string & s );
    385383        /// generates a null pointer value for the given type. void * if omitted.
    386384        static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
     
    693691        unsigned long long id;
    694692
    695         UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1 );
     693        UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1ull );
    696694
    697695        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
  • src/Parser/ExpressionNode.cc

    rdc5072f r6a1dfda  
    354354                strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
    355355        } // switch
    356         ArrayType * at = new ArrayType( noQualifiers, strtype,
    357                                                                         new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
    358                                                                         false, false );
    359         Expression * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
     356        Expression * ret = new ConstantExpr( Constant::from_string( str, strtype ) );
    360357        if ( units.length() != 0 ) {
    361358                ret = new UntypedExpr( new NameExpr( units ), { ret } );
  • src/ResolvExpr/Candidate.hpp

    rdc5072f r6a1dfda  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed Jun 5 14:30:00 2019
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Wed Jun 5 14:30:00 2019
    13 // Update Count     : 1
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Jun 12 14:15:00 2019
     13// Update Count     : 2
    1414//
    1515
     
    4949
    5050        Candidate() : expr(), cost( Cost::zero ), cvtCost( Cost::zero ), env(), open(), need() {}
    51        
     51
    5252        Candidate( const ast::Expr * x, const ast::TypeEnvironment & e )
    5353        : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() {}
    5454
    5555        Candidate( const Candidate & o, const ast::Expr * x )
    56         : expr( x ), cost( o.cost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ), 
     56        : expr( x ), cost( o.cost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ),
    5757          need( o.need ) {}
    58        
    59         Candidate( 
    60                 const ast::Expr * x, ast::TypeEnvironment && e, ast::OpenVarSet && o, 
    61                 ast::AssertionSet && n, const Cost & c )
    62         : expr( x ), cost( c ), cvtCost( Cost::zero ), env( std::move( e ) ), open( std::move( o ) ),
     58
     59        Candidate(
     60                const ast::Expr * x, ast::TypeEnvironment && e, ast::OpenVarSet && o,
     61                ast::AssertionSet && n, const Cost & c, const Cost & cvt = Cost::zero )
     62        : expr( x ), cost( c ), cvtCost( cvt ), env( std::move( e ) ), open( std::move( o ) ),
    6363          need( n.begin(), n.end() ) {}
    6464};
  • src/SynTree/Constant.cc

    rdc5072f r6a1dfda  
    5151}
    5252
    53 Constant Constant::from_string( std::string const & str ) {
    54         return Constant(
    55                 new ArrayType(
    56                         noQualifiers,
    57                         new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
    58                         new ConstantExpr( Constant::from_int( str.size() + 1 /* \0 */ )),
    59                         false, false ),
    60                 std::string("\"") + str + "\"", (unsigned long long int)0 );
     53Constant Constant::from_string( std::string const & cEscapedVal, Type *charType ) {
     54        assert(cEscapedVal.length() >= 2);
     55        assert(cEscapedVal.front() == '"');
     56        assert(cEscapedVal.back() == '"');
     57        ArrayType * at = new ArrayType( noQualifiers, charType,
     58                                                                        new ConstantExpr( Constant::from_ulong( cEscapedVal.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
     59                                                                        false, false );
     60        return Constant( at, cEscapedVal, (unsigned long long int)0 );
    6161}
    6262
  • src/SynTree/Constant.h

    rdc5072f r6a1dfda  
    5252        static Constant from_double( double d );
    5353        /// generates an array of chars constant of the given string
    54         static Constant from_string( std::string const & s );
     54        static Constant from_string( std::string const & cEscapedVal, Type *charType );
    5555
    5656        /// generates a null pointer value for the given type. void * if omitted.
  • tests/.in/manipulatorsInput.txt

    rdc5072f r6a1dfda  
    55abcyyy
    66aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
    7 abc
    87abc
    98xx
Note: See TracChangeset for help on using the changeset viewer.