source: translator/CodeGen/GenType.cc@ 643a2e1

#include <strstream>
#include <cassert>

#include "GenType.h"
#include "CodeGenerator2.h"
#include "SynTree/Visitor.h"
#include "SynTree/Type.h"
#include "SynTree/Expression.h"

namespace CodeGen {
    class GenType : public Visitor {
      public:
        GenType( const std::string &typeString );
        std::string get_typeString() const { return typeString; }
        void set_typeString( const std::string &newValue ) { typeString = newValue; }
  
        virtual void visit( FunctionType *funcType );
        virtual void visit( VoidType *voidType );
        virtual void visit( BasicType *basicType );
        virtual void visit( PointerType *pointerType );
        virtual void visit( ArrayType *arrayType );
        virtual void visit( StructInstType *structInst );
        virtual void visit( UnionInstType *unionInst );
        virtual void visit( EnumInstType *enumInst );
        virtual void visit( TypeInstType *typeInst );
  
      private:
        void handleQualifiers( Type *type );
        void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
  
        std::string typeString;
    };

    std::string genType( Type *type, const std::string &baseString ) {
        GenType gt( baseString );
        type->accept( gt );
        return gt.get_typeString();
    }

    GenType::GenType( const std::string &typeString ) : typeString( typeString ) {}

    void GenType::visit( VoidType *voidType ) {
        typeString = "void " + typeString;
        handleQualifiers( voidType );
    }

    void GenType::visit( BasicType *basicType ) {
        BasicType::Kind kind = basicType->get_kind();
        assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
        typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
        handleQualifiers( basicType );
    }

    void GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) {
        std::ostrstream os;
        if ( typeString != "" ) {
            if ( typeString[ 0 ] == '*' ) {
                os << "(" << typeString << ")";
            } else {
                os << typeString;
            } // if
        } // if
        os << "[";

        if ( isStatic ) {
            os << "static ";
        } // if
        if ( qualifiers.isConst ) {
            os << "const ";
        } // if
        if ( qualifiers.isVolatile ) {
            os << "volatile ";
        } // if
        if ( qualifiers.isRestrict ) {
            os << "__restrict ";
        } // if
        if ( isVarLen ) {
            os << "*";
        } // if
        if ( dimension != 0 ) {
            CodeGenerator2 cg( os );
            dimension->accept( cg );
        } // if
        os << "]";

        typeString = std::string( os.str(), os.pcount() );
  
        base->accept( *this );
    }

    void GenType::visit( PointerType *pointerType ) {
        assert( pointerType->get_base() != 0);
        if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->get_dimension() ) {
            genArray( pointerType->get_qualifiers(), pointerType->get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() );
        } else {
            handleQualifiers( pointerType );
            if ( typeString[ 0 ] == '?' ) {
                typeString = "* " + typeString;
            } else {
                typeString = "*" + typeString;
            } // if
            pointerType->get_base()->accept( *this );
        } // if
    }

    void GenType::visit( ArrayType *arrayType ){
        genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
    }

    void GenType::visit( FunctionType *funcType ) {
        std::ostrstream os;

        if ( typeString != "" ) {
            if ( typeString[ 0 ] == '*' ) {
                os << "(" << typeString << ")";
            } else {
                os << typeString;
            } // if
        } // if
  
        /************* parameters ***************/

        const std::list<DeclarationWithType *> &pars = funcType->get_parameters();

        if ( pars.empty() ) {
            if ( funcType->get_isVarArgs() ) {
                os << "()";
            } else {
                os << "(void)";
            } // if
        } else {
            CodeGenerator2 cg( os );
            os << "(" ;

            cg.genCommaList( pars.begin(), pars.end() );

            if ( funcType->get_isVarArgs() ){
                os << ", ...";
            } // if
            os << ")";
        } // if
  
        typeString = std::string( os.str(), os.pcount() );

        if ( funcType->get_returnVals().size() == 0 ) {
            typeString = "void " + typeString;
        } else {
            funcType->get_returnVals().front()->get_type()->accept( *this );
        } // if
    }

    void GenType::visit( StructInstType *structInst )  {
        typeString = "struct " + structInst->get_name() + " " + typeString;
        handleQualifiers( structInst );
    }

    void GenType::visit( UnionInstType *unionInst ) {
        typeString = "union " + unionInst->get_name() + " " + typeString;
        handleQualifiers( unionInst );
    }

    void GenType::visit( EnumInstType *enumInst ) {
        typeString = "enum " + enumInst->get_name() + " " + typeString;
        handleQualifiers( enumInst );
    }

    void GenType::visit( TypeInstType *typeInst ) {
        typeString = typeInst->get_name() + " " + typeString;
        handleQualifiers( typeInst );
    }

    void GenType::handleQualifiers( Type *type ) {
        if ( type->get_isConst() ) {
            typeString = "const " + typeString;
        } // if
        if ( type->get_isVolatile() ) {
            typeString = "volatile " + typeString;
        } // if
        if ( type->get_isRestrict() ) {
            typeString = "__restrict " + typeString;
        } // if
    }
} // namespace CodeGen