/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmSourceFilePropertyHelper.h"

#include <cm/string_view>

#include <cmext/string_view>

#include "cmExecutionStatus.h"

#include "cmGlobalGenerator.h"

#include "cmMakefile.h"

#include "cmPolicies.h"

#include "cmSetPropertyCommand.h"

#include "cmSourceFile.h"

#include "cmSystemTools.h"

#include "cmValue.h"

namespace {

bool GetSourceFilePropertyGENERATED(std::string const& name, cmMakefile& mf,

                                    cmValue& propertyValue)

{

  // Globally set as generated?

  // Note: If the given "name" only contains a filename or a relative path

  //       the file's location is ambiguous. In general, one would expect

  //       it in the source-directory, because that is where source files

  //       are located normally. However, generated files are normally

  //       generated in the build-directory. Therefore, we first check for

  //       a generated file in the build-directory before we check for a

  //       generated file in the source-directory.

  {

    auto file =

      cmSystemTools::CollapseFullPath(name, mf.GetCurrentBinaryDirectory());

    if (mf.GetGlobalGenerator()->IsGeneratedFile(file)) {

      propertyValue = cmValue::True;

      return true;

    }

  }

  {

    auto file =

      cmSystemTools::CollapseFullPath(name, mf.GetCurrentSourceDirectory());

    if (mf.GetGlobalGenerator()->IsGeneratedFile(file)) {

      propertyValue = cmValue::True;

      return true;

    }

  }

  propertyValue = cmValue::False;

  return true;

}

}

cmGetSourceFilePropertyResult cmGetSourceFileProperty(

  std::string const& sourceName, std::string const& propertyName,

  cmExecutionStatus& status, bool sourceFileDirectoryOptionEnabled,

  bool sourceFileTargetOptionEnabled,

  std::vector<std::string>& sourceFileDirectories,

  std::vector<std::string>& sourceFileTargetDirectories,

  cmValue& propertyValue, bool alwaysCreateSource)

{

  std::vector<cmMakefile*> sourceFileDirectoryMakefiles;

  if (!SetPropertyCommand::HandleAndValidateSourceFileDirectoryScopes(

        status, sourceFileDirectoryOptionEnabled,

        sourceFileTargetOptionEnabled, sourceFileDirectories,

        sourceFileTargetDirectories, sourceFileDirectoryMakefiles)) {

    return cmGetSourceFilePropertyResult::ScopeError;

  }

  bool const sourceFilePathsShouldBeAbsolute =

    sourceFileDirectoryOptionEnabled || sourceFileTargetOptionEnabled;

  cmMakefile& directoryMakefile = *sourceFileDirectoryMakefiles[0];

  // Special handling for GENERATED property.

  // Note: Only if CMP0163 is set to NEW.

  if (propertyName == "GENERATED"_s) {

    auto cmp0163 = directoryMakefile.GetPolicyStatus(cmPolicies::CMP0163);

    bool const cmp0163new =

      cmp0163 != cmPolicies::OLD && cmp0163 != cmPolicies::WARN;

    if (cmp0163new) {

      if (!GetSourceFilePropertyGENERATED(sourceName, status.GetMakefile(),

                                          propertyValue)) {

        return cmGetSourceFilePropertyResult::Error;

      }

      return cmGetSourceFilePropertyResult::Success;

    }

  }

  std::string const absolutePath =

    SetPropertyCommand::MakeSourceFilePathAbsoluteIfNeeded(

      status, sourceName, sourceFilePathsShouldBeAbsolute);

  cmSourceFile* sf = nullptr;

  if (alwaysCreateSource || propertyName == "LOCATION"_s) {

    sf = directoryMakefile.GetOrCreateSource(absolutePath);

    if (!sf) {

      return cmGetSourceFilePropertyResult::Error;

    }

  } else {

    sf = directoryMakefile.GetSource(absolutePath);

    if (!sf) {

      return cmGetSourceFilePropertyResult::SourceNotFound;

    }

  }

  propertyValue = sf->GetPropertyForUser(propertyName);

  return cmGetSourceFilePropertyResult::Success;

}