AVM_Defines.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//! @file       AVM_Defines.h
//! @brief      Scope defines header file.
//! @attention  No special attention requered.
//! @copyright  (C) 2015-2020 ANVILEX LLC
//!             $HeadURL: https://192.168.3.4:8443/svn/P004_07/ConOpSys/Defines/AVM_Defines.h $
//!             $Revision: 2075 $
//!             $Date: 2020-09-12 14:00:31 +0500 (Сб, 12 сен 2020) $
//!             $Author: minch $
//------------------------------------------------------------------------------
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of ANVILEX nor the names of its contributors may be
//    used to endorse or promote products derived from this software without 
//    specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
// POSSIBILITY OF SUCH DAMAGE.
//------------------------------------------------------------------------------
  
//------------------------------------------------------------------------------
// Protecting header files from mutual, recursive inclusion.
//------------------------------------------------------------------------------
 
#pragma once
 
//------------------------------------------------------------------------------
// Include standard libraries header files
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// Include thrid party header files
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// Include ConOpSys header files
//------------------------------------------------------------------------------
 
#include "Defines.h"
 
//------------------------------------------------------------------------------
// Include ConOpSys application header files
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// Macros
//------------------------------------------------------------------------------
 
//! @brief Commands for vertual machine
enum class TConOpSys_Opcode : U16
{
 
  //! @brief Unassigned command
  enum_Unassigned_Command = 0,
 
  //! @brief Unknown command
  enum_Unknown_Command = 1023,
  
  //----------------------------------------------------------------------------
  // Unar operators
  //----------------------------------------------------------------------------
  
  // '-'
  enum_NEG_I8    = 1,
  enum_NEG_I16   = 2,
  enum_NEG_U16   = 3,
  enum_NEG_I32   = 4,
  enum_NEG_F32   = 5,
  enum_NEG_I64   = 6,
  enum_NEG_F64   = 7,
  
  // '!'
  enum_NOT_BOOL  = 8,
  enum_NOT_I8    = 9,
  enum_NOT_U8    = 10,
  enum_NOT_I16   = 11,
  enum_NOT_U16   = 12,
  enum_NOT_I32   = 13,
  enum_NOT_U32   = 14,
  enum_NOT_F32   = 15,
  enum_NOT_I64   = 16,
  enum_NOT_U64   = 17,
  enum_NOT_F64   = 18,
 
  //----------------------------------------------------------------------------
  // Binar operators
  //----------------------------------------------------------------------------
  
  // '**' 
  enum_POW_I8  = 20,
  enum_POW_U8  = 21,
  enum_POW_I16 = 22,
  enum_POW_U16 = 23,
  enum_POW_I32 = 24,
  enum_POW_U32 = 25,
  enum_POW_F32 = 26,
  enum_POW_I64 = 27,
  enum_POW_U64 = 28,
  enum_POW_F64 = 29,
 
  // '*'
  enum_MUL_I8  = 30,
  enum_MUL_U8  = 31,
  enum_MUL_I16 = 32,
  enum_MUL_U16 = 33,
  enum_MUL_I32 = 34,
  enum_MUL_U32 = 35,
  enum_MUL_F32 = 36,
  enum_MUL_I64 = 37,
  enum_MUL_U64 = 38,
  enum_MUL_F64 = 39,
 
  // '/'
  enum_DIV_I8  = 40,
  enum_DIV_U8  = 41,
  enum_DIV_I16 = 42,
  enum_DIV_U16 = 43,
  enum_DIV_I32 = 44,
  enum_DIV_U32 = 45,
  enum_DIV_F32 = 46,
  enum_DIV_I64 = 47,
  enum_DIV_U64 = 48,
  enum_DIV_F64 = 49,
 
  // '%'
  enum_MOD_I8  = 50,
  enum_MOD_U8  = 51,
  enum_MOD_I16 = 52,
  enum_MOD_U16 = 53,
  enum_MOD_I32 = 54,
  enum_MOD_U32 = 55,
  enum_MOD_F32 = 56,
  enum_MOD_I64 = 57,
  enum_MOD_U64 = 58,
  enum_MOD_F64 = 59,
 
  // '+'
  enum_ADD_I8  = 60,
  enum_ADD_U8  = 61,
  enum_ADD_I16 = 62,
  enum_ADD_U16 = 63,
  enum_ADD_I32 = 64,
  enum_ADD_U32 = 65,
  enum_ADD_F32 = 66,
  enum_ADD_I64 = 67,
  enum_ADD_U64 = 68,
  enum_ADD_F64 = 69,
 
  // '-'
  enum_SUB_I8  = 70,
  enum_SUB_U8  = 71,
  enum_SUB_I16 = 72,
  enum_SUB_U16 = 73,
  enum_SUB_I32 = 74,
  enum_SUB_U32 = 75,
  enum_SUB_F32 = 76,
  enum_SUB_I64 = 77,
  enum_SUB_U64 = 78,
  enum_SUB_F64 = 79,
 
  // '<'
  enum_JL_I8  = 80,
  enum_JL_U8  = 81,
  enum_JL_I16 = 82,
  enum_JL_U16 = 83,
  enum_JL_I32 = 84,
  enum_JL_U32 = 85,
  enum_JL_F32 = 86,
  enum_JL_I64 = 87,
  enum_JL_U64 = 88,
  enum_JL_F64 = 89,
  
  // '>'
  enum_JG_I8  = 90,
  enum_JG_U8  = 91,
  enum_JG_I16 = 92,
  enum_JG_U16 = 93,
  enum_JG_I32 = 94,
  enum_JG_U32 = 95,
  enum_JG_F32 = 96,
  enum_JG_I64 = 97,
  enum_JG_U64 = 98,
  enum_JG_F64 = 99,
  
  // '<='
  enum_JLE_I8  = 100,
  enum_JLE_U8  = 101,
  enum_JLE_I16 = 102,
  enum_JLE_U16 = 103,
  enum_JLE_I32 = 104,
  enum_JLE_U32 = 105,
  enum_JLE_F32 = 106,
  enum_JLE_I64 = 107,
  enum_JLE_U64 = 108,
  enum_JLE_F64 = 109,
  
  // '>='
  enum_JGE_I8  = 110,
  enum_JGE_U8  = 111,
  enum_JGE_I16 = 112,
  enum_JGE_U16 = 113,
  enum_JGE_I32 = 114,
  enum_JGE_U32 = 115,
  enum_JGE_F32 = 116,
  enum_JGE_I64 = 117,
  enum_JGE_U64 = 118,
  enum_JGE_F64 = 119,
  
  // '=='
  enum_EQUL_BOOL = 120,
  enum_EQUL_I8   = 121,
  enum_EQUL_U8   = 122,
  enum_EQUL_I16  = 123,
  enum_EQUL_U16  = 124,
  enum_EQUL_I32  = 125,
  enum_EQUL_U32  = 126,
  enum_EQUL_F32  = 127,
  enum_EQUL_I64  = 128,
  enum_EQUL_U64  = 129,
  enum_EQUL_F64  = 130,
 
  // '!='
  enum_NOT_EQUL_BOOL = 131,
  enum_NOT_EQUL_I8   = 132,
  enum_NOT_EQUL_U8   = 133,
  enum_NOT_EQUL_I16  = 134,
  enum_NOT_EQUL_U16  = 135,
  enum_NOT_EQUL_I32  = 136,
  enum_NOT_EQUL_U32  = 137,
  enum_NOT_EQUL_F32  = 138,
  enum_NOT_EQUL_I64  = 139,
  enum_NOT_EQUL_U64  = 140,
  enum_NOT_EQUL_F64  = 141,
  
  // '&&'
  enum_AND_BOOL = 142,
  enum_AND_I8   = 143,
  enum_AND_U8   = 144,
  enum_AND_I16  = 145,
  enum_AND_U16  = 146,
  enum_AND_I32  = 147,
  enum_AND_U32  = 148,
  enum_AND_F32  = 149,
  enum_AND_I64  = 150,
  enum_AND_U64  = 151,
  enum_AND_F64  = 152,
  
  // '~~'
  enum_XOR_BOOL = 153,
  enum_XOR_I8   = 154,
  enum_XOR_U8   = 155,
  enum_XOR_I16  = 156,
  enum_XOR_U16  = 157,
  enum_XOR_I32  = 158,
  enum_XOR_U32  = 159,
  enum_XOR_F32  = 160,
  enum_XOR_I64  = 161,
  enum_XOR_U64  = 162,
  enum_XOR_F64  = 163,
 
  // '||'
  enum_OR_BOOL = 164,
  enum_OR_I8   = 165,
  enum_OR_U8   = 166,
  enum_OR_I16  = 167,
  enum_OR_U16  = 168,
  enum_OR_I32  = 169,
  enum_OR_U32  = 170,
  enum_OR_F32  = 171,
  enum_OR_I64  = 172,
  enum_OR_U64  = 173,
  enum_OR_F64  = 174,
 
  //! @brief Unconditional jump command
  enum_GO_TO = 200,
 
  //! @brief Сonditional jump command
  enum_IF_GO_TO = 201,
 
  //! @brief Halt program execution instruction
  enum_HALT = 202,
  
  //----------------------------------------------------------------------------
  // Stack operation instructions
  //----------------------------------------------------------------------------
 
  // S[SP] <= PC
  // SP = SP - 1
  // PC <= OP1
  enum_CALL = 210,
 
  //! @brief Move Debug
  //! @note May be replased by COPY SP, M[] command
  enum_RET = 211,
 
  //----------------------------------------------------------------------------
  // Data transfer instructions
  //----------------------------------------------------------------------------
 
  //! @brief Copy command
  enum_COPY_BOOL = 221,
  enum_COPY_I8   = 222,
  enum_COPY_U8   = 223,
  enum_COPY_I16  = 224,
  enum_COPY_U16  = 225,
  enum_COPY_I32  = 226,
  enum_COPY_U32  = 227,
  enum_COPY_F32  = 228,
  enum_COPY_I64  = 229,
  enum_COPY_U64  = 230,
  enum_COPY_F64  = 231,
 
  //! @brief Flush result register to data destination
//  enum_FLUSH,
 
};
 
//! @brief Operand location
enum class TConOpSys_Operand_Type : U16
{
 
  //! @brief Input allocated opreand
  enum_Input_Data_Type = 0,
 
  //! @brief Memory allocated opreand
  enum_Memory_Data_Type = 1,
 
  //! @brief Parameter allocated opreand
  enum_Parameter_Data_Type = 2,
 
  //! @brief Immidiate value opreand
  enum_Immidiate_Data_Type = 3
 
};
    
//! @brief Result location
enum class TConOpSys_Result_Type : U16
{
 
  //! @brief Output allocated opreand
  enum_Output_Data_Type = 0,
 
  //! @brief Memory allocated opreand
  enum_Memory_Data_Type = 2,
 
  //! @brief Parameter allocated opreand
  enum_Parameter_Data_Type = 1
 
};
 
//------------------------------------------------------------------------------
// End Of File
//------------------------------------------------------------------------------