| OLD | NEW |
| 1 /* | 1 /* |
| 2 * Copyright 2005 Maksim Orlovich <maksim@kde.org> | 2 * Copyright 2005 Maksim Orlovich <maksim@kde.org> |
| 3 * Copyright (C) 2006 Apple Computer, Inc. | 3 * Copyright (C) 2006 Apple Computer, Inc. |
| 4 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org> | 4 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org> |
| 5 * | 5 * |
| 6 * Redistribution and use in source and binary forms, with or without | 6 * Redistribution and use in source and binary forms, with or without |
| 7 * modification, are permitted provided that the following conditions | 7 * modification, are permitted provided that the following conditions |
| 8 * are met: | 8 * are met: |
| 9 * | 9 * |
| 10 * 1. Redistributions of source code must retain the above copyright | 10 * 1. Redistributions of source code must retain the above copyright |
| (...skipping 447 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 458 if (namespaceURI.isNull()) | 458 if (namespaceURI.isNull()) |
| 459 return false; | 459 return false; |
| 460 localName = AtomicString(qName.substring(colon + 1)); | 460 localName = AtomicString(qName.substring(colon + 1)); |
| 461 } else { | 461 } else { |
| 462 localName = AtomicString(qName); | 462 localName = AtomicString(qName); |
| 463 } | 463 } |
| 464 | 464 |
| 465 return true; | 465 return true; |
| 466 } | 466 } |
| 467 | 467 |
| 468 PassOwnPtrWillBeRawPtr<Expression> Parser::parseStatement(const String& statemen
t, PassRefPtrWillBeRawPtr<XPathNSResolver> resolver, ExceptionState& exceptionSt
ate) | 468 Expression* Parser::parseStatement(const String& statement, XPathNSResolver* res
olver, ExceptionState& exceptionState) |
| 469 { | 469 { |
| 470 reset(statement); | 470 reset(statement); |
| 471 | 471 |
| 472 m_resolver = resolver; | 472 m_resolver = resolver; |
| 473 | 473 |
| 474 Parser* oldParser = currentParser; | 474 Parser* oldParser = currentParser; |
| 475 currentParser = this; | 475 currentParser = this; |
| 476 int parseError = xpathyyparse(this); | 476 int parseError = xpathyyparse(this); |
| 477 currentParser = oldParser; | 477 currentParser = oldParser; |
| 478 | 478 |
| 479 if (parseError) { | 479 if (parseError) { |
| 480 #if !ENABLE(OILPAN) | |
| 481 while (!m_parseNodes.isEmpty()) | |
| 482 delete m_parseNodes.takeAny(); | |
| 483 | |
| 484 for (auto& predicate : m_predicateVectors) | |
| 485 delete predicate; | |
| 486 m_predicateVectors.clear(); | |
| 487 | |
| 488 for (auto& expression : m_expressionVectors) | |
| 489 delete expression; | |
| 490 m_expressionVectors.clear(); | |
| 491 | |
| 492 m_nodeTests.clear(); | |
| 493 #endif | |
| 494 | |
| 495 m_strings.clear(); | 480 m_strings.clear(); |
| 496 | 481 |
| 497 m_topExpr = nullptr; | 482 m_topExpr = nullptr; |
| 498 | 483 |
| 499 if (m_gotNamespaceError) | 484 if (m_gotNamespaceError) |
| 500 exceptionState.throwDOMException(NamespaceError, "The string '" + st
atement + "' contains unresolvable namespaces."); | 485 exceptionState.throwDOMException(NamespaceError, "The string '" + st
atement + "' contains unresolvable namespaces."); |
| 501 else | 486 else |
| 502 exceptionState.throwDOMException(SyntaxError, "The string '" + state
ment + "' is not a valid XPath expression."); | 487 exceptionState.throwDOMException(SyntaxError, "The string '" + state
ment + "' is not a valid XPath expression."); |
| 503 return nullptr; | 488 return nullptr; |
| 504 } | 489 } |
| 505 ASSERT(m_strings.size() == 0); | 490 ASSERT(m_strings.size() == 0); |
| 506 #if !ENABLE(OILPAN) | |
| 507 ASSERT(m_parseNodes.size() == 1); | |
| 508 ASSERT(*m_parseNodes.begin() == m_topExpr); | |
| 509 ASSERT(m_expressionVectors.size() == 0); | |
| 510 ASSERT(m_predicateVectors.size() == 0); | |
| 511 ASSERT(m_nodeTests.size() == 0); | |
| 512 m_parseNodes.clear(); | |
| 513 #endif | |
| 514 | |
| 515 Expression* result = m_topExpr; | 491 Expression* result = m_topExpr; |
| 516 m_topExpr = nullptr; | 492 m_topExpr = nullptr; |
| 517 | 493 |
| 518 return adoptPtrWillBeNoop(result); | 494 return result; |
| 519 } | |
| 520 | |
| 521 void Parser::registerParseNode(ParseNode* node) | |
| 522 { | |
| 523 #if !ENABLE(OILPAN) | |
| 524 if (node == 0) | |
| 525 return; | |
| 526 | |
| 527 ASSERT(!m_parseNodes.contains(node)); | |
| 528 | |
| 529 m_parseNodes.add(node); | |
| 530 #endif | |
| 531 } | |
| 532 | |
| 533 void Parser::unregisterParseNode(ParseNode* node) | |
| 534 { | |
| 535 #if !ENABLE(OILPAN) | |
| 536 if (node == 0) | |
| 537 return; | |
| 538 | |
| 539 ASSERT(m_parseNodes.contains(node)); | |
| 540 | |
| 541 m_parseNodes.remove(node); | |
| 542 #endif | |
| 543 } | |
| 544 | |
| 545 void Parser::registerPredicateVector(WillBeHeapVector<OwnPtrWillBeMember<Predica
te>>* vector) | |
| 546 { | |
| 547 #if !ENABLE(OILPAN) | |
| 548 if (vector == 0) | |
| 549 return; | |
| 550 | |
| 551 ASSERT(!m_predicateVectors.contains(vector)); | |
| 552 | |
| 553 m_predicateVectors.add(vector); | |
| 554 #endif | |
| 555 } | |
| 556 | |
| 557 void Parser::deletePredicateVector(WillBeHeapVector<OwnPtrWillBeMember<Predicate
>>* vector) | |
| 558 { | |
| 559 #if !ENABLE(OILPAN) | |
| 560 if (vector == 0) | |
| 561 return; | |
| 562 | |
| 563 ASSERT(m_predicateVectors.contains(vector)); | |
| 564 | |
| 565 m_predicateVectors.remove(vector); | |
| 566 delete vector; | |
| 567 #endif | |
| 568 } | |
| 569 | |
| 570 | |
| 571 void Parser::registerExpressionVector(WillBeHeapVector<OwnPtrWillBeMember<Expres
sion>>* vector) | |
| 572 { | |
| 573 #if !ENABLE(OILPAN) | |
| 574 if (vector == 0) | |
| 575 return; | |
| 576 | |
| 577 ASSERT(!m_expressionVectors.contains(vector)); | |
| 578 | |
| 579 m_expressionVectors.add(vector); | |
| 580 #endif | |
| 581 } | |
| 582 | |
| 583 void Parser::deleteExpressionVector(WillBeHeapVector<OwnPtrWillBeMember<Expressi
on>>* vector) | |
| 584 { | |
| 585 #if !ENABLE(OILPAN) | |
| 586 if (vector == 0) | |
| 587 return; | |
| 588 | |
| 589 ASSERT(m_expressionVectors.contains(vector)); | |
| 590 | |
| 591 m_expressionVectors.remove(vector); | |
| 592 delete vector; | |
| 593 #endif | |
| 594 } | 495 } |
| 595 | 496 |
| 596 void Parser::registerString(String* s) | 497 void Parser::registerString(String* s) |
| 597 { | 498 { |
| 598 if (s == 0) | 499 if (s == 0) |
| 599 return; | 500 return; |
| 600 | 501 |
| 601 ASSERT(!m_strings.contains(s)); | 502 ASSERT(!m_strings.contains(s)); |
| 602 | 503 |
| 603 m_strings.add(adoptPtr(s)); | 504 m_strings.add(adoptPtr(s)); |
| 604 } | 505 } |
| 605 | 506 |
| 606 void Parser::deleteString(String* s) | 507 void Parser::deleteString(String* s) |
| 607 { | 508 { |
| 608 if (s == 0) | 509 if (s == 0) |
| 609 return; | 510 return; |
| 610 | 511 |
| 611 ASSERT(m_strings.contains(s)); | 512 ASSERT(m_strings.contains(s)); |
| 612 | 513 |
| 613 m_strings.remove(s); | 514 m_strings.remove(s); |
| 614 } | 515 } |
| 615 | |
| 616 void Parser::registerNodeTest(Step::NodeTest* t) | |
| 617 { | |
| 618 #if !ENABLE(OILPAN) | |
| 619 if (t == 0) | |
| 620 return; | |
| 621 | |
| 622 ASSERT(!m_nodeTests.contains(t)); | |
| 623 | |
| 624 m_nodeTests.add(adoptPtr(t)); | |
| 625 #endif | |
| 626 } | |
| 627 | |
| 628 void Parser::deleteNodeTest(Step::NodeTest* t) | |
| 629 { | |
| 630 #if !ENABLE(OILPAN) | |
| 631 if (t == 0) | |
| 632 return; | |
| 633 | |
| 634 ASSERT(m_nodeTests.contains(t)); | |
| 635 | |
| 636 m_nodeTests.remove(t); | |
| 637 #endif | |
| 638 } | |
| 639 | |
| OLD | NEW |