include/comma/parser/ParseClient.h

Go to the documentation of this file.

//===-- parser/ParseClient.h ---------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_PARSECLIENT_HDR_GUARD
#define COMMA_PARSECLIENT_HDR_GUARD

#include "comma/basic/ParameterModes.h"
#include "comma/basic/IdentifierInfo.h"

#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/PointerIntPair.h"

namespace llvm {

class APInt;

} // end llvm namespace

namespace comma {

class ParseClient;

//===----------------------------------------------------------------------===//
// Node
//
// This class encapsulates (in a non-type-safe manner) the internal data
// structures produced by a ParseClient, and provides automatic memory
// management of that data by way of a reference counting mechanism.
//
// When a ParseClient returns data to the parser, it wraps it up in a Node
// instance.  This provides a uniform, opaque handle on the data which the
// parser can collect and submit back to the ParseClient.
//
// A Node provides automatic memory management using a reference counting
// mechanism.  Nodes can be freely copied and assigned to.  Each Node contains a
// pointer to the ParseClient which produced its associated data.  When the
// reference count drops to zero, ParseClient::deleteNode is called with the
// Node about to be freed, giving the ParseClient the opportunity to manage to
// allocation of its data.
//
// In general, automatic reclamation of nodes occurs when an error is
// encountered during parsing, or during the analysis performed by the
// ParseClient itself.  When the ParseClient accepts a particular construct that
// the parser produces, the associated Node's are typically released, thereby
// inhibiting the automatic reclamation that would otherwise occur.
//
// A Node can be marked as "invalid", meaning that the data which is associated
// with the Node is malformed in some respect.  A ParseClient can return invalid
// nodes to indicate that it could not handle a construct produced by the
// parser.  The parser in turn never submits an invalid Node back to the client.
class Node {

    // This simple structure is used to maintain the ParseClient and reference
    // count associated with each node.
    struct NodeState {

        // Disjoint properties associated with each node, recorded in the low
        // order bits of NodeState::client.
        enum Property {
            None     = 0,      
            Invalid  = 1,      
            Released = 2       
        };

        // The ParseClient associated with this node.  We encode the
        // NodePropertys associated with this node in the low order bits of this
        // field as it is expected to be accessed relatively infrequently.
        llvm::PointerIntPair<ParseClient *, 2> client;

        // The reference count.
        unsigned rc;

        // The payload associated with this node.
        void *payload;

        // NOTE: Constructor initializes the reference count to 1.
        NodeState(ParseClient *client,
                  void *ptr = 0, Property prop = None)
            : client(client, prop),
              rc(1),
              payload(ptr) { }

    private:
        // Do not implement.
        NodeState(const NodeState &state);
        NodeState &operator=(const NodeState &state);
    };

    // Construction of nodes is prohibited except by the ParseClient producing
    // them.  Thus, all direct constructors are private and we define the
    // ParseClient as a friend.
    Node(ParseClient *client, void *ptr, NodeState::Property prop)
        : state(new NodeState(client, ptr, prop)) { }

    Node(ParseClient *client, void *ptr = 0)
        : state(new NodeState(client, ptr)) { }

    static Node getInvalidNode(ParseClient *client) {
        return Node(client, 0, NodeState::Invalid);
    }

    static Node getNullNode(ParseClient *client) {
        return Node(client);
    }

    friend class ParseClient;

public:
    Node(const Node &node)
        : state(node.state) {
        ++state->rc;
    }

    ~Node() { dispose(); }

    Node &operator=(const Node &node);


    // Returns true if this node is invalid.
    bool isInvalid() const {
        return state->client.getInt() & NodeState::Invalid;
    }

    // Returns true if this Node is valid.
    bool isValid() const { return !isInvalid(); }

    // Marks this node as invalid.
    void markInvalid();

    // Returns true if this Node is not associated with any data.
    bool isNull() const {
        return state->payload == 0;
    }

    // Releases ownership of this node (and all copies).
    void release();

    // Returns true if this Node owns the associated pointer.
    bool isOwning();

    // Returns the reference count associated with this node.
    unsigned getRC() { return state->rc; }

    // Returns the pointer associated with this node cast to the supplied type.
    template <class T> static T *lift(Node &node) {
        return reinterpret_cast<T*>(node.state->payload);
    }

private:
    void dispose();

    // Heap-allocated state associated with this node (and all copies).
    NodeState *state;
};

//===----------------------------------------------------------------------===//
// NodeVector
//
// A simple vector type which manages a collection of Node's.  This type
// provides a release method which releases all of the Node's associated with
// the vector.
class NodeVector : public llvm::SmallVector<Node, 16> {
public:
    void release();
};

class ParseClient {

public:
    Node getNullNode() { return Node::getNullNode(this); }

    Node getInvalidNode() { return Node::getInvalidNode(this); }

    virtual void deleteNode(Node &node) = 0;


    virtual void beginCapsule() = 0;
    virtual void endCapsule() = 0;










    virtual void beginGenericFormals() = 0;
    virtual void endGenericFormals() = 0;

    virtual void acceptFormalDomain(IdentifierInfo *name, Location loc,
                                    Node sig) = 0;


    virtual void beginDomainDecl(IdentifierInfo *name, Location loc) = 0;
    virtual void beginSignatureDecl(IdentifierInfo *name, Location loc) = 0;











    virtual void beginSignatureProfile() = 0;
    virtual void endSignatureProfile() = 0;

    virtual void acceptSupersignature(Node typeNode) = 0;

    virtual void beginAddExpression() = 0;

    virtual void endAddExpression() = 0;

    virtual void acceptCarrier(IdentifierInfo *name, Location loc,
                               Node typeNode) = 0;


    virtual void beginFunctionDeclaration(IdentifierInfo *name,
                                          Location loc) = 0;
    virtual void beginProcedureDeclaration(IdentifierInfo *name,
                                           Location loc) = 0;

    virtual void acceptFunctionReturnType(Node typeNode) = 0;

    virtual void acceptSubroutineParameter(IdentifierInfo *formal, Location loc,
                                           Node typeNode,
                                           PM::ParameterMode mode) = 0;

    virtual Node endSubroutineDeclaration(bool definitionFollows) = 0;



    virtual Node beginSubroutineDefinition(Node declarationNode) = 0;

    virtual void endSubroutineBody(Node context) = 0;

    virtual void endSubroutineDefinition() = 0;


    virtual Node acceptDirectName(IdentifierInfo *name, Location loc,
                                  bool forStatement) = 0;

    virtual Node acceptCharacterLiteral(IdentifierInfo *lit, Location loc) = 0;

    virtual Node acceptSelectedComponent(Node prefix,
                                         IdentifierInfo *name,
                                         Location loc,
                                         bool forStatement) = 0;

    virtual Node acceptParameterAssociation(IdentifierInfo *key,
                                            Location loc, Node rhs) = 0;

    virtual Node acceptApplication(Node prefix, NodeVector &argumentNodes) = 0;

    virtual Node acceptAttribute(Node prefix,
                                 IdentifierInfo *name, Location loc) = 0;

    virtual Node finishName(Node name) = 0;




    virtual void beginAggregate(Location loc) = 0;

    virtual void acceptPositionalAggregateComponent(Node component) = 0;

    virtual Node acceptAggregateKey(Node lower, Node upper) = 0;

    virtual Node acceptAggregateKey(Node key) = 0;

    virtual Node acceptAggregateKey(IdentifierInfo *name, Location loc) = 0;

    virtual void acceptKeyedAggregateComponent(NodeVector &keys,
                                               Node expr, Location loc) = 0;

    virtual void acceptAggregateOthers(Location loc, Node component) = 0;

    virtual Node endAggregate() = 0;




    virtual Node beginForStmt(Location loc,
                              IdentifierInfo *iterName, Location iterLoc,
                              Node control, bool isReversed) = 0;

    virtual Node endForStmt(Node forNode, NodeVector &bodyNodes) = 0;



    virtual Node acceptDSTDefinition(Node name, Node lower, Node upper) = 0;

    virtual Node acceptDSTDefinition(Node nameOrAttribute,
                                     bool isUnconstrained) = 0;

    virtual Node acceptDSTDefinition(Node lower, Node upper) = 0;



    virtual Node beginBlockStmt(Location loc, IdentifierInfo *label = 0) = 0;

    virtual void endBlockStmt(Node block) = 0;



    virtual Node beginHandlerStmt(Location loc, NodeVector &choices) = 0;

    virtual void endHandlerStmt(Node context, Node handler) = 0;

    virtual Node acceptNullStmt(Location loc) = 0;

    virtual bool acceptStmt(Node context, Node stmt) = 0;

    virtual bool acceptObjectDeclaration(Location loc, IdentifierInfo *name,
                                         Node type, Node initializer) = 0;

    virtual bool acceptRenamedObjectDeclaration(Location loc,
                                                IdentifierInfo *name,
                                                Node type, Node target) = 0;

    virtual Node acceptPercent(Location loc) = 0;

    virtual Node acceptProcedureCall(Node name) = 0;

    virtual Node acceptInj(Location loc, Node expr) = 0;

    virtual Node acceptPrj(Location loc, Node expr) = 0;

    virtual Node acceptIntegerLiteral(llvm::APInt &value, Location loc) = 0;

    virtual Node acceptStringLiteral(const char *string, unsigned len,
                                     Location loc) = 0;

    virtual Node acceptNullExpr(Location loc) = 0;

    virtual Node acceptAllocatorExpr(Node operand, Location loc) = 0;

    virtual Node acceptQualifiedExpr(Node qualifier, Node operand) = 0;

    virtual Node acceptDereference(Node prefix, Location loc) = 0;

    virtual bool acceptImportDeclaration(Node importedType) = 0;

    virtual Node acceptIfStmt(Location loc, Node condition,
                              NodeVector &consequents) = 0;

    virtual Node acceptElseStmt(Location loc, Node ifNode,
                                NodeVector &alternates) = 0;

    virtual Node acceptElsifStmt(Location loc, Node ifNode, Node condition,
                                 NodeVector &consequents) = 0;

    virtual Node acceptEmptyReturnStmt(Location loc) = 0;

    virtual Node acceptReturnStmt(Location loc, Node retNode) = 0;

    virtual Node acceptAssignmentStmt(Node target, Node value) = 0;

    virtual Node acceptWhileStmt(Location loc, Node condition,
                                 NodeVector &stmtNodes) = 0;

    virtual Node acceptLoopStmt(Location loc, NodeVector &stmtNodes) = 0;

    virtual Node acceptRaiseStmt(Location loc, Node exception,
                                 Node message) = 0;

    virtual Node acceptPragmaStmt(IdentifierInfo *name, Location loc,
                                  NodeVector &pragmaArgs) = 0;

    virtual void
    acceptPragmaImport(Location pragmaLoc,
                       IdentifierInfo *convention, Location conventionLoc,
                       IdentifierInfo *enity, Location entityLoc,
                       Node externalNameNode) = 0;









    virtual void beginEnumeration(IdentifierInfo *name, Location loc) = 0;

    virtual void acceptEnumerationIdentifier(IdentifierInfo *name,
                                             Location loc) = 0;

    virtual void acceptEnumerationCharacter(IdentifierInfo *name,
                                            Location loc) = 0;

    virtual void endEnumeration() = 0;

    virtual void acceptIntegerTypeDecl(IdentifierInfo *name, Location loc,
                                       Node low, Node high) = 0;

    virtual void acceptRangedSubtypeDecl(IdentifierInfo *name, Location loc,
                                         Node subtype,
                                         Node low, Node high) = 0;

    virtual void acceptSubtypeDecl(IdentifierInfo *name, Location loc,
                                   Node subtype) = 0;

    virtual void acceptIncompleteTypeDecl(IdentifierInfo *name,
                                          Location loc) = 0;

    virtual void acceptAccessTypeDecl(IdentifierInfo *name, Location loc,
                                      Node subtype) = 0;

    virtual void acceptArrayDecl(IdentifierInfo *name, Location loc,
                                 NodeVector indices, Node component) = 0;



    virtual void beginRecord(IdentifierInfo *name, Location loc) = 0;

    virtual void acceptRecordComponent(IdentifierInfo *name, Location loc,
                                       Node type) = 0;

    virtual void endRecord() = 0;

protected:
    Node getNode(void *ptr) { return Node(this, ptr); }

    Node getReleasedNode(void *ptr) {
        Node node(this, ptr);
        node.release();
        return node;
    }
};

//===----------------------------------------------------------------------===//
// Inline methods.

inline void Node::dispose()
{
    assert(state->rc != 0);
    if (--state->rc == 0) {
        if (isOwning())
            state->client.getPointer()->deleteNode(*this);
        delete state;
    }
}

inline Node &Node::operator=(const Node &node)
{
    if (state != node.state) {
        ++node.state->rc;
        dispose();
        state = node.state;
    }
    return *this;
}

inline void Node::release()
{
    unsigned prop = state->client.getInt();
    state->client.setInt(prop | NodeState::Released);
}

inline bool Node::isOwning()
{
    return !(state->client.getInt() & NodeState::Released);
}

inline void Node::markInvalid()
{
    unsigned prop = state->client.getInt();
    state->client.setInt(prop | NodeState::Invalid);
}

inline void NodeVector::release()
{
    for (iterator iter = begin(); iter != end(); ++iter)
        iter->release();
}

} // End comma namespace.

#endif

---