Changeset f43df73


Ignore:
Timestamp:
Sep 1, 2017, 11:04:35 PM (4 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
e612146c
Parents:
dbc733e
Message:

remove std:: qualifiers

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    rdbc733e rf43df73  
    77// ExpressionNode.cc --
    88//
    9 // Author           : Rodolfo G. Esteves
     9// Author           : Peter A. Buhr
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep  1 21:49:16 2017
    13 // Update Count     : 622
     12// Last Modified On : Fri Sep  1 22:57:24 2017
     13// Update Count     : 625
    1414//
    1515
     
    155155} // build_constantInteger
    156156
    157 Expression * build_constantFloat( std::string & str ) {
     157Expression * build_constantFloat( string & str ) {
    158158        static const BasicType::Kind kind[2][3] = {
    159159                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
     
    205205} // sepString
    206206
    207 Expression * build_constantChar( std::string & str ) {
     207Expression * build_constantChar( string & str ) {
    208208        string units;                                                                           // units
    209209        sepString( str, units, '\'' );                                          // separate constant from units
     
    218218} // build_constantChar
    219219
    220 ConstantExpr * build_constantStr( std::string & str ) {
     220ConstantExpr * build_constantStr( string & str ) {
    221221        string units;                                                                           // units
    222222        sepString( str, units, '"' );                                           // separate constant from units
     
    235235} // build_constantStr
    236236
    237 Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
     237Expression * build_field_name_FLOATINGconstant( const string & str ) {
    238238        // str is of the form A.B -> separate at the . and return member expression
    239239        int a, b;
    240240        char dot;
    241         std::stringstream ss( str );
     241        stringstream ss( str );
    242242        ss >> a >> dot >> b;
    243243        UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
     
    253253                } else {
    254254                        return new UntypedMemberExpr( fracts, fieldName );
    255                 }
    256         }
     255                } // if
     256        } // if
    257257        return fieldName;
    258258} // make_field_name_fraction_constants
     
    262262} // build_field_name_fraction_constants
    263263
    264 Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
     264Expression * build_field_name_REALFRACTIONconstant( const string & str ) {
    265265        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
    266         Expression * ret = build_constantInteger( *new std::string( str.substr(1) ) );
     266        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
    267267        delete &str;
    268268        return ret;
    269269} // build_field_name_REALFRACTIONconstant
    270270
    271 Expression * build_field_name_REALDECIMALconstant( const std::string & str ) {
     271Expression * build_field_name_REALDECIMALconstant( const string & str ) {
    272272        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
    273         Expression * ret = build_constantInteger( *new std::string( str.substr( 0, str.size()-1 ) ) );
     273        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
    274274        delete &str;
    275275        return ret;
     
    353353
    354354Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
    355         std::list< Expression * > args;
     355        list< Expression * > args;
    356356        args.push_back( maybeMoveBuild< Expression >(expr_node) );
    357357        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     
    359359
    360360Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
    361         std::list< Expression * > args;
     361        list< Expression * > args;
    362362        args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
    363363        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     
    365365
    366366Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
    367         std::list< Expression * > args;
     367        list< Expression * > args;
    368368        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
    369369        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
     
    372372
    373373Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
    374         std::list< Expression * > args;
     374        list< Expression * > args;
    375375        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
    376376        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
     
    395395
    396396Expression * build_tuple( ExpressionNode * expr_node ) {
    397         std::list< Expression * > exprs;
     397        list< Expression * > exprs;
    398398        buildMoveList( expr_node, exprs );
    399399        return new UntypedTupleExpr( exprs );;
     
    401401
    402402Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
    403         std::list< Expression * > args;
     403        list< Expression * > args;
    404404        buildMoveList( expr_node, args );
    405405        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
Note: See TracChangeset for help on using the changeset viewer.