include/comma/ast/SubroutineCall.h

Go to the documentation of this file.

//===-- ast/SubroutineCall.h ---------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_SUBROUTINECALL_HDR_GUARD
#define COMMA_AST_SUBROUTINECALL_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/SubroutineRef.h"

namespace comma {

class SubroutineCall {

public:
    SubroutineCall(SubroutineRef *connective,
                   Expr **positionalArgs, unsigned numPositional,
                   KeywordSelector **keyedArgs, unsigned numKeys);

    SubroutineCall(SubroutineDecl *connective,
                   Expr **positionalArgs, unsigned numPositional,
                   KeywordSelector **keyedArgs, unsigned numKeys);

    virtual ~SubroutineCall();

    bool isaFunctionCall() const;

    bool isaProcedureCall() const;

    bool denotesOperator() const;


    FunctionCallExpr *asFunctionCall();
    const FunctionCallExpr *asFunctionCall() const;


    ProcedureCallStmt *asProcedureCall();
    const ProcedureCallStmt *asProcedureCall() const;

    virtual Location getLocation() const = 0;

    bool isAmbiguous() const {
        return connective->isOverloaded() || connective->empty();
    }

    bool isUnambiguous() const { return !isAmbiguous(); }

    bool isPrimitive() const {
        return isUnambiguous() && getConnective()->isPrimitive();
    }

    bool isAttributeCall() const;



    bool isLocalCall() const;

    bool isDirectCall() const;

    bool isAbstractCall() const;

    bool isForeignCall() const;

    virtual void resolveConnective(SubroutineDecl *connective);

    unsigned getNumArgs() const { return numPositional + numKeys; }

    unsigned getNumPositionalArgs() const { return numPositional; }

    unsigned getNumKeyedArgs() const { return numKeys; }

    bool containsConnective(SubroutineType *srTy) const {
        return connective->contains(srTy);
    }

    unsigned numConnectives() const { return connective->numDeclarations(); }


    const SubroutineDecl *getConnective(unsigned i) const {
        return connective->getDeclaration(i);
    }
    SubroutineDecl *getConnective(unsigned i) {
        return connective->getDeclaration(i);
    }




    SubroutineDecl *getConnective() {
        assert(isUnambiguous() &&
               "No unique connective associated with this call!");
        return connective->getDeclaration(0);
    }

    const SubroutineDecl *getConnective() const {
        assert(isUnambiguous() &&
               "No unique connective associated with this call!");
        return connective->getDeclaration(0);
    }



    typedef SubroutineRef::iterator connective_iterator;
    connective_iterator begin_connectives() { return connective->begin(); }
    connective_iterator end_connectives() { return connective->end(); }

    typedef SubroutineRef::const_iterator const_connective_iterator;
    const_connective_iterator begin_connectives() const {
        return connective->begin();
    }
    const_connective_iterator end_connectives() const {
        return connective->end();
    }


    typedef Expr **arg_iterator;
    arg_iterator begin_arguments() {
        assert(isUnambiguous() &&
               "Cannot iterate over the arguments of an ambiguous call expr!");
        return arguments ? &arguments[0] : 0;
    }
    arg_iterator end_arguments() {
        assert(isUnambiguous() &&
               "Cannot iterate over the arguments of an ambiguous call expr!");
        return arguments ? &arguments[getNumArgs()] : 0;
    }

    typedef const Expr *const *const_arg_iterator;
    const_arg_iterator begin_arguments() const {
        assert(isUnambiguous() &&
               "Cannot iterate over the arguments of an ambiguous call expr!");
        return arguments ? &arguments[0] : 0;
    }
    const_arg_iterator end_arguments() const {
        assert(isUnambiguous() &&
               "Cannot iterate over the arguments of an ambiguous call expr!");
        return arguments ? &arguments[getNumArgs()] : 0;
    }


    arg_iterator begin_positional() {
        return numPositional ? &arguments[0] : 0;
    }
    arg_iterator end_positional() {
        return numPositional ? &arguments[numPositional] : 0;
    }

    const_arg_iterator begin_positional() const {
        return numPositional ? &arguments[0] : 0;
    }
    const_arg_iterator end_positional() const {
        return numPositional ? &arguments[numPositional] : 0;
    }


    typedef KeywordSelector **key_iterator;
    key_iterator begin_keys() { return numKeys ? &keyedArgs[0] : 0; }
    key_iterator end_keys() { return numKeys ? &keyedArgs[numKeys] : 0; }

    typedef KeywordSelector *const *const_key_iterator;
    const_key_iterator begin_keys() const {
        return numKeys ? &keyedArgs[0] : 0;
    }
    const_key_iterator end_keys() const {
        return numKeys ? &keyedArgs[numKeys] : 0;
    }


    void setArgument(arg_iterator I, Expr *expr);
    void setArgument(key_iterator I, Expr *expr);

    Ast *asAst();
    const Ast *asAst() const;

    // Support isa and dyn_cast.
    static bool classof(const Ast *node) {
        Ast::AstKind kind = node->getKind();
        return (kind == Ast::AST_FunctionCallExpr ||
                kind == Ast::AST_ProcedureCallStmt);
    }
    static bool classof(const FunctionCallExpr *node) { return true; }
    static bool classof(const ProcedureCallStmt *node) { return true; }

protected:
    SubroutineRef *connective;
    Expr **arguments;
    KeywordSelector **keyedArgs;
    unsigned numPositional;
    unsigned numKeys;

    bool isCompatible(SubroutineDecl *decl) const;

    int argExprIndex(Expr *expr) const;

    int keyExprIndex(Expr *expr) const;

private:
    void initializeArguments(Expr **posArgs, unsigned numPos,
                             KeywordSelector **keyArgs, unsigned numKeys);

    void propagateKeyedArguments();
};

} // end comma namespace.

namespace llvm {

// Specialize isa_impl_wrap to test if a SubroutineCall is a specific Ast node.
template<class To>
struct isa_impl_wrap<To,
                     const comma::SubroutineCall, const comma::SubroutineCall> {
    static bool doit(const comma::SubroutineCall &val) {
        return To::classof(val.asAst());
    }
};

template<class To>
struct isa_impl_wrap<To, comma::SubroutineCall, comma::SubroutineCall>
  : public isa_impl_wrap<To,
                         const comma::SubroutineCall,
                         const comma::SubroutineCall> { };

// Ast to SubroutineCall conversions.
template<class From>
struct cast_convert_val<comma::SubroutineCall, From, From> {
    static comma::SubroutineCall &doit(const From &val) {
        const From *ptr = &val;
        return (dyn_cast<comma::FunctionCallExpr>(ptr) ||
                dyn_cast<comma::ProcedureCallStmt>(ptr));
    }
};

template<class From>
struct cast_convert_val<comma::SubroutineCall, From*, From*> {
    static comma::SubroutineCall *doit(const From *val) {
        return (dyn_cast<comma::FunctionCallExpr>(val) ||
                dyn_cast<comma::ProcedureCallStmt>(val));
    }
};

template<class From>
struct cast_convert_val<const comma::SubroutineCall, From, From> {
    static const comma::SubroutineCall &doit(const From &val) {
        const From *ptr = &val;
        return (dyn_cast<comma::FunctionCallExpr>(ptr) ||
                dyn_cast<comma::ProcedureCallStmt>(ptr));
    }
};

template<class From>
struct cast_convert_val<const comma::SubroutineCall, From*, From*> {
    static const comma::SubroutineCall *doit(const From *val) {
        return (dyn_cast<comma::FunctionCallExpr>(val) ||
                dyn_cast<comma::ProcedureCallStmt>(val));
    }
};

// SubroutineCall to Ast conversions.
template<class To>
struct cast_convert_val<To,
                        const comma::SubroutineCall,
                        const comma::SubroutineCall> {
    static To &doit(const comma::SubroutineCall &val) {
        return *reinterpret_cast<To*>(
            const_cast<comma::Ast*>(val.asAst()));
    }
};

template<class To>
struct cast_convert_val<To, comma::SubroutineCall, comma::SubroutineCall>
    : public cast_convert_val<To,
                              const comma::SubroutineCall,
                              const comma::SubroutineCall> { };

template<class To>
struct cast_convert_val<To,
                        const comma::SubroutineCall*,
                        const comma::SubroutineCall*> {
    static To *doit(const comma::SubroutineCall *val) {
        return reinterpret_cast<To*>(
            const_cast<comma::Ast*>(val->asAst()));
    }
};

template<class To>
struct cast_convert_val<To, comma::SubroutineCall*, comma::SubroutineCall*>
    : public cast_convert_val<To,
                              const comma::SubroutineCall*,
                              const comma::SubroutineCall*> { };

} // end llvm namespace;


#endif

---