source: translator/Parser/ExpressionNode.cc@ fe3b61b

#include <cassert>
#include <cctype>
#include <algorithm>

#include "ParseNode.h"
#include "SynTree/Type.h"
#include "SynTree/Constant.h"
#include "SynTree/Expression.h"
#include "SynTree/Declaration.h"
#include "UnimplementedError.h"
#include "parseutility.h"
#include "utility.h"

using namespace std;

ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}

ExpressionNode::ExpressionNode(string *name_) : ParseNode( *name_ ), argName( 0 ) {
    delete name_;
}

ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
    if ( other.argName ) {
        argName = other.argName->clone();
    } else {
        argName = 0;
    }
}

ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) {
    argName = new VarRefNode(aName);
    return this;
}

ExpressionNode * ExpressionNode::set_asArgName( ExpressionNode *aDesignator ) {
    argName = aDesignator;
    return this;
}

void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
    if ( argName ) {
        os << string(' ', indent) << "(designated by:  ";
        argName->printOneLine(os, indent );
        os << ")" << std::endl;
    }
}

NullExprNode::NullExprNode() {}

NullExprNode *NullExprNode::clone() const {
    return new NullExprNode();
}

void NullExprNode::print(std::ostream & os, int indent) const {
    printDesignation(os);
    os << "null expression";
}

void NullExprNode::printOneLine(std::ostream & os, int indent) const {
    printDesignation(os);
    os << "null";
}

Expression *NullExprNode::build() const {
    return 0;
}

CommaExprNode *ExpressionNode::add_to_list(ExpressionNode *exp){
    return new CommaExprNode(this, exp );
}

//  enum ConstantNode::Type =  { Integer, Float, Character, String, Range }

ConstantNode::ConstantNode(void) : ExpressionNode(), sign(true), longs(0), size(0) {}

ConstantNode::ConstantNode(string *name_) : ExpressionNode(name_), sign(true), longs(0), size(0) {}

ConstantNode::ConstantNode(Type t, string *inVal) : type(t), sign(true), longs(0), size(0) {
    if ( inVal ) {
        value = *inVal;
        delete inVal;
    } else {
        value = "";
    }

    classify(value);
}

ConstantNode::ConstantNode( const ConstantNode &other )
    : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ), base( other.base ), longs( other.longs ), size( other.size ) {
}

// for some reason, std::tolower doesn't work as an argument to std::transform in g++ 3.1
inline char tolower_hack( char c ) {
    return std::tolower( c );
}

void ConstantNode::classify(std::string &str){
    switch (type){
      case Integer:
      case Float:
        {
            std::string sfx("");
            char c;
            int i = str.length() - 1;

            while ( i >= 0 && !isxdigit(c = str.at(i--)) )
                sfx += c;

            value = str.substr( 0, i + 2 );

            // get rid of underscores
            value.erase(remove(value.begin(), value.end(), '_'), value.end());

            std::transform(sfx.begin(), sfx.end(), sfx.begin(), tolower_hack);

            if ( sfx.find("ll") != string::npos ){
                longs = 2;
            } else if (sfx.find("l") != string::npos ){
                longs = 1;
            }

            assert((longs >= 0) && (longs <= 2));

            if ( sfx.find("u") != string::npos )
                sign = false;

            break;
        }
      case Character:
        {
            // remove underscores from hex and oct escapes
            if (str.substr(1,2) == "\\x")
                value.erase(remove(value.begin(), value.end(), '_'), value.end());

            break;
        }
      default:
        // shouldn't be here
        ;
    }
}

ConstantNode::Type ConstantNode::get_type(void) const {
    return type;
}

ConstantNode *ConstantNode::append( std::string *newValue ) {
    if ( newValue ) {
        if (type == String){
            std::string temp = *newValue;
            value.resize( value.size() - 1 );
            value += newValue->substr(1, newValue->size());
        } else
            value += *newValue;

        delete newValue;
    }
    return this;
}

void ConstantNode::printOneLine(std::ostream &os, int indent ) const {
    os << string(indent, ' ');
    printDesignation(os);

    switch ( type ) {
        /* integers */
      case Integer:
        os << value ;
        break;
      case Float:
        os << value ;
        break;

      case Character:
        os << "'" << value << "'";
        break;

      case String:
        os << '"' << value << '"';
        break;
    }

    os << ' ';
}

void ConstantNode::print(std::ostream &os, int indent ) const {
    printOneLine( os, indent );
    os << endl;
}

Expression *ConstantNode::build() const {
    ::Type::Qualifiers q;
    BasicType *bt;

    switch (get_type()){
      case Integer:
        /* Cfr. standard 6.4.4.1 */
        //bt.set_kind(BasicType::SignedInt);
        bt = new BasicType(q, BasicType::SignedInt);
        break;
      case Float:
        bt = new BasicType(q, BasicType::Float);
        break;
      case Character:
        bt = new BasicType(q, BasicType::Char);
        break;
      case String:
        // string should probably be a primitive type
        ArrayType *at;
        std::string value = get_value();
        at = new ArrayType(q, new BasicType(q, BasicType::Char),
                           new ConstantExpr( Constant( new BasicType(q, BasicType::SignedInt),
                                                       toString( value.size() - 1 ) ) ),  // account for '\0'
                           false, false );
        return new ConstantExpr( Constant(at, value), maybeBuild< Expression >( get_argName() ) );
    }
    return new ConstantExpr(  Constant(bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
}

VarRefNode::VarRefNode() : isLabel(false) {}

VarRefNode::VarRefNode(string *name_, bool labelp) : ExpressionNode(name_), isLabel(labelp) {}

VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
}

Expression *VarRefNode::build() const {
    return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
}

void VarRefNode::printOneLine(std::ostream &os, int indent ) const {
    printDesignation(os);
    os << get_name() << ' ';
}

void VarRefNode::print(std::ostream &os, int indent ) const {
    printDesignation(os);
    os << '\r' << string(indent, ' ') << "Referencing: ";
    os << "Variable: " << get_name();
    os << endl;
}

OperatorNode::OperatorNode(Type t) : type(t) {}

OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
}

OperatorNode::~OperatorNode() {}

OperatorNode::Type OperatorNode::get_type(void) const{
    return type;
}

void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
    printDesignation(os);
    os << OpName[ type ] << ' ';
}

void OperatorNode::print( std::ostream &os, int indent ) const{
    printDesignation(os);
    os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl;
    return;
}

std::string OperatorNode::get_typename(void) const{
    return string(OpName[ type ]);
}

const char *OperatorNode::OpName[] = {
    "TupleC",  "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic
    // triadic
    "Cond",   "NCond",
    // diadic
    "SizeOf",      "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
    "And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
    "LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
    "MinusAssn", "LSAssn", "RSAssn",  "AndAssn", "ERAssn",  "OrAssn",  "Index",   "FieldSel","PFieldSel",
    "Range",
    // monadic
    "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress"
};

CompositeExprNode::CompositeExprNode(void) : ExpressionNode(), function( 0 ), arguments( 0 ) {
}

CompositeExprNode::CompositeExprNode(string *name_) : ExpressionNode(name_), function( 0 ), arguments( 0 ) {
}

CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *args):
    function(f), arguments(args) {
}

CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
    function(f), arguments(arg1) {
    arguments->set_link(arg2);
}

CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ) {
    ParseNode *cur = other.arguments;
    while ( cur ) {
        if ( arguments ) {
            arguments->set_link( cur->clone() );
        } else {
            arguments = (ExpressionNode*)cur->clone();
        }
        cur = cur->get_link();
    }
}

CompositeExprNode::~CompositeExprNode() {
    delete function;
    delete arguments;
}

// the names that users use to define operator functions
static const char *opFuncName[] = {
    "",  "", "",
    "",   "",
    // diadic
    "",   "", "", "", "?+?",    "?-?",   "?*?",     "?/?",     "?%?",     "",       "",
    "?|?",  "?&?",  "?^?",     "",    "?<<?",  "?>>?",  "?<?",   "?>?",    "?<=?",
    "?>=?", "?==?",      "?!=?",     "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
    "?<<=?", "?>>=?",  "?&=?", "?^=?",  "?|=?",  "?[?]",   "","","Range",
    // monadic
    "+?", "-?", "", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "LabAddress"
};

#include "utility.h"

Expression *CompositeExprNode::build() const {
    OperatorNode *op;
    std::list<Expression *> args;

    buildList(get_args(), args);

    if ( ! ( op = dynamic_cast<OperatorNode *>(function)) ) {
        // a function as opposed to an operator
        return new UntypedExpr(function->build(), args, maybeBuild< Expression >( get_argName() ));
    } else {
        switch (op->get_type()){
          case OperatorNode::Incr:
          case OperatorNode::Decr:
          case OperatorNode::IncrPost:
          case OperatorNode::DecrPost:
          case OperatorNode::Assign:
          case OperatorNode::MulAssn:
          case OperatorNode::DivAssn:
          case OperatorNode::ModAssn:
          case OperatorNode::PlusAssn:
          case OperatorNode::MinusAssn:
          case OperatorNode::LSAssn:
          case OperatorNode::RSAssn:
          case OperatorNode::AndAssn:
          case OperatorNode::ERAssn:
          case OperatorNode::OrAssn:
            // the rewrite rules for these expressions specify that the first argument has its address taken
            assert( !args.empty() );
            args.front() = new AddressExpr( args.front() );
            break;
          default:
            /* do nothing */
            ;
        }

        switch ( op->get_type() ) {
          case OperatorNode::Incr:
          case OperatorNode::Decr:
          case OperatorNode::IncrPost:
          case OperatorNode::DecrPost:
          case OperatorNode::Assign:
          case OperatorNode::MulAssn:
          case OperatorNode::DivAssn:
          case OperatorNode::ModAssn:
          case OperatorNode::PlusAssn:
          case OperatorNode::MinusAssn:
          case OperatorNode::LSAssn:
          case OperatorNode::RSAssn:
          case OperatorNode::AndAssn:
          case OperatorNode::ERAssn:
          case OperatorNode::OrAssn:
          case OperatorNode::Plus:
          case OperatorNode::Minus:
          case OperatorNode::Mul:
          case OperatorNode::Div:
          case OperatorNode::Mod:
          case OperatorNode::BitOr:
          case OperatorNode::BitAnd:
          case OperatorNode::Xor:
          case OperatorNode::LShift:
          case OperatorNode::RShift:
          case OperatorNode::LThan:
          case OperatorNode::GThan:
          case OperatorNode::LEThan:
          case OperatorNode::GEThan:
          case OperatorNode::Eq:
          case OperatorNode::Neq:
          case OperatorNode::Index:
          case OperatorNode::Range:
          case OperatorNode::UnPlus:
          case OperatorNode::UnMinus:
          case OperatorNode::PointTo:
          case OperatorNode::Neg:
          case OperatorNode::BitNeg:
          case OperatorNode::LabelAddress:
            return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
          case OperatorNode::AddressOf:
            assert( args.size() == 1 );
            assert( args.front() );

            return new AddressExpr( args.front() );
          case OperatorNode::Cast:
            {
                TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args());
                assert( arg );

                DeclarationNode *decl_node = arg->get_decl();
                ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>(arg->get_link());

                Type *targetType = decl_node->buildType();
                if ( dynamic_cast< VoidType* >( targetType ) ) {
                    delete targetType;
                    return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
                } else {
                    return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
                }
            }
          case OperatorNode::FieldSel:
            {
                assert( args.size() == 2 );

                NameExpr *member = dynamic_cast<NameExpr *>(args.back());
                // TupleExpr *memberTup = dynamic_cast<TupleExpr *>(args.back());

                if ( member != 0 )
                    {
                        UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), args.front());
                        delete member;
                        return ret;
                    }
                /* else if ( memberTup != 0 )
                   {
                   UntypedMemberExpr *ret = new UntypedMemberExpr(memberTup->get_name(), args.front());
                   delete member;
                   return ret;
                   } */
                else
                    assert( false );
            }
          case OperatorNode::PFieldSel:
            {
                assert( args.size() == 2 );

                NameExpr *member = dynamic_cast<NameExpr *>(args.back());  // modify for Tuples   xxx
                assert( member != 0 );

                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                deref->get_args().push_back( args.front() );

                UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref);
                delete member;
                return ret;
            }
          case OperatorNode::AlignOf:
          case OperatorNode::SizeOf:
            {
///     bool isSizeOf = (op->get_type() == OperatorNode::SizeOf);

                if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()) ) {
                    return new SizeofExpr(arg->get_decl()->buildType());
                } else {
                    return new SizeofExpr(args.front());
                }
            }
          case OperatorNode::Attr:
            {
                VarRefNode *var = dynamic_cast<VarRefNode *>(get_args());
                assert( var );
                if ( !get_args()->get_link() ) {
                    return new AttrExpr(var->build(), (Expression*)0);
                } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()->get_link()) ) {
                    return new AttrExpr(var->build(), arg->get_decl()->buildType());
                } else {
                    return new AttrExpr(var->build(), args.back());
                }
            }
          case OperatorNode::CompLit:
            throw UnimplementedError( "C99 compound literals" );
            // the short-circuited operators
          case OperatorNode::Or:
          case OperatorNode::And:
            assert(args.size() == 2);
            return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), (op->get_type() == OperatorNode::And) );
          case OperatorNode::Cond:
            {
                assert(args.size() == 3);
                std::list< Expression* >::const_iterator i = args.begin();
                Expression *arg1 = notZeroExpr( *i++ );
                Expression *arg2 = *i++;
                Expression *arg3 = *i++;
                return new ConditionalExpr( arg1, arg2, arg3 );
            }
          case OperatorNode::NCond:
            throw UnimplementedError( "GNU 2-argument conditional expression" );
          case OperatorNode::Comma:
            {
                assert(args.size() == 2);
                std::list< Expression* >::const_iterator i = args.begin();
                Expression *ret = *i++;
                while ( i != args.end() ) {
                    ret = new CommaExpr( ret, *i++ );
                }
                return ret;
            }
            // Tuples
          case OperatorNode::TupleC:
            {
                TupleExpr *ret = new TupleExpr();
                std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
                return ret;
            }
          default:
            // shouldn't happen
            return 0;
        }
    }
}

void CompositeExprNode::printOneLine(std::ostream &os, int indent) const {
    printDesignation(os);
    os << "( ";
    function->printOneLine( os, indent );
    for( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
        cur->printOneLine( os, indent );
    }
    os << ") ";
}

void CompositeExprNode::print(std::ostream &os, int indent) const {
    printDesignation(os);
    os << '\r' << string(indent, ' ') << "Application of: " << endl;
    function->print( os, indent + ParseNode::indent_by );

    os << '\r' << string(indent, ' ') ;
    if ( arguments ) {
        os << "... on arguments: " << endl;
        arguments->printList(os, indent + ParseNode::indent_by);
    } else
        os << "... on no arguments: " << endl;
}

void CompositeExprNode::set_function(ExpressionNode *f){
    function = f;
}

void CompositeExprNode::set_args(ExpressionNode *args){
    arguments = args;
}

ExpressionNode *CompositeExprNode::get_function(void) const {
    return function;
}

ExpressionNode *CompositeExprNode::get_args(void) const {
    return arguments;
}

void CompositeExprNode::add_arg(ExpressionNode *arg){
    if (arguments)
        arguments->set_link(arg);
    else
        set_args(arg);
}

CommaExprNode::CommaExprNode(): CompositeExprNode(new OperatorNode(OperatorNode::Comma)) {}

CommaExprNode::CommaExprNode(ExpressionNode *exp) : CompositeExprNode( new OperatorNode(OperatorNode::Comma), exp ) {
}

CommaExprNode::CommaExprNode(ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode(new OperatorNode(OperatorNode::Comma), exp1, exp2) {
}

CommaExprNode *CommaExprNode::add_to_list(ExpressionNode *exp){
    add_arg(exp);

    return this;
}

CommaExprNode::CommaExprNode( const CommaExprNode &other ) : CompositeExprNode( other ) {
}

ValofExprNode::ValofExprNode(StatementNode *s): body(s) {}

ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
}

ValofExprNode::~ValofExprNode() {
    delete body;
}

void ValofExprNode::print( std::ostream &os, int indent ) const {
    printDesignation(os);
    os << string(indent, ' ') << "Valof Expression:" << std::endl;
    get_body()->print(os, indent + 4);
}

void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
    assert( false );
}

Expression *ValofExprNode::build() const {
    return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
}

ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr) throw (SemanticError) : condition(cond), change(incr) {
    if ( init_ == 0 )
        init = 0;
    else {
        DeclarationNode *decl;
        ExpressionNode *exp;

        if ((decl = dynamic_cast<DeclarationNode *>(init_)) != 0)
            init = new StatementNode(decl);
        else if ((exp = dynamic_cast<ExpressionNode *>(init_)) != 0)
            init = new StatementNode(StatementNode::Exp, exp);
        else
            throw SemanticError("Error in for control expression");
    }
}

ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
    : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
}

ForCtlExprNode::~ForCtlExprNode(){
    delete init;
    delete condition;
    delete change;
}

Expression *ForCtlExprNode::build() const {
    // this shouldn't be used!
    assert( false );
    return 0;
}

void ForCtlExprNode::print( std::ostream &os, int indent ) const{
    os << string(indent,' ') << "For Control Expression -- : " << endl;

    os << "\r" << string(indent + 2,' ') << "initialization: ";
    if (init != 0)
        init->print(os, indent + 4);

    os << "\n\r" << string(indent + 2,' ') << "condition: ";
    if (condition != 0)
        condition->print(os, indent + 4);
    os << "\n\r" << string(indent + 2,' ') << "increment: ";
    if (change != 0)
        change->print(os, indent + 4);
}

void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
    assert( false );
}

TypeValueNode::TypeValueNode(DeclarationNode *decl)
    : decl( decl ) {
}

TypeValueNode::TypeValueNode( const TypeValueNode &other )
    : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
}

Expression *TypeValueNode::build() const {
    return new TypeExpr( decl->buildType() );
}

void TypeValueNode::print(std::ostream &os, int indent) const {
    os << std::string( indent, ' ' ) << "Type:";
    get_decl()->print(os, indent + 2);
}

void TypeValueNode::printOneLine(std::ostream &os, int indent) const {
    os << "Type:";
    get_decl()->print(os, indent + 2);
}

ExpressionNode *flattenCommas( ExpressionNode *list ) {
    if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) )
        {
            OperatorNode *op;
            if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) )
                {
                    if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
                        composite->add_arg( next );
                    return flattenCommas( composite->get_args() );
                }
        }

    if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
        list->set_next( flattenCommas( next ) );

    return list;
}

ExpressionNode *tupleContents( ExpressionNode *tuple ) {
    if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
        OperatorNode *op = 0;
        if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) )
            return composite->get_args();
    }
    return tuple;
}