// Copyright 2015 The Shaderc Authors. All rights reserved.

//

// 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.

#ifndef GLSLC_FILE_COMPILER_H

#define GLSLC_FILE_COMPILER_H

#include <string>

#include "libshaderc_util/file_finder.h"

#include "libshaderc_util/string_piece.h"

#include "shaderc/shaderc.hpp"

#include "dependency_info.h"

namespace glslc {

// Describes an input file to be compiled.

struct InputFileSpec {

  std::string name;

  shaderc_shader_kind stage;

  shaderc_source_language language;

  std::string entry_point_name;

};

// Context for managing compilation of source GLSL files into destination

// SPIR-V files or preprocessed output.

class FileCompiler {

 public:

  enum class SpirvBinaryEmissionFormat {

    Unspecified,  // No binary output format specified, this is the only valid

                  // option when the compilation output is not in SPIR-V binary

                  // code form.

    Binary,       // Emits SPIR-V binary code directly.

    Numbers,      // Emits SPIR-V binary code as a list of hex numbers.

    CInitList,    // Emits SPIR-V binary code as a C-style initializer list

                  // of hex numbers.

    WGSL,         // Emits SPIR-V module converted to WGSL source text.

                  // Requires a build with Tint support.

  };

  FileCompiler()

      : output_type_(OutputType::SpirvBinary),

        binary_emission_format_(SpirvBinaryEmissionFormat::Unspecified),

        needs_linking_(true),

        total_warnings_(0),

        total_errors_(0) {}

  // Compiles a shader received as specified by input_file, returning true

  // on success and false otherwise. If force_shader_stage is not

  // shaderc_glsl_infer_source or any default shader stage then the given

  // shader_stage will be used, otherwise it will be determined from the source

  // or the file type.

  //

  // Places the compilation output into a new file whose name is derived from

  // input_file according to the rules from glslc/README.asciidoc.

  //

  // If version/profile has been forced, the shader's version/profile is set to

  // that value regardless of the #version directive in the source code.

  //

  // Any errors/warnings found in the shader source will be output to std::cerr

  // and increment the counts reported by OutputMessages().

  bool CompileShaderFile(const InputFileSpec& input_file);

  // Adds a directory to be searched when processing #include directives.

  //

  // Best practice: if you add an empty string before any other path, that will

  // correctly resolve both absolute paths and paths relative to the current

  // working directory.

  void AddIncludeDirectory(const std::string& path);

  // Sets the output filename. A name of "-" indicates standard output.

  void SetOutputFileName(const shaderc_util::string_piece& file) {

    output_file_name_ = file;

  }

  // Sets the format for SPIR-V binary compilation output.

  void SetSpirvBinaryOutputFormat(SpirvBinaryEmissionFormat format) {

    binary_emission_format_ = format;

  }

  // Returns false if any options are incompatible. The num_files parameter

  // represents the number of files that will be compiled.

  bool ValidateOptions(size_t num_files);

  // Outputs to std::cerr the number of warnings and errors if there are any.

  void OutputMessages();

  // Sets the flag to indicate individual compilation mode. In this mode, all

  // files are compiled individually and written to separate output files

  // instead of linked together. This method also disables linking and sets the

  // output file extension to ".spv". Disassembly mode and preprocessing only

  // mode override this mode and flags.

  void SetIndividualCompilationFlag();

  // Sets the flag to indicate disassembly mode. In this mode, the compiler

  // emits disassembled textual output, instead of outputting object files.

  // This method also sets the output file extension to ".spvasm" and disables

  // linking. This mode overrides individual compilation mode, and preprocessing

  // only mode overrides this mode.

  void SetDisassemblyFlag();

  // Sets the flag to indicate preprocessing only mode. In this mode, instead of

  // outputting object files, the compiler emits the preprocessed source files.

  // This method disables linking and sets the output file to stdout. This mode

  // overrides disassembly mode and individual compilation mode.

  void SetPreprocessingOnlyFlag();

  // Gets the reference of the compiler options which reflects the command-line

  // arguments.

  shaderc::CompileOptions& options() { return options_; }

  // Gets a pointer which points to the dependency info dumping hander. Creates

  // such a handler if such one does not exist.

  DependencyInfoDumpingHandler* GetDependencyDumpingHandler() {

    if (!dependency_info_dumping_handler_) {

      dependency_info_dumping_handler_.reset(

          new DependencyInfoDumpingHandler());

    }

    return dependency_info_dumping_handler_.get();

  }

 private:

  enum class OutputType {

    SpirvBinary,  // A binary module, as defined by the SPIR-V specification.

    SpirvAssemblyText,  // Assembly syntax defined by the SPIRV-Tools project.

    PreprocessedText,   // Preprocessed source code.

  };

  // Emits the compilation output from the given result to the given output

  // file and returns true if the result represents a successful compilation

  // step.  Otherwise returns false, possibly emits messages to the standard

  // error stream, and does not produce an output file.  Accumulates error

  // and warning counts for use by the OutputMessages() method.

  template <typename CompilationResultType>

  bool EmitCompiledResult(

      const CompilationResultType& result, const std::string& input_file_name,

      const std::string& output_file_name,

      shaderc_util::string_piece error_file_name,

      const std::unordered_set<std::string>& used_source_files);

  // Returns the final file name to be used for the output file.

  //

  // If an output file name is specified by the SetOutputFileName(), use that

  // argument as the final output file name.

  //

  // If the user did not specify an output filename:

  //  If linking is not required, and the input filename has a

  //  standard stage extension (e.g. .vert) then returns the input filename

  //  without directory names but with the result extenstion (e.g. .spv or

  //  .spvasm) appended.

  //

  //  If linking is not required, and the input file name does not have a

  //  standard stage extension, then also returns the directory-stripped input

  //  filename, but replaces its extension with the result extension. (If the

  //  resolved input filename does not have an extension, then appends the

  //  result extension.)

  //

  //  If linking is required and output filename is not specified, returns

  //  "a.spv".

  std::string GetOutputFileName(std::string input_filename);

  // Returns the candidate output file name deduced from input file name and

  // user specified output file name. It is computed as follows:

  //

  // If the user did specify an output filename and the compiler is not in

  // preprocessing-only mode, then returns that file name.

  //

  // If the user did not specify an output filename:

  //  If the input filename has a standard stage extension (e.g. .vert) then

  //  returns the input filename without directory names but with the result

  //  extenstion (e.g. .spv or .spvasm) appended.

  //

  //  If the input file name does not have a standard stage extension, then also

  //  returns the directory-stripped input filename, but replaces its extension

  //  with the result extension. (If the resolved input filename does not have

  //  an extension, then appends the result extension.)

  //

  //  When a resolved extension is not available because the compiler is in

  //  preprocessing-only mode or the compilation requires linking, use .spv as

  //  the extension.

  std::string GetCandidateOutputFileName(std::string input_filename);

  // Returns true if the compiler's output is preprocessed text.

  bool PreprocessingOnly() {

    return output_type_ == OutputType::PreprocessedText;

  }

  // Performs actual SPIR-V compilation on the contents of input files.

  shaderc::Compiler compiler_;

  // Reflects the command-line arguments and goes into

  // compiler_.CompileGlslToSpv().

  shaderc::CompileOptions options_;

  // What kind of output will be produced?

  OutputType output_type_;

  // The Flag to indicate to which format the output SPIR-V binary code should

  // be emitted.

  SpirvBinaryEmissionFormat binary_emission_format_;

  // A FileFinder used to substitute #include directives in the source code.

  shaderc_util::FileFinder include_file_finder_;

  // Indicates whether linking is needed to generate the final output.

  bool needs_linking_;

  // The ownership of dependency dumping handler.

  std::unique_ptr<DependencyInfoDumpingHandler>

      dependency_info_dumping_handler_ = nullptr;

  // Reflects the type of file being generated.

  std::string file_extension_;

  // Name of the file where the compilation output will go.

  shaderc_util::string_piece output_file_name_;

  // Counts warnings encountered in all compilations via this object.

  size_t total_warnings_;

  // Counts errors encountered in all compilations via this object.

  size_t total_errors_;

};

}  // namespace glslc

#endif  // GLSLC_FILE_COMPILER_H