Changing XPathGrammer.y to not use global using blink

third_party/WebKit/Source/core/xml/XPathGrammar.y

 /*
  * Copyright 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 31 matching lines @@
 }
 
 #define YYMALLOC yyFastMalloc
 #define YYFREE WTF::Partitions::FastFree
 
 #define YYENABLE_NLS 0
 #define YYLTYPE_IS_TRIVIAL 1
 #define YYDEBUG 0
 #define YYMAXDEPTH 10000
 
-using namespace blink;
-using namespace XPath;
-
+using blink::XPath::Step;
 %}
 
 %pure-parser
 %parse-param { blink::XPath::Parser* parser }
 
 %union
 {
     blink::XPath::Step::Axis axis;
     blink::XPath::Step::NodeTest* nodeTest;
     blink::XPath::NumericOp::Opcode numop;
     blink::XPath::EqTestOp::Opcode eqop;
     String* str;
     blink::XPath::Expression* expr;
     blink::HeapVector<blink::Member<blink::XPath::Predicate>>* predList;
     blink::HeapVector<blink::Member<blink::XPath::Expression>>* argList;
     blink::XPath::Step* step;
     blink::XPath::LocationPath* locationPath;
 }
 
 %{
 
-static int xpathyylex(YYSTYPE* yylval) { return Parser::Current()->Lex(yylval); }
+static int xpathyylex(YYSTYPE* yylval) { return blink::XPath::Parser::Current()->Lex(yylval); }
 static void xpathyyerror(void*, const char*) { }
 
 %}
 
 %left <numop> MULOP
 %left <eqop> EQOP RELOP
 %left PLUS MINUS
 %left OR AND
 %token <axis> AXISNAME
 %token <str> NODETYPE PI FUNCTIONNAME LITERAL
@@ skipping 46 matching lines @@
     |
     AbsoluteLocationPath
     {
         $$->SetAbsolute(true);
     }
     ;
 
 AbsoluteLocationPath:
     '/'
     {
-        $$ = new LocationPath;
+        $$ = new blink::XPath::LocationPath;
     }
     |
     '/' RelativeLocationPath
     {
         $$ = $2;
     }
     |
     DescendantOrSelf RelativeLocationPath
     {
         $$ = $2;
         $$->InsertFirstStep($1);
     }
     ;
 
 RelativeLocationPath:
     Step
     {
-        $$ = new LocationPath;
+        $$ = new blink::XPath::LocationPath;
         $$->AppendStep($1);
     }
     |
     RelativeLocationPath '/' Step
     {
         $$->AppendStep($3);
     }
     |
     RelativeLocationPath DescendantOrSelf Step
     {
@@ skipping 95 matching lines @@
     {
         $$ = 0;
     }
     |
     PredicateList
     ;
 
 PredicateList:
     Predicate
     {
-        $$ = new blink::HeapVector<blink::Member<Predicate>>;
-        $$->push_back(new Predicate($1));
+        $$ = new blink::HeapVector<blink::Member<blink::XPath::Predicate>>;
+        $$->push_back(new blink::XPath::Predicate($1));
     }
     |
     PredicateList Predicate
     {
-        $$->push_back(new Predicate($2));
+        $$->push_back(new blink::XPath::Predicate($2));
     }
     ;
 
 Predicate:
     '[' Expr ']'
     {
         $$ = $2;
     }
     ;
 
@@ skipping 12 matching lines @@
     |
     DOTDOT
     {
         $$ = new Step(Step::kParentAxis, Step::NodeTest(Step::NodeTest::kAnyNodeTest));
     }
     ;
 
 PrimaryExpr:
     VARIABLEREFERENCE
     {
-        $$ = new VariableReference(*$1);
+        $$ = new blink::XPath::VariableReference(*$1);
         parser->DeleteString($1);
     }
     |
     '(' Expr ')'
     {
         $$ = $2;
     }
     |
     LITERAL
     {
-        $$ = new StringExpression(*$1);
+        $$ = new blink::XPath::StringExpression(*$1);
         parser->DeleteString($1);
     }
     |
     NUMBER
     {
-        $$ = new Number($1->ToDouble());
+        $$ = new blink::XPath::Number($1->ToDouble());
         parser->DeleteString($1);
     }
     |
     FunctionCall
     ;
 
 FunctionCall:
     FUNCTIONNAME '(' ')'
     {
-        $$ = CreateFunction(*$1);
+        $$ = blink::XPath::CreateFunction(*$1);
         if (!$$)
             YYABORT;
         parser->DeleteString($1);
     }
     |
     FUNCTIONNAME '(' ArgumentList ')'
     {
-        $$ = CreateFunction(*$1, *$3);
+        $$ = blink::XPath::CreateFunction(*$1, *$3);
         if (!$$)
             YYABORT;
         parser->DeleteString($1);
     }
     ;
 
 ArgumentList:
     Argument
     {
-        $$ = new blink::HeapVector<blink::Member<Expression>>;
+        $$ = new blink::HeapVector<blink::Member<blink::XPath::Expression>>;
         $$->push_back($1);
     }
     |
     ArgumentList ',' Argument
     {
         $$->push_back($3);
     }
     ;
 
 Argument:
     Expr
     ;
 
 UnionExpr:
     PathExpr
     |
     UnionExpr '|' PathExpr
     {
-        $$ = new Union;
+        $$ = new blink::XPath::Union;
         $$->AddSubExpression($1);
         $$->AddSubExpression($3);
     }
     ;
 
 PathExpr:
     LocationPath
     {
         $$ = $1;
     }
@@ skipping 21 matching lines @@
     {
         $$ = new blink::XPath::Filter($1, *$2);
     }
     ;
 
 OrExpr:
     AndExpr
     |
     OrExpr OR AndExpr
     {
-        $$ = new LogicalOp(LogicalOp::kOP_Or, $1, $3);
+        $$ = new blink::XPath::LogicalOp(blink::XPath::LogicalOp::kOP_Or, $1, $3);
     }
     ;
 
 AndExpr:
     EqualityExpr
     |
     AndExpr AND EqualityExpr
     {
-        $$ = new LogicalOp(LogicalOp::kOP_And, $1, $3);
+        $$ = new blink::XPath::LogicalOp(blink::XPath::LogicalOp::kOP_And, $1, $3);
     }
     ;
 
 EqualityExpr:
     RelationalExpr
     |
     EqualityExpr EQOP RelationalExpr
     {
-        $$ = new EqTestOp($2, $1, $3);
+        $$ = new blink::XPath::EqTestOp($2, $1, $3);
     }
     ;
 
 RelationalExpr:
     AdditiveExpr
     |
     RelationalExpr RELOP AdditiveExpr
     {
-        $$ = new EqTestOp($2, $1, $3);
+        $$ = new blink::XPath::EqTestOp($2, $1, $3);
     }
     ;
 
 AdditiveExpr:
     MultiplicativeExpr
     |
     AdditiveExpr PLUS MultiplicativeExpr
     {
-        $$ = new NumericOp(NumericOp::kOP_Add, $1, $3);
+        $$ = new blink::XPath::NumericOp(blink::XPath::NumericOp::kOP_Add, $1, $3);
     }
     |
     AdditiveExpr MINUS MultiplicativeExpr
     {
-        $$ = new NumericOp(NumericOp::kOP_Sub, $1, $3);
+        $$ = new blink::XPath::NumericOp(blink::XPath::NumericOp::kOP_Sub, $1, $3);
     }
     ;
 
 MultiplicativeExpr:
     UnaryExpr
     |
     MultiplicativeExpr MULOP UnaryExpr
     {
-        $$ = new NumericOp($2, $1, $3);
+        $$ = new blink::XPath::NumericOp($2, $1, $3);
     }
     ;
 
 UnaryExpr:
     UnionExpr
     |
     MINUS UnaryExpr
     {
-        $$ = new Negative;
+        $$ = new blink::XPath::Negative;
         $$->AddSubExpression($2);
     }
     ;
 
 %%