// Copyright (c) 2015 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and/or associated documentation files (the
// "Materials"), to deal in the Materials without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Materials, and to
// permit persons to whom the Materials are furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Materials.
//
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
//    https://www.khronos.org/registry/
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

#ifndef LIBSPIRV_OPERAND_H_
#define LIBSPIRV_OPERAND_H_

#include <deque>

#include "libspirv/libspirv.h"
#include "table.h"

/// @brief A sequence of operand types.
///
/// A SPIR-V parser uses an operand pattern to describe what is expected
/// next on the input.
///
/// As we parse an instruction in text or binary form from left to right,
/// we pull and push from the front of the pattern.
using spv_operand_pattern_t = std::deque<spv_operand_type_t>;

/// @brief Find the named operand in the table
///
/// @param[in] table to lookup
/// @param[in] type the operand group's type
/// @param[in] name of the operand to find
/// @param[in] nameLength number of bytes of name to compare
/// @param[out] pEntry returned operand table entry
///
/// @return result code
spv_result_t spvOperandTableNameLookup(const spv_operand_table table,
                                       const spv_operand_type_t type,
                                       const char* name,
                                       const size_t nameLength,
                                       spv_operand_desc* pEntry);

/// @brief Find the operand with value in the table
///
/// @param[in] table to lookup
/// @param[in] type the operand group's type
/// @param[in] value of the operand to find
/// @param[out] pEntry return operand table entry
///
/// @return result code
spv_result_t spvOperandTableValueLookup(const spv_operand_table table,
                                        const spv_operand_type_t type,
                                        const uint32_t value,
                                        spv_operand_desc* pEntry);

/// @brief Get the name string of the non-variable operand type
///
/// @param type the type of the operand
///
/// @return the string name of the operand
const char* spvOperandTypeStr(spv_operand_type_t type);

/// @brief Returns true if an operand of the given type is optional.
///
/// @param[in] type The operand type
///
/// @return bool
bool spvOperandIsOptional(spv_operand_type_t type);

/// @brief Returns true if an operand type represents zero or more
/// logical operands.
///
/// Note that a single logical operand may still be a variable number
/// of words.  For example, a literal string may be many words, but
/// is just one logical operand.
///
/// @param[in] type The operand type
///
/// @return bool
bool spvOperandIsVariable(spv_operand_type_t type);

/// @brief Inserts a list of operand types into the front of the given pattern.
///
/// @param[in] types source array of types, ending with SPV_OPERAND_TYPE_NONE.
/// @param[in,out] pattern the destination sequence
void spvPrependOperandTypes(const spv_operand_type_t* types,
                            spv_operand_pattern_t* pattern);

/// @brief Inserts the operands expected after the given typed mask onto the
/// front of the given pattern.
///
/// Each set bit in the mask represents zero or more operand types that should
/// be prepended onto the pattern.  Operands for a less significant bit always
/// appear before operands for a more significant bit.
///
/// If a set bit is unknown, then we assume it has no operands.
///
/// @param[in] operandTable the table of operand type definitions
/// @param[in] type the type of operand
/// @param[in] mask the mask value for the given type
/// @param[in,out] pattern the destination sequence of operand types
void spvPrependOperandTypesForMask(const spv_operand_table operandTable,
                                   const spv_operand_type_t type,
                                   const uint32_t mask,
                                   spv_operand_pattern_t* pattern);

/// @brief Expands an operand type representing zero or more logical operands,
/// exactly once.
///
/// If the given type represents potentially several logical operands,
/// then prepend the given pattern with the first expansion of the logical
/// operands, followed by original type.  Otherwise, don't modify the pattern.
///
/// For example, the SPV_OPERAND_TYPE_VARIABLE_ID represents zero or more
/// IDs.  In that case we would prepend the pattern with SPV_OPERAND_TYPE_ID
/// followed by SPV_OPERAND_TYPE_VARIABLE_ID again.
///
/// This also applies to zero or more tuples of logical operands.  In that case
/// we prepend pattern with for the members of the tuple, followed by the
/// original type argument.  The pattern must encode the fact that if any part
/// of the tuple is present, then all tuple members should be.  So the first
/// member of the tuple must be optional, and the remaining members
/// non-optional.
///
/// @param [in] type an operand type, maybe representing a sequence of operands
/// @param [in,out] pattern the list of operand types
///
/// @return true if we modified the pattern
bool spvExpandOperandSequenceOnce(spv_operand_type_t type,
                                  spv_operand_pattern_t* pattern);

/// Expands the first element in the pattern until it is a matchable operand
/// type, then pops it off the front and returns it.  The pattern must not be
/// empty.
///
/// A matchable operand type is anything other than a zero-or-more-items
/// operand type.
spv_operand_type_t spvTakeFirstMatchableOperand(spv_operand_pattern_t* pattern);

/// Calculates the corresponding post-immediate alternate pattern, which allows
/// a limited set of operand types.
spv_operand_pattern_t spvAlternatePatternFollowingImmediate(
    const spv_operand_pattern_t& pattern);

#endif  // LIBSPIRV_OPERAND_H_