summaryrefslogtreecommitdiff
path: root/lib/querypath/src/QueryPath/CSS/Parser.php
diff options
context:
space:
mode:
Diffstat (limited to 'lib/querypath/src/QueryPath/CSS/Parser.php')
-rw-r--r--lib/querypath/src/QueryPath/CSS/Parser.php575
1 files changed, 575 insertions, 0 deletions
diff --git a/lib/querypath/src/QueryPath/CSS/Parser.php b/lib/querypath/src/QueryPath/CSS/Parser.php
new file mode 100644
index 0000000..f041612
--- /dev/null
+++ b/lib/querypath/src/QueryPath/CSS/Parser.php
@@ -0,0 +1,575 @@
+<?php
+/**
+ * @file
+ *
+ * The CSS parser
+ */
+
+namespace QueryPath\CSS;
+
+/**
+ * Parse a CSS selector.
+ *
+ * In CSS, a selector is used to identify which element or elements
+ * in a DOM are being selected for the application of a particular style.
+ * Effectively, selectors function as a query language for a structured
+ * document -- almost always HTML or XML.
+ *
+ * This class provides an event-based parser for CSS selectors. It can be
+ * used, for example, as a basis for writing a DOM query engine based on
+ * CSS.
+ *
+ * @ingroup querypath_css
+ */
+class Parser {
+ protected $scanner = NULL;
+ protected $buffer = '';
+ protected $handler = NULL;
+ protected $strict = FALSE;
+
+ protected $DEBUG = FALSE;
+
+ /**
+ * Construct a new CSS parser object. This will attempt to
+ * parse the string as a CSS selector. As it parses, it will
+ * send events to the EventHandler implementation.
+ */
+ public function __construct($string, EventHandler $handler) {
+ $this->originalString = $string;
+ $is = new InputStream($string);
+ $this->scanner = new Scanner($is);
+ $this->handler = $handler;
+ }
+
+ /**
+ * Parse the selector.
+ *
+ * This begins an event-based parsing process that will
+ * fire events as the selector is handled. A EventHandler
+ * implementation will be responsible for handling the events.
+ * @throws ParseException
+ */
+ public function parse() {
+
+ $this->scanner->nextToken();
+ while ($this->scanner->token !== FALSE) {
+ // Primitive recursion detection.
+ $position = $this->scanner->position();
+
+ if ($this->DEBUG) {
+ print "PARSE " . $this->scanner->token. "\n";
+ }
+ $this->selector();
+
+ $finalPosition = $this->scanner->position();
+
+ if ($this->scanner->token !== FALSE && $finalPosition == $position) {
+ // If we get here, then the scanner did not pop a single character
+ // off of the input stream during a full run of the parser, which
+ // means that the current input does not match any recognizable
+ // pattern.
+ throw new ParseException('CSS selector is not well formed.');
+ }
+
+ }
+
+ }
+
+ /**
+ * A restricted parser that can only parse simple selectors.
+ * The pseudoClass handler for this parser will throw an
+ * exception if it encounters a pseudo-element or the
+ * negation pseudo-class.
+ *
+ * @deprecated This is not used anywhere in QueryPath and
+ * may be removed.
+ *//*
+ public function parseSimpleSelector() {
+ while ($this->scanner->token !== FALSE) {
+ if ($this->DEBUG) print "SIMPLE SELECTOR\n";
+ $this->allElements();
+ $this->elementName();
+ $this->elementClass();
+ $this->elementID();
+ $this->pseudoClass(TRUE); // Operate in restricted mode.
+ $this->attribute();
+
+ // TODO: Need to add failure conditions here.
+ }
+ }*/
+
+ /**
+ * Handle an entire CSS selector.
+ */
+ private function selector() {
+ if ($this->DEBUG) print "SELECTOR{$this->scanner->position()}\n";
+ $this->consumeWhitespace(); // Remove leading whitespace
+ $this->simpleSelectors();
+ $this->combinator();
+ }
+
+ /**
+ * Consume whitespace and return a count of the number of whitespace consumed.
+ */
+ private function consumeWhitespace() {
+ if ($this->DEBUG) print "CONSUME WHITESPACE\n";
+ $white = 0;
+ while ($this->scanner->token == Token::white) {
+ $this->scanner->nextToken();
+ ++$white;
+ }
+ return $white;
+ }
+
+ /**
+ * Handle one of the five combinators: '>', '+', ' ', '~', and ','.
+ * This will call the appropriate event handlers.
+ * @see EventHandler::directDescendant(),
+ * @see EventHandler::adjacent(),
+ * @see EventHandler::anyDescendant(),
+ * @see EventHandler::anotherSelector().
+ */
+ private function combinator() {
+ if ($this->DEBUG) print "COMBINATOR\n";
+ /*
+ * Problem: ' ' and ' > ' are both valid combinators.
+ * So we have to track whitespace consumption to see
+ * if we are hitting the ' ' combinator or if the
+ * selector just has whitespace padding another combinator.
+ */
+
+ // Flag to indicate that post-checks need doing
+ $inCombinator = FALSE;
+ $white = $this->consumeWhitespace();
+ $t = $this->scanner->token;
+
+ if ($t == Token::rangle) {
+ $this->handler->directDescendant();
+ $this->scanner->nextToken();
+ $inCombinator = TRUE;
+ //$this->simpleSelectors();
+ }
+ elseif ($t == Token::plus) {
+ $this->handler->adjacent();
+ $this->scanner->nextToken();
+ $inCombinator = TRUE;
+ //$this->simpleSelectors();
+ }
+ elseif ($t == Token::comma) {
+ $this->handler->anotherSelector();
+ $this->scanner->nextToken();
+ $inCombinator = TRUE;
+ //$this->scanner->selectors();
+ }
+ elseif ($t == Token::tilde) {
+ $this->handler->sibling();
+ $this->scanner->nextToken();
+ $inCombinator = TRUE;
+ }
+
+ // Check that we don't get two combinators in a row.
+ if ($inCombinator) {
+ $white = 0;
+ if ($this->DEBUG) print "COMBINATOR: " . Token::name($t) . "\n";
+ $this->consumeWhitespace();
+ if ($this->isCombinator($this->scanner->token)) {
+ throw new ParseException("Illegal combinator: Cannot have two combinators in sequence.");
+ }
+ }
+ // Check to see if we have whitespace combinator:
+ elseif ($white > 0) {
+ if ($this->DEBUG) print "COMBINATOR: any descendant\n";
+ $inCombinator = TRUE;
+ $this->handler->anyDescendant();
+ }
+ else {
+ if ($this->DEBUG) print "COMBINATOR: no combinator found.\n";
+ }
+ }
+
+ /**
+ * Check if the token is a combinator.
+ */
+ private function isCombinator($tok) {
+ $combinators = array(Token::plus, Token::rangle, Token::comma, Token::tilde);
+ return in_array($tok, $combinators);
+ }
+
+ /**
+ * Handle a simple selector.
+ */
+ private function simpleSelectors() {
+ if ($this->DEBUG) print "SIMPLE SELECTOR\n";
+ $this->allElements();
+ $this->elementName();
+ $this->elementClass();
+ $this->elementID();
+ $this->pseudoClass();
+ $this->attribute();
+ }
+
+ /**
+ * Handles CSS ID selectors.
+ * This will call EventHandler::elementID().
+ */
+ private function elementID() {
+ if ($this->DEBUG) print "ELEMENT ID\n";
+ if ($this->scanner->token == Token::octo) {
+ $this->scanner->nextToken();
+ if ($this->scanner->token !== Token::char) {
+ throw new ParseException("Expected string after #");
+ }
+ $id = $this->scanner->getNameString();
+ $this->handler->elementID($id);
+ }
+ }
+
+ /**
+ * Handles CSS class selectors.
+ * This will call the EventHandler::elementClass() method.
+ */
+ private function elementClass() {
+ if ($this->DEBUG) print "ELEMENT CLASS\n";
+ if ($this->scanner->token == Token::dot) {
+ $this->scanner->nextToken();
+ $this->consumeWhitespace(); // We're very fault tolerent. This should prob through error.
+ $cssClass = $this->scanner->getNameString();
+ $this->handler->elementClass($cssClass);
+ }
+ }
+
+ /**
+ * Handle a pseudo-class and pseudo-element.
+ *
+ * CSS 3 selectors support separate pseudo-elements, using :: instead
+ * of : for separator. This is now supported, and calls the pseudoElement
+ * handler, EventHandler::pseudoElement().
+ *
+ * This will call EventHandler::pseudoClass() when a
+ * pseudo-class is parsed.
+ */
+ private function pseudoClass($restricted = FALSE) {
+ if ($this->DEBUG) print "PSEUDO-CLASS\n";
+ if ($this->scanner->token == Token::colon) {
+
+ // Check for CSS 3 pseudo element:
+ $isPseudoElement = FALSE;
+ if ($this->scanner->nextToken() === Token::colon) {
+ $isPseudoElement = TRUE;
+ $this->scanner->nextToken();
+ }
+
+ $name = $this->scanner->getNameString();
+ if ($restricted && $name == 'not') {
+ throw new ParseException("The 'not' pseudo-class is illegal in this context.");
+ }
+
+ $value = NULL;
+ if ($this->scanner->token == Token::lparen) {
+ if ($isPseudoElement) {
+ throw new ParseException("Illegal left paren. Pseudo-Element cannot have arguments.");
+ }
+ $value = $this->pseudoClassValue();
+ }
+
+ // FIXME: This should throw errors when pseudo element has values.
+ if ($isPseudoElement) {
+ if ($restricted) {
+ throw new ParseException("Pseudo-Elements are illegal in this context.");
+ }
+ $this->handler->pseudoElement($name);
+ $this->consumeWhitespace();
+
+ // Per the spec, pseudo-elements must be the last items in a selector, so we
+ // check to make sure that we are either at the end of the stream or that a
+ // new selector is starting. Only one pseudo-element is allowed per selector.
+ if ($this->scanner->token !== FALSE && $this->scanner->token !== Token::comma) {
+ throw new ParseException("A Pseudo-Element must be the last item in a selector.");
+ }
+ }
+ else {
+ $this->handler->pseudoClass($name, $value);
+ }
+ }
+ }
+
+ /**
+ * Get the value of a pseudo-classes.
+ *
+ * @return string
+ * Returns the value found from a pseudo-class.
+ *
+ * @todo Pseudoclasses can be passed pseudo-elements and
+ * other pseudo-classes as values, which means :pseudo(::pseudo)
+ * is legal.
+ */
+ private function pseudoClassValue() {
+ if ($this->scanner->token == Token::lparen) {
+ $buf = '';
+
+ // For now, just leave pseudoClass value vague.
+ /*
+ // We have to peek to see if next char is a colon because
+ // pseudo-classes and pseudo-elements are legal strings here.
+ print $this->scanner->peek();
+ if ($this->scanner->peek() == ':') {
+ print "Is pseudo\n";
+ $this->scanner->nextToken();
+
+ // Pseudo class
+ if ($this->scanner->token == Token::colon) {
+ $buf .= ':';
+ $this->scanner->nextToken();
+ // Pseudo element
+ if ($this->scanner->token == Token::colon) {
+ $buf .= ':';
+ $this->scanner->nextToken();
+ }
+ // Ident
+ $buf .= $this->scanner->getNameString();
+ }
+ }
+ else {
+ print "fetching string.\n";
+ $buf .= $this->scanner->getQuotedString();
+ if ($this->scanner->token != Token::rparen) {
+ $this->throwError(Token::rparen, $this->scanner->token);
+ }
+ $this->scanner->nextToken();
+ }
+ return $buf;
+ */
+ //$buf .= $this->scanner->getQuotedString();
+ $buf .= $this->scanner->getPseudoClassString();
+ return $buf;
+ }
+ }
+
+ /**
+ * Handle element names.
+ * This will call the EventHandler::elementName().
+ *
+ * This handles:
+ * <code>
+ * name (EventHandler::element())
+ * |name (EventHandler::element())
+ * ns|name (EventHandler::elementNS())
+ * ns|* (EventHandler::elementNS())
+ * </code>
+ */
+ private function elementName() {
+ if ($this->DEBUG) print "ELEMENT NAME\n";
+ if ($this->scanner->token === Token::pipe) {
+ // We have '|name', which is equiv to 'name'
+ $this->scanner->nextToken();
+ $this->consumeWhitespace();
+ $elementName = $this->scanner->getNameString();
+ $this->handler->element($elementName);
+ }
+ elseif ($this->scanner->token === Token::char) {
+ $elementName = $this->scanner->getNameString();
+ if ($this->scanner->token == Token::pipe) {
+ // Get ns|name
+ $elementNS = $elementName;
+ $this->scanner->nextToken();
+ $this->consumeWhitespace();
+ if ($this->scanner->token === Token::star) {
+ // We have ns|*
+ $this->handler->anyElementInNS($elementNS);
+ $this->scanner->nextToken();
+ }
+ elseif ($this->scanner->token !== Token::char) {
+ $this->throwError(Token::char, $this->scanner->token);
+ }
+ else {
+ $elementName = $this->scanner->getNameString();
+ // We have ns|name
+ $this->handler->elementNS($elementName, $elementNS);
+ }
+
+ }
+ else {
+ $this->handler->element($elementName);
+ }
+ }
+ }
+
+ /**
+ * Check for all elements designators. Due to the new CSS 3 namespace
+ * support, this is slightly more complicated, now, as it handles
+ * the *|name and *|* cases as well as *.
+ *
+ * Calls EventHandler::anyElement() or EventHandler::elementName().
+ */
+ private function allElements() {
+ if ($this->scanner->token === Token::star) {
+ $this->scanner->nextToken();
+ if ($this->scanner->token === Token::pipe) {
+ $this->scanner->nextToken();
+ if ($this->scanner->token === Token::star) {
+ // We got *|*. According to spec, this requires
+ // that the element has a namespace, so we pass it on
+ // to the handler:
+ $this->scanner->nextToken();
+ $this->handler->anyElementInNS('*');
+ }
+ else {
+ // We got *|name, which means the name MUST be in a namespce,
+ // so we pass this off to elementNameNS().
+ $name = $this->scanner->getNameString();
+ $this->handler->elementNS($name, '*');
+ }
+ }
+ else {
+ $this->handler->anyElement();
+ }
+ }
+ }
+
+ /**
+ * Handler an attribute.
+ * An attribute can be in one of two forms:
+ * <code>[attrName]</code>
+ * or
+ * <code>[attrName="AttrValue"]</code>
+ *
+ * This may call the following event handlers: EventHandler::attribute().
+ */
+ private function attribute() {
+ if($this->scanner->token == Token::lsquare) {
+ $attrVal = $op = $ns = NULL;
+
+ $this->scanner->nextToken();
+ $this->consumeWhitespace();
+
+ if ($this->scanner->token === Token::at) {
+ if ($this->strict) {
+ throw new ParseException('The @ is illegal in attributes.');
+ }
+ else {
+ $this->scanner->nextToken();
+ $this->consumeWhitespace();
+ }
+ }
+
+ if ($this->scanner->token === Token::star) {
+ // Global namespace... requires that attr be prefixed,
+ // so we pass this on to a namespace handler.
+ $ns = '*';
+ $this->scanner->nextToken();
+ }
+ if ($this->scanner->token === Token::pipe) {
+ // Skip this. It's a global namespace.
+ $this->scanner->nextToken();
+ $this->consumeWhitespace();
+ }
+
+ $attrName = $this->scanner->getNameString();
+ $this->consumeWhitespace();
+
+ // Check for namespace attribute: ns|attr. We have to peek() to make
+ // sure that we haven't hit the |= operator, which looks the same.
+ if ($this->scanner->token === Token::pipe && $this->scanner->peek() !== '=') {
+ // We have a namespaced attribute.
+ $ns = $attrName;
+ $this->scanner->nextToken();
+ $attrName = $this->scanner->getNameString();
+ $this->consumeWhitespace();
+ }
+
+ // Note: We require that operators do not have spaces
+ // between characters, e.g. ~= , not ~ =.
+
+ // Get the operator:
+ switch ($this->scanner->token) {
+ case Token::eq:
+ $this->consumeWhitespace();
+ $op = EventHandler::isExactly;
+ break;
+ case Token::tilde:
+ if ($this->scanner->nextToken() !== Token::eq) {
+ $this->throwError(Token::eq, $this->scanner->token);
+ }
+ $op = EventHandler::containsWithSpace;
+ break;
+ case Token::pipe:
+ if ($this->scanner->nextToken() !== Token::eq) {
+ $this->throwError(Token::eq, $this->scanner->token);
+ }
+ $op = EventHandler::containsWithHyphen;
+ break;
+ case Token::star:
+ if ($this->scanner->nextToken() !== Token::eq) {
+ $this->throwError(Token::eq, $this->scanner->token);
+ }
+ $op = EventHandler::containsInString;
+ break;
+ case Token::dollar;
+ if ($this->scanner->nextToken() !== Token::eq) {
+ $this->throwError(Token::eq, $this->scanner->token);
+ }
+ $op = EventHandler::endsWith;
+ break;
+ case Token::carat:
+ if ($this->scanner->nextToken() !== Token::eq) {
+ $this->throwError(Token::eq, $this->scanner->token);
+ }
+ $op = EventHandler::beginsWith;
+ break;
+ }
+
+ if (isset($op)) {
+ // Consume '=' and go on.
+ $this->scanner->nextToken();
+ $this->consumeWhitespace();
+
+ // So... here we have a problem. The grammer suggests that the
+ // value here is String1 or String2, both of which are enclosed
+ // in quotes of some sort, and both of which allow lots of special
+ // characters. But the spec itself includes examples like this:
+ // [lang=fr]
+ // So some bareword support is assumed. To get around this, we assume
+ // that bare words follow the NAME rules, while quoted strings follow
+ // the String1/String2 rules.
+
+ if ($this->scanner->token === Token::quote || $this->scanner->token === Token::squote) {
+ $attrVal = $this->scanner->getQuotedString();
+ }
+ else {
+ $attrVal = $this->scanner->getNameString();
+ }
+
+ if ($this->DEBUG) {
+ print "ATTR: $attrVal AND OP: $op\n";
+ }
+ }
+
+ $this->consumeWhitespace();
+
+ if ($this->scanner->token != Token::rsquare) {
+ $this->throwError(Token::rsquare, $this->scanner->token);
+ }
+
+ if (isset($ns)) {
+ $this->handler->attributeNS($attrName, $ns, $attrVal, $op);
+ }
+ elseif (isset($attrVal)) {
+ $this->handler->attribute($attrName, $attrVal, $op);
+ }
+ else {
+ $this->handler->attribute($attrName);
+ }
+ $this->scanner->nextToken();
+ }
+ }
+
+ /**
+ * Utility for throwing a consistantly-formatted parse error.
+ */
+ private function throwError($expected, $got) {
+ $filter = sprintf('Expected %s, got %s', Token::name($expected), Token::name($got));
+ throw new ParseException($filter);
+ }
+
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-07 03:06:22 +0000