Home | History | Annotate | Download | only in gn
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef TOOLS_GN_ARGS_H_
      6 #define TOOLS_GN_ARGS_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/containers/hash_tables.h"
     10 #include "base/synchronization/lock.h"
     11 #include "tools/gn/err.h"
     12 #include "tools/gn/scope.h"
     13 
     14 extern const char kBuildArgs_Help[];
     15 
     16 // Manages build arguments. It stores the global arguments specified on the
     17 // command line, and sets up the root scope with the proper values.
     18 //
     19 // This class tracks accesses so we can report errors about unused variables.
     20 // The use case is if the user specifies an override on the command line, but
     21 // no buildfile actually uses that variable. We want to be able to report that
     22 // the argument was unused.
     23 class Args {
     24  public:
     25   Args();
     26   Args(const Args& other);
     27   ~Args();
     28 
     29   // Specifies overrides of the build arguments. These are normally specified
     30   // on the command line.
     31   void AddArgOverride(const char* name, const Value& value);
     32   void AddArgOverrides(const Scope::KeyValueMap& overrides);
     33 
     34   // Returns the value corresponding to the given argument name, or NULL if no
     35   // argument is set.
     36   const Value* GetArgOverride(const char* name) const;
     37 
     38   // Gets all overrides set on the build.
     39   Scope::KeyValueMap GetAllOverrides() const;
     40 
     41   // Sets up the root scope for a toolchain. This applies the default system
     42   // flags, then any overrides stored in this object, then applies any
     43   // toolchain overrides specified in the argument.
     44   void SetupRootScope(Scope* dest,
     45                       const Scope::KeyValueMap& toolchain_overrides) const;
     46 
     47   // Sets up the given scope with arguments passed in.
     48   //
     49   // If the values specified in the args are not already set, the values in
     50   // the args list will be used (which are assumed to be the defaults), but
     51   // they will not override the system defaults or the current overrides.
     52   //
     53   // All args specified in the input will be marked as "used".
     54   //
     55   // On failure, the err will be set and it will return false.
     56   bool DeclareArgs(const Scope::KeyValueMap& args,
     57                    Scope* scope_to_set,
     58                    Err* err) const;
     59 
     60   // Checks to see if any of the overrides ever used were never declared as
     61   // arguments. If there are, this returns false and sets the error.
     62   bool VerifyAllOverridesUsed(Err* err) const;
     63 
     64   // Like VerifyAllOverridesUsed but takes the lists of overrides specified and
     65   // parameters declared.
     66   static bool VerifyAllOverridesUsed(
     67       const Scope::KeyValueMap& overrides,
     68       const Scope::KeyValueMap& declared_arguments,
     69       Err* err);
     70 
     71   // Adds all declared arguments to the given output list. If the values exist
     72   // in the list already, their values will be overwriten, but other values
     73   // already in the list will remain.
     74   void MergeDeclaredArguments(Scope::KeyValueMap* dest) const;
     75 
     76  private:
     77   // Sets the default config based on the current system.
     78   void SetSystemVarsLocked(Scope* scope) const;
     79 
     80   // Sets the given vars on the given scope.
     81   void ApplyOverridesLocked(const Scope::KeyValueMap& values,
     82                             Scope* scope) const;
     83 
     84   void SaveOverrideRecordLocked(const Scope::KeyValueMap& values) const;
     85 
     86   // Since this is called during setup which we assume is single-threaded,
     87   // this is not protected by the lock. It should be set only during init.
     88   Scope::KeyValueMap overrides_;
     89 
     90   mutable base::Lock lock_;
     91 
     92   // Maintains a list of all overrides we've ever seen. This is the main
     93   // |overrides_| as well as toolchain overrides. Tracking this allows us to
     94   // check for overrides that were specified but never used.
     95   mutable Scope::KeyValueMap all_overrides_;
     96 
     97   // Tracks all variables declared in any buildfile. This is so we can see if
     98   // the user set variables on the command line that are not used anywhere.
     99   mutable Scope::KeyValueMap declared_arguments_;
    100 
    101   Args& operator=(const Args& other);  // Disallow assignment.
    102 };
    103 
    104 #endif  // TOOLS_GN_ARGS_H_
    105