Support for source_target_relative expansion in GN

tools/gn/substitution_writer.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef TOOLS_GN_SUBSTITUTION_WRITER_H_
 #define TOOLS_GN_SUBSTITUTION_WRITER_H_
 
 #include <iosfwd>
 #include <vector>
 
@@ skipping 28 matching lines @@
 //  - Compiler substitutions: These are used to compute compiler outputs.
 //    It includes all source substitutions (since they depend on the various
 //    parts of the source file) as well as the target substitutions.
 //
 //  - Linker substitutions: These are used to compute linker outputs. It
 //    includes the target substitutions.
 //
 // The compiler and linker specific substitutions do NOT include the various
 // cflags, ldflags, libraries, etc. These are written by the ninja target
 // writer since they depend on traversing the dependency tree.
+//
+// The methods which take a target as an argument can accept null target
+// pointer if there is no target context, in which case the substitutions
+// requiring target context will not work.
 class SubstitutionWriter {
  public:
   enum OutputStyle {
     OUTPUT_ABSOLUTE,  // Dirs will be absolute "//foo/bar".
     OUTPUT_RELATIVE,  // Dirs will be relative to a given directory.
   };
 
   // Writes the pattern to the given stream with no special handling, and with
   // Ninja variables replacing the patterns.
   static void WriteWithNinjaVariables(
@@ skipping 15 matching lines @@
       const SubstitutionList& list,
       std::vector<OutputFile>* output);
 
   // Source substitutions -----------------------------------------------------
 
   // Applies the substitution pattern to a source file, returning the result
   // as either a string, a SourceFile or an OutputFile. If the result is
   // expected to be a SourceFile or an OutputFile, this will CHECK if the
   // result isn't in the correct directory. The caller should validate this
   // first (see for example IsFileInOuputDir).
+  //
+  // The target can be null (see class comment above).
   static SourceFile ApplyPatternToSource(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source);
   static std::string ApplyPatternToSourceAsString(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source);
   static OutputFile ApplyPatternToSourceAsOutputFile(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source);
 
   // Applies the substitution list to a source, APPENDING the result to the
   // given output vector. It works this way so one can call multiple times to
   // apply to multiple files and create a list. The result can either be
   // SourceFiles or OutputFiles.
+  //
+  // The target can be null (see class comment above).
   static void ApplyListToSource(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const SourceFile& source,
       std::vector<SourceFile>* output);
   static void ApplyListToSourceAsString(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const SourceFile& source,
       std::vector<std::string>* output);
   static void ApplyListToSourceAsOutputFile(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const SourceFile& source,
       std::vector<OutputFile>* output);
 
   // Like ApplyListToSource but applies the list to all sources and replaces
   // rather than appends the output (this produces the complete output).
+  //
+  // The target can be null (see class comment above).
   static void ApplyListToSources(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const std::vector<SourceFile>& sources,
       std::vector<SourceFile>* output);
   static void ApplyListToSourcesAsString(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const std::vector<SourceFile>& sources,
       std::vector<std::string>* output);
   static void ApplyListToSourcesAsOutputFile(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const std::vector<SourceFile>& sources,
       std::vector<OutputFile>* output);
 
   // Given a list of source replacement types used, writes the Ninja variable
   // definitions for the given source file to use for those replacements. The
   // variables will be indented two spaces. Since this is for writing to
   // Ninja files, paths will be relative to the build dir, and no definition
   // for {{source}} will be written since that maps to Ninja's implicit $in
   // variable.
+  //
+  // The target can be null (see class comment above).
   static void WriteNinjaVariablesForSource(
+      const Target* target,
       const Settings* settings,
       const SourceFile& source,
       const std::vector<SubstitutionType>& types,
       const EscapeOptions& escape_options,
       std::ostream& out);
 
   // Extracts the given type of substitution related to a source file from the
   // given source file. If output_style is OUTPUT_RELATIVE, relative_to
   // indicates the directory that the relative directories should be relative
   // to, otherwise it is ignored.
+  //
+  // The target can be null (see class comment above).
   static std::string GetSourceSubstitution(
+      const Target* target,
       const Settings* settings,
       const SourceFile& source,
       SubstitutionType type,
       OutputStyle output_style,
       const SourceDir& relative_to);
 
   // Target substitutions ------------------------------------------------------
   //
   // Handles the target substitutions that apply to both compiler and linker
   // tools.
@@ skipping 57 matching lines @@
   // Like GetSourceSubstitution but for strings based on the target or
   // toolchain. This type of result will always be relative to the build
   // directory.
   static std::string GetLinkerSubstitution(
       const Target* target,
       const Tool* tool,
       SubstitutionType type);
 };
 
 #endif  // TOOLS_GN_SUBSTITUTION_WRITER_H_