//===-- Various CPP Macros For Doing Assertions -----------------*- 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/Base/Assert.h
/// @author Reid Spencer <rspencer@reidspencer.com>
/// @date 2006/05/20
/// @since 0.1
/// @brief Assertion and error checking macros.
///
/// This file provides various preprocessor macros that can be used to assist
/// the programmer to check assertions, handle dead code locations, do range
/// checking, etc. These are intended to be used to check class invariants,
/// function arguments, and other points in the logic where an assertion
/// can be made to ensure the program is operating within its parameters.
/// Note that if an assertion macro is triggered, it results in an
/// exception being thrown. Make sure that your code can exit cleanly in
/// the face of the assertion being thrown. Generally this means that
/// you should place all your assertions at the beginning of a function
/// so that you don't attempt to operate on the parameters or objects
/// that are outside of the specified limits. Also note that these macros
/// can be turned off with the HLVM_ASSERT configuration variable. Ensure
/// that no needed side effects are encapsulated in the arguments to these
/// macros as those side effects will disappear when building without the
/// HLVM_ASSERT configuration. Assertions should only be used to check
/// validity of logic that should always be true (such as parameter ranges)
/// but not for end user error messages.
////////////////////////////////////////////////////////////////////////////////

#ifndef HLVM_BASE_ASSERT_H
#define HLVM_BASE_ASSERT_H

#ifdef HLVM_ASSERT
#include <cassert>
#endif
/// This  macro enforces any expression that the programmer cares to
/// assert at the point in the program where the macro is used. The argument
/// can be any valid logical expression that can be used with the ! operator.
/// Note that the exception thrown will contain the text of the expression so
/// that it will be easier to identify which condition failed. Watch out for
/// side effects of the expression! Do all assignments before the assertion!
/// @param expr Any logic expression to be tested. The macro throws if the expression evaluates to false.
/// @brief Check an arbitrary expression for truth.
#ifdef HLVM_ASSERT
#define hlvmAssert( expr ) assert(expr)
#else
#define hlvmAssert( expr ) {}
#endif

/// The DEAD_CODE macro is intended to be used to signify locations in the 
/// code that should never be reached. It serves as a sentinel in the software 
/// and will \em always throw an exception when it is encountered. Use this to 
/// place some code in the \p default label of a switch statement that should 
/// not be reached or at the end of a function that should normally return 
/// through some other execution path.
/// @param msg Provides a message that will become part of the exception 
/// object thrown.
/// @brief Identify locations in the code that should not be reached.
#ifdef HLVM_ASSERT
#define hlvmDeadCode( msg ) assert(! "Dead Code:" msg)
#else
#define hlvmDeadCode( msg ) {}
#endif

/// This macro can be utilized to state that a function is not implemented. It
/// throws a "Not Implemented" exception that indicates the name of the function
/// that has not been implemented. This can be used as the sole content of any 
/// to ensure that unimplemented functionality is recognized. You should use 
/// this macro in every function when you are doing rapid prototyping.
/// @param msg Provides a message that will become part of the exception 
/// object thrown.
/// @brief Identify unimplemented functionality
#ifdef HLVM_ASSERT
#define hlvmNotImplemented( msg ) assert(! "Not Implemented:" msg)
#else
#define hlvmNotImplemented(msg) {}
#endif

/// This macro allows the programmer to make a range assertion about the 
/// \p value argument when compared with the \p min and \p max arguments. The 
/// \p value can be anything that is compatible with the \c < and \c > 
/// operators.  Note that the range being checked is inclusive of both \p min 
/// and \p max.
/// @param value The value checked against the \p min and \p max parameters.
/// @param min The (inclusive) minimum value to be checked.
/// @param max The (inclusive) maximum value to be checked.
/// @brief Check numerical range of a value.
#ifdef HLVM_ASSERT
#define hlvmRangeCheck( value, min, max ) \
  assert(((value)>=(min) || (value)<=(max)) && "Range Error!")
#else
#define hlvmRangeCheck(value,min,max) {}
#endif

namespace hlvm {
void panic(const char* msg);
}

#endif