src/tools/gn/parse_tree.h

   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_PARSE_TREE_H_
   6 #define TOOLS_GN_PARSE_TREE_H_
   7
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "tools/gn/err.h"
  14 #include "tools/gn/token.h"
  15 #include "tools/gn/value.h"
  16
  17 class AccessorNode;
  18 class BinaryOpNode;
  19 class BlockNode;
  20 class ConditionNode;
  21 class FunctionCallNode;
  22 class IdentifierNode;
  23 class ListNode;
  24 class LiteralNode;
  25 class Scope;
  26 class UnaryOpNode;
  27
  28 // ParseNode -------------------------------------------------------------------
  29
  30 // A node in the AST.
  31 class ParseNode {
  32  public:
  33   ParseNode();
  34   virtual ~ParseNode();
  35
  36   virtual const AccessorNode* AsAccessor() const;
  37   virtual const BinaryOpNode* AsBinaryOp() const;
  38   virtual const BlockNode* AsBlock() const;
  39   virtual const ConditionNode* AsConditionNode() const;
  40   virtual const FunctionCallNode* AsFunctionCall() const;
  41   virtual const IdentifierNode* AsIdentifier() const;
  42   virtual const ListNode* AsList() const;
  43   virtual const LiteralNode* AsLiteral() const;
  44   virtual const UnaryOpNode* AsUnaryOp() const;
  45
  46   virtual Value Execute(Scope* scope, Err* err) const = 0;
  47
  48   virtual LocationRange GetRange() const = 0;
  49
  50   // Returns an error with the given messages and the range set to something
  51   // that indicates this node.
  52   virtual Err MakeErrorDescribing(
  53       const std::string& msg,
  54       const std::string& help = std::string()) const = 0;
  55
  56   // Prints a representation of this node to the given string, indenting
  57   // by the given number of spaces.
  58   virtual void Print(std::ostream& out, int indent) const = 0;
  59
  60  private:
  61   DISALLOW_COPY_AND_ASSIGN(ParseNode);
  62 };
  63
  64 // AccessorNode ----------------------------------------------------------------
  65
  66 // Access an array element.
  67 //
  68 // If we need to add support for member variables like "variable.len" I was
  69 // thinking this would also handle that case.
  70 class AccessorNode : public ParseNode {
  71  public:
  72   AccessorNode();
  73   virtual ~AccessorNode();
  74
  75   virtual const AccessorNode* AsAccessor() const OVERRIDE;
  76   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
  77   virtual LocationRange GetRange() const OVERRIDE;
  78   virtual Err MakeErrorDescribing(
  79       const std::string& msg,
  80       const std::string& help = std::string()) const OVERRIDE;
  81   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
  82
  83   // Base is the thing on the left of the [], currently always required to be
  84   // an identifier token.
  85   const Token& base() const { return base_; }
  86   void set_base(const Token& b) { base_ = b; }
  87
  88   // Index is the expression inside the [].
  89   const ParseNode* index() const { return index_.get(); }
  90   void set_index(scoped_ptr<ParseNode> i) { index_ = i.Pass(); }
  91
  92  private:
  93   Token base_;
  94   scoped_ptr<ParseNode> index_;
  95
  96   DISALLOW_COPY_AND_ASSIGN(AccessorNode);
  97 };
  98
  99 // BinaryOpNode ----------------------------------------------------------------
 100
 101 class BinaryOpNode : public ParseNode {
 102  public:
 103   BinaryOpNode();
 104   virtual ~BinaryOpNode();
 105
 106   virtual const BinaryOpNode* AsBinaryOp() const OVERRIDE;
 107   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 108   virtual LocationRange GetRange() const OVERRIDE;
 109   virtual Err MakeErrorDescribing(
 110       const std::string& msg,
 111       const std::string& help = std::string()) const OVERRIDE;
 112   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 113
 114   const Token& op() const { return op_; }
 115   void set_op(const Token& t) { op_ = t; }
 116
 117   const ParseNode* left() const { return left_.get(); }
 118   void set_left(scoped_ptr<ParseNode> left) {
 119     left_ = left.Pass();
 120   }
 121
 122   const ParseNode* right() const { return right_.get(); }
 123   void set_right(scoped_ptr<ParseNode> right) {
 124     right_ = right.Pass();
 125   }
 126
 127  private:
 128   scoped_ptr<ParseNode> left_;
 129   Token op_;
 130   scoped_ptr<ParseNode> right_;
 131
 132   DISALLOW_COPY_AND_ASSIGN(BinaryOpNode);
 133 };
 134
 135 // BlockNode -------------------------------------------------------------------
 136
 137 class BlockNode : public ParseNode {
 138  public:
 139   // Set has_scope if this block introduces a nested scope.
 140   explicit BlockNode(bool has_scope);
 141   virtual ~BlockNode();
 142
 143   virtual const BlockNode* AsBlock() const OVERRIDE;
 144   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 145   virtual LocationRange GetRange() const OVERRIDE;
 146   virtual Err MakeErrorDescribing(
 147       const std::string& msg,
 148       const std::string& help = std::string()) const OVERRIDE;
 149   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 150
 151   void set_begin_token(const Token& t) { begin_token_ = t; }
 152   void set_end_token(const Token& t) { end_token_ = t; }
 153
 154   const std::vector<ParseNode*>& statements() const { return statements_; }
 155   void append_statement(scoped_ptr<ParseNode> s) {
 156     statements_.push_back(s.release());
 157   }
 158
 159   // Doesn't create a nested scope.
 160   Value ExecuteBlockInScope(Scope* our_scope, Err* err) const;
 161
 162  private:
 163   bool has_scope_;
 164
 165   // Tokens corresponding to { and }, if any (may be NULL).
 166   Token begin_token_;
 167   Token end_token_;
 168
 169   // Owning pointers, use unique_ptr when we can use C++11.
 170   std::vector<ParseNode*> statements_;
 171
 172   DISALLOW_COPY_AND_ASSIGN(BlockNode);
 173 };
 174
 175 // ConditionNode ---------------------------------------------------------------
 176
 177 class ConditionNode : public ParseNode {
 178  public:
 179   ConditionNode();
 180   virtual ~ConditionNode();
 181
 182   virtual const ConditionNode* AsConditionNode() const OVERRIDE;
 183   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 184   virtual LocationRange GetRange() const OVERRIDE;
 185   virtual Err MakeErrorDescribing(
 186       const std::string& msg,
 187       const std::string& help = std::string()) const OVERRIDE;
 188   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 189
 190   void set_if_token(const Token& token) { if_token_ = token; }
 191
 192   const ParseNode* condition() const { return condition_.get(); }
 193   void set_condition(scoped_ptr<ParseNode> c) {
 194     condition_ = c.Pass();
 195   }
 196
 197   const BlockNode* if_true() const { return if_true_.get(); }
 198   void set_if_true(scoped_ptr<BlockNode> t) {
 199     if_true_ = t.Pass();
 200   }
 201
 202   // This is either empty, a block (for the else clause), or another
 203   // condition.
 204   const ParseNode* if_false() const { return if_false_.get(); }
 205   void set_if_false(scoped_ptr<ParseNode> f) {
 206     if_false_ = f.Pass();
 207   }
 208
 209  private:
 210   // Token corresponding to the "if" string.
 211   Token if_token_;
 212
 213   scoped_ptr<ParseNode> condition_;  // Always non-null.
 214   scoped_ptr<BlockNode> if_true_;  // Always non-null.
 215   scoped_ptr<ParseNode> if_false_;  // May be null.
 216
 217   DISALLOW_COPY_AND_ASSIGN(ConditionNode);
 218 };
 219
 220 // FunctionCallNode ------------------------------------------------------------
 221
 222 class FunctionCallNode : public ParseNode {
 223  public:
 224   FunctionCallNode();
 225   virtual ~FunctionCallNode();
 226
 227   virtual const FunctionCallNode* AsFunctionCall() const OVERRIDE;
 228   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 229   virtual LocationRange GetRange() const OVERRIDE;
 230   virtual Err MakeErrorDescribing(
 231       const std::string& msg,
 232       const std::string& help = std::string()) const OVERRIDE;
 233   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 234
 235   const Token& function() const { return function_; }
 236   void set_function(Token t) { function_ = t; }
 237
 238   const ListNode* args() const { return args_.get(); }
 239   void set_args(scoped_ptr<ListNode> a) { args_ = a.Pass(); }
 240
 241   const BlockNode* block() const { return block_.get(); }
 242   void set_block(scoped_ptr<BlockNode> b) { block_ = b.Pass(); }
 243
 244  private:
 245   Token function_;
 246   scoped_ptr<ListNode> args_;
 247   scoped_ptr<BlockNode> block_;  // May be null.
 248
 249   DISALLOW_COPY_AND_ASSIGN(FunctionCallNode);
 250 };
 251
 252 // IdentifierNode --------------------------------------------------------------
 253
 254 class IdentifierNode : public ParseNode {
 255  public:
 256   IdentifierNode();
 257   IdentifierNode(const Token& token);
 258   virtual ~IdentifierNode();
 259
 260   virtual const IdentifierNode* AsIdentifier() const OVERRIDE;
 261   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 262   virtual LocationRange GetRange() const OVERRIDE;
 263   virtual Err MakeErrorDescribing(
 264       const std::string& msg,
 265       const std::string& help = std::string()) const OVERRIDE;
 266   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 267
 268   const Token& value() const { return value_; }
 269   void set_value(const Token& t) { value_ = t; }
 270
 271  private:
 272   Token value_;
 273
 274   DISALLOW_COPY_AND_ASSIGN(IdentifierNode);
 275 };
 276
 277 // ListNode --------------------------------------------------------------------
 278
 279 class ListNode : public ParseNode {
 280  public:
 281   ListNode();
 282   virtual ~ListNode();
 283
 284   virtual const ListNode* AsList() const OVERRIDE;
 285   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 286   virtual LocationRange GetRange() const OVERRIDE;
 287   virtual Err MakeErrorDescribing(
 288       const std::string& msg,
 289       const std::string& help = std::string()) const OVERRIDE;
 290   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 291
 292   void set_begin_token(const Token& t) { begin_token_ = t; }
 293   void set_end_token(const Token& t) { end_token_ = t; }
 294
 295   void append_item(scoped_ptr<ParseNode> s) {
 296     contents_.push_back(s.release());
 297   }
 298   const std::vector<const ParseNode*>& contents() const { return contents_; }
 299
 300  private:
 301   // Tokens corresponding to the [ and ].
 302   Token begin_token_;
 303   Token end_token_;
 304
 305   // Owning pointers, use unique_ptr when we can use C++11.
 306   std::vector<const ParseNode*> contents_;
 307
 308   DISALLOW_COPY_AND_ASSIGN(ListNode);
 309 };
 310
 311 // LiteralNode -----------------------------------------------------------------
 312
 313 class LiteralNode : public ParseNode {
 314  public:
 315   LiteralNode();
 316   LiteralNode(const Token& token);
 317   virtual ~LiteralNode();
 318
 319   virtual const LiteralNode* AsLiteral() const OVERRIDE;
 320   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 321   virtual LocationRange GetRange() const OVERRIDE;
 322   virtual Err MakeErrorDescribing(
 323       const std::string& msg,
 324       const std::string& help = std::string()) const OVERRIDE;
 325   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 326
 327   const Token& value() const { return value_; }
 328   void set_value(const Token& t) { value_ = t; }
 329
 330  private:
 331   Token value_;
 332
 333   DISALLOW_COPY_AND_ASSIGN(LiteralNode);
 334 };
 335
 336 // UnaryOpNode -----------------------------------------------------------------
 337
 338 class UnaryOpNode : public ParseNode {
 339  public:
 340   UnaryOpNode();
 341   virtual ~UnaryOpNode();
 342
 343   virtual const UnaryOpNode* AsUnaryOp() const OVERRIDE;
 344   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
 345   virtual LocationRange GetRange() const OVERRIDE;
 346   virtual Err MakeErrorDescribing(
 347       const std::string& msg,
 348       const std::string& help = std::string()) const OVERRIDE;
 349   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 350
 351   const Token& op() const { return op_; }
 352   void set_op(const Token& t) { op_ = t; }
 353
 354   const ParseNode* operand() const { return operand_.get(); }
 355   void set_operand(scoped_ptr<ParseNode> operand) {
 356     operand_ = operand.Pass();
 357   }
 358
 359  private:
 360   Token op_;
 361   scoped_ptr<ParseNode> operand_;
 362
 363   DISALLOW_COPY_AND_ASSIGN(UnaryOpNode);
 364 };
 365
 366 #endif  // TOOLS_GN_PARSE_TREE_H_