//===-- AST Boolean Operators Interface -------------------------*- C++ -*-===//
//
//                      High Level Virtual Machine (HLVM)
//
// Copyright (C) 2006 Reid Spencer. All Rights Reserved.
//
// This software is free software; you can redistribute it and/or modify it 
// under the terms of the GNU Lesser General Public License as published by 
// the Free Software Foundation; either version 2.1 of the License, or (at 
// your option) any later version.
//
// This software is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for 
// more details.
//
// You should have received a copy of the GNU Lesser General Public License 
// along with this library in the file named LICENSE.txt; if not, write to the 
// Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA 02110-1301 USA
//
//===----------------------------------------------------------------------===//
/// @file hlvm/AST/BooleanOps.h
/// @author Reid Spencer <rspencer@reidspencer.com> (original author)
/// @date 2006/06/14
/// @since 0.2.0
/// @brief Declares the AST Boolean Operators 
//===----------------------------------------------------------------------===//

#ifndef HLVM_AST_BOOLEANOPS_H 
#define HLVM_AST_BOOLEANOPS_H 

#include <hlvm/AST/Operator.h>

namespace hlvm 
{

/// This class provides an Abstract Syntax Tree node that represents a not
/// operator. The NotOp is a unary operator that returns false if its operand is
/// is non-zero and true if its operand is zero.
/// @brief AST Not Operator Node   
class NotOp : public UnaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    NotOp() : UnaryOperator(NotOpID)  {}
    virtual ~NotOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const NotOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(NotOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// to compute the logical and of two quantities. The AndOp is a binary operator
/// that returns true if both its operands are non-zero and returns false
/// otherwise. 
/// @brief AST And Operator Node   
class AndOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    AndOp() : BinaryOperator(AndOpID)  {}
    virtual ~AndOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const AndOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(AndOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// to compute the logical or of two quantities. The OrOp is a binary operator
/// that returns false if both its operands are zero and returns true otherwise.
/// @brief AST Or Operator Node   
class OrOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    OrOp() : BinaryOperator(OrOpID)  {}
    virtual ~OrOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const OrOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(OrOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// to compute the logical nor of two quantities. The NorOp is a binary operator
/// that returns true if both its operands are zero and returns false
/// otherwise. 
/// @brief AST And Operator Node   
class NorOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    NorOp() : BinaryOperator(NorOpID)  {}
    virtual ~NorOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const NorOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(NorOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// to compute the logical exclusive or of two quantities. The XorOp is a 
/// binary operator that returns true if either of its operands are non-zero 
/// and returns false if both operands are zero or non-zero.
/// @brief AST Xor Operator Node   
class XorOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    XorOp() : BinaryOperator(XorOpID)  {}
    virtual ~XorOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const XorOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(XorOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// for performing less-than test. The LessThanOp compares its operands and if 
/// the first operand is less than the second operand it returns true, otherwise
/// it returns false.
/// @brief AST Less-Than Operator Node   
class LessThanOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    LessThanOp() : BinaryOperator(LessThanOpID)  {}
    virtual ~LessThanOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const LessThanOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(LessThanOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// for performing greater-than test. The GreaterThanOp compares its operands 
/// and if the first operand is greater than the second operand it returns true,
/// otherwise it returns false.
/// @brief AST Less-Than Operator Node   
class GreaterThanOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    GreaterThanOp() : BinaryOperator(GreaterThanOpID)  {}
    virtual ~GreaterThanOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const GreaterThanOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(GreaterThanOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// for performing less-equal test. The LessEqualOp compares its operands and 
/// if the first operand is less than or equal to the second operand it returns
/// true, otherwise it returns false.
/// @brief AST Less-Equal Operator Node   
class LessEqualOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    LessEqualOp() : BinaryOperator(LessEqualOpID)  {}
    virtual ~LessEqualOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const LessEqualOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(LessEqualOpID); }

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// for performing greater-equal test. The GreaterEqualOp compares its operands
/// and if the first operand is less than or equal to the second operand it 
/// returns true, otherwise it returns false.
/// @brief AST Less-Equal Operator Node   
class GreaterEqualOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    GreaterEqualOp() : BinaryOperator(GreaterEqualOpID)  {}
    virtual ~GreaterEqualOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const GreaterEqualOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(GreaterEqualOpID);}

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// for performing equality test. The EqualsOp compares its operands
/// and if the first operand is equal to the second operand it 
/// returns true, otherwise it returns false.
/// @brief AST Equality Operator Node   
class EqualityOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    EqualityOp() : BinaryOperator(EqualityOpID)  {}
    virtual ~EqualityOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const EqualityOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(EqualityOpID);}

  /// @}
  friend class AST;
};

/// This class provides an Abstract Syntax Tree node that represents an operator
/// for performing inequality test. The InequalityOp  compares its operands
/// and if the first operand is less than or equal to the second operand it 
/// returns true, otherwise it returns false.
/// @brief AST Inequality Operator Node   
class InequalityOp : public BinaryOperator
{
  /// @name Constructors
  /// @{
  protected:
    InequalityOp() : BinaryOperator(InequalityOpID)  {}
    virtual ~InequalityOp();

  /// @}
  /// @name Accessors
  /// @{
  public:
    static inline bool classof(const InequalityOp*) { return true; }
    static inline bool classof(const Node* N) { return N->is(InequalityOpID);}

  /// @}
  friend class AST;
};

} // end hlvm namespace

#endif