// Copyright (c) 2017 Google Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include "source/spirv_validator_options.h"

#include <cassert>

#include <cstring>

bool spvParseUniversalLimitsOptions(const char* s, spv_validator_limit* type) {

  auto match = [s](const char* b) {

    return s && (0 == strncmp(s, b, strlen(b)));

  };

  if (match("--max-struct-members")) {

    *type = spv_validator_limit_max_struct_members;

  } else if (match("--max-struct_depth")) {

    *type = spv_validator_limit_max_struct_depth;

  } else if (match("--max-local-variables")) {

    *type = spv_validator_limit_max_local_variables;

  } else if (match("--max-global-variables")) {

    *type = spv_validator_limit_max_global_variables;

  } else if (match("--max-switch-branches")) {

    *type = spv_validator_limit_max_global_variables;

  } else if (match("--max-function-args")) {

    *type = spv_validator_limit_max_function_args;

  } else if (match("--max-control-flow-nesting-depth")) {

    *type = spv_validator_limit_max_control_flow_nesting_depth;

  } else if (match("--max-access-chain-indexes")) {

    *type = spv_validator_limit_max_access_chain_indexes;

  } else if (match("--max-id-bound")) {

    *type = spv_validator_limit_max_id_bound;

  } else {

    // The command line option for this validator limit has not been added.

    // Therefore we return false.

    return false;

  }

  return true;

}

spv_validator_options spvValidatorOptionsCreate(void) {

  return new spv_validator_options_t;

}

void spvValidatorOptionsDestroy(spv_validator_options options) {

  delete options;

}

void spvValidatorOptionsSetUniversalLimit(spv_validator_options options,

                                          spv_validator_limit limit_type,

                                          uint32_t limit) {

  assert(options && "Validator options object may not be Null");

  switch (limit_type) {

#define LIMIT(TYPE, FIELD)                    \

  case TYPE:                                  \

    options->universal_limits_.FIELD = limit; \

    break;

    LIMIT(spv_validator_limit_max_struct_members, max_struct_members)

    LIMIT(spv_validator_limit_max_struct_depth, max_struct_depth)

    LIMIT(spv_validator_limit_max_local_variables, max_local_variables)

    LIMIT(spv_validator_limit_max_global_variables, max_global_variables)

    LIMIT(spv_validator_limit_max_switch_branches, max_switch_branches)

    LIMIT(spv_validator_limit_max_function_args, max_function_args)

    LIMIT(spv_validator_limit_max_control_flow_nesting_depth,

          max_control_flow_nesting_depth)

    LIMIT(spv_validator_limit_max_access_chain_indexes,

          max_access_chain_indexes)

    LIMIT(spv_validator_limit_max_id_bound, max_id_bound)

#undef LIMIT

  }

}

void spvValidatorOptionsSetRelaxStoreStruct(spv_validator_options options,

                                            bool val) {

  options->relax_struct_store = val;

}

void spvValidatorOptionsSetRelaxLogicalPointer(spv_validator_options options,

                                               bool val) {

  options->relax_logical_pointer = val;

}

void spvValidatorOptionsSetBeforeHlslLegalization(spv_validator_options options,

                                                  bool val) {

  options->before_hlsl_legalization = val;

  options->relax_logical_pointer = val;

}

void spvValidatorOptionsSetRelaxBlockLayout(spv_validator_options options,

                                            bool val) {

  options->relax_block_layout = val;

}

void spvValidatorOptionsSetUniformBufferStandardLayout(

    spv_validator_options options, bool val) {

  options->uniform_buffer_standard_layout = val;

}

void spvValidatorOptionsSetScalarBlockLayout(spv_validator_options options,

                                             bool val) {

  options->scalar_block_layout = val;

}

void spvValidatorOptionsSetWorkgroupScalarBlockLayout(spv_validator_options options,

                                                      bool val) {

  options->workgroup_scalar_block_layout = val;

}

void spvValidatorOptionsSetSkipBlockLayout(spv_validator_options options,

                                           bool val) {

  options->skip_block_layout = val;

}

void spvValidatorOptionsSetAllowLocalSizeId(spv_validator_options options,

                                            bool val) {

  options->allow_localsizeid = val;

}

void spvValidatorOptionsSetAllowOffsetTextureOperand(

    spv_validator_options options, bool val) {

  options->allow_offset_texture_operand = val;

}

void spvValidatorOptionsSetAllowVulkan32BitBitwise(

    spv_validator_options options, bool val) {

  options->allow_vulkan_32_bit_bitwise = val;

}

void spvValidatorOptionsSetFriendlyNames(spv_validator_options options,

                                         bool val) {

  options->use_friendly_names = val;

}