| /external/clang/test/Analysis/ |
| unions.cpp | 6 struct ParseNode {
9 ParseNode *data;
12 struct Definition : public ParseNode { };
14 void CloneParseTree(ParseNode *opn, ParseNode *pn, ParseNode *x) {
33 struct ParseNode {
41 ParseNode *data;
45 struct Definition : public ParseNode { };
47 void CloneParseTree(ParseNode *opn, ParseNode *pn, ParseNode *x)
[all...] |
| /external/chromium_org/tools/gn/ |
| input_conversion.h | 11 class ParseNode;
24 const ParseNode* origin,
|
| import_manager.h | 13 class ParseNode;
27 const ParseNode* node_for_err,
|
| parse_tree.h | 28 // ParseNode -------------------------------------------------------------------
31 class ParseNode {
33 ParseNode();
34 virtual ~ParseNode();
61 DISALLOW_COPY_AND_ASSIGN(ParseNode);
70 class AccessorNode : public ParseNode {
89 const ParseNode* index() const { return index_.get(); }
90 void set_index(scoped_ptr<ParseNode> i) { index_ = i.Pass(); }
94 scoped_ptr<ParseNode> index_;
101 class BinaryOpNode : public ParseNode {
[all...] |
| value.h | 13 class ParseNode;
26 Value(const ParseNode* origin, Type t);
27 Value(const ParseNode* origin, int64 int_val);
28 Value(const ParseNode* origin, const base::StringPiece& str_val);
37 const ParseNode* origin() const { return origin_; }
38 void set_origin(const ParseNode* o) { origin_ = o; }
88 const ParseNode* origin_;
|
| operators.h | 10 class ParseNode;
31 const ParseNode* left,
32 const ParseNode* right,
|
| setup.h | 22 class ParseNode;
62 scoped_ptr<ParseNode> dotfile_root_;
|
| parser.cc | 33 scoped_ptr<ParseNode> Parser::Parse(const std::vector<Token>& tokens,
36 return p.ParseBlock(false).PassAs<ParseNode>();
40 scoped_ptr<ParseNode> Parser::ParseExpression(const std::vector<Token>& tokens,
67 scoped_ptr<ParseNode> expr = ParseExpression().Pass();
117 block->append_statement(ParseCondition().PassAs<ParseNode>());
120 block->append_statement(ParseBlock(true).PassAs<ParseNode>());
123 block->append_statement(ParseExpression().PassAs<ParseNode>());
198 cond->set_if_false(ParseCondition().PassAs<ParseNode>());
201 cond->set_if_false(ParseBlock(true).PassAs<ParseNode>());
227 scoped_ptr<ParseNode> Parser::ParseExpression()
[all...] |
| input_file_manager.h | 26 class ParseNode;
41 typedef base::Callback<void(const ParseNode*)> FileLoadCallback;
52 // ParseNode pointer. The given |origin| will be blamed for the invocation.
62 const ParseNode* SyncLoadFile(const LocationRange& origin,
98 scoped_ptr<ParseNode> parsed_root;
|
| parser.h | 18 // use of the ParseNode.
22 static scoped_ptr<ParseNode> Parse(const std::vector<Token>& tokens,
26 static scoped_ptr<ParseNode> ParseExpression(const std::vector<Token>& tokens,
37 scoped_ptr<ParseNode> ParseExpression();
38 scoped_ptr<ParseNode> ParseExpressionExceptBinaryOperators();
42 scoped_ptr<ParseNode> ParseParenExpression();
|
| import_manager.cc | 17 const ParseNode* node_for_err,
19 const ParseNode* node = g_scheduler->input_file_manager()->SyncLoadFile(
46 const ParseNode* node_for_err,
|
| toolchain_manager.h | 19 class ParseNode;
145 const ParseNode* root);
151 const ParseNode* root);
|
| input_conversion.cc | 58 const ParseNode* origin,
79 void RecursivelySetOrigin(Value* value, const ParseNode* origin) {
89 const ParseNode* origin,
101 scoped_ptr<ParseNode> expression = Parser::ParseExpression(tokens, err);
141 const ParseNode* origin,
188 const ParseNode* origin,
|
| value.cc | 15 Value::Value(const ParseNode* origin, Type t)
21 Value::Value(const ParseNode* origin, int64 int_val)
27 Value::Value(const ParseNode* origin, const base::StringPiece& str_val)
|
| scope.h | 20 class ParseNode;
96 const ParseNode* set_node);
103 const ParseNode* set_node);
147 const ParseNode* node_for_err,
|
| parse_tree.cc | 27 ParseNode::ParseNode() {
30 ParseNode::~ParseNode() {
33 const AccessorNode* ParseNode::AsAccessor() const { return NULL; }
34 const BinaryOpNode* ParseNode::AsBinaryOp() const { return NULL; }
35 const BlockNode* ParseNode::AsBlock() const { return NULL; }
36 const ConditionNode* ParseNode::AsConditionNode() const { return NULL; }
37 const FunctionCallNode* ParseNode::AsFunctionCall() const { return NULL; }
38 const IdentifierNode* ParseNode::AsIdentifier() const { return NULL;
[all...] |
| err.h | 14 class ParseNode;
48 Err(const ParseNode* node,
|
| file_template.h | 13 class ParseNode;
45 const ParseNode* origin,
|
| parser_unittest.cc | 22 bool IsIdentifierEqual(const ParseNode* node, const char* val) {
31 bool IsLiteralEqual(const ParseNode* node, const char* val) {
41 bool IsAssignment(const ParseNode* node, const char* ident, const char* value) {
53 bool IsBlockWithAssignment(const ParseNode* node,
72 scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
90 scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
110 scoped_ptr<ParseNode> expr = set.ParseExpression();
|
| input_file_manager.cc | 18 const ParseNode* node) {
99 const ParseNode* InputFileManager::SyncLoadFile(
228 scoped_ptr<ParseNode> root = Parser::Parse(tokens, err);
231 ParseNode* unowned_root = root.get();
|
| /external/chromium_org/third_party/WebKit/Source/core/xml/ |
| XPathExpressionNode.h | 51 class ParseNode {
53 virtual ~ParseNode() { }
56 class Expression : public ParseNode {
|
| XPathParser.h | 41 class ParseNode;
76 void registerParseNode(ParseNode*);
77 void unregisterParseNode(ParseNode*);
118 HashSet<ParseNode*> m_parseNodes;
|
| XPathStep.h | 41 class Step : public ParseNode {
|
| /external/antlr/antlr-3.4/runtime/CSharp2/Sources/Antlr3.Runtime/Antlr.Runtime.Tree/ |
| TreePatternParser.cs | 53 object node = ParseNode();
67 object root = ParseNode();
79 object child = ParseNode();
94 public virtual object ParseNode() {
|
| /external/antlr/antlr-3.4/runtime/CSharp3/Sources/Antlr3.Runtime/Tree/ |
| TreePatternParser.cs | 60 object node = ParseNode();
76 object root = ParseNode();
93 object child = ParseNode();
109 public virtual object ParseNode()
|
