\d+) ?(?P.*?)".
+ "(?:\r?\n(?P.*))?$@s";
+
+ // We need to parse one or more header blocks in case we got any
+ // "HTTP/1.X 100 Continue" nonsense back as part of the response. This
+ // happens with HTTPS requests, at the least.
+ $response = $raw_response;
+ while (true) {
+ $matches = null;
+ if (!preg_match($rex_base, $response, $matches)) {
+ return $this->buildMalformedResult($raw_response);
+ }
+
+ $head = $matches['head'];
+ $body = $matches['body'];
+
+ if (!preg_match($rex_head, $head, $matches)) {
+ return $this->buildMalformedResult($raw_response);
+ }
+
+ $response_code = (int)$matches['code'];
+ $response_status = strtolower($matches['status']);
+ if ($response_code == 100) {
+ // This is HTTP/1.X 100 Continue, so this whole chunk is moot.
+ $response = $body;
+ } else if (($response_code == 200) &&
+ ($response_status == 'connection established')) {
+ // When tunneling through an HTTPS proxy, we get an initial header
+ // block like "HTTP/1.X 200 Connection established", then newlines,
+ // then the normal response. Drop this chunk.
+ $response = $body;
+ } else {
+ $headers = $this->parseHeaders(idx($matches, 'headers'));
+ break;
+ }
+ }
+
+ $status = new HTTPFutureHTTPResponseStatus(
+ $response_code,
+ $body,
+ $headers,
+ $this->expect);
+
+ return array($status, $body, $headers);
+ }
+
+ /**
+ * Parse an HTTP header block.
+ *
+ * @param string Raw HTTP headers.
+ * @return list List of HTTP header tuples.
+ * @task internal
+ */
+ protected function parseHeaders($head_raw) {
+ $rex_header = '@^(?P.*?):\s*(?P.*)$@';
+
+ $headers = array();
+
+ if (!$head_raw) {
+ return $headers;
+ }
+
+ $headers_raw = preg_split("/\r?\n/", $head_raw);
+ foreach ($headers_raw as $header) {
+ $m = null;
+ if (preg_match($rex_header, $header, $m)) {
+ $headers[] = array($m['name'], $m['value']);
+ } else {
+ $headers[] = array($header, null);
+ }
+ }
+
+ return $headers;
+ }
+
+
+ /**
+ * Find value of the first header with given name.
+ *
+ * @param list List of headers from `resolve()`.
+ * @param string Case insensitive header name.
+ * @return string Value of the header or null if not found.
+ * @task resolve
+ */
+ public static function getHeader(array $headers, $search) {
+ assert_instances_of($headers, 'array');
+ foreach ($headers as $header) {
+ list($name, $value) = $header;
+ if (strcasecmp($name, $search) == 0) {
+ return $value;
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Build a result tuple indicating a parse error resulting from a malformed
+ * HTTP response.
+ *
+ * @return tuple Valid resolution tuple.
+ * @task internal
+ */
+ protected function buildMalformedResult($raw_response) {
+ $body = null;
+ $headers = array();
+
+ $status = new HTTPFutureParseResponseStatus(
+ HTTPFutureParseResponseStatus::ERROR_MALFORMED_RESPONSE,
+ $raw_response);
+ return array($status, $body, $headers);
+ }
+
+}
diff --git a/src/future/http/HTTPFuture.php b/src/future/http/HTTPFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/HTTPFuture.php
@@ -0,0 +1,302 @@
+resolvex();
+ *
+ * Or
+ *
+ * $future = new HTTPFuture('http://www.example.com/');
+ * list($http_response_status_object,
+ * $response_body,
+ * $headers) = $future->resolve();
+ *
+ * Prefer @{method:resolvex} to @{method:resolve} as the former throws
+ * @{class:HTTPFutureHTTPResponseStatus} on failures, which includes an
+ * informative exception message.
+ */
+final class HTTPFuture extends BaseHTTPFuture {
+
+ private $host;
+ private $port = 80;
+ private $fullRequestPath;
+
+ private $socket;
+ private $writeBuffer;
+ private $response;
+
+ private $stateConnected = false;
+ private $stateWriteComplete = false;
+ private $stateReady = false;
+ private $stateStartTime;
+
+ private $profilerCallID;
+
+ public function setURI($uri) {
+ $parts = parse_url($uri);
+ if (!$parts) {
+ throw new Exception(pht("Could not parse URI '%s'.", $uri));
+ }
+
+ if (empty($parts['scheme']) || $parts['scheme'] !== 'http') {
+ throw new Exception(
+ pht(
+ "URI '%s' must be fully qualified with '%s' scheme.",
+ $uri,
+ 'http://'));
+ }
+
+ if (!isset($parts['host'])) {
+ throw new Exception(
+ pht("URI '%s' must be fully qualified and include host name.", $uri));
+ }
+
+ $this->host = $parts['host'];
+
+ if (!empty($parts['port'])) {
+ $this->port = $parts['port'];
+ }
+
+ if (isset($parts['user']) || isset($parts['pass'])) {
+ throw new Exception(
+ pht('HTTP Basic Auth is not supported by %s.', __CLASS__));
+ }
+
+ if (isset($parts['path'])) {
+ $this->fullRequestPath = $parts['path'];
+ } else {
+ $this->fullRequestPath = '/';
+ }
+
+ if (isset($parts['query'])) {
+ $this->fullRequestPath .= '?'.$parts['query'];
+ }
+
+ return parent::setURI($uri);
+ }
+
+ public function __destruct() {
+ if ($this->socket) {
+ @fclose($this->socket);
+ $this->socket = null;
+ }
+ }
+
+ public function getReadSockets() {
+ if ($this->socket) {
+ return array($this->socket);
+ }
+ return array();
+ }
+
+ public function getWriteSockets() {
+ if (strlen($this->writeBuffer)) {
+ return array($this->socket);
+ }
+ return array();
+ }
+
+ public function isWriteComplete() {
+ return $this->stateWriteComplete;
+ }
+
+ private function getDefaultUserAgent() {
+ return __CLASS__.'/1.0';
+ }
+
+ public function isReady() {
+ if ($this->stateReady) {
+ return true;
+ }
+
+ if (!$this->socket) {
+ $this->stateStartTime = microtime(true);
+ $this->socket = $this->buildSocket();
+ if (!$this->socket) {
+ return $this->stateReady;
+ }
+
+ $profiler = PhutilServiceProfiler::getInstance();
+ $this->profilerCallID = $profiler->beginServiceCall(
+ array(
+ 'type' => 'http',
+ 'uri' => $this->getURI(),
+ ));
+ }
+
+ if (!$this->stateConnected) {
+ $read = array();
+ $write = array($this->socket);
+ $except = array();
+ $select = stream_select($read, $write, $except, $tv_sec = 0);
+ if ($write) {
+ $this->stateConnected = true;
+ }
+ }
+
+ if ($this->stateConnected) {
+ if (strlen($this->writeBuffer)) {
+ $bytes = @fwrite($this->socket, $this->writeBuffer);
+ if ($bytes === false) {
+ throw new Exception(pht('Failed to write to buffer.'));
+ } else if ($bytes) {
+ $this->writeBuffer = substr($this->writeBuffer, $bytes);
+ }
+ }
+
+ if (!strlen($this->writeBuffer)) {
+ $this->stateWriteComplete = true;
+ }
+
+ while (($data = fread($this->socket, 32768)) || strlen($data)) {
+ $this->response .= $data;
+ }
+
+ if ($data === false) {
+ throw new Exception(pht('Failed to read socket.'));
+ }
+ }
+
+ return $this->checkSocket();
+ }
+
+ private function buildSocket() {
+ $errno = null;
+ $errstr = null;
+ $socket = @stream_socket_client(
+ 'tcp://'.$this->host.':'.$this->port,
+ $errno,
+ $errstr,
+ $ignored_connection_timeout = 1.0,
+ STREAM_CLIENT_CONNECT | STREAM_CLIENT_ASYNC_CONNECT);
+
+ if (!$socket) {
+ $this->stateReady = true;
+ $this->result = $this->buildErrorResult(
+ HTTPFutureTransportResponseStatus::ERROR_CONNECTION_FAILED);
+ return null;
+ }
+
+ $ok = stream_set_blocking($socket, 0);
+ if (!$ok) {
+ throw new Exception(pht('Failed to set stream nonblocking.'));
+ }
+
+ $this->writeBuffer = $this->buildHTTPRequest();
+
+ return $socket;
+ }
+
+ private function checkSocket() {
+ $timeout = false;
+ $now = microtime(true);
+ if (($now - $this->stateStartTime) > $this->getTimeout()) {
+ $timeout = true;
+ }
+
+ if (!feof($this->socket) && !$timeout) {
+ return false;
+ }
+
+ $this->stateReady = true;
+
+ if ($timeout) {
+ $this->result = $this->buildErrorResult(
+ HTTPFutureTransportResponseStatus::ERROR_TIMEOUT);
+ } else if (!$this->stateConnected) {
+ $this->result = $this->buildErrorResult(
+ HTTPFutureTransportResponseStatus::ERROR_CONNECTION_REFUSED);
+ } else if (!$this->stateWriteComplete) {
+ $this->result = $this->buildErrorResult(
+ HTTPFutureTransportResponseStatus::ERROR_CONNECTION_FAILED);
+ } else {
+ $this->result = $this->parseRawHTTPResponse($this->response);
+ }
+
+ $profiler = PhutilServiceProfiler::getInstance();
+ $profiler->endServiceCall($this->profilerCallID, array());
+
+ return true;
+ }
+
+ private function buildErrorResult($error) {
+ return array(
+ $status = new HTTPFutureTransportResponseStatus($error, $this->getURI()),
+ $body = null,
+ $headers = array(),
+ );
+ }
+
+ private function buildHTTPRequest() {
+ $data = $this->getData();
+ $method = $this->getMethod();
+ $uri = $this->fullRequestPath;
+
+ $add_headers = array();
+
+ if ($this->getMethod() == 'GET') {
+ if (is_array($data)) {
+ $data = http_build_query($data, '', '&');
+ if (strpos($uri, '?') !== false) {
+ $uri .= '&'.$data;
+ } else {
+ $uri .= '?'.$data;
+ }
+ $data = '';
+ }
+ } else {
+ if (is_array($data)) {
+ $data = http_build_query($data, '', '&')."\r\n";
+ $add_headers[] = array(
+ 'Content-Type',
+ 'application/x-www-form-urlencoded',
+ );
+ }
+ }
+
+ $length = strlen($data);
+
+ $add_headers[] = array(
+ 'Content-Length',
+ $length,
+ );
+
+ if (!$this->getHeaders('User-Agent')) {
+ $add_headers[] = array(
+ 'User-Agent',
+ $this->getDefaultUserAgent(),
+ );
+ }
+
+ if (!$this->getHeaders('Host')) {
+ $add_headers[] = array(
+ 'Host',
+ $this->host,
+ );
+ }
+
+ $headers = array_merge($this->getHeaders(), $add_headers);
+ foreach ($headers as $key => $header) {
+ list($name, $value) = $header;
+ if (strlen($value)) {
+ $value = ': '.$value;
+ }
+ $headers[$key] = $name.$value."\r\n";
+ }
+
+ return
+ "{$method} {$uri} HTTP/1.0\r\n".
+ implode('', $headers).
+ "\r\n".
+ $data;
+ }
+
+}
diff --git a/src/future/http/HTTPSFuture.php b/src/future/http/HTTPSFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/HTTPSFuture.php
@@ -0,0 +1,689 @@
+cabundle = $temp;
+ return $this;
+ }
+
+ /**
+ * Set the SSL certificate to use for this session, given a path.
+ *
+ * @param string The path to a valid SSL certificate for this session
+ * @return this
+ */
+ public function setCABundleFromPath($path) {
+ $this->cabundle = $path;
+ return $this;
+ }
+
+ /**
+ * Get the path to the SSL certificate for this session.
+ *
+ * @return string|null
+ */
+ public function getCABundle() {
+ return $this->cabundle;
+ }
+
+ /**
+ * Set whether Location headers in the response will be respected.
+ * The default is true.
+ *
+ * @param boolean true to follow any Location header present in the response,
+ * false to return the request directly
+ * @return this
+ */
+ public function setFollowLocation($follow) {
+ $this->followLocation = $follow;
+ return $this;
+ }
+
+ /**
+ * Get whether Location headers in the response will be respected.
+ *
+ * @return boolean
+ */
+ public function getFollowLocation() {
+ return $this->followLocation;
+ }
+
+ /**
+ * Set the fallback CA certificate if one is not specified
+ * for the session, given a path.
+ *
+ * @param string The path to a valid SSL certificate
+ * @return void
+ */
+ public static function setGlobalCABundleFromPath($path) {
+ self::$globalCABundle = $path;
+ }
+ /**
+ * Set the fallback CA certificate if one is not specified
+ * for the session, given a string.
+ *
+ * @param string The certificate
+ * @return void
+ */
+ public static function setGlobalCABundleFromString($certificate) {
+ $temp = new TempFile();
+ Filesystem::writeFile($temp, $certificate);
+ self::$globalCABundle = $temp;
+ }
+
+ /**
+ * Get the fallback global CA certificate
+ *
+ * @return string
+ */
+ public static function getGlobalCABundle() {
+ return self::$globalCABundle;
+ }
+
+ /**
+ * Load contents of remote URI. Behaves pretty much like
+ * `@file_get_contents($uri)` but doesn't require `allow_url_fopen`.
+ *
+ * @param string
+ * @param float
+ * @return string|false
+ */
+ public static function loadContent($uri, $timeout = null) {
+ $future = new HTTPSFuture($uri);
+ if ($timeout !== null) {
+ $future->setTimeout($timeout);
+ }
+ try {
+ list($body) = $future->resolvex();
+ return $body;
+ } catch (HTTPFutureResponseStatus $ex) {
+ return false;
+ }
+ }
+
+ /**
+ * Attach a file to the request.
+ *
+ * @param string HTTP parameter name.
+ * @param string File content.
+ * @param string File name.
+ * @param string File mime type.
+ * @return this
+ */
+ public function attachFileData($key, $data, $name, $mime_type) {
+ if (isset($this->files[$key])) {
+ throw new Exception(
+ pht(
+ '%s currently supports only one file attachment for each '.
+ 'parameter name. You are trying to attach two different files with '.
+ 'the same parameter, "%s".',
+ __CLASS__,
+ $key));
+ }
+
+ $this->files[$key] = array(
+ 'data' => $data,
+ 'name' => $name,
+ 'mime' => $mime_type,
+ );
+
+ return $this;
+ }
+
+ public function isReady() {
+ if (isset($this->result)) {
+ return true;
+ }
+
+ $uri = $this->getURI();
+ $domain = id(new PhutilURI($uri))->getDomain();
+
+ if (!$this->handle) {
+ $uri_object = new PhutilURI($uri);
+ $proxy = PhutilHTTPEngineExtension::buildHTTPProxyURI($uri_object);
+
+ $profiler = PhutilServiceProfiler::getInstance();
+ $this->profilerCallID = $profiler->beginServiceCall(
+ array(
+ 'type' => 'http',
+ 'uri' => $uri,
+ 'proxy' => (string)$proxy,
+ ));
+
+ if (!self::$multi) {
+ self::$multi = curl_multi_init();
+ if (!self::$multi) {
+ throw new Exception(pht('%s failed!', 'curl_multi_init()'));
+ }
+ }
+
+ if (!empty(self::$pool[$domain])) {
+ $curl = array_pop(self::$pool[$domain]);
+ } else {
+ $curl = curl_init();
+ if (!$curl) {
+ throw new Exception(pht('%s failed!', 'curl_init()'));
+ }
+ }
+
+ $this->handle = $curl;
+ curl_multi_add_handle(self::$multi, $curl);
+
+ curl_setopt($curl, CURLOPT_URL, $uri);
+
+ if (defined('CURLOPT_PROTOCOLS')) {
+ // cURL supports a lot of protocols, and by default it will honor
+ // redirects across protocols (for instance, from HTTP to POP3). Beyond
+ // being very silly, this also has security implications:
+ //
+ // http://blog.volema.com/curl-rce.html
+ //
+ // Disable all protocols other than HTTP and HTTPS.
+
+ $allowed_protocols = CURLPROTO_HTTPS | CURLPROTO_HTTP;
+ curl_setopt($curl, CURLOPT_PROTOCOLS, $allowed_protocols);
+ curl_setopt($curl, CURLOPT_REDIR_PROTOCOLS, $allowed_protocols);
+ }
+
+ if (strlen($this->rawBody)) {
+ if ($this->getData()) {
+ throw new Exception(
+ pht(
+ 'You can not execute an HTTP future with both a raw request '.
+ 'body and structured request data.'));
+ }
+
+ // We aren't actually going to use this file handle, since we are
+ // just pushing data through the callback, but cURL gets upset if
+ // we don't hand it a real file handle.
+ $tmp = new TempFile();
+ $this->fileHandle = fopen($tmp, 'r');
+
+ // NOTE: We must set CURLOPT_PUT here to make cURL use CURLOPT_INFILE.
+ // We'll possibly overwrite the method later on, unless this is really
+ // a PUT request.
+ curl_setopt($curl, CURLOPT_PUT, true);
+ curl_setopt($curl, CURLOPT_INFILE, $this->fileHandle);
+ curl_setopt($curl, CURLOPT_INFILESIZE, strlen($this->rawBody));
+ curl_setopt($curl, CURLOPT_READFUNCTION,
+ array($this, 'willWriteBody'));
+ } else {
+ $data = $this->formatRequestDataForCURL();
+ curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
+ }
+
+ $headers = $this->getHeaders();
+
+ $saw_expect = false;
+ for ($ii = 0; $ii < count($headers); $ii++) {
+ list($name, $value) = $headers[$ii];
+ $headers[$ii] = $name.': '.$value;
+ if (!strncasecmp($name, 'Expect', strlen('Expect'))) {
+ $saw_expect = true;
+ }
+ }
+ if (!$saw_expect) {
+ // cURL sends an "Expect" header by default for certain requests. While
+ // there is some reasoning behind this, it causes a practical problem
+ // in that lighttpd servers reject these requests with a 417. Both sides
+ // are locked in an eternal struggle (lighttpd has introduced a
+ // 'server.reject-expect-100-with-417' option to deal with this case).
+ //
+ // The ostensibly correct way to suppress this behavior on the cURL side
+ // is to add an empty "Expect:" header. If we haven't seen some other
+ // explicit "Expect:" header, do so.
+ //
+ // See here, for example, although this issue is fairly widespread:
+ // http://curl.haxx.se/mail/archive-2009-07/0008.html
+ $headers[] = 'Expect:';
+ }
+ curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
+
+ // Set the requested HTTP method, e.g. GET / POST / PUT.
+ curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $this->getMethod());
+
+ // Make sure we get the headers and data back.
+ curl_setopt($curl, CURLOPT_HEADER, true);
+ curl_setopt($curl, CURLOPT_WRITEFUNCTION,
+ array($this, 'didReceiveDataCallback'));
+
+ if ($this->followLocation) {
+ curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
+ curl_setopt($curl, CURLOPT_MAXREDIRS, 20);
+ }
+
+ if (defined('CURLOPT_TIMEOUT_MS')) {
+ // If CURLOPT_TIMEOUT_MS is available, use the higher-precision timeout.
+ $timeout = max(1, ceil(1000 * $this->getTimeout()));
+ curl_setopt($curl, CURLOPT_TIMEOUT_MS, $timeout);
+ } else {
+ // Otherwise, fall back to the lower-precision timeout.
+ $timeout = max(1, ceil($this->getTimeout()));
+ curl_setopt($curl, CURLOPT_TIMEOUT, $timeout);
+ }
+
+ // We're going to try to set CAINFO below. This doesn't work at all on
+ // OSX around Yosemite (see T5913). On these systems, we'll use the
+ // system CA and then try to tell the user that their settings were
+ // ignored and how to fix things if we encounter a CA-related error.
+ // Assume we have custom CA settings to start with; we'll clear this
+ // flag if we read the default CA info below.
+
+ // Try some decent fallbacks here:
+ // - First, check if a bundle is set explicitly for this request, via
+ // `setCABundle()` or similar.
+ // - Then, check if a global bundle is set explicitly for all requests,
+ // via `setGlobalCABundle()` or similar.
+ // - Then, if a local custom.pem exists, use that, because it probably
+ // means that the user wants to override everything (also because the
+ // user might not have access to change the box's php.ini to add
+ // curl.cainfo).
+ // - Otherwise, try using curl.cainfo. If it's set explicitly, it's
+ // probably reasonable to try using it before we fall back to what
+ // libphutil ships with.
+ // - Lastly, try the default that libphutil ships with. If it doesn't
+ // work, give up and yell at the user.
+
+ if (!$this->getCABundle()) {
+ $caroot = dirname(phutil_get_library_root('phutil')).'/resources/ssl/';
+ $ini_val = ini_get('curl.cainfo');
+ if (self::getGlobalCABundle()) {
+ $this->setCABundleFromPath(self::getGlobalCABundle());
+ } else if (Filesystem::pathExists($caroot.'custom.pem')) {
+ $this->setCABundleFromPath($caroot.'custom.pem');
+ } else if ($ini_val) {
+ // TODO: We can probably do a pathExists() here, even.
+ $this->setCABundleFromPath($ini_val);
+ } else {
+ $this->setCABundleFromPath($caroot.'default.pem');
+ }
+ }
+
+ if ($this->canSetCAInfo()) {
+ curl_setopt($curl, CURLOPT_CAINFO, $this->getCABundle());
+ }
+
+ $verify_peer = 1;
+ $verify_host = 2;
+
+ $extensions = PhutilHTTPEngineExtension::getAllExtensions();
+ foreach ($extensions as $extension) {
+ if ($extension->shouldTrustAnySSLAuthorityForURI($uri_object)) {
+ $verify_peer = 0;
+ }
+ if ($extension->shouldTrustAnySSLHostnameForURI($uri_object)) {
+ $verify_host = 0;
+ }
+ }
+
+ curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, $verify_peer);
+ curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, $verify_host);
+ curl_setopt($curl, CURLOPT_SSLVERSION, 0);
+
+ if ($proxy) {
+ curl_setopt($curl, CURLOPT_PROXY, (string)$proxy);
+ }
+ } else {
+ $curl = $this->handle;
+
+ if (!self::$results) {
+ // NOTE: In curl_multi_select(), PHP calls curl_multi_fdset() but does
+ // not check the return value of &maxfd for -1 until recent versions
+ // of PHP (5.4.8 and newer). cURL may return -1 as maxfd in some unusual
+ // situations; if it does, PHP enters select() with nfds=0, which blocks
+ // until the timeout is reached.
+ //
+ // We could try to guess whether this will happen or not by examining
+ // the version identifier, but we can also just sleep for only a short
+ // period of time.
+ curl_multi_select(self::$multi, 0.01);
+ }
+ }
+
+ do {
+ $active = null;
+ $result = curl_multi_exec(self::$multi, $active);
+ } while ($result == CURLM_CALL_MULTI_PERFORM);
+
+ while ($info = curl_multi_info_read(self::$multi)) {
+ if ($info['msg'] == CURLMSG_DONE) {
+ self::$results[(int)$info['handle']] = $info;
+ }
+ }
+
+ if (!array_key_exists((int)$curl, self::$results)) {
+ return false;
+ }
+
+ // The request is complete, so release any temporary files we wrote
+ // earlier.
+ $this->temporaryFiles = array();
+
+ $info = self::$results[(int)$curl];
+ $result = $this->responseBuffer;
+ $err_code = $info['result'];
+
+ if ($err_code) {
+ if (($err_code == CURLE_SSL_CACERT) && !$this->canSetCAInfo()) {
+ $status = new HTTPFutureCertificateResponseStatus(
+ HTTPFutureCertificateResponseStatus::ERROR_IMMUTABLE_CERTIFICATES,
+ $uri);
+ } else {
+ $status = new HTTPFutureCURLResponseStatus($err_code, $uri);
+ }
+
+ $body = null;
+ $headers = array();
+ $this->result = array($status, $body, $headers);
+ } else {
+ // cURL returns headers of all redirects, we strip all but the final one.
+ $redirects = curl_getinfo($curl, CURLINFO_REDIRECT_COUNT);
+ $result = preg_replace('/^(.*\r\n\r\n){'.$redirects.'}/sU', '', $result);
+ $this->result = $this->parseRawHTTPResponse($result);
+ }
+
+ curl_multi_remove_handle(self::$multi, $curl);
+ unset(self::$results[(int)$curl]);
+
+ // NOTE: We want to use keepalive if possible. Return the handle to a
+ // pool for the domain; don't close it.
+ if ($this->shouldReuseHandles()) {
+ self::$pool[$domain][] = $curl;
+ }
+
+ $profiler = PhutilServiceProfiler::getInstance();
+ $profiler->endServiceCall($this->profilerCallID, array());
+
+ return true;
+ }
+
+
+ /**
+ * Callback invoked by cURL as it reads HTTP data from the response. We save
+ * the data to a buffer.
+ */
+ public function didReceiveDataCallback($handle, $data) {
+ $this->responseBuffer .= $data;
+ return strlen($data);
+ }
+
+
+ /**
+ * Read data from the response buffer.
+ *
+ * NOTE: Like @{class:ExecFuture}, this method advances a read cursor but
+ * does not discard the data. The data will still be buffered, and it will
+ * all be returned when the future resolves. To discard the data after
+ * reading it, call @{method:discardBuffers}.
+ *
+ * @return string Response data, if available.
+ */
+ public function read() {
+ $result = substr($this->responseBuffer, $this->responseBufferPos);
+ $this->responseBufferPos = strlen($this->responseBuffer);
+ return $result;
+ }
+
+
+ /**
+ * Discard any buffered data. Normally, you call this after reading the
+ * data with @{method:read}.
+ *
+ * @return this
+ */
+ public function discardBuffers() {
+ $this->responseBuffer = '';
+ $this->responseBufferPos = 0;
+ return $this;
+ }
+
+
+ /**
+ * Produces a value safe to pass to `CURLOPT_POSTFIELDS`.
+ *
+ * @return wild Some value, suitable for use in `CURLOPT_POSTFIELDS`.
+ */
+ private function formatRequestDataForCURL() {
+ // We're generating a value to hand to cURL as CURLOPT_POSTFIELDS. The way
+ // cURL handles this value has some tricky caveats.
+
+ // First, we can return either an array or a query string. If we return
+ // an array, we get a "multipart/form-data" request. If we return a
+ // query string, we get an "application/x-www-form-urlencoded" request.
+
+ // Second, if we return an array we can't duplicate keys. The user might
+ // want to send the same parameter multiple times.
+
+ // Third, if we return an array and any of the values start with "@",
+ // cURL includes arbitrary files off disk and sends them to an untrusted
+ // remote server. For example, an array like:
+ //
+ // array('name' => '@/usr/local/secret')
+ //
+ // ...will attempt to read that file off disk and transmit its contents with
+ // the request. This behavior is pretty surprising, and it can easily
+ // become a relatively severe security vulnerability which allows an
+ // attacker to read any file the HTTP process has access to. Since this
+ // feature is very dangerous and not particularly useful, we prevent its
+ // use. Broadly, this means we must reject some requests because they
+ // contain an "@" in an inconvenient place.
+
+ // Generally, to avoid the "@" case and because most servers usually
+ // expect "application/x-www-form-urlencoded" data, we try to return a
+ // string unless there are files attached to this request.
+
+ $data = $this->getData();
+ $files = $this->files;
+
+ $any_data = ($data || (is_string($data) && strlen($data)));
+ $any_files = (bool)$this->files;
+
+ if (!$any_data && !$any_files) {
+ // No files or data, so just bail.
+ return null;
+ }
+
+ if (!$any_files) {
+ // If we don't have any files, just encode the data as a query string,
+ // make sure it's not including any files, and we're good to go.
+ if (is_array($data)) {
+ $data = http_build_query($data, '', '&');
+ }
+
+ $this->checkForDangerousCURLMagic($data, $is_query_string = true);
+
+ return $data;
+ }
+
+ // If we've made it this far, we have some files, so we need to return
+ // an array. First, convert the other data into an array if it isn't one
+ // already.
+
+ if (is_string($data)) {
+ // NOTE: We explicitly don't want fancy array parsing here, so just
+ // do a basic parse and then convert it into a dictionary ourselves.
+ $parser = new PhutilQueryStringParser();
+ $pairs = $parser->parseQueryStringToPairList($data);
+
+ $map = array();
+ foreach ($pairs as $pair) {
+ list($key, $value) = $pair;
+ if (array_key_exists($key, $map)) {
+ throw new Exception(
+ pht(
+ 'Request specifies two values for key "%s", but parameter '.
+ 'names must be unique if you are posting file data due to '.
+ 'limitations with cURL.',
+ $key));
+ }
+ $map[$key] = $value;
+ }
+
+ $data = $map;
+ }
+
+ foreach ($data as $key => $value) {
+ $this->checkForDangerousCURLMagic($value, $is_query_string = false);
+ }
+
+ foreach ($this->files as $name => $info) {
+ if (array_key_exists($name, $data)) {
+ throw new Exception(
+ pht(
+ 'Request specifies a file with key "%s", but that key is also '.
+ 'defined by normal request data. Due to limitations with cURL, '.
+ 'requests that post file data must use unique keys.',
+ $name));
+ }
+
+ $tmp = new TempFile($info['name']);
+ Filesystem::writeFile($tmp, $info['data']);
+ $this->temporaryFiles[] = $tmp;
+
+ // In 5.5.0 and later, we can use CURLFile. Prior to that, we have to
+ // use this "@" stuff.
+
+ if (class_exists('CURLFile', false)) {
+ $file_value = new CURLFile((string)$tmp, $info['mime'], $info['name']);
+ } else {
+ $file_value = '@'.(string)$tmp;
+ }
+
+ $data[$name] = $file_value;
+ }
+
+ return $data;
+ }
+
+
+ /**
+ * Detect strings which will cause cURL to do horrible, insecure things.
+ *
+ * @param string Possibly dangerous string.
+ * @param bool True if this string is being used as part of a query string.
+ * @return void
+ */
+ private function checkForDangerousCURLMagic($string, $is_query_string) {
+ if (empty($string[0]) || ($string[0] != '@')) {
+ // This isn't an "@..." string, so it's fine.
+ return;
+ }
+
+ if ($is_query_string) {
+ if (version_compare(phpversion(), '5.2.0', '<')) {
+ throw new Exception(
+ pht(
+ 'Attempting to make an HTTP request, but query string data begins '.
+ 'with "%s". Prior to PHP 5.2.0 this reads files off disk, which '.
+ 'creates a wide attack window for security vulnerabilities. '.
+ 'Upgrade PHP or avoid making cURL requests which begin with "%s".',
+ '@',
+ '@'));
+ }
+
+ // This is safe if we're on PHP 5.2.0 or newer.
+ return;
+ }
+
+ throw new Exception(
+ pht(
+ 'Attempting to make an HTTP request which includes file data, but the '.
+ 'value of a query parameter begins with "%s". PHP interprets these '.
+ 'values to mean that it should read arbitrary files off disk and '.
+ 'transmit them to remote servers. Declining to make this request.',
+ '@'));
+ }
+
+
+ /**
+ * Determine whether CURLOPT_CAINFO is usable on this system.
+ */
+ private function canSetCAInfo() {
+ // We cannot set CAInfo on OSX after Yosemite.
+
+ $osx_version = PhutilExecutionEnvironment::getOSXVersion();
+ if ($osx_version) {
+ if (version_compare($osx_version, 14, '>=')) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+
+ /**
+ * Write a raw HTTP body into the request.
+ *
+ * You must write the entire body before starting the request.
+ *
+ * @param string Raw body.
+ * @return this
+ */
+ public function write($raw_body) {
+ $this->rawBody = $raw_body;
+ return $this;
+ }
+
+
+ /**
+ * Callback to pass data to cURL.
+ */
+ public function willWriteBody($handle, $infile, $len) {
+ $bytes = substr($this->rawBody, $this->rawBodyPos, $len);
+ $this->rawBodyPos += $len;
+ return $bytes;
+ }
+
+ private function shouldReuseHandles() {
+ $curl_version = curl_version();
+ $version = idx($curl_version, 'version');
+
+ // NOTE: cURL 7.43.0 has a bug where the POST body length is not recomputed
+ // properly when a handle is reused. For this version of cURL, disable
+ // handle reuse and accept a small performance penalty. See T8654.
+ if ($version == '7.43.0') {
+ return false;
+ }
+
+ return true;
+ }
+
+
+}
diff --git a/src/future/http/PhutilHTTPEngineExtension.php b/src/future/http/PhutilHTTPEngineExtension.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/PhutilHTTPEngineExtension.php
@@ -0,0 +1,141 @@
+getPhobjectClassConstant('EXTENSIONKEY');
+ }
+
+ final public static function getAllExtensions() {
+ return id(new PhutilClassMapQuery())
+ ->setAncestorClass(__CLASS__)
+ ->setUniqueMethod('getExtensionKey')
+ ->execute();
+ }
+
+ final public static function getExtension($key) {
+ $extensions = self::getAllExtensions();
+ return idx($extensions, $key);
+ }
+
+ final public static function requireExtension($key) {
+ $extension = self::getExtension($key);
+
+ if (!$extension) {
+ throw new Exception(
+ pht(
+ 'No HTTP engine extension exists with extension key "%s".',
+ $key));
+ }
+
+ return $extension;
+ }
+
+ final public static function buildHTTPProxyURI(PhutilURI $uri) {
+ $proxy = null;
+ $via = null;
+
+ $extensions = self::getAllExtensions();
+ foreach ($extensions as $extension) {
+ $extension_proxy = $extension->getHTTPProxyURI($uri);
+
+ if ($extension_proxy === null) {
+ continue;
+ }
+
+ if (!($extension_proxy instanceof PhutilURI)) {
+ throw new Exception(
+ pht(
+ 'HTTP extension "%s" (of class "%s") returned an invalid '.
+ 'result from "%s": expected null, or an object of class "%s".',
+ $extension->getExtensionName(),
+ get_class($extension),
+ 'getHTTPProxyURI()',
+ 'PhutilURI'));
+ }
+
+ if ($proxy) {
+ throw new Exception(
+ pht(
+ 'Two different HTTP extensions ("%s" of class "%s" and "%s" of '.
+ 'class "%s") both provided a proxy URI for URI "%s". No more '.
+ 'than one extension may provide a proxy for any URI.',
+ $extension->getExtensionName(),
+ get_class($extension),
+ $via->getExtensionName(),
+ get_class($via),
+ (string)$uri));
+ }
+
+ $proxy = $extension_proxy;
+ $via = $extension;
+ }
+
+ return $proxy;
+ }
+
+}
diff --git a/src/future/http/status/HTTPFutureCURLResponseStatus.php b/src/future/http/status/HTTPFutureCURLResponseStatus.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/status/HTTPFutureCURLResponseStatus.php
@@ -0,0 +1,86 @@
+getStatusCode() == CURLE_OPERATION_TIMEOUTED);
+ }
+
+ protected function getErrorCodeDescription($code) {
+ $constants = get_defined_constants();
+
+ $constant_name = null;
+ foreach ($constants as $constant => $value) {
+ if ($value == $code && preg_match('/^CURLE_/', $constant)) {
+ $constant_name = '<'.$constant.'> ';
+ break;
+ }
+ }
+
+ $map = array(
+ CURLE_COULDNT_RESOLVE_HOST => pht(
+ 'There was an error resolving the server hostname. Check that you are '.
+ 'connected to the internet and that DNS is correctly configured. (Did '.
+ 'you add the domain to `%s` on some other machine, but not this one?)',
+ '/etc/hosts'),
+
+ CURLE_SSL_CACERT => pht(
+ 'There was an error verifying the SSL Certificate Authority while '.
+ 'negotiating the SSL connection. This usually indicates that you are '.
+ 'using a self-signed certificate but have not added your CA to the '.
+ 'CA bundle. See instructions in "%s".',
+ 'libphutil/resources/ssl/README'),
+
+ // Apparently there's no error constant for this? In cURL it's
+ // CURLE_SSL_CACERT_BADFILE but there's no corresponding constant in
+ // PHP.
+ 77 => pht(
+ 'The SSL CA Bundles that we tried to use could not be read or are '.
+ 'not formatted correctly.'),
+
+ CURLE_SSL_CONNECT_ERROR => pht(
+ 'There was an error negotiating the SSL connection. This usually '.
+ 'indicates that the remote host has a bad SSL certificate, or your '.
+ 'local host has some sort of SSL misconfiguration which prevents it '.
+ 'from accepting the CA. If you are using a self-signed certificate, '.
+ 'see instructions in "%s".',
+ 'libphutil/resources/ssl/README'),
+
+ CURLE_OPERATION_TIMEOUTED => pht(
+ 'The request took too long to complete.'),
+
+ CURLE_SSL_PEER_CERTIFICATE => pht(
+ 'There was an error verifying the SSL connection. This usually '.
+ 'indicates that the remote host has an SSL certificate for a '.
+ 'different domain name than you are connecting with. Make sure the '.
+ 'certificate you have installed is signed for the correct domain.'),
+ );
+
+ $default_message = pht(
+ 'The cURL library raised an error while making a request. You may be '.
+ 'able to find more information about this error (error code: %d) '.
+ 'on the cURL site: %s',
+ $code,
+ 'http://curl.haxx.se/libcurl/c/libcurl-errors.html#'.
+ preg_replace('/[^A-Z]/', '', $constant_name));
+
+ $detailed_message = idx($map, $code, $default_message);
+
+ return $constant_name.$detailed_message;
+ }
+
+}
diff --git a/src/future/http/status/HTTPFutureCertificateResponseStatus.php b/src/future/http/status/HTTPFutureCertificateResponseStatus.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/status/HTTPFutureCertificateResponseStatus.php
@@ -0,0 +1,33 @@
+ 512) {
+ $excerpt = substr($body, 0, 512).'...';
+ } else {
+ $excerpt = $body;
+ }
+
+ $content_type = BaseHTTPFuture::getHeader($headers, 'Content-Type');
+ $match = null;
+ if (preg_match('/;\s*charset=([^;]+)/', $content_type, $match)) {
+ $encoding = trim($match[1], "\"'");
+ try {
+ $excerpt = phutil_utf8_convert($excerpt, 'UTF-8', $encoding);
+ } catch (Exception $ex) {}
+ }
+
+ $this->excerpt = phutil_utf8ize($excerpt);
+ $this->expect = $expect;
+
+ parent::__construct($status_code);
+ }
+
+ protected function getErrorCodeType($code) {
+ return 'HTTP';
+ }
+
+ public function isError() {
+ if ($this->expect === null) {
+ return ($this->getStatusCode() < 200) || ($this->getStatusCode() > 299);
+ }
+
+ return !in_array($this->getStatusCode(), $this->expect, true);
+ }
+
+ public function isRedirect() {
+ $code = $this->getStatusCode();
+ return ($code >= 300 && $code < 400);
+ }
+
+ public function isTimeout() {
+ return false;
+ }
+
+ protected function getErrorCodeDescription($code) {
+ static $map = array(
+ 404 => 'Not Found',
+ 500 => 'Internal Server Error',
+ );
+
+ return idx($map, $code)."\n".$this->excerpt."\n";
+ }
+
+}
diff --git a/src/future/http/status/HTTPFutureParseResponseStatus.php b/src/future/http/status/HTTPFutureParseResponseStatus.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/status/HTTPFutureParseResponseStatus.php
@@ -0,0 +1,32 @@
+rawResponse = $raw_response;
+ parent::__construct($code);
+ }
+
+ protected function getErrorCodeType($code) {
+ return 'Parse';
+ }
+
+ public function isError() {
+ return true;
+ }
+
+ public function isTimeout() {
+ return false;
+ }
+
+ protected function getErrorCodeDescription($code) {
+ return pht(
+ 'The remote host returned something other than an HTTP response: %s',
+ $this->rawResponse);
+ }
+
+}
diff --git a/src/future/http/status/HTTPFutureResponseStatus.php b/src/future/http/status/HTTPFutureResponseStatus.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/status/HTTPFutureResponseStatus.php
@@ -0,0 +1,43 @@
+statusCode = $status_code;
+ $this->uri = (string)$uri;
+
+ $type = $this->getErrorCodeType($status_code);
+ $description = $this->getErrorCodeDescription($status_code);
+
+ $uri_info = '';
+ if ($this->uri) {
+ $uri_info = ' ('.$this->uri.')';
+ }
+
+ $message = rtrim("[{$type}/{$status_code}]{$uri_info} {$description}");
+
+ parent::__construct($message);
+ }
+
+ final public function getStatusCode() {
+ return $this->statusCode;
+ }
+
+ final public function getURI() {
+ return $this->uri;
+ }
+
+ abstract public function isError();
+ abstract public function isTimeout();
+
+ public function isRedirect() {
+ return false;
+ }
+
+ abstract protected function getErrorCodeType($code);
+ abstract protected function getErrorCodeDescription($code);
+
+}
diff --git a/src/future/http/status/HTTPFutureTransportResponseStatus.php b/src/future/http/status/HTTPFutureTransportResponseStatus.php
new file mode 100644
--- /dev/null
+++ b/src/future/http/status/HTTPFutureTransportResponseStatus.php
@@ -0,0 +1,44 @@
+getStatusCode() == self::ERROR_TIMEOUT);
+ }
+
+ protected function getErrorCodeDescription($code) {
+ $map = array(
+ self::ERROR_TIMEOUT => pht(
+ 'The request took too long to complete.'),
+ self::ERROR_CONNECTION_ABORTED => pht(
+ 'The remote host closed the connection before the request completed.'),
+ self::ERROR_CONNECTION_REFUSED => pht(
+ 'The remote host refused the connection. This usually means the '.
+ 'host is not running an HTTP server, or the network is blocking '.
+ 'connections from this machine. Verify you can connect to the '.
+ 'remote host from this host.'),
+ self::ERROR_CONNECTION_FAILED => pht(
+ 'Connection could not be initiated. This usually indicates a DNS '.
+ 'problem: verify the domain name is correct, that you can '.
+ 'perform a DNS lookup for it from this machine. (Did you add the '.
+ 'domain to `%s` on some other machine, but not this one?) '.
+ 'This might also indicate that you specified the wrong port.',
+ '/etc/hosts'),
+ );
+ return idx($map, $code);
+ }
+
+}
diff --git a/src/future/oauth/PhutilOAuth1Future.php b/src/future/oauth/PhutilOAuth1Future.php
new file mode 100644
--- /dev/null
+++ b/src/future/oauth/PhutilOAuth1Future.php
@@ -0,0 +1,291 @@
+callbackURI = $callback_uri;
+ return $this;
+ }
+
+ public function setTimestamp($timestamp) {
+ $this->timestamp = $timestamp;
+ return $this;
+ }
+
+ public function setNonce($nonce) {
+ $this->nonce = $nonce;
+ return $this;
+ }
+
+ public function setTokenSecret($token_secret) {
+ $this->tokenSecret = $token_secret;
+ return $this;
+ }
+
+ public function setToken($token) {
+ $this->token = $token;
+ return $this;
+ }
+
+ public function setPrivateKey(PhutilOpaqueEnvelope $private_key) {
+ $this->privateKey = $private_key;
+ return $this;
+ }
+
+ public function setSignatureMethod($signature_method) {
+ $this->signatureMethod = $signature_method;
+ return $this;
+ }
+
+ public function setConsumerKey($consumer_key) {
+ $this->consumerKey = $consumer_key;
+ return $this;
+ }
+
+ public function setConsumerSecret(PhutilOpaqueEnvelope $consumer_secret) {
+ $this->consumerSecret = $consumer_secret;
+ return $this;
+ }
+
+ public function setMethod($method) {
+ $this->method = $method;
+ return $this;
+ }
+
+ public function __construct($uri, $data = array()) {
+ $this->uri = new PhutilURI((string)$uri);
+ $this->data = $data;
+ $this->setProxiedFuture(new HTTPSFuture($uri, $data));
+ }
+
+ public function getSignature() {
+ $params = array();
+
+ // NOTE: The JIRA API uses JSON-encoded request bodies which are not
+ // signed, and OAuth1 provides no real way to sign a nonparameterized
+ // request body. Possibly we should split this apart into flags which
+ // control which data is signed, but for now this rule seems to cover
+ // all the use cases.
+
+ if (is_array($this->data)) {
+ $params = $this->data;
+ }
+
+ $params = $params
+ + $this->uri->getQueryParams()
+ + $this->getOAuth1Headers();
+
+ return $this->sign($params);
+ }
+
+ public function addHeader($name, $value) {
+ // If we haven't built the future yet, hold on to the header until after
+ // we do, since there might be more changes coming which will affect the
+ // signature process.
+
+ if (!$this->hasConstructedFuture) {
+ $this->headers[] = array($name, $value);
+ } else {
+ $this->getProxiedFuture()->addHeader($name, $value);
+ }
+ return $this;
+ }
+
+ protected function getProxiedFuture() {
+ $future = parent::getProxiedFuture();
+
+ if (!$this->hasConstructedFuture) {
+ $future->setMethod($this->method);
+
+ $oauth_headers = $this->getOAuth1Headers();
+ $oauth_headers['oauth_signature'] = $this->getSignature();
+
+ $full_oauth_header = array();
+ foreach ($oauth_headers as $header => $value) {
+ $full_oauth_header[] = $header.'="'.urlencode($value).'"';
+ }
+ $full_oauth_header = 'OAuth '.implode(', ', $full_oauth_header);
+
+ $future->addHeader('Authorization', $full_oauth_header);
+
+ foreach ($this->headers as $header) {
+ $future->addHeader($header[0], $header[1]);
+ }
+ $this->headers = array();
+
+ $this->hasConstructedFuture = true;
+ }
+
+ return $future;
+ }
+
+ protected function didReceiveResult($result) {
+ return $result;
+ }
+
+ private function getOAuth1Headers() {
+ if (!$this->nonce) {
+ $this->nonce = Filesystem::readRandomCharacters(32);
+ }
+ if (!$this->timestamp) {
+ $this->timestamp = time();
+ }
+
+ $oauth_headers = array(
+ 'oauth_consumer_key' => $this->consumerKey,
+ 'oauth_signature_method' => $this->signatureMethod,
+ 'oauth_timestamp' => $this->timestamp,
+ 'oauth_nonce' => $this->nonce,
+ 'oauth_version' => '1.0',
+ );
+
+ if ($this->callbackURI) {
+ $oauth_headers['oauth_callback'] = (string)$this->callbackURI;
+ }
+
+ if ($this->token) {
+ $oauth_headers['oauth_token'] = $this->token;
+ }
+
+ return $oauth_headers;
+ }
+
+ private function sign(array $params) {
+ ksort($params);
+
+ $pstr = array();
+ foreach ($params as $key => $value) {
+ $pstr[] = rawurlencode($key).'='.rawurlencode($value);
+ }
+ $pstr = implode('&', $pstr);
+
+ $sign_uri = clone $this->uri;
+ $sign_uri->setFragment('');
+ $sign_uri->setQueryParams(array());
+
+ $sign_uri->setProtocol(phutil_utf8_strtolower($sign_uri->getProtocol()));
+ $protocol = $sign_uri->getProtocol();
+ switch ($protocol) {
+ case 'http':
+ if ($sign_uri->getPort() == 80) {
+ $sign_uri->setPort(null);
+ }
+ break;
+ case 'https':
+ if ($sign_uri->getPort() == 443) {
+ $sign_uri->setPort(null);
+ }
+ break;
+ }
+
+ $method = rawurlencode(phutil_utf8_strtoupper($this->method));
+ $sign_uri = rawurlencode((string)$sign_uri);
+ $pstr = rawurlencode($pstr);
+
+ $sign_input = "{$method}&{$sign_uri}&{$pstr}";
+ return $this->signString($sign_input);
+ }
+
+ private function signString($string) {
+ $consumer_secret = null;
+ if ($this->consumerSecret) {
+ $consumer_secret = $this->consumerSecret->openEnvelope();
+ }
+
+ $key = urlencode($consumer_secret).'&'.urlencode($this->tokenSecret);
+
+ switch ($this->signatureMethod) {
+ case 'HMAC-SHA1':
+ if (!$this->consumerSecret) {
+ throw new Exception(
+ pht(
+ "Signature method '%s' requires %s!",
+ 'HMAC-SHA1',
+ 'setConsumerSecret()'));
+ }
+
+ $hash = hash_hmac('sha1', $string, $key, true);
+ return base64_encode($hash);
+ case 'RSA-SHA1':
+ if (!$this->privateKey) {
+ throw new Exception(
+ pht(
+ "Signature method '%s' requires %s!",
+ 'RSA-SHA1',
+ 'setPrivateKey()'));
+ }
+
+ $cert = @openssl_pkey_get_private($this->privateKey->openEnvelope());
+ if (!$cert) {
+ throw new Exception(pht('%s failed!', 'openssl_pkey_get_private()'));
+ }
+
+ $pkey = @openssl_get_privatekey($cert);
+ if (!$pkey) {
+ throw new Exception(pht('%s failed!', 'openssl_get_privatekey()'));
+ }
+
+ $signature = null;
+ $ok = openssl_sign($string, $signature, $pkey, OPENSSL_ALGO_SHA1);
+ if (!$ok) {
+ throw new Exception(pht('%s failed!', 'openssl_sign()'));
+ }
+
+ openssl_free_key($pkey);
+
+ return base64_encode($signature);
+ case 'PLAINTEXT':
+ if (!$this->consumerSecret) {
+ throw new Exception(
+ pht(
+ "Signature method '%s' requires %s!",
+ 'PLAINTEXT',
+ 'setConsumerSecret()'));
+ }
+ return $key;
+ default:
+ throw new Exception(pht("Unknown signature method '%s'!", $string));
+ }
+ }
+
+ public function resolvex() {
+ $result = $this->getProxiedFuture()->resolvex();
+ return $this->didReceiveResult($result);
+ }
+
+ public function resolveJSON() {
+ $result = $this->getProxiedFuture()->resolvex();
+ $result = $this->didReceiveResult($result);
+ list($body) = $result;
+
+ try {
+ return phutil_json_decode($body);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(pht('Expected JSON.'), $ex);
+ }
+ }
+
+
+}
diff --git a/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php b/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php
@@ -0,0 +1,159 @@
+setTimestamp(1191242090)
+ ->setNonce('hsu94j3884jdopsl')
+ ->setConsumerKey('dpf43f3p2l4k3l03')
+ ->setConsumerSecret(new PhutilOpaqueEnvelope('kd94hf93k423kf44'))
+ ->setSignatureMethod('PLAINTEXT');
+
+ $this->assertEqual('kd94hf93k423kf44&', $future->getSignature());
+
+
+ $uri = 'http://photos.example.net/photos';
+ $data = array(
+ 'file' => 'vacation.jpg',
+ 'size' => 'original',
+ );
+
+ $future = id(new PhutilOAuth1Future($uri, $data))
+ ->setMethod('GET')
+ ->setTimestamp(1191242096)
+ ->setNonce('kllo9940pd9333jh')
+ ->setConsumerKey('dpf43f3p2l4k3l03')
+ ->setConsumerSecret(new PhutilOpaqueEnvelope('kd94hf93k423kf44'))
+ ->setSignatureMethod('HMAC-SHA1')
+ ->setToken('nnch734d00sl2jdk')
+ ->setTokenSecret('pfkkdhi9sl3r4s00');
+
+ $this->assertEqual('tR3+Ty81lMeYAr/Fid0kMTYa/WM=', $future->getSignature());
+ }
+
+ public function testOAuth1SigningWithTwitterExamples() {
+
+ // NOTE: This example is from Twitter.
+ // https://dev.twitter.com/docs/auth/creating-signature
+
+ $uri = 'https://api.twitter.com/1/statuses/update.json?'.
+ 'include_entities=true';
+ $data = array(
+ 'status' => 'Hello Ladies + Gentlemen, a signed OAuth request!',
+ );
+
+ $future = id(new PhutilOAuth1Future($uri, $data))
+ ->setMethod('POST')
+ ->setConsumerKey('xvz1evFS4wEEPTGEFPHBog')
+ ->setConsumerSecret(
+ new PhutilOpaqueEnvelope('kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw'))
+ ->setNonce('kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg')
+ ->setSignatureMethod('HMAC-SHA1')
+ ->setTimestamp(1318622958)
+ ->setToken('370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb')
+ ->setTokenSecret('LswwdoUaIvS8ltyTt5jkRh4J50vUPVVHtR2YPi5kE');
+
+ $this->assertEqual('tnnArxj06cWHq44gCs1OSKk/jLY=', $future->getSignature());
+ }
+
+ public function testOAuth1SigningWithJIRAExamples() {
+
+ // NOTE: This is an emprically example against JIRA v6.0.6, in that the
+ // code seems to work when actually authing. It primarily serves as a check
+ // of the RSA-SHA1 signature method.
+
+$public_key = <<setConsumerKey('quackquack')
+ ->setPrivateKey(new PhutilOpaqueEnvelope($private_key))
+ ->setTimestamp('1375984131')
+ ->setNonce('iamaduck')
+ ->setSignatureMethod('RSA-SHA1');
+
+ // The actual signature is 684 bytes and begins "QwigfVxpOm0AKoWJkFRwbyseso
+ // VJobhiXpyY0J79Kzki+vwlT4Xz2Tr4vlwDLsra5gJbfdeme4qJ2rE..."
+ $this->assertEqual(
+ '5e63e65237e2b8078426996d5ef1a706',
+ md5($future->getSignature()));
+ }
+
+}
diff --git a/src/future/paypal/PhutilPayPalAPIFuture.php b/src/future/paypal/PhutilPayPalAPIFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/paypal/PhutilPayPalAPIFuture.php
@@ -0,0 +1,88 @@
+host = $host;
+ return $this;
+ }
+
+ public function getHost() {
+ return $this->host;
+ }
+
+ public function setAPIUsername($api_username) {
+ $this->apiUsername = $api_username;
+ return $this;
+ }
+
+ public function setAPIPassword($api_password) {
+ $this->apiPassword = $api_password;
+ return $this;
+ }
+
+ public function setAPISignature($api_signature) {
+ $this->apiSignature = $api_signature;
+ return $this;
+ }
+
+ public function setRawPayPalQuery($action, array $params = array()) {
+ $this->params = array('METHOD' => $action) + $params + $this->params;
+ return $this;
+ }
+
+ protected function getProxiedFuture() {
+ if (!$this->future) {
+ $params = $this->params;
+
+ if (!$this->params) {
+ throw new Exception(pht('You must %s!', 'setRawPayPalQuery()'));
+ }
+
+ if (!$this->apiUsername) {
+ throw new Exception(pht('You must set PayPal API credentials!'));
+ }
+
+ $params['VERSION'] = '98.0';
+ $params['USER'] = $this->apiUsername;
+ $params['PWD'] = $this->apiPassword;
+ $params['SIGNATURE'] = $this->apiSignature;
+
+ $this->future = id(new HTTPSFuture($this->getHost(), $params))
+ ->setMethod('POST');
+ }
+
+ return $this->future;
+ }
+
+ protected function didReceiveResult($result) {
+ list($status, $body, $headers) = $result;
+
+ if ($status->isError()) {
+ throw $status;
+ }
+
+ $dict = array();
+ parse_str($body, $dict);
+
+ if (idx($dict, 'ACK') !== 'Success') {
+ throw new Exception(
+ pht('PayPal API call failed: %s', print_r($dict, true)));
+ }
+
+ return $dict;
+ }
+
+}
diff --git a/src/future/postmark/PhutilPostmarkFuture.php b/src/future/postmark/PhutilPostmarkFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/postmark/PhutilPostmarkFuture.php
@@ -0,0 +1,85 @@
+accessToken = $token;
+ return $this;
+ }
+
+ public function setClientID($client_id) {
+ $this->clientID = $client_id;
+ return $this;
+ }
+
+ public function setMethod($method, array $parameters) {
+ $this->method = $method;
+ $this->parameters = $parameters;
+ return $this;
+ }
+
+ protected function getProxiedFuture() {
+ if (!$this->future) {
+ if ($this->accessToken === null) {
+ throw new PhutilInvalidStateException('setAccessToken');
+ }
+
+ if ($this->method === null || $this->parameters === null) {
+ throw new PhutilInvalidStateException('setMethod');
+ }
+
+ $uri = id(new PhutilURI('https://api.postmarkapp.com/'))
+ ->setPath('/'.$this->method);
+
+ $request_body = phutil_json_encode($this->parameters);
+
+ $future = id(new HTTPSFuture($uri))
+ ->setData($request_body)
+ ->setMethod('POST')
+ ->addHeader('X-Postmark-Server-Token', $this->accessToken)
+ ->addHeader('Accept', 'application/json')
+ ->addHeader('Content-Type', 'application/json');
+
+ $this->future = $future;
+ }
+
+ return $this->future;
+ }
+
+ protected function didReceiveResult($result) {
+ list($status, $body, $headers) = $result;
+
+ if ($status->isError()) {
+ throw $status;
+ }
+
+ try {
+ $data = phutil_json_decode($body);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht('Expected JSON response from Postmark.'),
+ $ex);
+ }
+
+ if (idx($data, 'ErrorCode')) {
+ $error = $data['ErrorCode'];
+ throw new Exception(
+ pht(
+ 'Received error from Postmark: (%s) %s',
+ $error,
+ idx($data, 'Message')));
+ }
+
+ return $data;
+ }
+
+}
diff --git a/src/future/query/QueryFuture.php b/src/future/query/QueryFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/query/QueryFuture.php
@@ -0,0 +1,129 @@
+resolve();
+ * } catch (AphrontQueryException $ex) {
+ * }
+ * }
+ *
+ * `$result` contains a list of dicts for select queries or number of modified
+ * rows for modification queries.
+ */
+final class QueryFuture extends Future {
+
+ private static $futures = array();
+
+ private $conn;
+ private $query;
+ private $id;
+ private $async;
+ private $profilerCallID;
+
+ public function __construct(
+ AphrontDatabaseConnection $conn,
+ $pattern/* , ... */) {
+
+ $this->conn = $conn;
+
+ $args = func_get_args();
+ $args = array_slice($args, 2);
+ $this->query = vqsprintf($conn, $pattern, $args);
+
+ self::$futures[] = $this;
+ $this->id = last_key(self::$futures);
+ }
+
+ public function isReady() {
+ if ($this->result !== null || $this->exception) {
+ return true;
+ }
+
+ if (!$this->conn->supportsAsyncQueries()) {
+ if ($this->conn->supportsParallelQueries()) {
+ $queries = array();
+ $conns = array();
+ foreach (self::$futures as $id => $future) {
+ $queries[$id] = $future->query;
+ $conns[$id] = $future->conn;
+ }
+ $results = $this->conn->executeParallelQueries($queries, $conns);
+ $this->processResults($results);
+ return true;
+ }
+
+ $conns = array();
+ $conn_queries = array();
+ foreach (self::$futures as $id => $future) {
+ $hash = spl_object_hash($future->conn);
+ $conns[$hash] = $future->conn;
+ $conn_queries[$hash][$id] = $future->query;
+ }
+ foreach ($conn_queries as $hash => $queries) {
+ $this->processResults($conns[$hash]->executeRawQueries($queries));
+ }
+ return true;
+ }
+
+ if (!$this->async) {
+ $profiler = PhutilServiceProfiler::getInstance();
+ $this->profilerCallID = $profiler->beginServiceCall(
+ array(
+ 'type' => 'query',
+ 'query' => $this->query,
+ 'async' => true,
+ ));
+
+ $this->async = $this->conn->asyncQuery($this->query);
+ return false;
+ }
+
+ $conns = array();
+ $asyncs = array();
+ foreach (self::$futures as $id => $future) {
+ if ($future->async) {
+ $conns[$id] = $future->conn;
+ $asyncs[$id] = $future->async;
+ }
+ }
+
+ $this->processResults($this->conn->resolveAsyncQueries($conns, $asyncs));
+
+ if ($this->result !== null || $this->exception) {
+ return true;
+ }
+ return false;
+ }
+
+ private function processResults(array $results) {
+ foreach ($results as $id => $result) {
+ $future = self::$futures[$id];
+ if ($result instanceof Exception) {
+ $future->exception = $result;
+ } else {
+ $future->result = $result;
+ }
+ unset(self::$futures[$id]);
+ if ($future->profilerCallID) {
+ $profiler = PhutilServiceProfiler::getInstance();
+ $profiler->endServiceCall($future->profilerCallID, array());
+ }
+ }
+ }
+}
diff --git a/src/future/slack/PhutilSlackFuture.php b/src/future/slack/PhutilSlackFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/slack/PhutilSlackFuture.php
@@ -0,0 +1,87 @@
+accessToken = $token;
+ return $this;
+ }
+
+ public function setClientID($client_id) {
+ $this->clientID = $client_id;
+ return $this;
+ }
+
+ public function setRawSlackQuery($action, array $params = array()) {
+ $this->action = $action;
+ $this->params = $params;
+ return $this;
+ }
+
+ public function setMethod($method) {
+ $this->method = $method;
+ return $this;
+ }
+
+ protected function getProxiedFuture() {
+ if (!$this->future) {
+ $params = $this->params;
+
+ if (!$this->action) {
+ throw new Exception(pht('You must %s!', 'setRawSlackQuery()'));
+ }
+
+ if (!$this->accessToken) {
+ throw new Exception(pht('You must %s!', 'setAccessToken()'));
+ }
+
+ $uri = new PhutilURI('https://slack.com/');
+ $uri->setPath('/api/'.$this->action);
+ $uri->setQueryParam('token', $this->accessToken);
+
+ $future = new HTTPSFuture($uri);
+ $future->setData($this->params);
+ $future->setMethod($this->method);
+
+ $this->future = $future;
+ }
+
+ return $this->future;
+ }
+
+ protected function didReceiveResult($result) {
+ list($status, $body, $headers) = $result;
+
+ if ($status->isError()) {
+ throw $status;
+ }
+
+ $data = null;
+ try {
+ $data = phutil_json_decode($body);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht('Expected JSON response from Slack.'),
+ $ex);
+ }
+
+ if (idx($data, 'error')) {
+ $error = $data['error'];
+ throw new Exception(pht('Received error from Slack: %s', $error));
+ }
+
+ return $data;
+ }
+
+}
diff --git a/src/future/twitch/PhutilTwitchFuture.php b/src/future/twitch/PhutilTwitchFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/twitch/PhutilTwitchFuture.php
@@ -0,0 +1,93 @@
+accessToken = $token;
+ return $this;
+ }
+
+ public function setClientID($client_id) {
+ $this->clientID = $client_id;
+ return $this;
+ }
+
+ public function setRawTwitchQuery($action, array $params = array()) {
+ $this->action = $action;
+ $this->params = $params;
+ return $this;
+ }
+
+ public function setMethod($method) {
+ $this->method = $method;
+ return $this;
+ }
+
+ protected function getProxiedFuture() {
+ if (!$this->future) {
+ $params = $this->params;
+
+ if (!$this->action) {
+ throw new Exception(pht('You must %s!', 'setRawTwitchQuery()'));
+ }
+
+ if (!$this->accessToken) {
+ throw new Exception(pht('You must %s!', 'setAccessToken()'));
+ }
+
+ $uri = new PhutilURI('https://api.twitch.tv/');
+ $uri->setPath('/kraken/'.ltrim($this->action, '/'));
+ $uri->setQueryParam('oauth_token', $this->accessToken);
+
+ $future = new HTTPSFuture($uri);
+ $future->setData($this->params);
+ $future->setMethod($this->method);
+
+ // NOTE: This is how the Twitch API is versioned.
+ $future->addHeader('Accept', 'application/vnd.twitchtv.2+json');
+
+ // NOTE: This is required to avoid rate limiting.
+ $future->addHeader('Client-ID', $this->clientID);
+
+ $this->future = $future;
+ }
+
+ return $this->future;
+ }
+
+ protected function didReceiveResult($result) {
+ list($status, $body, $headers) = $result;
+
+ if ($status->isError()) {
+ throw $status;
+ }
+
+ $data = null;
+ try {
+ $data = phutil_json_decode($body);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht('Expected JSON response from Twitch.'),
+ $ex);
+ }
+
+ if (idx($data, 'error')) {
+ $error = $data['error'];
+ throw new Exception(pht('Received error from Twitch: %s', $error));
+ }
+
+ return $data;
+ }
+
+}
diff --git a/src/future/wordpress/PhutilWordPressFuture.php b/src/future/wordpress/PhutilWordPressFuture.php
new file mode 100644
--- /dev/null
+++ b/src/future/wordpress/PhutilWordPressFuture.php
@@ -0,0 +1,89 @@
+accessToken = $token;
+ return $this;
+ }
+
+ public function setClientID($client_id) {
+ $this->clientID = $client_id;
+ return $this;
+ }
+
+ public function setRawWordPressQuery($action, array $params = array()) {
+ $this->action = $action;
+ $this->params = $params;
+ return $this;
+ }
+
+ public function setMethod($method) {
+ $this->method = $method;
+ return $this;
+ }
+
+ protected function getProxiedFuture() {
+ if (!$this->future) {
+ $params = $this->params;
+
+ if (!$this->action) {
+ throw new Exception(pht('You must %s!', 'setRawWordPressQuery()'));
+ }
+
+ if (!$this->accessToken) {
+ throw new Exception(pht('You must %s!', 'setAccessToken()'));
+ }
+
+ $uri = new PhutilURI('https://public-api.wordpress.com/');
+ $uri->setPath('/rest/v1/'.ltrim($this->action, '/'));
+
+ $future = new HTTPSFuture($uri);
+ $future->setData($this->params);
+ $future->setMethod($this->method);
+
+ // NOTE: This is how WordPress.com REST API authenticates
+ $future->addHeader('Authorization', 'Bearer '.$this->accessToken);
+
+ $this->future = $future;
+ }
+
+ return $this->future;
+ }
+
+ protected function didReceiveResult($result) {
+ list($status, $body, $headers) = $result;
+
+ if ($status->isError()) {
+ throw $status;
+ }
+
+ try {
+ $data = phutil_json_decode($body);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht('Expected JSON response from WordPress.com.'),
+ $ex);
+ }
+
+ if (idx($data, 'error')) {
+ $error = $data['error'];
+ throw new Exception(
+ pht('Received error from WordPress.com: %s', $error));
+ }
+
+ return $data;
+ }
+
+}
diff --git a/src/grammar/PhutilContextFreeGrammar.php b/src/grammar/PhutilContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/PhutilContextFreeGrammar.php
@@ -0,0 +1,93 @@
+generate();
+ }
+ return implode($implode, $paragraph);
+ }
+
+ public function generate() {
+ $count = 0;
+ $rules = $this->getRules();
+ return $this->applyRules('[start]', $count, $rules);
+ }
+
+ final protected function applyRules($input, &$count, array $rules) {
+ if (++$count > $this->limit) {
+ throw new Exception(pht('Token replacement count exceeded limit!'));
+ }
+
+ $matches = null;
+ preg_match_all('/(\\[[^\\]]+\\])/', $input, $matches, PREG_OFFSET_CAPTURE);
+
+ foreach (array_reverse($matches[1]) as $token_spec) {
+ list($token, $offset) = $token_spec;
+ $token_name = substr($token, 1, -1);
+ $options = array();
+
+ if (($name_end = strpos($token_name, ','))) {
+ $options_parser = new PhutilSimpleOptions();
+ $options = $options_parser->parse($token_name);
+ $token_name = substr($token_name, 0, $name_end);
+ }
+
+ if (empty($rules[$token_name])) {
+ throw new Exception(pht("Invalid token '%s' in grammar.", $token_name));
+ }
+
+ $key = array_rand($rules[$token_name]);
+ $replacement = $this->applyRules($rules[$token_name][$key],
+ $count, $rules);
+
+ if (isset($options['indent'])) {
+ if (is_numeric($options['indent'])) {
+ $replacement = self::strPadLines($replacement, $options['indent']);
+ } else {
+ $replacement = self::strPadLines($replacement);
+ }
+ }
+ if (isset($options['trim'])) {
+ switch ($options['trim']) {
+ case 'left':
+ $replacement = ltrim($replacement);
+ break;
+ case 'right':
+ $replacement = rtrim($replacement);
+ break;
+ default:
+ case 'both':
+ $replacement = trim($replacement);
+ break;
+ }
+ }
+ if (isset($options['block'])) {
+ $replacement = "\n".$replacement."\n";
+ }
+
+ $input = substr_replace($input, $replacement, $offset, strlen($token));
+ }
+
+ return $input;
+ }
+
+ private static function strPadLines($text, $num_spaces = 2) {
+ $text_lines = phutil_split_lines($text);
+ foreach ($text_lines as $linenr => $line) {
+ $text_lines[$linenr] = str_repeat(' ', $num_spaces).$line;
+ }
+
+ return implode('', $text_lines);
+ }
+
+}
diff --git a/src/grammar/PhutilLipsumContextFreeGrammar.php b/src/grammar/PhutilLipsumContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/PhutilLipsumContextFreeGrammar.php
@@ -0,0 +1,107 @@
+ array(
+ '[words].',
+ '[words].',
+ '[words].',
+ '[words]: [word], [word], [word] [word].',
+ '[words]; [lowerwords].',
+ '[words]!',
+ '[words], "[words]."',
+ '[words] ("[upperword] [upperword] [upperword]") [lowerwords].',
+ '[words]?',
+ ),
+ 'words' => array(
+ '[upperword] [lowerwords]',
+ ),
+ 'upperword' => array(
+ 'Lorem',
+ 'Ipsum',
+ 'Dolor',
+ 'Sit',
+ 'Amet',
+ ),
+ 'lowerwords' => array(
+ '[word]',
+ '[word] [word]',
+ '[word] [word] [word]',
+ '[word] [word] [word] [word]',
+ '[word] [word] [word] [word] [word]',
+ '[word] [word] [word] [word] [word]',
+ '[word] [word] [word] [word] [word] [word]',
+ '[word] [word] [word] [word] [word] [word]',
+ ),
+ 'word' => array(
+ 'ad',
+ 'adipisicing',
+ 'aliqua',
+ 'aliquip',
+ 'amet',
+ 'anim',
+ 'aute',
+ 'cillum',
+ 'commodo',
+ 'consectetur',
+ 'consequat',
+ 'culpa',
+ 'cupidatat',
+ 'deserunt',
+ 'do',
+ 'dolor',
+ 'dolore',
+ 'duis',
+ 'ea',
+ 'eiusmod',
+ 'elit',
+ 'enim',
+ 'esse',
+ 'est',
+ 'et',
+ 'eu',
+ 'ex',
+ 'excepteur',
+ 'exercitation',
+ 'fugiat',
+ 'id',
+ 'in',
+ 'incididunt',
+ 'ipsum',
+ 'irure',
+ 'labore',
+ 'laboris',
+ 'laborum',
+ 'lorem',
+ 'magna',
+ 'minim',
+ 'mollit',
+ 'nisi',
+ 'non',
+ 'nostrud',
+ 'nulla',
+ 'occaecat',
+ 'officia',
+ 'pariatur',
+ 'proident',
+ 'qui',
+ 'quis',
+ 'reprehenderit',
+ 'sed',
+ 'sint',
+ 'sit',
+ 'sunt',
+ 'tempor',
+ 'ullamco',
+ 'ut',
+ 'velit',
+ 'veniam',
+ 'voluptate',
+ ),
+ );
+ }
+
+}
diff --git a/src/grammar/PhutilRealNameContextFreeGrammar.php b/src/grammar/PhutilRealNameContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/PhutilRealNameContextFreeGrammar.php
@@ -0,0 +1,155 @@
+ array(
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]',
+ '[first] [last]-[last]',
+ '[first] [middle] [last]',
+ '[first] "[nick]" [last]',
+ '[first] [particle] [particle] [particle]',
+ ),
+ 'first' => array(
+ 'Mohamed',
+ 'Youssef',
+ 'Ahmed',
+ 'Mahmoud',
+ 'Mustafa',
+ 'Fatma',
+ 'Aya',
+ 'Noam',
+ 'Adam',
+ 'Lucas',
+ 'Noah',
+ 'Jakub',
+ 'Victor',
+ 'Harry',
+ 'Rasmus',
+ 'Nathan',
+ 'Emil',
+ 'Charlie',
+ 'Leon',
+ 'Dylan',
+ 'Alexander',
+ 'Emma',
+ 'Marie',
+ 'Lea',
+ 'Amelia',
+ 'Hanna',
+ 'Emily',
+ 'Sofia',
+ 'Julia',
+ 'Santiago',
+ 'Sebastian',
+ 'Olivia',
+ 'Madison',
+ 'Isabella',
+ 'Esther',
+ 'Anya',
+ 'Camila',
+ 'Jack',
+ 'Oliver',
+ ),
+ 'nick' => array(
+ 'Buzz',
+ 'Juggernaut',
+ 'Haze',
+ 'Hawk',
+ 'Iceman',
+ 'Killer',
+ 'Apex',
+ 'Ocelot',
+ ),
+ 'middle' => array(
+ 'Rose',
+ 'Grace',
+ 'Jane',
+ 'Louise',
+ 'Jade',
+ 'James',
+ 'John',
+ 'William',
+ 'Thomas',
+ 'Alexander',
+ ),
+ 'last' => array(
+ '[termlast]',
+ '[termlast]',
+ '[termlast]',
+ '[termlast]',
+ '[termlast]',
+ '[termlast]',
+ '[termlast]',
+ '[termlast]',
+ 'O\'[termlast]',
+ 'Mc[termlast]',
+ ),
+ 'termlast' => array(
+ 'Smith',
+ 'Johnson',
+ 'Williams',
+ 'Jones',
+ 'Brown',
+ 'Davis',
+ 'Miller',
+ 'Wilson',
+ 'Moore',
+ 'Taylor',
+ 'Anderson',
+ 'Thomas',
+ 'Jackson',
+ 'White',
+ 'Harris',
+ 'Martin',
+ 'Thompson',
+ 'Garcia',
+ 'Marinez',
+ 'Robinson',
+ 'Clark',
+ 'Rodrigues',
+ 'Lewis',
+ 'Lee',
+ 'Walker',
+ 'Hall',
+ 'Allen',
+ 'Young',
+ 'Hernandex',
+ 'King',
+ 'Wang',
+ 'Li',
+ 'Zhang',
+ 'Liu',
+ 'Chen',
+ 'Yang',
+ 'Huang',
+ 'Zhao',
+ 'Wu',
+ 'Zhou',
+ 'Xu',
+ 'Sun',
+ 'Ma',
+ ),
+ 'particle' => array(
+ 'Wu',
+ 'Xu',
+ 'Ma',
+ 'Li',
+ 'Liu',
+ 'Shao',
+ 'Lin',
+ 'Khan',
+ ),
+ );
+ }
+
+}
diff --git a/src/grammar/code/PhutilCLikeCodeSnippetContextFreeGrammar.php b/src/grammar/code/PhutilCLikeCodeSnippetContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/code/PhutilCLikeCodeSnippetContextFreeGrammar.php
@@ -0,0 +1,254 @@
+getStmtTerminationGrammarSet(),
+ $this->getVarNameGrammarSet(),
+ $this->getNullExprGrammarSet(),
+ $this->getNumberGrammarSet(),
+ $this->getExprGrammarSet(),
+ $this->getCondGrammarSet(),
+ $this->getLoopGrammarSet(),
+ $this->getStmtGrammarSet(),
+ $this->getAssignmentGrammarSet(),
+ $this->getArithExprGrammarSet(),
+ $this->getBoolExprGrammarSet(),
+ $this->getBoolValGrammarSet(),
+ $this->getTernaryExprGrammarSet(),
+
+ $this->getFuncNameGrammarSet(),
+ $this->getFuncCallGrammarSet(),
+ $this->getFuncCallParamGrammarSet(),
+ $this->getFuncDeclGrammarSet(),
+ $this->getFuncParamGrammarSet(),
+ $this->getFuncBodyGrammarSet(),
+ $this->getFuncReturnGrammarSet(),
+ );
+ }
+
+ protected function getStartGrammarSet() {
+ $start_grammar = parent::getStartGrammarSet();
+
+ $start_grammar['start'][] = '[funcdecl]';
+
+ return $start_grammar;
+ }
+
+ protected function getStmtTerminationGrammarSet() {
+ return $this->buildGrammarSet('term', array(';'));
+ }
+
+ protected function getFuncCallGrammarSet() {
+ return $this->buildGrammarSet('funccall',
+ array(
+ '[funcname]([funccallparam])',
+ ));
+ }
+
+ protected function getFuncCallParamGrammarSet() {
+ return $this->buildGrammarSet('funccallparam',
+ array(
+ '',
+ '[expr]',
+ '[expr], [expr]',
+ ));
+ }
+
+ protected function getFuncDeclGrammarSet() {
+ return $this->buildGrammarSet('funcdecl',
+ array(
+ 'function [funcname]([funcparam]) '.
+ '{[funcbody, indent, block, trim=right]}',
+ ));
+ }
+
+ protected function getFuncParamGrammarSet() {
+ return $this->buildGrammarSet('funcparam',
+ array(
+ '',
+ '[varname]',
+ '[varname], [varname]',
+ '[varname], [varname], [varname]',
+ ));
+ }
+
+ protected function getFuncBodyGrammarSet() {
+ return $this->buildGrammarSet('funcbody',
+ array(
+ "[stmt]\n[stmt]\n[funcreturn]",
+ "[stmt]\n[stmt]\n[stmt]\n[funcreturn]",
+ "[stmt]\n[stmt]\n[stmt]\n[stmt]\n[funcreturn]",
+ ));
+ }
+
+ protected function getFuncReturnGrammarSet() {
+ return $this->buildGrammarSet('funcreturn',
+ array(
+ 'return [expr][term]',
+ '',
+ ));
+ }
+
+ // Not really C, but put it here because of the curly braces and mostly shared
+ // among Java and PHP
+ protected function getClassDeclGrammarSet() {
+ return $this->buildGrammarSet('classdecl',
+ array(
+ '[classinheritancemod] class [classname] {[classbody, indent, block]}',
+ 'class [classname] {[classbody, indent, block]}',
+ ));
+ }
+
+ protected function getClassNameGrammarSet() {
+ return $this->buildGrammarSet('classname',
+ array(
+ 'MuffinHouse',
+ 'MuffinReader',
+ 'MuffinAwesomizer',
+ 'SuperException',
+ 'Librarian',
+ 'Book',
+ 'Ball',
+ 'BallOfCode',
+ 'AliceAndBobsSharedSecret',
+ 'FileInputStream',
+ 'FileOutputStream',
+ 'BufferedReader',
+ 'BufferedWriter',
+ 'Cardigan',
+ 'HouseOfCards',
+ 'UmbrellaClass',
+ 'GenericThing',
+ ));
+ }
+
+ protected function getClassBodyGrammarSet() {
+ return $this->buildGrammarSet('classbody',
+ array(
+ '[methoddecl]',
+ "[methoddecl]\n\n[methoddecl]",
+ "[propdecl]\n[propdecl]\n\n[methoddecl]\n\n[methoddecl]",
+ "[propdecl]\n[propdecl]\n[propdecl]\n\n[methoddecl]\n\n[methoddecl]".
+ "\n\n[methoddecl]",
+ ));
+ }
+
+ protected function getVisibilityGrammarSet() {
+ return $this->buildGrammarSet('visibility',
+ array(
+ 'private',
+ 'protected',
+ 'public',
+ ));
+ }
+
+ protected function getClassInheritanceModGrammarSet() {
+ return $this->buildGrammarSet('classinheritancemod',
+ array(
+ 'final',
+ 'abstract',
+ ));
+ }
+
+ // Keeping this separate so we won't give abstract methods a function body
+ protected function getMethodInheritanceModGrammarSet() {
+ return $this->buildGrammarSet('methodinheritancemod',
+ array(
+ 'final',
+ ));
+ }
+
+ protected function getMethodDeclGrammarSet() {
+ return $this->buildGrammarSet('methoddecl',
+ array(
+ '[visibility] [methodfuncdecl]',
+ '[visibility] [methodfuncdecl]',
+ '[methodinheritancemod] [visibility] [methodfuncdecl]',
+ '[abstractmethoddecl]',
+ ));
+ }
+
+ protected function getMethodFuncDeclGrammarSet() {
+ return $this->buildGrammarSet('methodfuncdecl',
+ array(
+ 'function [funcname]([funcparam]) '.
+ '{[methodbody, indent, block, trim=right]}',
+ ));
+ }
+
+ protected function getMethodBodyGrammarSet() {
+ return $this->buildGrammarSet('methodbody',
+ array(
+ "[methodstmt]\n[methodbody]",
+ "[methodstmt]\n[funcreturn]",
+ ));
+ }
+
+ protected function getMethodStmtGrammarSet() {
+ $stmts = $this->getStmtGrammarSet();
+
+ return $this->buildGrammarSet('methodstmt',
+ array_merge(
+ $stmts['stmt'],
+ array(
+ '[methodcall][term]',
+ )));
+ }
+
+ protected function getMethodCallGrammarSet() {
+ // Java/JavaScript
+ return $this->buildGrammarSet('methodcall',
+ array(
+ 'this.[funccall]',
+ '[varname].[funccall]',
+ '[classname].[funccall]',
+ ));
+ }
+
+ protected function getAbstractMethodDeclGrammarSet() {
+ return $this->buildGrammarSet('abstractmethoddecl',
+ array(
+ 'abstract function [funcname]([funcparam])[term]',
+ ));
+ }
+
+ protected function getPropDeclGrammarSet() {
+ return $this->buildGrammarSet('propdecl',
+ array(
+ '[visibility] [varname][term]',
+ ));
+ }
+
+ protected function getClassRuleSets() {
+ return array(
+ $this->getClassInheritanceModGrammarSet(),
+ $this->getMethodInheritanceModGrammarSet(),
+ $this->getClassDeclGrammarSet(),
+ $this->getClassNameGrammarSet(),
+ $this->getClassBodyGrammarSet(),
+ $this->getMethodDeclGrammarSet(),
+ $this->getMethodFuncDeclGrammarSet(),
+ $this->getMethodBodyGrammarSet(),
+ $this->getMethodStmtGrammarSet(),
+ $this->getMethodCallGrammarSet(),
+ $this->getAbstractMethodDeclGrammarSet(),
+ $this->getPropDeclGrammarSet(),
+ $this->getVisibilityGrammarSet(),
+ );
+ }
+
+ public function generateClass() {
+ $rules = array_merge($this->getRules(), $this->getClassRuleSets());
+ $rules['start'] = array('[classdecl]');
+ $count = 0;
+ return $this->applyRules('[start]', $count, $rules);
+ }
+
+}
diff --git a/src/grammar/code/PhutilCodeSnippetContextFreeGrammar.php b/src/grammar/code/PhutilCodeSnippetContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/code/PhutilCodeSnippetContextFreeGrammar.php
@@ -0,0 +1,205 @@
+getStartGrammarSet(),
+ $this->getStmtGrammarSet(),
+ array_mergev($this->buildRuleSet()));
+ }
+
+ abstract protected function buildRuleSet();
+
+ protected function buildGrammarSet($name, array $set) {
+ return array(
+ $name => $set,
+ );
+ }
+
+ protected function getStartGrammarSet() {
+ return $this->buildGrammarSet('start',
+ array(
+ "[stmt]\n[stmt]",
+ "[stmt]\n[stmt]\n[stmt]",
+ "[stmt]\n[stmt]\n[stmt]\n[stmt]",
+ ));
+ }
+
+ protected function getStmtGrammarSet() {
+ return $this->buildGrammarSet('stmt',
+ array(
+ '[assignment][term]',
+ '[assignment][term]',
+ '[assignment][term]',
+ '[assignment][term]',
+ '[funccall][term]',
+ '[funccall][term]',
+ '[funccall][term]',
+ '[funccall][term]',
+ '[cond]',
+ '[loop]',
+ ));
+ }
+
+ protected function getFuncNameGrammarSet() {
+ return $this->buildGrammarSet('funcname',
+ array(
+ 'do_something',
+ 'nonempty',
+ 'noOp',
+ 'call_user_func',
+ 'getenv',
+ 'render',
+ 'super',
+ 'derpify',
+ 'awesomize',
+ 'equals',
+ 'run',
+ 'flee',
+ 'fight',
+ 'notify',
+ 'listen',
+ 'calculate',
+ 'aim',
+ 'open',
+ ));
+ }
+
+ protected function getVarNameGrammarSet() {
+ return $this->buildGrammarSet('varname',
+ array(
+ 'is_something',
+ 'object',
+ 'name',
+ 'token',
+ 'label',
+ 'piece_of_the_pie',
+ 'type',
+ 'state',
+ 'param',
+ 'action',
+ 'key',
+ 'timeout',
+ 'result',
+ ));
+ }
+
+ protected function getNullExprGrammarSet() {
+ return $this->buildGrammarSet('null', array('null'));
+ }
+
+ protected function getNumberGrammarSet() {
+ return $this->buildGrammarSet('number',
+ array(
+ mt_rand(-1, 100),
+ mt_rand(-100, 1000),
+ mt_rand(-1000, 5000),
+ mt_rand(0, 1).'.'.mt_rand(1, 1000),
+ mt_rand(0, 50).'.'.mt_rand(1, 1000),
+ ));
+ }
+
+ protected function getExprGrammarSet() {
+ return $this->buildGrammarSet('expr',
+ array(
+ '[null]',
+ '[number]',
+ '[number]',
+ '[varname]',
+ '[varname]',
+ '[boolval]',
+ '[boolval]',
+ '[boolexpr]',
+ '[boolexpr]',
+ '[funccall]',
+ '[arithexpr]',
+ '[arithexpr]',
+ // Some random strings
+ '"'.Filesystem::readRandomCharacters(4).'"',
+ '"'.Filesystem::readRandomCharacters(5).'"',
+ ));
+ }
+
+ protected function getBoolExprGrammarSet() {
+ return $this->buildGrammarSet('boolexpr',
+ array(
+ '[varname]',
+ '![varname]',
+ '[varname] == [boolval]',
+ '[varname] != [boolval]',
+ '[ternary]',
+ ));
+ }
+
+ protected function getBoolValGrammarSet() {
+ return $this->buildGrammarSet('boolval',
+ array(
+ 'true',
+ 'false',
+ ));
+ }
+
+ protected function getArithExprGrammarSet() {
+ return $this->buildGrammarSet('arithexpr',
+ array(
+ '[varname]++',
+ '++[varname]',
+ '[varname] + [number]',
+ '[varname]--',
+ '--[varname]',
+ '[varname] - [number]',
+ ));
+ }
+
+ protected function getAssignmentGrammarSet() {
+ return $this->buildGrammarSet('assignment',
+ array(
+ '[varname] = [expr]',
+ '[varname] = [arithexpr]',
+ '[varname] += [expr]',
+ ));
+ }
+
+ protected function getCondGrammarSet() {
+ return $this->buildGrammarSet('cond',
+ array(
+ 'if ([boolexpr]) {[stmt, indent, block]}',
+ 'if ([boolexpr]) {[stmt, indent, block]} else {[stmt, indent, block]}',
+ ));
+ }
+
+ protected function getLoopGrammarSet() {
+ return $this->buildGrammarSet('loop',
+ array(
+ 'while ([boolexpr]) {[stmt, indent, block]}',
+ 'do {[stmt, indent, block]} while ([boolexpr])[term]',
+ 'for ([assignment]; [boolexpr]; [expr]) {[stmt, indent, block]}',
+ ));
+ }
+
+ protected function getTernaryExprGrammarSet() {
+ return $this->buildGrammarSet('ternary',
+ array(
+ '[boolexpr] ? [expr] : [expr]',
+ ));
+ }
+
+ protected function getStmtTerminationGrammarSet() {
+ return $this->buildGrammarSet('term', array(''));
+ }
+
+}
diff --git a/src/grammar/code/PhutilJavaCodeSnippetContextFreeGrammar.php b/src/grammar/code/PhutilJavaCodeSnippetContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/code/PhutilJavaCodeSnippetContextFreeGrammar.php
@@ -0,0 +1,184 @@
+getClassRuleSets());
+
+ $rulesset[] = $this->getTypeNameGrammarSet();
+ $rulesset[] = $this->getNamespaceDeclGrammarSet();
+ $rulesset[] = $this->getNamespaceNameGrammarSet();
+ $rulesset[] = $this->getImportGrammarSet();
+ $rulesset[] = $this->getMethodReturnTypeGrammarSet();
+ $rulesset[] = $this->getMethodNameGrammarSet();
+ $rulesset[] = $this->getVarDeclGrammarSet();
+ $rulesset[] = $this->getClassDerivGrammarSet();
+
+ return $rulesset;
+ }
+
+ protected function getStartGrammarSet() {
+ return $this->buildGrammarSet('start',
+ array(
+ '[import, block][nmspdecl, block][classdecl, block]',
+ ));
+ }
+
+ protected function getClassDeclGrammarSet() {
+ return $this->buildGrammarSet('classdecl',
+ array(
+ '[classinheritancemod] [visibility] class [classname][classderiv] '.
+ '{[classbody, indent, block]}',
+ '[visibility] class [classname][classderiv] '.
+ '{[classbody, indent, block]}',
+ ));
+ }
+
+ protected function getClassDerivGrammarSet() {
+ return $this->buildGrammarSet('classderiv',
+ array(
+ ' extends [classname]',
+ '',
+ '',
+ ));
+ }
+
+ protected function getTypeNameGrammarSet() {
+ return $this->buildGrammarSet('type',
+ array(
+ 'int',
+ 'boolean',
+ 'char',
+ 'short',
+ 'long',
+ 'float',
+ 'double',
+ '[classname]',
+ '[type][]',
+ ));
+ }
+
+ protected function getMethodReturnTypeGrammarSet() {
+ return $this->buildGrammarSet('methodreturn',
+ array(
+ '[type]',
+ 'void',
+ ));
+ }
+
+ protected function getNamespaceDeclGrammarSet() {
+ return $this->buildGrammarSet('nmspdecl',
+ array(
+ 'package [nmspname][term]',
+ ));
+ }
+
+ protected function getNamespaceNameGrammarSet() {
+ return $this->buildGrammarSet('nmspname',
+ array(
+ 'java.lang',
+ 'java.io',
+ 'com.example.proj.std',
+ 'derp.example.www',
+ ));
+ }
+
+ protected function getImportGrammarSet() {
+ return $this->buildGrammarSet('import',
+ array(
+ 'import [nmspname][term]',
+ 'import [nmspname].*[term]',
+ 'import [nmspname].[classname][term]',
+ ));
+ }
+
+ protected function getExprGrammarSet() {
+ $expr = parent::getExprGrammarSet();
+
+ $expr['expr'][] = 'new [classname]([funccallparam])';
+
+ $expr['expr'][] = '[methodcall]';
+ $expr['expr'][] = '[methodcall]';
+ $expr['expr'][] = '[methodcall]';
+ $expr['expr'][] = '[methodcall]';
+
+ // Add some 'char's
+ for ($ii = 0; $ii < 2; $ii++) {
+ $expr['expr'][] = "'".Filesystem::readRandomCharacters(1)."'";
+ }
+
+ return $expr;
+ }
+
+ protected function getStmtGrammarSet() {
+ $stmt = parent::getStmtGrammarSet();
+
+ $stmt['stmt'][] = '[vardecl]';
+ $stmt['stmt'][] = '[vardecl]';
+ // `try` to `throw` a `Ball`!
+ $stmt['stmt'][] = 'throw [classname][term]';
+
+ return $stmt;
+ }
+
+ protected function getPropDeclGrammarSet() {
+ return $this->buildGrammarSet('propdecl',
+ array(
+ '[visibility] [type] [varname][term]',
+ ));
+ }
+
+ protected function getVarDeclGrammarSet() {
+ return $this->buildGrammarSet('vardecl',
+ array(
+ '[type] [varname][term]',
+ '[type] [assignment][term]',
+ ));
+ }
+
+ protected function getFuncNameGrammarSet() {
+ return $this->buildGrammarSet('funcname',
+ array(
+ '[methodname]',
+ '[classname].[methodname]',
+ // This is just silly (too much recursion)
+ // '[classname].[funcname]',
+ // Don't do this for now, it just clutters up output (thanks to rec.)
+ // '[nmspname].[classname].[methodname]',
+ ));
+ }
+
+ // Renamed from `funcname`
+ protected function getMethodNameGrammarSet() {
+ $funcnames = head(parent::getFuncNameGrammarSet());
+ return $this->buildGrammarSet('methodname', $funcnames);
+ }
+
+ protected function getMethodFuncDeclGrammarSet() {
+ return $this->buildGrammarSet('methodfuncdecl',
+ array(
+ '[methodreturn] [methodname]([funcparam]) '.
+ '{[methodbody, indent, block, trim=right]}',
+ ));
+ }
+
+ protected function getFuncParamGrammarSet() {
+ return $this->buildGrammarSet('funcparam',
+ array(
+ '',
+ '[type] [varname]',
+ '[type] [varname], [type] [varname]',
+ '[type] [varname], [type] [varname], [type] [varname]',
+ ));
+ }
+
+ protected function getAbstractMethodDeclGrammarSet() {
+ return $this->buildGrammarSet('abstractmethoddecl',
+ array(
+ 'abstract [methodreturn] [methodname]([funcparam])[term]',
+ ));
+ }
+
+}
diff --git a/src/grammar/code/PhutilPHPCodeSnippetContextFreeGrammar.php b/src/grammar/code/PhutilPHPCodeSnippetContextFreeGrammar.php
new file mode 100644
--- /dev/null
+++ b/src/grammar/code/PhutilPHPCodeSnippetContextFreeGrammar.php
@@ -0,0 +1,57 @@
+getClassRuleSets());
+ }
+
+ protected function getStartGrammarSet() {
+ $start_grammar = parent::getStartGrammarSet();
+
+ $start_grammar['start'][] = '[classdecl]';
+ $start_grammar['start'][] = '[classdecl]';
+
+ return $start_grammar;
+ }
+
+ protected function getExprGrammarSet() {
+ $expr = parent::getExprGrammarSet();
+
+ $expr['expr'][] = 'new [classname]([funccallparam])';
+
+ $expr['expr'][] = '[classname]::[funccall]';
+
+ return $expr;
+ }
+
+ protected function getVarNameGrammarSet() {
+ $varnames = parent::getVarNameGrammarSet();
+
+ foreach ($varnames as $vn_key => $vn_val) {
+ foreach ($vn_val as $vv_key => $vv_value) {
+ $varnames[$vn_key][$vv_key] = '$'.$vv_value;
+ }
+ }
+
+ return $varnames;
+ }
+
+ protected function getFuncNameGrammarSet() {
+ return $this->buildGrammarSet('funcname',
+ array_mergev(get_defined_functions()));
+ }
+
+ protected function getMethodCallGrammarSet() {
+ return $this->buildGrammarSet('methodcall',
+ array(
+ '$this->[funccall]',
+ 'self::[funccall]',
+ 'static::[funccall]',
+ '[varname]->[funccall]',
+ '[classname]::[funccall]',
+ ));
+ }
+
+}
diff --git a/src/internationalization/PhutilLocale.php b/src/internationalization/PhutilLocale.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/PhutilLocale.php
@@ -0,0 +1,247 @@
+" order.
+ *
+ * @param const `PhutilPerson` gender constant.
+ * @param list List of variants.
+ * @return string Variant for use.
+ */
+ public function selectGenderVariant($variant, array $translations) {
+ if ($variant == PhutilPerson::GENDER_FEMININE) {
+ return end($translations);
+ } else {
+ return reset($translations);
+ }
+ }
+
+
+ /**
+ * Select a plural variant for this locale. By default, locales use a simple
+ * rule with two plural variants, listed in "" order.
+ *
+ * @param int Plurality of the value.
+ * @param list List of variants.
+ * @return string Variant for use.
+ */
+ public function selectPluralVariant($variant, array $translations) {
+ if ($variant == 1) {
+ return reset($translations);
+ } else {
+ return end($translations);
+ }
+ }
+
+
+ /**
+ * Flags a locale as silly, like "English (Pirate)".
+ *
+ * These locales are fun but disastrously inappropriate for serious
+ * businesses.
+ *
+ * @return bool True if this locale is silly.
+ */
+ public function isSillyLocale() {
+ return false;
+ }
+
+
+ /**
+ * Flags a locale as a testing locale, like "English (US, ALL CAPS)". These
+ * locales are useful for translation development, but not for normal users.
+ *
+ * @return bool True if this is a locale for testing or development.
+ */
+ public function isTestLocale() {
+ return false;
+ }
+
+
+ /**
+ * Indicates that the translator should post-process translations in this
+ * locale by calling @{method:didTranslateString}.
+ *
+ * Doing this incurs a performance penalty, and is not useful for most
+ * languages. However, it can be used to implement test translations like
+ * "English (US, ALL CAPS)".
+ *
+ * @return bool True to postprocess strings.
+ */
+ public function shouldPostProcessTranslations() {
+ return false;
+ }
+
+
+ /**
+ * Callback for post-processing translations.
+ *
+ * By default, this callback is not invoked. To activate it, return `true`
+ * from @{method:shouldPostProcessTranslations}. Activating this callback
+ * incurs a performance penalty.
+ *
+ * @param string The raw input pattern.
+ * @param string The selected translation pattern.
+ * @param list The raw input arguments.
+ * @param string The translated string.
+ * @return string Post-processed translation string.
+ */
+ public function didTranslateString(
+ $raw_pattern,
+ $translated_pattern,
+ array $args,
+ $result_text) {
+ return $result_text;
+ }
+
+
+ /**
+ * Load all available locales.
+ *
+ * @return map Map from codes to locale objects.
+ */
+ public static function loadAllLocales() {
+ static $locales;
+
+ if ($locales === null) {
+ $objects = id(new PhutilClassMapQuery())
+ ->setAncestorClass(__CLASS__)
+ ->execute();
+
+ $locale_map = array();
+ foreach ($objects as $object) {
+ $locale_code = $object->getLocaleCode();
+ if (empty($locale_map[$locale_code])) {
+ $locale_map[$locale_code] = $object;
+ } else {
+ throw new Exception(
+ pht(
+ 'Two subclasses of "%s" ("%s" and "%s") define '.
+ 'locales with the same locale code ("%s"). Each locale must '.
+ 'have a unique locale code.',
+ __CLASS__,
+ get_class($object),
+ get_class($locale_map[$locale_code]),
+ $locale_code));
+ }
+ }
+
+ foreach ($locale_map as $locale_code => $locale) {
+ $fallback_code = $locale->getFallbackLocaleCode();
+ if ($fallback_code !== null) {
+ if (empty($locale_map[$fallback_code])) {
+ throw new Exception(
+ pht(
+ 'The locale "%s" has an invalid fallback locale code ("%s"). '.
+ 'No locale class exists which defines this locale.',
+ get_class($locale),
+ $fallback_code));
+ }
+ }
+ }
+
+ foreach ($locale_map as $locale_code => $locale) {
+ $seen = array($locale_code => get_class($locale));
+ self::checkLocaleFallback($locale_map, $locale, $seen);
+ }
+
+ $locales = $locale_map;
+ }
+ return $locales;
+ }
+
+
+ /**
+ * Load a specific locale using a locale code.
+ *
+ * @param string Locale code.
+ * @return PhutilLocale Locale object.
+ */
+ public static function loadLocale($locale_code) {
+ $all_locales = self::loadAllLocales();
+ $locale = idx($all_locales, $locale_code);
+
+ if (!$locale) {
+ throw new Exception(
+ pht(
+ 'There is no locale with the locale code "%s".',
+ $locale_code));
+ }
+
+ return $locale;
+ }
+
+
+ /**
+ * Recursively check locale fallbacks for cycles.
+ *
+ * @param map Map of locales.
+ * @param PhutilLocale Current locale.
+ * @param map Map of visited locales.
+ * @return void
+ */
+ private static function checkLocaleFallback(
+ array $map,
+ PhutilLocale $locale,
+ array $seen) {
+
+ $fallback_code = $locale->getFallbackLocaleCode();
+ if ($fallback_code === null) {
+ return;
+ }
+
+ if (isset($seen[$fallback_code])) {
+ $seen[] = get_class($locale);
+ $seen[] = pht('...');
+ throw new Exception(
+ pht(
+ 'Locale "%s" is part of a cycle of locales which fall back on '.
+ 'one another in a loop (%s). Locales which fall back on other '.
+ 'locales must not loop.',
+ get_class($locale),
+ implode(' -> ', $seen)));
+ }
+
+ $seen[$fallback_code] = get_class($locale);
+ self::checkLocaleFallback($map, $map[$fallback_code], $seen);
+ }
+
+}
diff --git a/src/internationalization/PhutilNumber.php b/src/internationalization/PhutilNumber.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/PhutilNumber.php
@@ -0,0 +1,26 @@
+value = $value;
+ $this->decimals = $decimals;
+ }
+
+ public function getNumber() {
+ return $this->value;
+ }
+
+ public function setDecimals($decimals) {
+ $this->decimals = $decimals;
+ return $this;
+ }
+
+ public function getDecimals() {
+ return $this->decimals;
+ }
+
+}
diff --git a/src/internationalization/PhutilPerson.php b/src/internationalization/PhutilPerson.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/PhutilPerson.php
@@ -0,0 +1,11 @@
+ Map of raw strings to translations.
+ */
+ abstract protected function getTranslations();
+
+
+ /**
+ * Return a filtered map of all strings in this translation.
+ *
+ * Filters out empty/placeholder translations.
+ *
+ * @return map Map of raw strings to translations.
+ */
+ final public function getFilteredTranslations() {
+ $translations = $this->getTranslations();
+
+ foreach ($translations as $key => $translation) {
+ if ($translation === null) {
+ unset($translations[$key]);
+ }
+ }
+
+ return $translations;
+ }
+
+
+ /**
+ * Load all available translation objects.
+ *
+ * @return list List of available translation sources.
+ */
+ public static function loadAllTranslations() {
+ return id(new PhutilClassMapQuery())
+ ->setAncestorClass(__CLASS__)
+ ->execute();
+ }
+
+
+ /**
+ * Load the complete translation map for a locale.
+ *
+ * This will compile primary and fallback translations into a single
+ * translation map.
+ *
+ * @param string Locale code, like "en_US".
+ * @return map Map of all avialable translations.
+ */
+ public static function getTranslationMapForLocale($locale_code) {
+ $locale = PhutilLocale::loadLocale($locale_code);
+
+ $translations = self::loadAllTranslations();
+
+ $results = array();
+ foreach ($translations as $translation) {
+ if ($translation->getLocaleCode() == $locale_code) {
+ $results += $translation->getFilteredTranslations();
+ }
+ }
+
+ $fallback_code = $locale->getFallbackLocaleCode();
+ if ($fallback_code !== null) {
+ $results += self::getTranslationMapForLocale($fallback_code);
+ }
+
+ return $results;
+ }
+
+}
diff --git a/src/internationalization/PhutilTranslator.php b/src/internationalization/PhutilTranslator.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/PhutilTranslator.php
@@ -0,0 +1,269 @@
+locale = $locale;
+ $this->localeCode = $locale->getLocaleCode();
+ $this->shouldPostProcess = $locale->shouldPostProcessTranslations();
+ return $this;
+ }
+
+ public function setWillTranslateCallback($callback) {
+ $this->willTranslateCallback = $callback;
+ return $this;
+ }
+
+ public function getWillTranslateCallback() {
+ return $this->willTranslateCallback;
+ }
+
+ /**
+ * Add translations which will be later used by @{method:translate}.
+ * The parameter is an array of strings (for simple translations) or arrays
+ * (for translations with variants). The number of items in the array is
+ * language specific. It is `array($singular, $plural)` for English.
+ *
+ * array(
+ * 'color' => 'colour',
+ * '%d beer(s)' => array('%d beer', '%d beers'),
+ * );
+ *
+ * The arrays can be nested for strings with more variant parts:
+ *
+ * array(
+ * '%d char(s) on %d row(s)' => array(
+ * array('%d char on %d row', '%d char on %d rows'),
+ * array('%d chars on %d row', '%d chars on %d rows'),
+ * ),
+ * );
+ *
+ * The translation should have the same placeholders as originals. Swapping
+ * parameter order is possible:
+ *
+ * array(
+ * '%s owns %s.' => '%2$s is owned by %1$s.',
+ * );
+ *
+ * @param array Identifier in key, translation in value.
+ * @return PhutilTranslator Provides fluent interface.
+ */
+ public function setTranslations(array $translations) {
+ $this->translations = $translations;
+ return $this;
+ }
+
+ public function translate($text /* , ... */) {
+ $args = func_get_args();
+
+ if ($this->willTranslateCallback) {
+ call_user_func_array($this->willTranslateCallback, $args);
+ }
+
+ if (isset($this->translations[$text])) {
+ $translation = $this->translations[$text];
+ } else {
+ $translation = $text;
+ }
+
+ while (is_array($translation)) {
+ $arg = next($args);
+ $translation = $this->chooseVariant($translation, $arg);
+ if ($translation === null) {
+ $pos = key($args);
+
+ if (is_object($arg)) {
+ $kind = get_class($arg);
+ } else {
+ $kind = gettype($arg);
+ }
+
+ return sprintf(
+ '[Invalid Translation!] The "%s" language data offers variant '.
+ 'translations for the plurality or gender of argument %s, but '.
+ 'the value for that argument is not an integer, PhutilNumber, or '.
+ 'PhutilPerson (it is a value of type "%s"). Raw input: <%s>.',
+ $this->localeCode,
+ $pos,
+ $kind,
+ $text);
+ }
+ }
+ array_shift($args);
+
+ foreach ($args as $k => $arg) {
+ if ($arg instanceof PhutilNumber) {
+ $args[$k] = $this->formatNumber($arg->getNumber(), $arg->getDecimals());
+ }
+ }
+
+ // Check if any arguments are PhutilSafeHTML. If they are, we will apply
+ // any escaping necessary and output HTML.
+ $is_html = false;
+ foreach ($args as $arg) {
+ if ($arg instanceof PhutilSafeHTML ||
+ $arg instanceof PhutilSafeHTMLProducerInterface) {
+ $is_html = true;
+ break;
+ }
+ }
+
+ if ($is_html) {
+ foreach ($args as $k => $arg) {
+ $args[$k] = (string)phutil_escape_html($arg);
+ }
+ }
+
+ $result = vsprintf($translation, $args);
+ if ($result === false) {
+ // If vsprintf() fails (often because the translated string references
+ // too many parameters), show the bad template with a note instead of
+ // returning an empty string. This makes it easier to figure out what
+ // went wrong and fix it.
+ $result = pht('[Invalid Translation!] %s', $translation);
+ }
+
+ if ($this->shouldPostProcess) {
+ $result = $this->locale->didTranslateString(
+ $text,
+ $translation,
+ $args,
+ $result);
+ }
+
+ if ($is_html) {
+ $result = phutil_safe_html($result);
+ }
+
+ return $result;
+ }
+
+ private function chooseVariant(array $translations, $variant) {
+ if (count($translations) == 1) {
+ // If we only have one variant, we can select it directly.
+ return reset($translations);
+ }
+
+ if ($variant instanceof PhutilNumber) {
+ $is_gender = false;
+ $variant = $variant->getNumber();
+ } else if ($variant instanceof PhutilPerson) {
+ $is_gender = true;
+ $variant = $variant->getGender();
+ } else if (is_int($variant)) {
+ $is_gender = false;
+ } else {
+ return null;
+ }
+
+ if ($is_gender) {
+ return $this->locale->selectGenderVariant($variant, $translations);
+ } else {
+
+ // NOTE: This is a microoptimization which slightly improves performance
+ // for common languages with simple plural rules. Languages do not need
+ // to be added here even if they use the simple rules. The benefit of
+ // inclusion here is small, on the order of 5%.
+ static $simple_plural = array(
+ 'en_US' => true,
+ 'en_GB' => true,
+ 'en_ES' => true,
+ 'ko_KR' => true,
+ );
+
+ if (isset($simple_plural[$this->localeCode])) {
+ if ($variant == 1) {
+ return reset($translations);
+ } else {
+ return end($translations);
+ }
+ } else {
+ return $this->locale->selectPluralVariant($variant, $translations);
+ }
+ }
+
+ }
+
+ /**
+ * Translate date formatted by `$date->format()`.
+ *
+ * @param string Format accepted by `DateTime::format()`.
+ * @param DateTime
+ * @return string Formatted and translated date.
+ */
+ public function translateDate($format, DateTime $date) {
+ static $format_cache = array();
+ if (!isset($format_cache[$format])) {
+ $translatable = 'DlSFMaA';
+ preg_match_all(
+ '/['.$translatable.']|(\\\\.|[^'.$translatable.'])+/',
+ $format,
+ $format_cache[$format],
+ PREG_SET_ORDER);
+ }
+
+ $parts = array();
+ foreach ($format_cache[$format] as $match) {
+ $part = $date->format($match[0]);
+ if (!isset($match[1])) {
+ $part = $this->translate($part);
+ }
+ $parts[] = $part;
+ }
+ return implode('', $parts);
+ }
+
+ /**
+ * Format number with grouped thousands and optional decimal part. Requires
+ * translations of '.' (decimal point) and ',' (thousands separator). Both
+ * these translations must be 1 byte long with PHP < 5.4.0.
+ *
+ * @param float
+ * @param int
+ * @return string
+ */
+ public function formatNumber($number, $decimals = 0) {
+ return number_format(
+ $number,
+ $decimals,
+ $this->translate('.'),
+ $this->translate(','));
+ }
+
+ public function validateTranslation($original, $translation) {
+ $pattern = '/<(\S[^>]*>?)?|&(\S[^;]*;?)?/i';
+ $original_matches = null;
+ $translation_matches = null;
+
+ preg_match_all($pattern, $original, $original_matches);
+ preg_match_all($pattern, $translation, $translation_matches);
+
+ sort($original_matches[0]);
+ sort($translation_matches[0]);
+
+ if ($original_matches[0] !== $translation_matches[0]) {
+ return false;
+ }
+ return true;
+ }
+
+}
diff --git a/src/internationalization/__tests__/PhutilLocaleTestCase.php b/src/internationalization/__tests__/PhutilLocaleTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/__tests__/PhutilLocaleTestCase.php
@@ -0,0 +1,10 @@
+assertTrue(true);
+ }
+
+}
diff --git a/src/internationalization/__tests__/PhutilPersonTest.php b/src/internationalization/__tests__/PhutilPersonTest.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/__tests__/PhutilPersonTest.php
@@ -0,0 +1,20 @@
+gender;
+ }
+
+ public function setGender($value) {
+ $this->gender = $value;
+ return $this;
+ }
+
+ public function __toString() {
+ return pht('Test (%s)', $this->gender);
+ }
+
+}
diff --git a/src/internationalization/__tests__/PhutilPhtTestCase.php b/src/internationalization/__tests__/PhutilPhtTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/__tests__/PhutilPhtTestCase.php
@@ -0,0 +1,101 @@
+assertEqual('beer', pht('beer'));
+ $this->assertEqual('1 beer(s)', pht('%d beer(s)', 1));
+
+ $english_locale = PhutilLocale::loadLocale('en_US');
+ PhutilTranslator::getInstance()->setLocale($english_locale);
+ PhutilTranslator::getInstance()->setTranslations(
+ array(
+ '%d beer(s)' => array('%d beer', '%d beers'),
+ ));
+
+ $this->assertEqual('1 beer', pht('%d beer(s)', 1));
+
+ $czech_locale = PhutilLocale::loadLocale('cs_CZ');
+ PhutilTranslator::getInstance()->setLocale($czech_locale);
+ PhutilTranslator::getInstance()->setTranslations(
+ array(
+ '%d beer(s)' => array('%d pivo', '%d piva', '%d piv'),
+ ));
+
+ $this->assertEqual('5 piv', pht('%d beer(s)', 5));
+ }
+
+ public function getDateTranslations() {
+ // The only purpose of this function is to provide a static list of
+ // translations which can come from PhutilTranslator::translateDate() to
+ // allow translation extractor getting them.
+ return array(
+ 'D' => array(
+ pht('Sun'),
+ pht('Mon'),
+ pht('Tue'),
+ pht('Wed'),
+ pht('Thu'),
+ pht('Fri'),
+ pht('Sat'),
+ ),
+ 'l' => array(
+ pht('Sunday'),
+ pht('Monday'),
+ pht('Tuesday'),
+ pht('Wednesday'),
+ pht('Thursday'),
+ pht('Friday'),
+ pht('Saturday'),
+ ),
+ 'S' => array(
+ pht('st'),
+ pht('nd'),
+ pht('rd'),
+ pht('th'),
+ ),
+ 'F' => array(
+ pht('January'),
+ pht('February'),
+ pht('March'),
+ pht('April'),
+ pht('May'),
+ pht('June'),
+ pht('July'),
+ pht('August'),
+ pht('September'),
+ pht('October'),
+ pht('November'),
+ pht('December'),
+ ),
+ 'M' => array(
+ pht('Jan'),
+ pht('Feb'),
+ pht('Mar'),
+ pht('Apr'),
+ pht('May'),
+ pht('Jun'),
+ pht('Jul'),
+ pht('Aug'),
+ pht('Sep'),
+ pht('Oct'),
+ pht('Nov'),
+ pht('Dec'),
+ ),
+ 'a' => array(
+ pht('am'),
+ pht('pm'),
+ ),
+ 'A' => array(
+ pht('AM'),
+ pht('PM'),
+ ),
+ );
+ }
+
+}
diff --git a/src/internationalization/__tests__/PhutilTranslationTestCase.php b/src/internationalization/__tests__/PhutilTranslationTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/__tests__/PhutilTranslationTestCase.php
@@ -0,0 +1,10 @@
+assertTrue(true);
+ }
+
+}
diff --git a/src/internationalization/__tests__/PhutilTranslatorTestCase.php b/src/internationalization/__tests__/PhutilTranslatorTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/__tests__/PhutilTranslatorTestCase.php
@@ -0,0 +1,261 @@
+newTranslator('en_US');
+ $translator->setTranslations(
+ array(
+ '%d line(s)' => array('%d line', '%d lines'),
+ '%d char(s) on %d row(s)' => array(
+ array('%d char on %d row', '%d char on %d rows'),
+ array('%d chars on %d row', '%d chars on %d rows'),
+ ),
+ ));
+
+ $this->assertEqual('line', $translator->translate('line'));
+ $this->assertEqual('param', $translator->translate('%s', 'param'));
+
+ $this->assertEqual('0 lines', $translator->translate('%d line(s)', 0));
+ $this->assertEqual('1 line', $translator->translate('%d line(s)', 1));
+ $this->assertEqual('2 lines', $translator->translate('%d line(s)', 2));
+
+ $this->assertEqual(
+ '1 char on 1 row',
+ $translator->translate('%d char(s) on %d row(s)', 1, 1));
+ $this->assertEqual(
+ '5 chars on 2 rows',
+ $translator->translate('%d char(s) on %d row(s)', 5, 2));
+
+ $this->assertEqual('1 beer(s)', $translator->translate('%d beer(s)', 1));
+ }
+
+ public function testSingleVariant() {
+ $translator = $this->newTranslator('en_US');
+
+ // In this translation, we have no alternatives for the first conversion.
+ $translator->setTranslations(
+ array(
+ 'Run the command %s %d time(s).' => array(
+ array(
+ 'Run the command %s once.',
+ 'Run the command %s %d times.',
+ ),
+ ),
+ ));
+
+ $this->assertEqual(
+ 'Run the command ls 123 times.',
+ (string)$translator->translate(
+ 'Run the command %s %d time(s).',
+ hsprintf('%s', 'ls'),
+ 123));
+ }
+
+ public function testCzech() {
+ $translator = $this->newTranslator('cs_CZ');
+ $translator->setTranslations(
+ array(
+ '%d beer(s)' => array('%d pivo', '%d piva', '%d piv'),
+ ));
+
+ $this->assertEqual('0 piv', $translator->translate('%d beer(s)', 0));
+ $this->assertEqual('1 pivo', $translator->translate('%d beer(s)', 1));
+ $this->assertEqual('2 piva', $translator->translate('%d beer(s)', 2));
+ $this->assertEqual('5 piv', $translator->translate('%d beer(s)', 5));
+
+ $this->assertEqual('1 line(s)', $translator->translate('%d line(s)', 1));
+ }
+
+ public function testPerson() {
+ $translator = $this->newTranslator('cs_CZ');
+ $translator->setTranslations(
+ array(
+ '%s wrote.' => array('%s napsal.', '%s napsala.'),
+ ));
+
+ $person = new PhutilPersonTest();
+ $this->assertEqual(
+ 'Test () napsal.',
+ $translator->translate('%s wrote.', $person));
+
+ $person->setGender(PhutilPerson::GENDER_MASCULINE);
+ $this->assertEqual(
+ 'Test (m) napsal.',
+ $translator->translate('%s wrote.', $person));
+
+ $person->setGender(PhutilPerson::GENDER_FEMININE);
+ $this->assertEqual(
+ 'Test (f) napsala.',
+ $translator->translate('%s wrote.', $person));
+ }
+
+ public function testTranslateDate() {
+ $date = new DateTime('2012-06-21');
+ $translator = $this->newTranslator('en_US');
+
+ $this->assertEqual('June', $translator->translateDate('F', $date));
+ $this->assertEqual('June 21', $translator->translateDate('F d', $date));
+ $this->assertEqual('F', $translator->translateDate('\F', $date));
+
+ $translator->setTranslations(
+ array(
+ 'June' => 'correct',
+ '21' => 'wrong',
+ 'F' => 'wrong',
+ ));
+ $this->assertEqual('correct', $translator->translateDate('F', $date));
+ $this->assertEqual('correct 21', $translator->translateDate('F d', $date));
+ $this->assertEqual('F', $translator->translateDate('\F', $date));
+ }
+
+ public function testSetInstance() {
+ $english_translator = $this->newTranslator('en_US');
+
+ PhutilTranslator::setInstance($english_translator);
+ $original = PhutilTranslator::getInstance();
+ $this->assertEqual('color', pht('color'));
+
+ $british_locale = PhutilLocale::loadLocale('en_GB');
+
+ $british = new PhutilTranslator();
+ $british->setLocale($british_locale);
+ $british->setTranslations(
+ array(
+ 'color' => 'colour',
+ ));
+ PhutilTranslator::setInstance($british);
+ $this->assertEqual('colour', pht('color'));
+
+ PhutilTranslator::setInstance($original);
+ $this->assertEqual('color', pht('color'));
+ }
+
+ public function testFormatNumber() {
+ $translator = $this->newTranslator('en_US');
+
+ $this->assertEqual('1,234', $translator->formatNumber(1234));
+ $this->assertEqual('1,234.5', $translator->formatNumber(1234.5, 1));
+ $this->assertEqual('1,234.5678', $translator->formatNumber(1234.5678, 4));
+
+ $translator->setTranslations(
+ array(
+ ',' => ' ',
+ '.' => ',',
+ ));
+ $this->assertEqual('1 234', $translator->formatNumber(1234));
+ $this->assertEqual('1 234,5', $translator->formatNumber(1234.5, 1));
+ $this->assertEqual('1 234,5678', $translator->formatNumber(1234.5678, 4));
+ }
+
+ public function testNumberTranslations() {
+ $translator = $this->newTranslator('en_US');
+
+ $translator->setTranslations(
+ array(
+ '%s line(s)' => array('%s line', '%s lines'),
+ ));
+
+ $this->assertEqual(
+ '1 line',
+ $translator->translate('%s line(s)', new PhutilNumber(1)));
+
+ $this->assertEqual(
+ '1,000 lines',
+ $translator->translate('%s line(s)', new PhutilNumber(1000)));
+
+ $this->assertEqual(
+ '8.5 lines',
+ $translator->translate(
+ '%s line(s)',
+ id(new PhutilNumber(8.5))->setDecimals(1)));
+ }
+
+ public function testValidateTranslation() {
+ $tests = array(
+ 'a < 2' => array(
+ 'a < 2' => true,
+ 'b < 3' => true,
+ '2 > a' => false,
+ 'a<2' => false,
+ ),
+ 'We win' => array(
+ 'We win' => true,
+ 'We win' => true, // false positive
+ 'We win' => false,
+ 'We win' => false,
+ ),
+ 'We win & triumph' => array(
+ 'We triumph & win' => true,
+ 'We win and triumph' => false,
+ ),
+ 'beer' => array(
+ 'pivo' => true,
+ 'b<>r' => false,
+ 'b&&r' => false,
+ ),
+ );
+
+ $translator = $this->newTranslator('en_US');
+
+ foreach ($tests as $original => $translations) {
+ foreach ($translations as $translation => $expect) {
+ $valid = ($expect ? 'valid' : 'invalid');
+ $this->assertEqual(
+ $expect,
+ $translator->validateTranslation($original, $translation),
+ pht(
+ "'%s' should be %s with '%s'.",
+ $original,
+ $valid,
+ $translation));
+ }
+ }
+ }
+
+ public function testHTMLTranslations() {
+ $string = '%s awoke suddenly at %s.';
+ $when = '<4 AM>';
+
+ $translator = $this->newTranslator('en_US');
+
+ // When no components are HTML, everything is treated as a string.
+ $who = 'Abraham';
+ $translation = $translator->translate(
+ $string,
+ $who,
+ $when);
+ $this->assertEqual(
+ 'string',
+ gettype($translation));
+ $this->assertEqual(
+ 'Abraham awoke suddenly at <4 AM>.',
+ $translation);
+
+ // When at least one component is HTML, everything is treated as HTML.
+ $who = phutil_tag('span', array(), 'Abraham');
+ $translation = $translator->translate(
+ $string,
+ $who,
+ $when);
+ $this->assertTrue($translation instanceof PhutilSafeHTML);
+ $this->assertEqual(
+ 'Abraham awoke suddenly at <4 AM>.',
+ $translation->getHTMLContent());
+
+ $translation = $translator->translate(
+ $string,
+ $who,
+ new PhutilNumber(1383930802));
+ $this->assertEqual(
+ 'Abraham awoke suddenly at 1,383,930,802.',
+ $translation->getHTMLContent());
+ }
+
+ private function newTranslator($locale_code) {
+ $locale = PhutilLocale::loadLocale($locale_code);
+ return id(new PhutilTranslator())
+ ->setLocale($locale);
+ }
+
+}
diff --git a/src/internationalization/locales/PhutilAllCapsEnglishLocale.php b/src/internationalization/locales/PhutilAllCapsEnglishLocale.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/locales/PhutilAllCapsEnglishLocale.php
@@ -0,0 +1,38 @@
+= 2 && $variant <= 4) {
+ return $paucal;
+ }
+
+ return $plural;
+ }
+
+}
diff --git a/src/internationalization/locales/PhutilEmojiLocale.php b/src/internationalization/locales/PhutilEmojiLocale.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/locales/PhutilEmojiLocale.php
@@ -0,0 +1,33 @@
+setTranslations()` and language rules set
+ * by `PhutilTranslator::getInstance()->setLocale()`.
+ *
+ * @param string Translation identifier with `sprintf()` placeholders.
+ * @param mixed Value to select the variant from (e.g. singular or plural).
+ * @param ... Next values referenced from $text.
+ * @return string Translated string with substituted values.
+ */
+function pht($text, $variant = null /* , ... */) {
+ $args = func_get_args();
+ $translator = PhutilTranslator::getInstance();
+ return call_user_func_array(array($translator, 'translate'), $args);
+}
+
+/**
+ * Count all elements in an array, or something in an object.
+ *
+ * @param array|Countable A countable object.
+ * @return PhutilNumber Returns the number of elements in the input
+ * parameter.
+ */
+function phutil_count($countable) {
+ if (!(is_array($countable) || $countable instanceof Countable)) {
+ throw new InvalidArgumentException(pht('Argument should be countable.'));
+ }
+
+ return new PhutilNumber(count($countable));
+}
+
+/**
+ * Provide a gendered argument to the translation engine.
+ *
+ * This function does nothing and only serves as a marker for the static
+ * extractor so it knows particular arguments may vary on gender.
+ *
+ * @param PhutilPerson Something implementing @{interface:PhutilPerson}.
+ * @return PhutilPerson The argument, unmodified.
+ */
+function phutil_person(PhutilPerson $person) {
+ return $person;
+}
diff --git a/src/internationalization/translation/LibphutilUSEnglishTranslation.php b/src/internationalization/translation/LibphutilUSEnglishTranslation.php
new file mode 100644
--- /dev/null
+++ b/src/internationalization/translation/LibphutilUSEnglishTranslation.php
@@ -0,0 +1,34 @@
+ array(
+ 'Daemon was idle for more than one second, scaling pool down.',
+ 'Daemon was idle for more than %s seconds, scaling pool down.',
+ ),
+
+ 'Analyzing %s file(s) with %s subprocess(es)...' => array(
+ array(
+ 'Analyzing one file with a single subprocess...',
+ 'Analyzing %s file with %s subprocesses...',
+ ),
+ array(
+ 'Analyzing %s files with a single subprocess...',
+ 'Analyzing %s files with %s subprocesses...',
+ ),
+ ),
+
+ '... (%s more byte(s)) ...' => array(
+ '... (%s more byte) ...',
+ '... (%s more bytes) ...',
+ ),
+ );
+ }
+
+}
diff --git a/src/ip/PhutilCIDRBlock.php b/src/ip/PhutilCIDRBlock.php
new file mode 100644
--- /dev/null
+++ b/src/ip/PhutilCIDRBlock.php
@@ -0,0 +1,84 @@
+
+ }
+
+ public static function newBlock($in) {
+ if ($in instanceof PhutilCIDRBlock) {
+ return clone $in;
+ }
+
+ return self::newFromString($in);
+ }
+
+ private static function newFromString($str) {
+ if (!preg_match('(^[\d.:a-fA-F]+/[\d]+\z)', $str)) {
+ throw new Exception(
+ pht(
+ 'CIDR block "%s" is not formatted correctly. Expected an IP block '.
+ 'in CIDR notation, like "%s" or "%s".',
+ $str,
+ '172.30.0.0/16',
+ '23:45:67:89::/24'));
+ }
+
+ list($ip, $mask) = explode('/', $str);
+
+ $ip = PhutilIPAddress::newAddress($ip);
+
+ if (preg_match('/^0\d/', $mask)) {
+ throw new Exception(
+ pht(
+ 'CIDR block "%s" is not formatted correctly. The IP block mask '.
+ '("%s") must not have leading zeroes.',
+ $str,
+ $mask));
+ }
+
+ $max_bits = $ip->getBitCount();
+
+ $bits = (int)$mask;
+ if ($bits < 0 || $bits > $max_bits) {
+ throw new Exception(
+ pht(
+ 'CIDR block "%s" is not formatted correctly. The IP block mask '.
+ '("%s") must mask between 0 and %s bits, inclusive.',
+ $str,
+ $mask,
+ new PhutilNumber($max_bits)));
+ }
+
+ $obj = new PhutilCIDRBlock();
+ $obj->ip = $ip;
+ $obj->bits = $bits;
+
+ return $obj;
+ }
+
+ public function containsAddress($address) {
+ $address = PhutilIPAddress::newAddress($address);
+
+ $block_bits = $this->ip->toBits();
+ $address_bits = $address->toBits();
+
+ // If the two addresses have different bit widths (IPv4 vs IPv6), this
+ // CIDR block does not match the address.
+ if ($this->ip->getBitCount() != $address->getBitCount()) {
+ return false;
+ }
+
+ return (strncmp($block_bits, $address_bits, $this->bits) === 0);
+ }
+
+}
diff --git a/src/ip/PhutilCIDRList.php b/src/ip/PhutilCIDRList.php
new file mode 100644
--- /dev/null
+++ b/src/ip/PhutilCIDRList.php
@@ -0,0 +1,40 @@
+containsAddrsss('172.30.0.1');
+ */
+final class PhutilCIDRList extends Phobject {
+
+ private $blocks;
+
+ private function __construct() {
+ //
+ }
+
+ public static function newList(array $blocks) {
+ foreach ($blocks as $key => $block) {
+ $blocks[$key] = PhutilCIDRBlock::newBlock($block);
+ }
+
+ $obj = new PhutilCIDRList();
+ $obj->blocks = $blocks;
+ return $obj;
+ }
+
+ public function containsAddress($address) {
+ foreach ($this->blocks as $block) {
+ if ($block->containsAddress($address)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+}
diff --git a/src/ip/PhutilIPAddress.php b/src/ip/PhutilIPAddress.php
new file mode 100644
--- /dev/null
+++ b/src/ip/PhutilIPAddress.php
@@ -0,0 +1,43 @@
+
+ }
+
+ abstract public function toBits();
+ abstract public function getBitCount();
+ abstract public function getAddress();
+
+ public static function newAddress($in) {
+ if ($in instanceof PhutilIPAddress) {
+ return clone $in;
+ }
+
+ try {
+ return PhutilIPv4Address::newFromString($in);
+ } catch (Exception $ex) {
+ // Continue, trying the address as IPv6 instead.
+ }
+
+ try {
+ return PhutilIPv6Address::newFromString($in);
+ } catch (Exception $ex) {
+ // Continue, throwing a more tailored exception below.
+ }
+
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted. Expected an IPv4 address '.
+ 'like "%s", or an IPv6 address like "%s".',
+ $in,
+ '23.45.67.89',
+ '2345:6789:0123:abcd::'));
+ }
+
+}
diff --git a/src/ip/PhutilIPv4Address.php b/src/ip/PhutilIPv4Address.php
new file mode 100644
--- /dev/null
+++ b/src/ip/PhutilIPv4Address.php
@@ -0,0 +1,86 @@
+
+ }
+
+ public function getAddress() {
+ return $this->ip;
+ }
+
+ public function getBitCount() {
+ return 32;
+ }
+
+ protected static function newFromString($str) {
+ $matches = null;
+ $ok = preg_match('(^(\d+)\.(\d+)\.(\d+).(\d+)\z)', $str, $matches);
+ if (!$ok) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted. Expected an IPv4 '.
+ 'address like "%s".',
+ $str,
+ '23.45.67.89'));
+ }
+
+ $parts = array_slice($matches, 1);
+ foreach ($parts as $part) {
+ if (preg_match('/^0\d/', $part)) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted. Address segments '.
+ 'should have no leading zeroes, but segment "%s" has a leading '.
+ 'zero.',
+ $str,
+ $part));
+ }
+
+ $value = (int)$part;
+ if ($value < 0 || $value > 255) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted. Address segments '.
+ 'should be between 0 and 255, inclusive, but segment "%s" has '.
+ 'a value outside of this range.',
+ $str,
+ $part));
+ }
+ }
+
+ $obj = new self();
+ $obj->ip = $str;
+
+ return $obj;
+ }
+
+ public function toBits() {
+ if ($this->bits === null) {
+ $bits = '';
+ foreach (explode('.', $this->ip) as $part) {
+ $value = (int)$part;
+ for ($ii = 7; $ii >= 0; $ii--) {
+ $mask = (1 << $ii);
+ if (($value & $mask) === $mask) {
+ $bits .= '1';
+ } else {
+ $bits .= '0';
+ }
+ }
+ }
+
+ $this->bits = $bits;
+ }
+
+ return $this->bits;
+ }
+
+}
diff --git a/src/ip/PhutilIPv6Address.php b/src/ip/PhutilIPv6Address.php
new file mode 100644
--- /dev/null
+++ b/src/ip/PhutilIPv6Address.php
@@ -0,0 +1,212 @@
+
+ }
+
+ public function getBitCount() {
+ return 128;
+ }
+
+ protected static function newFromString($str) {
+ $parts = explode(':', $str);
+ if (count($parts) > 8) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted: is has too many '.
+ 'parts. Expected a maximum of 7 colons, like "%s".',
+ $str,
+ '1:2:3:4:a:b:c:d'));
+ }
+
+ if (count($parts) < 3) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formated: it has too few '.
+ 'parts. Expected a minimum of 2 colons, like "%s".',
+ $str,
+ '::1'));
+ }
+
+ // Look for leading or trailing empty parts. These are valid if the string
+ // begins or ends like "::", "::1", or "1::", but not valid otherwise.
+ $has_omission = false;
+ if ($str === '::') {
+ $parts = array(null);
+ $has_omission = true;
+ } else if ($parts[0] === '') {
+ if ($parts[1] === '') {
+ unset($parts[1]);
+ $parts[0] = null;
+ $parts = array_values($parts);
+ $has_omission = true;
+ } else {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted: an address with '.
+ 'omitted leading sements must begin with "::".',
+ $str));
+ }
+ } else if (last($parts) === '') {
+ if ($parts[count($parts) - 2] === '') {
+ array_pop($parts);
+ $parts[count($parts) - 1] = null;
+ $parts = array_values($parts);
+ $has_omission = true;
+ } else {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted: an address with '.
+ 'omitted trailing segments must end with "::".',
+ $str));
+ }
+ }
+
+ foreach ($parts as $idx => $part) {
+ if ($part !== '') {
+ continue;
+ }
+
+ if ($has_omission) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted: an address may '.
+ 'only contain a maximum of one subsequence omitted with "::".',
+ $str));
+ }
+
+ $has_omission = true;
+ $parts[$idx] = null;
+ }
+
+ if (!$has_omission) {
+ if (count($parts) !== 8) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted: an address must '.
+ 'contain exactly 8 segments, or omit a subsequence of segments '.
+ 'with "::".',
+ $str));
+ }
+ }
+
+ $values = array();
+ foreach ($parts as $idx => $part) {
+ // This is a "::" segment, so fill in any missing values with 0.
+ if ($part === null) {
+ for ($ii = count($parts); $ii <= 8; $ii++) {
+ $values[] = 0;
+ }
+ continue;
+ }
+
+ if (!preg_match('/^[0-9a-fA-F]{1,4}\z/', $part)) {
+ throw new Exception(
+ pht(
+ 'IP address "%s" is not properly formatted: the segments of '.
+ 'an address must be hexadecimal values between "0000" and "ffff", '.
+ 'inclusive. Segment "%s" is not.',
+ $str,
+ $part));
+ }
+
+ $values[] = (int)hexdec($part);
+ }
+
+ $obj = new self();
+ $obj->values = $values;
+
+ return $obj;
+ }
+
+ public function getAddress() {
+ if ($this->displayAddress === null) {
+ // Find the longest consecutive sequence of "0" values. We want to
+ // collapse this into "::".
+ $longest_run = 0;
+ $longest_index = 0;
+ $current_run = null;
+ $current_index = null;
+ foreach ($this->values as $idx => $value) {
+ if ($value !== 0) {
+ $current_run = null;
+ continue;
+ }
+
+ if ($current_run === null) {
+ $current_run = 1;
+ $current_index = $idx;
+ } else {
+ $current_run++;
+ }
+
+ if ($current_run > $longest_run) {
+ $longest_run = $current_run;
+ $longest_index = $current_index;
+ }
+ }
+
+ // Render the segments of the IPv6 address, omitting the longest run
+ // of consecutive "0" segments.
+ $pieces = array();
+ for ($idx = 0; $idx < count($this->values); $idx++) {
+ $value = $this->values[$idx];
+
+ if ($idx === $longest_index) {
+ if ($longest_run > 1) {
+ $pieces[] = null;
+ $idx += ($longest_run - 1);
+ continue;
+ }
+ }
+
+ $pieces[] = dechex($value);
+ }
+
+ // If the omitted segment is at the beginning or end of the address, add
+ // an extra piece so we get the leading or trailing "::" when we implode
+ // the pieces.
+ if (head($pieces) === null) {
+ array_unshift($pieces, null);
+ }
+
+ if (last($pieces) === null) {
+ $pieces[] = null;
+ }
+
+ $this->displayAddress = implode(':', $pieces);
+ }
+
+ return $this->displayAddress;
+ }
+
+ public function toBits() {
+ if ($this->bits === null) {
+ $bits = '';
+ foreach ($this->values as $value) {
+ for ($ii = 15; $ii >= 0; $ii--) {
+ $mask = (1 << $ii);
+ if (($value & $mask) === $mask) {
+ $bits .= '1';
+ } else {
+ $bits .= '0';
+ }
+ }
+ }
+
+ $this->bits = $bits;
+ }
+
+ return $this->bits;
+ }
+
+}
diff --git a/src/ip/__tests__/PhutilIPAddressTestCase.php b/src/ip/__tests__/PhutilIPAddressTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/ip/__tests__/PhutilIPAddressTestCase.php
@@ -0,0 +1,339 @@
+ true,
+
+ // No nonsense.
+ '1.2.3' => false,
+ 'duck' => false,
+ '' => false,
+ '1 2 3 4' => false,
+ '.' => false,
+ '1.2.3.4.' => false,
+ '1..3.4' => false,
+
+ // No leading zeroes.
+ '0.0.0.0' => true,
+ '0.0.0.01' => false,
+
+ // No segments > 255.
+ '255.255.255.255' => true,
+ '255.255.255.256' => false,
+ );
+
+ foreach ($cases as $input => $expect) {
+ $caught = null;
+ try {
+ PhutilIPAddress::newAddress($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual(
+ $expect,
+ !($caught instanceof Exception),
+ 'PhutilIPv4Address['.$input.']');
+ }
+ }
+
+ public function testValidIPv6Addresses() {
+ $cases = array(
+ '::' => true,
+ '::1' => true,
+ '1::' => true,
+ '1::1' => true,
+ '1:2:3:4:5:6:7:8' => true,
+ '1:2:3::5:6:7:8' => true,
+ '1:2:3::6:7:8' => true,
+
+ // No nonsense.
+ 'quack:duck' => false,
+ '11111:22222::' => false,
+
+
+ // Too long.
+ '1:2:3:4:5:6:7:8:9' => false,
+
+ // Too short.
+ '1:2:3' => false,
+
+ // Too many omitted segments.
+ '1:2:3:::7:8:9' => false,
+ '1::3::7:8:9' => false,
+ );
+
+ foreach ($cases as $input => $expect) {
+ $caught = null;
+ try {
+ PhutilIPAddress::newAddress($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual(
+ $expect,
+ !($caught instanceof Exception),
+ 'PhutilIPv6Address['.$input.']');
+ }
+ }
+
+ public function testIPv4AddressToBits() {
+ $cases = array(
+ '0.0.0.0' => '00000000000000000000000000000000',
+ '255.255.255.255' => '11111111111111111111111111111111',
+ '255.0.0.0' => '11111111000000000000000000000000',
+ '0.0.0.1' => '00000000000000000000000000000001',
+ '0.0.0.2' => '00000000000000000000000000000010',
+ '0.0.0.3' => '00000000000000000000000000000011',
+ );
+
+ foreach ($cases as $input => $expect) {
+ $actual = PhutilIPAddress::newAddress($input)->toBits();
+ $this->assertEqual(
+ $expect,
+ $actual,
+ 'PhutilIPv4Address['.$input.']->toBits()');
+ }
+ }
+
+ public function testIPv6AddressToBits() {
+ $cases = array(
+ '::' =>
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000',
+ '::1' =>
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000001',
+ '1::' =>
+ '0000000000000001 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000',
+ '::ffff:c000:0280' =>
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 1111111111111111'.
+ PhutilIPAddress::newAddress('192.0.2.128')->toBits(),
+ '21DA:00D3:0000:2F3B:02AA:00FF:FE28:9C5A' =>
+ '0010000111011010 0000000011010011'.
+ '0000000000000000 0010111100111011'.
+ '0000001010101010 0000000011111111'.
+ '1111111000101000 1001110001011010',
+ '2001:db8::1' =>
+ '0010000000000001 0000110110111000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000000'.
+ '0000000000000000 0000000000000001',
+
+ );
+
+ foreach ($cases as $input => $expect) {
+ // Remove any spaces, these are just to make the tests above easier to
+ // read.
+ $expect = str_replace(' ', '', $expect);
+
+ $actual = PhutilIPAddress::newAddress($input)->toBits();
+ $this->assertEqual(
+ $expect,
+ $actual,
+ 'PhutilIPv6Address['.$input.']->toBits()');
+ }
+ }
+
+ public function testIPv6AddressToAddress() {
+ $cases = array(
+ '::' => '::',
+ '::1' => '::1',
+ '::01' => '::1',
+ '0::0001' => '::1',
+ '0000::0001' => '::1',
+ '0000:0000::001' => '::1',
+
+ '1::' => '1::',
+ '01::' => '1::',
+ '01::0' => '1::',
+ '0001::0000' => '1::',
+
+ '1:0::0:2' => '1::2',
+ '1::0:2' => '1::2',
+ '1:0::2' => '1::2',
+
+ 'CAFE::' => 'cafe::',
+ '0000:aBe:0:0:1::' => '0:abe:0:0:1::',
+
+ '1:0:0:0:2:0:0:0' => '1::2:0:0:0',
+ '1:0:0:2:0:0:0:0' => '1:0:0:2::',
+ );
+
+ foreach ($cases as $input => $expect) {
+ $actual = PhutilIPAddress::newAddress($input)->getAddress();
+ $this->assertEqual(
+ $expect,
+ $actual,
+ 'PhutilIPv6Address['.$input.']->getAddress()');
+ }
+ }
+
+ public function testValidIPv4CIDRBlocks() {
+ $cases = array(
+ // Valid block.
+ '1.0.0.0/16' => true,
+
+ // No nonsense.
+ 'duck' => false,
+ '1/2/3' => false,
+ '23/0.0.0.0' => false,
+ '0.0.0.0/0.0.0.0' => false,
+
+ // No leading zeroes.
+ '1.0.0.0/4' => true,
+ '1.0.0.0/04' => false,
+
+ // No out-of-range masks.
+ '1.0.0.0/32' => true,
+ '1.0.0.0/33' => false,
+ );
+
+ foreach ($cases as $input => $expect) {
+ $caught = null;
+ try {
+ PhutilCIDRBlock::newBlock($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual(
+ $expect,
+ !($caught instanceof Exception),
+ 'PhutilCIDRBlock['.$input.']');
+ }
+ }
+
+ public function testValidIPv6CIDRBlocks() {
+ $cases = array(
+ // Valid block.
+ '::/16' => true,
+ '::/128' => true,
+
+ // No nonsense.
+ '::/1/2' => false,
+ '::/::' => false,
+ '::' => false,
+
+ // No leading zeroes.
+ '::/01' => false,
+
+ // No out-of-range masks.
+ '::/129' => false,
+ );
+
+ foreach ($cases as $input => $expect) {
+ $caught = null;
+ try {
+ PhutilCIDRBlock::newBlock($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual(
+ $expect,
+ !($caught instanceof Exception),
+ 'PhutilCIDRBlock['.$input.']');
+ }
+ }
+
+ public function testIPv4CIDRBlockContains() {
+ $cases = array(
+ '0.0.0.0/0' => array(
+ '0.0.0.0' => true,
+ '1.1.1.1' => true,
+ '2.3.4.5' => true,
+ '::' => false,
+ '::1' => false,
+ '::ffff:0:0' => false,
+ ),
+ '0.0.0.2/32' => array(
+ '0.0.0.1' => false,
+ '0.0.0.2' => true,
+ '0.0.0.3' => false,
+ '::' => false,
+ ),
+ '172.30.0.0/16' => array(
+ '172.29.255.255' => false,
+ '172.30.0.0' => true,
+ '172.30.255.255' => true,
+ '172.31.0.0' => false,
+ '::' => false,
+ ),
+ );
+
+ foreach ($cases as $input_block => $tests) {
+ $block = PhutilCIDRBlock::newBlock($input_block);
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ $block->containsAddress($input),
+ 'PhutilCIDRBlock['.$input_block.']->containsAddress('.$input.')');
+ }
+ }
+ }
+
+ public function testIPv6CIDRBlockContains() {
+ $cases = array(
+ '::/0' => array(
+ '1::' => true,
+ '2::' => true,
+ '127.0.0.1' => false,
+ ),
+ '::ffff:0:0/96' => array(
+ '::ffff:0:0' => true,
+ '::ffff:ffff:ffff' => true,
+ '::fffe:0:0' => false,
+ '127.0.0.1' => false,
+ ),
+ );
+
+ foreach ($cases as $input_block => $tests) {
+ $block = PhutilCIDRBlock::newBlock($input_block);
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ $block->containsAddress($input),
+ 'PhutilCIDRBlock['.$input_block.']->containsAddress('.$input.')');
+ }
+ }
+ }
+
+ public function testCIDRList() {
+ $list = array(
+ '172.30.0.0/16',
+ '127.0.0.3/32',
+ );
+
+ $cases = array(
+ '0.0.0.0' => false,
+ '172.30.0.5' => true,
+ '127.0.0.2' => false,
+ '127.0.0.3' => true,
+ );
+
+ $list = PhutilCIDRList::newList($list);
+
+ foreach ($cases as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ $list->containsAddress($input),
+ 'PhutilCIDRList->containsAddress('.$input.')');
+ }
+ }
+
+
+}
diff --git a/src/lexer/PhutilJSONFragmentLexer.php b/src/lexer/PhutilJSONFragmentLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilJSONFragmentLexer.php
@@ -0,0 +1,27 @@
+ array(
+ array('"', 's', 'double-quoted-string'),
+ array('\s+', null),
+ array('[\\[\\]{},:]', 'o'),
+ array('(?:true|false|null)', 'k'),
+ array('-?\d+(\.\d+([eE][-+]?\d+)?)?', 'mf'),
+ array('.', null),
+ ),
+ 'double-quoted-string' => array(
+ array('[^"\\\\]+', 's'),
+ array('"', 's', '!pop'),
+ array('\\\\u[0-9a-fA-F]{4}', 'k'),
+ array('\\\\.', 'k'),
+ ),
+ );
+ }
+
+}
diff --git a/src/lexer/PhutilJavaFragmentLexer.php b/src/lexer/PhutilJavaFragmentLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilJavaFragmentLexer.php
@@ -0,0 +1,120 @@
+ array_merge(
+ $nonsemantic_rules,
+ array(
+ array('('.implode('|', $keywords).')\\b', 'k'),
+ array('@[^\\W\\d][\\w.]*', 'nd'),
+ array('('.implode('|', $declarations).')\\b', 'k'),
+ array('('.implode('|', $types).')\\b', 't'),
+ array('(package|import\\s+static|import)\\b', 'kn', 'import'),
+ array('('.implode('|', $constants).')\\b', 'kc'),
+ array('(class|interface)\\b', 'kd', 'class'),
+ array('"(\\\\\\\\|\\\\"|[^"\\\\]+)*"', 's'),
+ array("'(\\\\.|[^\\\\]|\\\\u[0-9a-f-A-F]{4})'", 's'),
+ array('([^\\W\\d]|\\$)[\\w$]*:', 'nl'),
+ array('([^\\W\\d]|\\$)[\\w$]*', 'n'),
+ array(
+ '(([0-9][0-9_]*\\.([0-9][0-9_]*)?|'.
+ '\\.[0-9][0-9_]*)([eE][+-]?[0-9][0-9_]*)?[fFdD]?|'.
+ '[0-9][eE][+-]?[0-9][0-9_]*[fFdD]?|'.
+ '[0-9]([eE][+-]?[0-9][0-9_]*)?[fFdD]|'.
+ '0[xX]([0-9a-fA-F][0-9a-fA-F_]*\\.?|'.
+ '([0-9a-fA-F][0-9a-fA-F_]*)?\\.[0-9a-fA-F][0-9a-fA-F_]*)'.
+ '[pP][+-]?[0-9][0-9_]*[fFdD]?)',
+ 'mf',
+ ),
+ array('0[xX][0-9a-fA-F][0-9a-fA-F_]*[lL]?', 'mh'),
+ array('0[bB][01][01_]*[lL]?', 'mb'),
+ array('0[0-7_]+[lL]?', 'mo'),
+ array('(0|[1-9][0-9_]*[lL]?)', 'mi'),
+ array('([~^*!%&\\[\\](){}<>|+=:;,./?-])', 'o'),
+ array('(\S+|\s+)', null),
+ )),
+ 'class' => array_merge(
+ $nonsemantic_rules,
+ array(
+ array('([^\W\d]|\$)[\w$]*', 'nc', '!pop'),
+ array('', null, '!pop'),
+ )),
+ 'import' => array_merge(
+ $nonsemantic_rules,
+ array(
+ array('[\w.]+\*?', 'nn', '!pop'),
+ array('', null, '!pop'),
+ )),
+ );
+ }
+
+}
diff --git a/src/lexer/PhutilLexer.php b/src/lexer/PhutilLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilLexer.php
@@ -0,0 +1,362 @@
+ array(...),
+ * 'state1' => array(...),
+ * 'state2' => array(...),
+ * )
+ *
+ * Lexers start at the state named 'start'. Each state should have a list of
+ * rules which can match in that state. A list of rules looks like this:
+ *
+ * array(
+ * array('\s+', 'space'),
+ * array('\d+', 'digit'),
+ * array('\w+', 'word'),
+ * )
+ *
+ * The lexer operates by processing each rule in the current state in order.
+ * When one matches, it produces a token. For example, the lexer above would
+ * lex this text:
+ *
+ * 3 asdf
+ *
+ * ...to produce these tokens (assuming the rules are for the 'start' state):
+ *
+ * array('digit', '3', null),
+ * array('space', ' ', null),
+ * array('word', 'asdf', null),
+ *
+ * A rule can also cause a state transition:
+ *
+ * array('zebra', 'animal', 'saw_zebra'),
+ *
+ * This would match the text "zebra", emit a token of type "animal", and change
+ * the parser state to "saw_zebra", causing the lexer to start using the rules
+ * from that state.
+ *
+ * To pop the lexer's state, you can use the special state '!pop'.
+ *
+ * Finally, you can provide additional options in the fourth parameter.
+ * Supported options are `case-insensitive` and `context`.
+ *
+ * Possible values for `context` are `push` (push the token value onto the
+ * context stack), `pop` (pop the context stack and use it to provide context
+ * for the token), and `discard` (pop the context stack and throw away the
+ * value).
+ *
+ * For example, to lex text like this:
+ *
+ * Class::CONSTANT
+ *
+ * You can use a rule set like this:
+ *
+ * 'start' => array(
+ * array('\w+(?=::)', 'class', 'saw_class', array('context' => 'push')),
+ * ),
+ * 'saw_class' => array(
+ * array('::', 'operator'),
+ * array('\w+', 'constant, '!pop', array('context' => 'pop')),
+ * ),
+ *
+ * This would parse the above text into this token stream:
+ *
+ * array('class', 'Class', null),
+ * array('operator', '::', null),
+ * array('constant', 'CONSTANT', 'Class'),
+ *
+ * For a concrete implementation, see @{class:PhutilPHPFragmentLexer}.
+ *
+ * @task lexerimpl Lexer Implementation
+ * @task rule Lexer Rules
+ * @task tokens Lexer Tokens
+ */
+abstract class PhutilLexer extends Phobject {
+
+ private $processedRules;
+ private $lastState;
+
+
+/* -( Lexer Rules )-------------------------------------------------------- */
+
+
+ /**
+ * Return a set of rules for this lexer. See description in
+ * @{class:PhutilLexer}.
+ *
+ * @return dict Lexer rules.
+ * @task lexerimpl
+ */
+ abstract protected function getRawRules();
+
+
+/* -( Lexer Rules )-------------------------------------------------------- */
+
+
+ /**
+ * Process, normalize, and validate the raw lexer rules.
+ *
+ * @task rule
+ */
+ protected function getRules() {
+ $class = get_class($this);
+
+ $raw_rules = $this->getRawRules();
+
+ if (!is_array($raw_rules)) {
+ $type = gettype($raw_rules);
+ throw new UnexpectedValueException(
+ pht(
+ 'Expected %s to return array, got %s.',
+ $class.'->getRawRules()',
+ $type));
+ }
+
+ if (empty($raw_rules['start'])) {
+ throw new UnexpectedValueException(
+ pht(
+ "Expected %s rules to define rules for state '%s'.",
+ $class,
+ 'start'));
+ }
+
+ $processed_rules = array();
+ foreach ($raw_rules as $state => $rules) {
+
+ if (!is_array($rules)) {
+ $type = gettype($rules);
+ throw new UnexpectedValueException(
+ pht(
+ "Expected list of rules for state '%s' in %s, got %s.",
+ $state,
+ $class,
+ $type));
+ }
+
+ foreach ($rules as $key => $rule) {
+ $n = count($rule);
+ if ($n < 2 || $n > 4) {
+ throw new UnexpectedValueException(
+ pht(
+ "Expected rule '%s' in state '%s' in %s to have 2-4 elements ".
+ "(regex, token, [next state], [options]), got %d.",
+ $key,
+ $state,
+ $class,
+ $n));
+ }
+ $rule = array_values($rule);
+ if (count($rule) == 2) {
+ $rule[] = null;
+ }
+ if (count($rule) == 3) {
+ $rule[] = array();
+ }
+
+ foreach ($rule[3] as $option => $value) {
+ switch ($option) {
+ case 'context':
+ if ($value !== 'push' &&
+ $value !== 'pop' &&
+ $value !== 'discard' &&
+ $value !== null) {
+ throw new UnexpectedValueException(
+ pht(
+ "Rule '%s' in state '%s' in %s has unknown ".
+ "context rule '%s', expected '%s', '%s' or '%s'.",
+ $key,
+ $state,
+ $class,
+ $value,
+ 'push',
+ 'pop',
+ 'discard'));
+ }
+ break;
+ default:
+ throw new UnexpectedValueException(
+ pht(
+ "Rule '%s' in state '%s' in %s has unknown option '%s'.",
+ $key,
+ $state,
+ $class,
+ $option));
+ }
+ }
+
+ $flags = 'sS';
+
+ // NOTE: The "\G" assertion is an offset-aware version of "^".
+ $rule[0] = '(\\G'.$rule[0].')'.$flags;
+
+ if (@preg_match($rule[0], '') === false) {
+ $error = error_get_last();
+ throw new UnexpectedValueException(
+ pht(
+ "Rule '%s' in state '%s' in %s defines an ".
+ "invalid regular expression ('%s'): %s",
+ $key,
+ $state,
+ $class,
+ $rule[0],
+ idx($error, 'message')));
+ }
+
+ $next_state = $rule[2];
+ if ($next_state !== null && $next_state !== '!pop') {
+ if (empty($raw_rules[$next_state])) {
+ throw new UnexpectedValueException(
+ pht(
+ "Rule '%s' in state '%s' in %s transitions to ".
+ "state '%s', but there are no rules for that state.",
+ $key,
+ $state,
+ $class,
+ $next_state));
+ }
+ }
+
+ $processed_rules[$state][] = $rule;
+ }
+ }
+
+ return $processed_rules;
+ }
+
+
+/* -( Lexer Tokens )------------------------------------------------------- */
+
+
+ /**
+ * Lex an input string into tokens.
+ *
+ * @param string Input string.
+ * @param string Initial lexer state.
+ * @return list List of lexer tokens.
+ * @task tokens
+ */
+ public function getTokens($input, $initial_state = 'start') {
+ if (empty($this->processedRules)) {
+ $this->processedRules = $this->getRules();
+ }
+ $rules = $this->processedRules;
+
+ $this->lastState = null;
+
+ $position = 0;
+ $length = strlen($input);
+
+ $tokens = array();
+ $states = array();
+ $states[] = 'start';
+ if ($initial_state != 'start') {
+ $states[] = $initial_state;
+ }
+ $context = array();
+ while ($position < $length) {
+ $state_rules = idx($rules, end($states), array());
+ foreach ($state_rules as $rule) {
+
+ $matches = null;
+ if (!preg_match($rule[0], $input, $matches, 0, $position)) {
+ continue;
+ }
+
+ list($regexp, $token_type, $next_state, $options) = $rule;
+
+ $match_length = strlen($matches[0]);
+ if (!$match_length) {
+ if ($next_state === null) {
+ throw new UnexpectedValueException(
+ pht(
+ "Rule '%s' matched a zero-length token and causes no ".
+ "state transition.",
+ $regexp));
+ }
+ } else {
+ $position += $match_length;
+ $token = array($token_type, $matches[0]);
+
+ $copt = idx($options, 'context');
+ if ($copt == 'push') {
+ $context[] = $matches[0];
+ $token[] = null;
+ } else if ($copt == 'pop') {
+ if (empty($context)) {
+ throw new UnexpectedValueException(
+ pht("Rule '%s' popped empty context!", $regexp));
+ }
+ $token[] = array_pop($context);
+ } else if ($copt == 'discard') {
+ if (empty($context)) {
+ throw new UnexpectedValueException(
+ pht("Rule '%s' discarded empty context!", $regexp));
+ }
+ array_pop($context);
+ $token[] = null;
+ } else {
+ $token[] = null;
+ }
+
+ $tokens[] = $token;
+ }
+
+ if ($next_state !== null) {
+ if ($next_state == '!pop') {
+ array_pop($states);
+ if (empty($states)) {
+ throw new UnexpectedValueException(
+ pht("Rule '%s' popped off the last state.", $regexp));
+ }
+ } else {
+ $states[] = $next_state;
+ }
+ }
+
+ continue 2;
+ }
+
+ throw new UnexpectedValueException(
+ pht('No lexer rule matched input at char %d.', $position));
+ }
+
+ $this->lastState = $states;
+
+ return $tokens;
+ }
+
+
+ /**
+ * Merge adjacent tokens of the same type. For example, if a comment is
+ * tokenized as <"//", "comment">, this method will merge the two tokens into
+ * a single combined token.
+ */
+ public function mergeTokens(array $tokens) {
+ $last = null;
+ $result = array();
+ foreach ($tokens as $token) {
+ if ($last === null) {
+ $last = $token;
+ continue;
+ }
+ if (($token[0] == $last[0]) && ($token[2] == $last[2])) {
+ $last[1] .= $token[1];
+ } else {
+ $result[] = $last;
+ $last = $token;
+ }
+ }
+ if ($last !== null) {
+ $result[] = $last;
+ }
+ return $result;
+ }
+
+ public function getLexerState() {
+ return $this->lastState;
+ }
+
+}
diff --git a/src/lexer/PhutilPHPFragmentLexer.php b/src/lexer/PhutilPHPFragmentLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilPHPFragmentLexer.php
@@ -0,0 +1,281 @@
+ array(
+ array('<\\?(?i:php)?', 'cp', 'php'),
+ array('[^<]+', null),
+ array('<', null),
+ ),
+
+ 'php' => array_merge(array(
+ array('\\?>', 'cp', '!pop'),
+ array(
+ '<<<([\'"]?)('.$identifier_pattern.')\\1\\n.*?\\n\\2\\;?\\n',
+ 's',
+ ),
+ ), $nonsemantic_rules, array(
+ array('(?i:__halt_compiler)\\b', 'cp', 'halt_compiler'),
+ array('(->|::)', 'o', 'attr'),
+ array('[~!%^&*+=|:.<>/?@-]+', 'o'),
+ array('[\\[\\]{}();,]', 'o'),
+
+ // After 'new', try to match an unadorned symbol.
+ array('(?i:new|instanceof)\\b', 'k', 'possible_classname'),
+ array('(?i:function)\\b', 'k', 'function_definition'),
+
+ // After 'extends' or 'implements', match a list of classes/interfaces.
+ array('(?i:extends|implements)\\b', 'k', 'class_list'),
+
+ array('(?i:catch)\\b', 'k', 'catch'),
+
+ array('(?i:'.implode('|', $keywords).')\\b', 'k'),
+ array('(?i:'.implode('|', $constants).')\\b', 'kc'),
+
+ array('\\$+'.$identifier_pattern, 'nv'),
+
+ // Match "f(" as a function and "C::" as a class. These won't work
+ // if you put a comment between the symbol and the operator, but
+ // that's a bizarre usage.
+ array($identifier_ns_pattern.'(?=\s*[\\(])', 'nf'),
+ array(
+ $identifier_ns_pattern.'(?=\s*::)',
+ 'nc',
+ 'context_attr',
+ array(
+ 'context' => 'push',
+ ),
+ ),
+
+ array($identifier_ns_pattern, 'no'),
+ array('(\\d+\\.\\d*|\\d*\\.\\d+)([eE][+-]?[0-9]+)?', 'mf'),
+ array('\\d+[eE][+-]?[0-9]+', 'mf'),
+ array('0[0-7]+', 'mo'),
+ array('0[xX][a-fA-F0-9]+', 'mh'),
+ array('0[bB][0-1]+', 'm'),
+ array('\d+', 'mi'),
+ array("'", 's1', 'string1'),
+ array('`', 'sb', 'stringb'),
+ array('"', 's2', 'string2'),
+ array('.', null),
+ )),
+
+ // We've just matched a class name, with a "::" lookahead. The name of
+ // the class is on the top of the context stack. We want to try to match
+ // the attribute or method (e.g., "X::C" or "X::f()").
+ 'context_attr' => array_merge($nonsemantic_rules, array(
+ array('::', 'o'),
+ array(
+ $identifier_pattern.'(?=\s*[\\(])',
+ 'nf',
+ '!pop',
+ array(
+ 'context' => 'pop',
+ ),
+ ),
+ array(
+ $identifier_pattern,
+ 'na',
+ '!pop',
+ array(
+ 'context' => 'pop',
+ ),
+ ),
+ array(
+ '',
+ null,
+ '!pop',
+ array(
+ 'context' => 'discard',
+ ),
+ ),
+ )),
+
+ // After '->' or '::', a symbol is an attribute name. Note that we end
+ // up in 'context_attr' instead of here in some cases.
+ 'attr' => array_merge($nonsemantic_rules, array(
+ array($identifier_pattern, 'na', '!pop'),
+ array('', null, '!pop'),
+ )),
+
+ // After 'new', a symbol is a class name.
+ 'possible_classname' => array_merge($nonsemantic_rules, array(
+ array($identifier_ns_pattern, 'nc', '!pop'),
+ array('', null, '!pop'),
+ )),
+
+ 'string1' => array(
+ array('[^\'\\\\]+', 's1'),
+ array("'", 's1', '!pop'),
+ array('\\\\.', 'k'),
+ array('\\\\$', 'k'),
+ ),
+
+ 'stringb' => array(
+ array('[^`\\\\]+', 'sb'),
+ array('`', 'sb', '!pop'),
+ array('\\\\.', 'k'),
+ array('\\\\$', 'k'),
+ ),
+
+ 'string2' => array(
+ array('[^"\\\\]+', 's2'),
+ array('"', 's2', '!pop'),
+ array('\\\\.', 'k'),
+ array('\\\\$', 'k'),
+ ),
+
+ // In a function definition (after "function"), we don't link the name
+ // as a "nf" (name.function) since it is its own definition.
+ 'function_definition' => array_merge($nonsemantic_rules, array(
+ array('&', 'o'),
+ array('\\(', 'o', '!pop'),
+ array($identifier_pattern, 'no', '!pop'),
+ array('', null, '!pop'),
+ )),
+
+ // For "//" and "#" comments, we need to break out if we see "?" followed
+ // by ">".
+ 'line_comment' => array(
+ array('[^?\\n]+', 'c'),
+ array('\\n', null, '!pop'),
+ array('(?=\\?>)', null, '!pop'),
+ array('\\?', 'c'),
+ ),
+
+ // We've seen __halt_compiler. Grab the '();' afterward and then eat
+ // the rest of the file as raw data.
+ 'halt_compiler' => array_merge($nonsemantic_rules, array(
+ array('[()]', 'o'),
+
+ array(';', 'o', 'compiler_halted'),
+ array('\\?>', 'o', 'compiler_halted'),
+
+ // Just halt on anything else.
+ array('', null, 'compiler_halted'),
+ )),
+
+ // __halt_compiler has taken effect.
+ 'compiler_halted' => array(
+ array('.+', null),
+ ),
+
+ 'class_list' => array_merge($nonsemantic_rules, array(
+ array(',', 'o'),
+ array('(?i:implements)', 'k'),
+ array($identifier_ns_pattern, 'nc'),
+ array('', null, '!pop'),
+ )),
+
+ 'catch' => array_merge($nonsemantic_rules, array(
+ array('\\(', 'o'),
+ array($identifier_ns_pattern, 'nc'),
+ array('', null, '!pop'),
+ )),
+ );
+ }
+
+}
diff --git a/src/lexer/PhutilPythonFragmentLexer.php b/src/lexer/PhutilPythonFragmentLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilPythonFragmentLexer.php
@@ -0,0 +1,314 @@
+ array_merge(array(
+ array('\\n', null),
+ // TODO: Docstrings should match only at the start of a line
+ array('""".*?"""', 'sd'),
+ array('\'\'\'.*?\'\'\'', 'sd'),
+ ), $nonsemantic_rules, array(
+ array('[]{}:(),;[]', 'p'),
+ array('\\\\\\n', null),
+ array('\\\\', null),
+ array('(?:in|is|and|or|not)\\b', 'ow'),
+ array('(?:!=|==|<<|>>|[-~+/*%=<>&^|.])', 'o'),
+ array('(?:'.implode('|', $keywords).')\\b', 'k'),
+ array('def(?=\\s)', 'k', 'funcname'),
+ array('class(?=\\s)', 'k', 'classname'),
+ array('from(?=\\s)', 'kn', 'fromimport'),
+ array('import(?=\\s)', 'kn', 'import'),
+ array('(? array_merge($nonsemantic_rules, array(
+ array('[a-zA-Z_]\w*', 'nf', '!pop'),
+ array('', null, '!pop'),
+ )),
+
+ 'classname' => array_merge($nonsemantic_rules, array(
+ array('[a-zA-Z_]\w*', 'nc', '!pop'),
+ array('', null, '!pop'),
+ )),
+
+ 'fromimport' => array_merge($nonsemantic_rules, array(
+ array('import\b', 'kn', '!pop'),
+ // if None occurs here, it's "raise x from None", since None can
+ // never be a module name
+ array('None\b', 'bp', '!pop'),
+ // sadly, in "raise x from y" y will be highlighted as namespace too
+ array('[a-zA-Z_.][\w.]*', 'nn'),
+ array('', null, '!pop'),
+ )),
+
+ 'import' => array_merge($nonsemantic_rules, array(
+ array('as\b', 'kn'),
+ array(',', 'o'),
+ array('[a-zA-Z_.][\w.]*', 'nn'),
+ array('', null, '!pop'),
+ )),
+
+ 'dqs_raw' => $dqs,
+ 'sqs_raw' => $sqs,
+ 'dqs' => array_merge($stringescape, $dqs),
+ 'sqs' => array_merge($stringescape, $sqs),
+ 'tdqs_raw' => $tdqs,
+ 'tsqs_raw' => $tsqs,
+ 'tdqs' => array_merge($stringescape, $tdqs),
+ 'tsqs' => array_merge($stringescape, $tsqs),
+ );
+ }
+
+}
diff --git a/src/lexer/PhutilShellLexer.php b/src/lexer/PhutilShellLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilShellLexer.php
@@ -0,0 +1,86 @@
+getTokens($string);
+ if (count($this->getLexerState()) > 1) {
+ throw new UnexpectedValueException(
+ pht('Unterminated string in argument list!'));
+ }
+
+ foreach ($tokens as $key => $token) {
+ switch ($token[0]) {
+ case "'":
+ case '"':
+ unset($tokens[$key]);
+ break;
+ case 'esc':
+ $tokens[$key][0] = 'arg';
+ $tokens[$key][1] = substr($token[1], 1);
+ break;
+ default:
+ break;
+ }
+ }
+
+ $tokens = $this->mergeTokens(array_values($tokens));
+
+ $argv = array();
+ foreach ($tokens as $token) {
+ if ($token[0] == 'arg') {
+ $argv[] = $token[1];
+ }
+ }
+
+ return $argv;
+ }
+
+ protected function getRawRules() {
+ return array(
+ 'start' => array(
+ array('\s+', ' '),
+ array("'", "'", 'string1'),
+ array('"', '"', 'string2'),
+ array('\\\\.', 'esc'),
+ array('[^\\s\'"\\\\]+', 'arg'),
+ ),
+ 'string1' => array(
+ // NOTE: In a single-quoted string, backslash is not an escape.
+ array('[^\']+', 'arg'),
+ array("'", "'", '!pop'),
+ ),
+ 'string2' => array(
+ // NOTE: In a double-quoted string, backslash IS an escape, but only
+ // for some characters: ", $, `, \ and newline.
+ array('[^"\\\\]+', 'arg'),
+ array('"', '"', '!pop'),
+ array('\\\\["$`\\\\\\n]', 'esc'),
+ array('\\\\.', 'arg'),
+ ),
+ );
+ }
+
+}
diff --git a/src/lexer/PhutilSimpleOptionsLexer.php b/src/lexer/PhutilSimpleOptionsLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilSimpleOptionsLexer.php
@@ -0,0 +1,90 @@
+getTokens($input);
+
+ foreach ($tokens as $key => $token) {
+ list($type, $value) = $token;
+ switch ($type) {
+ case 'esc':
+ $tokens[$key][0] = 'word';
+ $tokens[$key][1] = substr($value, 1);
+ break;
+ }
+ }
+
+ $tokens = $this->mergeTokens($tokens);
+
+ // Find spaces in between two words and turn them into words. This allows
+ // us to parse unescaped spaces in values correctly.
+ for ($ii = 0; $ii < count($tokens); $ii++) {
+ list($type, $value) = $tokens[$ii];
+ if ($type != ' ') {
+ continue;
+ }
+ $last = idx($tokens, $ii - 1);
+ if (!$last) {
+ continue;
+ }
+ $next = idx($tokens, $ii + 1);
+ if (!$next) {
+ continue;
+ }
+ if ($last[0] == 'word' && $next[0] == 'word') {
+ $tokens[$ii][0] = 'word';
+ }
+ }
+
+ // NOTE: Strip these only after merging tokens, so "a b" merges into two
+ // words, "a" and "b", not a single "ab" word.
+ foreach ($tokens as $key => $token) {
+ list($type, $value) = $token;
+ switch ($type) {
+ case "'":
+ case '"':
+ case ' ':
+ unset($tokens[$key]);
+ break;
+ }
+ }
+
+ return array_values($tokens);
+ }
+
+ protected function getRawRules() {
+ return array(
+ 'start' => array(
+ array('\s+', ' '),
+ array("'", "'", 'string1'),
+ array('"', '"', 'string2'),
+ array(',', ','),
+ array('=', '='),
+ array('[^\\s\'"=,]+', 'word'),
+ ),
+ 'string1' => array(
+ array('[^\'\\\\]+', 'word'),
+ array("'", "'", '!pop'),
+ array('\\\\.', 'esc'),
+ array('\\\\$', '!pop'),
+ ),
+ 'string2' => array(
+ array('[^"\\\\]+', 'word'),
+ array('"', '"', '!pop'),
+ array('\\\\.', 'esc'),
+ array('\\\\$', '!pop'),
+ ),
+ );
+ }
+
+}
diff --git a/src/lexer/PhutilTypeLexer.php b/src/lexer/PhutilTypeLexer.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/PhutilTypeLexer.php
@@ -0,0 +1,32 @@
+ array(
+ array('\s+', ' '),
+ array('\\|', '|'),
+ array('<', '<'),
+ array('>', '>'),
+ array(',', ','),
+ array('\\?', '?'),
+ array('optional', 'opt'),
+ array('map', 'map'),
+ array('list', 'list'),
+ array('int|float|bool|string|null|callable|wild|regex', 'k'),
+ array('\\\\?[a-zA-Z_\x7f-\xff]+(\\\\[a-zA-Z_\x7f-\xff]+)*', 'k'),
+ array('\\(', '(', 'comment'),
+ ),
+ 'comment' => array(
+ array('\\)', ')', '!pop'),
+ array('[^\\)]+', 'cm'),
+ ),
+ );
+ }
+
+}
diff --git a/src/lexer/__tests__/PhutilPHPFragmentLexerTestCase.php b/src/lexer/__tests__/PhutilPHPFragmentLexerTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/__tests__/PhutilPHPFragmentLexerTestCase.php
@@ -0,0 +1,317 @@
+runLexer($file, $data);
+ }
+ }
+
+ private function runLexer($file, $data) {
+ $lexer = new PhutilPHPFragmentLexer();
+
+ $initial_state = 'start';
+ switch ($file) {
+ case 'pop-from-php.txt':
+ $initial_state = 'php';
+ break;
+ case 'trailing-backslash-1.txt':
+ case 'trailing-backslash-2.txt':
+ case 'trailing-backslash-b.txt':
+ // It's important these test cases not have trailing newlines.
+ $data = rtrim($data);
+ break;
+ }
+
+ $caught = null;
+ $tokens = null;
+ try {
+ $tokens = $lexer->getTokens($data, $initial_state);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ switch ($file) {
+ case 'basics.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $tokens = $lexer->mergeTokens($tokens);
+ $this->assertEqual(
+ array(
+ array('cp', '', null),
+ array(null, "\n\nd\n", null),
+ ),
+ $tokens,
+ $file);
+ break;
+ case 'extendsimplements.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', 'assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('cp', '?>', null),
+ array(null, "\n", null),
+ ),
+ $tokens,
+ $file);
+ break;
+ case 'trailing-backslash-1.txt':
+ case 'trailing-backslash-2.txt':
+ case 'trailing-backslash-b.txt':
+ $this->assertEqual(null, $caught);
+ break;
+ default:
+ throw new Exception(pht("No assertion block for test '%s'!", $file));
+ }
+ }
+
+
+}
diff --git a/src/lexer/__tests__/PhutilShellLexerTestCase.php b/src/lexer/__tests__/PhutilShellLexerTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/__tests__/PhutilShellLexerTestCase.php
@@ -0,0 +1,208 @@
+runLexer($file, $data);
+ }
+ }
+
+ private function runLexer($file, $data) {
+ $lexer = new PhutilShellLexer();
+
+ $initial_state = 'start';
+
+ $caught = null;
+ $tokens = null;
+ try {
+ $tokens = $lexer->getTokens($data, $initial_state);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $argv = null;
+ try {
+ $argv = $lexer->splitArguments($data);
+ } catch (Exception $ex) {
+ // Ignore; not diagnostically useful.
+ }
+
+ switch ($file) {
+ case 'basic.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('arg', 'arg1', null),
+ array(' ', ' ', null),
+ array('arg', 'arg2', null),
+ array(' ', ' ', null),
+ array('arg', 'arg3', null),
+ ),
+ $tokens,
+ $file);
+ $this->assertEqual(
+ array(
+ 'arg1',
+ 'arg2',
+ 'arg3',
+ ),
+ $argv,
+ $file);
+ break;
+ case 'escape.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array("'", "'", null),
+ array('arg', '\\', null),
+ array("'", "'", null),
+ array(' ', ' ', null),
+ array('"', '"', null),
+ array('esc', '\\"', null),
+ array('"', '"', null),
+ ),
+ $tokens,
+ $file);
+ $this->assertEqual(
+ array(
+ '\\',
+ '"',
+ ),
+ $argv,
+ $file);
+ break;
+ case 'slashes.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('arg', 'a', null),
+ array('esc', '\\ ', null),
+ array('arg', 'b', null),
+ array(' ', ' ', null),
+ array("'", "'", null),
+ array('arg', 'a\\b', null),
+ array("'", "'", null),
+ array(' ', ' ', null),
+ array('"', '"', null),
+ array('arg', 'a', null),
+ array('arg', '\\b', null),
+ array('"', '"', null),
+ array(' ', ' ', null),
+ array('"', '"', null),
+ array('esc', '\\$', null),
+ array('esc', '\\`', null),
+ array('esc', '\\\\', null),
+ array('esc', '\\"', null),
+ array('esc', '\\'."\n", null),
+ array('arg', 'xyz', null),
+ array('"', '"', null),
+ ),
+ $tokens,
+ $file);
+ $this->assertEqual(
+ array(
+ 'a b',
+ 'a\\b',
+ 'a\\b',
+ '$`\\"'."\n".'xyz',
+ ),
+ $argv,
+ $file);
+ break;
+ case 'spaces.txt':
+ $this->assertEqual(
+ array(
+ array('arg', 'arg1', null),
+ array(' ', ' ', null),
+ array('arg', 'arg2', null),
+ array(' ', ' ', null),
+ array('arg', 'arg3', null),
+ ),
+ $tokens,
+ $file);
+ $this->assertEqual(
+ array(
+ 'arg1',
+ 'arg2',
+ 'arg3',
+ ),
+ $argv,
+ $file);
+ break;
+ case 'strings.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ array('arg', 'a', null),
+ array(' ', ' ', null),
+ array("'", "'", null),
+ array('arg', 'b', null),
+ array("'", "'", null),
+ array(' ', ' ', null),
+ array('"', '"', null),
+ array('arg', 'c', null),
+ array('"', '"', null),
+ array(' ', ' ', null),
+ array("'", "'", null),
+ array('arg', 'd', null),
+ array("'", "'", null),
+ array("'", "'", null),
+ array('arg', 'e', null),
+ array("'", "'", null),
+ array(' ', ' ', null),
+ array('"', '"', null),
+ array('arg', 'f', null),
+ array('"', '"', null),
+ array('"', '"', null),
+ array('arg', 'g', null),
+ array('"', '"', null),
+ array(' ', ' ', null),
+ array('"', '"', null),
+ array('arg', 'h', null),
+ array('"', '"', null),
+ array('"', '"', null),
+ array('arg', "'", null),
+ array('"', '"', null),
+ array('"', '"', null),
+ array('arg', 'i', null),
+ array('"', '"', null),
+ ),
+ $tokens,
+ $file);
+ $this->assertEqual(
+ array(
+ 'a',
+ 'b',
+ 'c',
+ 'de',
+ 'fg',
+ 'h\'i',
+ ),
+ $argv,
+ $file);
+ break;
+ case 'unterminated.txt':
+ $this->assertEqual(null, $caught);
+ $this->assertEqual(
+ array(
+ 'start',
+ 'string1',
+ ),
+ $lexer->getLexerState(),
+ $file);
+ $this->assertEqual(
+ null,
+ $argv,
+ $file);
+ break;
+ default:
+ throw new Exception(pht("No assertion block for test '%s'!", $file));
+ }
+ }
+
+
+}
diff --git a/src/lexer/__tests__/PhutilSimpleOptionsLexerTestCase.php b/src/lexer/__tests__/PhutilSimpleOptionsLexerTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/lexer/__tests__/PhutilSimpleOptionsLexerTestCase.php
@@ -0,0 +1,61 @@
+assertEqual(
+ array(
+ array('word', 'legs', null),
+ array('=', '=', null),
+ array('word', '4', null),
+ ),
+ $this->getTokens('legs=4'));
+
+ $this->assertEqual(
+ array(
+ array('word', 'legs', null),
+ array('=', '=', null),
+ array('word', '4', null),
+ array(',', ',', null),
+ array(' ', ' ', null),
+ array('word', 'LEGS', null),
+ array('=', '=', null),
+ array('word', '4', null),
+ ),
+ $this->getTokens('legs=4, LEGS=4'));
+ }
+
+ public function testSimpleOptionsLexerNiceTokens() {
+ $this->assertEqual(
+ array(
+ array('word', 'legs', null),
+ ),
+ $this->getNiceTokens(' legs '));
+
+ $this->assertEqual(
+ array(
+ array('word', 'a', null),
+ array('word', ' ', null),
+ array('word', 'b', null),
+ ),
+ $this->getNiceTokens(' a b '));
+
+ $this->assertEqual(
+ array(
+ array('word', 'a', null),
+ array('word', 'b', null),
+ ),
+ $this->getNiceTokens('"a""b"'));
+ }
+
+ private function getTokens($input) {
+ $lexer = new PhutilSimpleOptionsLexer();
+ return $lexer->getTokens($input);
+ }
+
+ private function getNiceTokens($input) {
+ $lexer = new PhutilSimpleOptionsLexer();
+ return $lexer->getNiceTokens($input);
+ }
+
+}
diff --git a/src/lexer/__tests__/php/basics.txt b/src/lexer/__tests__/php/basics.txt
new file mode 100644
--- /dev/null
+++ b/src/lexer/__tests__/php/basics.txt
@@ -0,0 +1 @@
+
+
+d
diff --git a/src/lexer/__tests__/php/extendsimplements.txt b/src/lexer/__tests__/php/extendsimplements.txt
new file mode 100644
--- /dev/null
+++ b/src/lexer/__tests__/php/extendsimplements.txt
@@ -0,0 +1,3 @@
+
diff --git a/src/lexer/__tests__/php/symbols.txt b/src/lexer/__tests__/php/symbols.txt
new file mode 100644
--- /dev/null
+++ b/src/lexer/__tests__/php/symbols.txt
@@ -0,0 +1,8 @@
+content = (string)$content;
+ }
+
+ public function __toString() {
+ return $this->content;
+ }
+
+ public function getHTMLContent() {
+ return $this->content;
+ }
+
+ public function appendHTML($html /* , ... */) {
+ foreach (func_get_args() as $html) {
+ $this->content .= phutil_escape_html($html);
+ }
+ return $this;
+ }
+
+ public static function applyFunction($function, $string /* , ... */) {
+ $args = func_get_args();
+ array_shift($args);
+ $args = array_map('phutil_escape_html', $args);
+ return new PhutilSafeHTML(call_user_func_array($function, $args));
+ }
+
+// Requires http://pecl.php.net/operator.
+
+ public function __concat($html) {
+ $clone = clone $this;
+ return $clone->appendHTML($html);
+ }
+
+ public function __assign_concat($html) {
+ return $this->appendHTML($html);
+ }
+
+}
diff --git a/src/markup/PhutilSafeHTMLProducerInterface.php b/src/markup/PhutilSafeHTMLProducerInterface.php
new file mode 100644
--- /dev/null
+++ b/src/markup/PhutilSafeHTMLProducerInterface.php
@@ -0,0 +1,12 @@
+assertEqual(
+ (string)phutil_tag('br'),
+ (string)phutil_tag('br', array()));
+
+ $this->assertEqual(
+ (string)phutil_tag('br', array()),
+ (string)phutil_tag('br', array(), null));
+ }
+
+ public function testTagEmpty() {
+ $this->assertEqual(
+ '
',
+ (string)phutil_tag('br', array(), null));
+
+ $this->assertEqual(
+ '',
+ (string)phutil_tag('div', array(), null));
+
+ $this->assertEqual(
+ '',
+ (string)phutil_tag('div', array(), ''));
+ }
+
+ public function testTagBasics() {
+ $this->assertEqual(
+ '
',
+ (string)phutil_tag('br'));
+
+ $this->assertEqual(
+ 'y',
+ (string)phutil_tag('div', array(), 'y'));
+ }
+
+ public function testTagAttributes() {
+ $this->assertEqual(
+ 'y',
+ (string)phutil_tag('div', array('u' => 'v'), 'y'));
+
+ $this->assertEqual(
+ '
',
+ (string)phutil_tag('br', array('u' => 'v')));
+ }
+
+ public function testTagEscapes() {
+ $this->assertEqual(
+ '
',
+ (string)phutil_tag('br', array('u' => '<')));
+
+ $this->assertEqual(
+ '
',
+ (string)phutil_tag('div', array(), phutil_tag('br')));
+ }
+
+ public function testTagNullAttribute() {
+ $this->assertEqual(
+ '
',
+ (string)phutil_tag('br', array('y' => null)));
+ }
+
+ public function testTagJavascriptProtocolRejection() {
+ $hrefs = array(
+ 'javascript:alert(1)' => true,
+ 'JAVASCRIPT:alert(2)' => true,
+
+ // NOTE: When interpreted as a URI, this is dropped because of leading
+ // whitespace.
+ ' javascript:alert(3)' => array(true, false),
+ '/' => false,
+ '/path/to/stuff/' => false,
+ '' => false,
+ 'http://example.com/' => false,
+ '#' => false,
+ 'javascript://anything' => true,
+
+ // Chrome 33 and IE11, at a minimum, treat this as Javascript.
+ "javascript\n:alert(4)" => true,
+
+ // Opera currently accepts a variety of unicode spaces. This test case
+ // has a smattering of them.
+ "\xE2\x80\x89javascript:" => true,
+ "javascript\xE2\x80\x89:" => true,
+ "\xE2\x80\x84javascript:" => true,
+ "javascript\xE2\x80\x84:" => true,
+
+ // Because we're aggressive, all of unicode should trigger detection
+ // by default.
+ "\xE2\x98\x83javascript:" => true,
+ "javascript\xE2\x98\x83:" => true,
+ "\xE2\x98\x83javascript\xE2\x98\x83:" => true,
+
+ // We're aggressive about this, so we'll intentionally raise false
+ // positives in these cases.
+ 'javascript~:alert(5)' => true,
+ '!!!javascript!!!!:alert(6)' => true,
+
+ // However, we should raise true negatives in these slightly more
+ // reasonable cases.
+ 'javascript/:docs.html' => false,
+ 'javascripts:x.png' => false,
+ 'COOLjavascript:page' => false,
+ '/javascript:alert(1)' => false,
+ );
+
+ foreach (array(true, false) as $use_uri) {
+ foreach ($hrefs as $href => $expect) {
+ if (is_array($expect)) {
+ $expect = ($use_uri ? $expect[1] : $expect[0]);
+ }
+
+ if ($use_uri) {
+ $href_value = new PhutilURI($href);
+ } else {
+ $href_value = $href;
+ }
+
+ $caught = null;
+ try {
+ phutil_tag('a', array('href' => $href_value), 'click for candy');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $desc = pht(
+ 'Unexpected result for "%s". ',
+ $href,
+ $use_uri ? pht('Yes') : pht('No'),
+ $expect ? pht('Yes') : pht('No'));
+
+ $this->assertEqual(
+ $expect,
+ $caught instanceof Exception,
+ $desc);
+ }
+ }
+ }
+
+ public function testURIEscape() {
+ $this->assertEqual(
+ '%2B/%20%3F%23%26%3A%21xyz%25',
+ phutil_escape_uri('+/ ?#&:!xyz%'));
+ }
+
+ public function testURIPathComponentEscape() {
+ $this->assertEqual(
+ 'a%252Fb',
+ phutil_escape_uri_path_component('a/b'));
+
+ $str = '';
+ for ($ii = 0; $ii <= 255; $ii++) {
+ $str .= chr($ii);
+ }
+
+ $this->assertEqual(
+ $str,
+ phutil_unescape_uri_path_component(
+ rawurldecode( // Simulates webserver.
+ phutil_escape_uri_path_component($str))));
+ }
+
+ public function testHsprintf() {
+ $this->assertEqual(
+ '<3',
+ (string)hsprintf('%s', '<3'));
+ }
+
+ public function testAppendHTML() {
+ $html = phutil_tag('hr');
+ $html->appendHTML(phutil_tag('br'), '');
+ $this->assertEqual('
<evil>', $html->getHTMLContent());
+ }
+
+ public function testArrayEscaping() {
+ $this->assertEqual(
+ '<div>',
+ phutil_escape_html(
+ array(
+ hsprintf(''),
+ array(
+ array(
+ '<',
+ array(
+ 'd',
+ array(
+ array(
+ hsprintf('i'),
+ ),
+ 'v',
+ ),
+ ),
+ array(
+ array(
+ '>',
+ ),
+ ),
+ ),
+ ),
+ hsprintf(''),
+ )));
+
+ $this->assertEqual(
+ '
duck
+quack
+~~~~~~~~~~
+**duck quack**
diff --git a/src/markup/engine/__tests__/remarkup/backticks-whitespace.txt b/src/markup/engine/__tests__/remarkup/backticks-whitespace.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/backticks-whitespace.txt
@@ -0,0 +1,17 @@
+```x```
+
+```
+y
+```
+~~~~~~~~~~
+x
+
+
+
+y
+~~~~~~~~~~
+ x
+
+
+
+ y
diff --git a/src/markup/engine/__tests__/remarkup/block-then-list.txt b/src/markup/engine/__tests__/remarkup/block-then-list.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/block-then-list.txt
@@ -0,0 +1,12 @@
+ lang=txt
+ code block
+
+ - still a code block
+~~~~~~~~~~
+code block
+
+- still a code block
+~~~~~~~~~~
+ code block
+
+ - still a code block
diff --git a/src/markup/engine/__tests__/remarkup/code-block-whitespace.txt b/src/markup/engine/__tests__/remarkup/code-block-whitespace.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/code-block-whitespace.txt
@@ -0,0 +1,9 @@
+ lang=txt
+ x
+ y
+~~~~~~~~~~
+ x
+y
+~~~~~~~~~~
+ x
+ y
diff --git a/src/markup/engine/__tests__/remarkup/del.txt b/src/markup/engine/__tests__/remarkup/del.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/del.txt
@@ -0,0 +1,11 @@
+omg~~ wtf~~~~~ bbq~~~ lol~~
+~~deleted text~~
+~~This is a great idea~~~ die forever please
+~~~~~~
+~~~~~~~~~~
+omg~~ wtf~~~~~ bbq~~~ lol~~
+deleted text
+This is a great idea~ die forever please
+~~~~~~
+~~~~~~~~~~
+omg~~ wtf~~~~~ bbq~~~ lol~~ ~~deleted text~~ ~~This is a great idea~~~ die forever please ~~~~~~
diff --git a/src/markup/engine/__tests__/remarkup/diff.txt b/src/markup/engine/__tests__/remarkup/diff.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/diff.txt
@@ -0,0 +1,36 @@
+here is a diff
+
+ lang=diff
+ @@ derp derp @@
+ x
+ y
+
+ - x
+ - y
+ + z
+
+derp derp
+~~~~~~~~~~
+here is a diff
+
+@@ derp derp @@
+x
+y
+
+- x
+- y
++ z
+
+derp derp
+~~~~~~~~~~
+here is a diff
+
+ @@ derp derp @@
+ x
+ y
+
+ - x
+ - y
+ + z
+
+derp derp
diff --git a/src/markup/engine/__tests__/remarkup/disallowed-link.txt b/src/markup/engine/__tests__/remarkup/disallowed-link.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/disallowed-link.txt
@@ -0,0 +1,5 @@
+javascript://www.example.com/
+~~~~~~~~~~
+javascript://www.example.com/
+~~~~~~~~~~
+javascript://www.example.com/
diff --git a/src/markup/engine/__tests__/remarkup/entities.txt b/src/markup/engine/__tests__/remarkup/entities.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/entities.txt
@@ -0,0 +1,5 @@
+< > & "
+~~~~~~~~~~
+< > & "
+~~~~~~~~~~
+< > & "
diff --git a/src/markup/engine/__tests__/remarkup/header-skip.txt b/src/markup/engine/__tests__/remarkup/header-skip.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/header-skip.txt
@@ -0,0 +1,11 @@
+#2 is my favorite.
+
+#project
+~~~~~~~~~~
+#2 is my favorite.
+
+#project
+~~~~~~~~~~
+#2 is my favorite.
+
+#project
diff --git a/src/markup/engine/__tests__/remarkup/headers.txt b/src/markup/engine/__tests__/remarkup/headers.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/headers.txt
@@ -0,0 +1,57 @@
+@nolint (UTF8)
+
+=a=
+
+blah blah blah
+
+
+= b =
+
+Markdown-Style Large Header
+====
+
+Markdown-Style Small Header
+----
+
+=== Remarkup-Style Smaller Header
+
+
+= ☃☃☃ UTF8 Header ☃☃☃ =
+~~~~~~~~~~
+@nolint (UTF8)
+
+a
+
+blah blah blah
+
+b
+
+Markdown-Style Large Header
+
+Markdown-Style Small Header
+
+Remarkup-Style Smaller Header
+
+☃☃☃ UTF8 Header ☃☃☃
+~~~~~~~~~~
+@nolint (UTF8)
+
+a
+=
+
+blah blah blah
+
+b
+=
+
+Markdown-Style Large Header
+===========================
+
+Markdown-Style Small Header
+---------------------------
+
+Remarkup-Style Smaller Header
+-----------------------------
+
+☃☃☃ UTF8 Header ☃☃☃
+===================
diff --git a/src/markup/engine/__tests__/remarkup/highlight.txt b/src/markup/engine/__tests__/remarkup/highlight.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/highlight.txt
@@ -0,0 +1,9 @@
+how about we !!highlight!! some !!TEXT!!!
+wow this must be **!!very important!!**
+omg!!!!!
+~~~~~~~~~~
+how about we highlight some TEXT!
+wow this must be very important
+omg!!!!!
+~~~~~~~~~~
+how about we !!highlight!! some !!TEXT!!! wow this must be **!!very important!!** omg!!!!!
diff --git a/src/markup/engine/__tests__/remarkup/horizonal-rule.txt b/src/markup/engine/__tests__/remarkup/horizonal-rule.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/horizonal-rule.txt
@@ -0,0 +1,41 @@
+___
+
+_____
+
+***
+
+* * * * * * *
+
+---
+
+- - - - - - -
+
+ ---
+~~~~~~~~~~
+
+
+
+
+
+
+
+
+
+
+
+
+
+~~~~~~~~~~
+___
+
+_____
+
+***
+
+* * * * * * *
+
+---
+
+- - - - - - -
+
+ ---
diff --git a/src/markup/engine/__tests__/remarkup/important.txt b/src/markup/engine/__tests__/remarkup/important.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/important.txt
@@ -0,0 +1,15 @@
+IMPORTANT: interesting **stuff**
+
+(IMPORTANT) interesting **stuff**
+~~~~~~~~~~
+IMPORTANT: interesting stuff
+
+
+
+interesting stuff
+~~~~~~~~~~
+IMPORTANT: interesting **stuff**
+
+
+
+(IMPORTANT) interesting **stuff**
diff --git a/src/markup/engine/__tests__/remarkup/interpreter-test.txt b/src/markup/engine/__tests__/remarkup/interpreter-test.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/interpreter-test.txt
@@ -0,0 +1,58 @@
+phutil_test_block_interpreter (foo=bar) {{{
+content
+}}}
+
+phutil_test_block_interpreter {{{ content
+content }}}
+
+phutil_test_block_interpreter {{{ content }}}
+
+phutil_test_block_interpreter(x=y){{{content}}}
+
+phutil_fake_test_block_interpreter {{{ content }}}
+~~~~~~~~~~
+Content: (content)
+Argv: (foo=bar)
+
+
+
+Content: ( content
+content )
+Argv: ()
+
+
+
+Content: ( content )
+Argv: ()
+
+
+
+Content: (content)
+Argv: (x=y)
+
+
+
+No interpreter found: phutil_fake_test_block_interpreter
+~~~~~~~~~~
+Content: (content)
+Argv: (foo=bar)
+
+
+
+Content: ( content
+content )
+Argv: ()
+
+
+
+Content: ( content )
+Argv: ()
+
+
+
+Content: (content)
+Argv: (x=y)
+
+
+
+(No interpreter found: phutil_fake_test_block_interpreter)
diff --git a/src/markup/engine/__tests__/remarkup/just-backticks.txt b/src/markup/engine/__tests__/remarkup/just-backticks.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/just-backticks.txt
@@ -0,0 +1,5 @@
+```
+~~~~~~~~~~
+
+~~~~~~~~~~
+
diff --git a/src/markup/engine/__tests__/remarkup/leading-newline.txt b/src/markup/engine/__tests__/remarkup/leading-newline.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/leading-newline.txt
@@ -0,0 +1,6 @@
+
+a
+~~~~~~~~~~
+a
+~~~~~~~~~~
+a
diff --git a/src/markup/engine/__tests__/remarkup/link-alternate.txt b/src/markup/engine/__tests__/remarkup/link-alternate.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-alternate.txt
@@ -0,0 +1,12 @@
+[Example](http://www.example.com/)
+
+x[0][1](**ptr);
+
+~~~~~~~~~~
+
+
+x[0][1](**ptr);
+~~~~~~~~~~
+Example
+~~~~~~~~~~
+http://www.zany.com/omg/weird_url,,,
+~~~~~~~~~~
+http://www.zany.com/omg/weird_url,,,
diff --git a/src/markup/engine/__tests__/remarkup/link-edge-cases.txt b/src/markup/engine/__tests__/remarkup/link-edge-cases.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-edge-cases.txt
@@ -0,0 +1,35 @@
+http://www.example.com/
+
+(http://www.example.com/)
+
+http://www.example.com/wiki/example_(disambiguation)
+
+(example http://www.example.com/)
+
+Quick! http://www.example.com/!
+~~~~~~~~~~
+http://www.example.com/
+
+(http://www.example.com/)
+
+http://www.example.com/
+
+http://www.example.com/wiki/example_(disambiguation)
+
+(example http://www.example.com/)
+
+Quick! http://www.example.com/!
diff --git a/src/markup/engine/__tests__/remarkup/link-mailto.txt b/src/markup/engine/__tests__/remarkup/link-mailto.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-mailto.txt
@@ -0,0 +1,18 @@
+[[ mailto:alincoln@example.com | mail me ]]
+
+[ mail me ]( mailto:alincoln@example.com )
+
+[[mailto:alincoln@example.com]]
+
+~~~~~~~~~~
+
+
+
+
+
+~~~~~~~~~~
+mail me
+
+mail me
+
+alincoln@example.com
diff --git a/src/markup/engine/__tests__/remarkup/link-mixed.txt b/src/markup/engine/__tests__/remarkup/link-mixed.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-mixed.txt
@@ -0,0 +1,18 @@
+[[http://www.example.com/ | Example]](http://www.alternate.org/)
+
+(http://www.alternate.org/)[[http://www.example.com/ | Example]]
+
+
+
+~~~~~~~~~~
+Example(http://www.alternate.org/)
+
+(http://www.alternate.org/)Example
+
+<http://www.example.com/ Example>
+~~~~~~~~~~
+Example http://www.example.com/page/#anchor
+
+
+~~~~~~~~~~
+http://www.example.com/
+
+example.com
diff --git a/src/markup/engine/__tests__/remarkup/link-tel.txt b/src/markup/engine/__tests__/remarkup/link-tel.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-tel.txt
@@ -0,0 +1,18 @@
+[[ tel:18005555555 | call me ]]
+
+[ call me ]( tel:18005555555 )
+
+[[tel:18005555555]]
+
+~~~~~~~~~~
+
+
+
+
+
+~~~~~~~~~~
+call me <18005555555>
+
+call me <18005555555>
+
+18005555555
diff --git a/src/markup/engine/__tests__/remarkup/link-with-angle-brackets.txt b/src/markup/engine/__tests__/remarkup/link-with-angle-brackets.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-with-angle-brackets.txt
@@ -0,0 +1,5 @@
+http://.example.com/
+~~~~~~~~~~
+http://<www>.example.com/
+~~~~~~~~~~
+http://.example.com/
diff --git a/src/markup/engine/__tests__/remarkup/link-with-angle-link-anchor.txt b/src/markup/engine/__tests__/remarkup/link-with-angle-link-anchor.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-with-angle-link-anchor.txt
@@ -0,0 +1,5 @@
+
+~~~~~~~~~~
+<http://x.y#http://x.y#>
+~~~~~~~~~~
+
diff --git a/src/markup/engine/__tests__/remarkup/link-with-link-anchor.txt b/src/markup/engine/__tests__/remarkup/link-with-link-anchor.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-with-link-anchor.txt
@@ -0,0 +1,5 @@
+http://x.y#http://x.y#
+~~~~~~~~~~
+http://x.y#http://x.y#
+~~~~~~~~~~
+http://x.y#http://x.y#
diff --git a/src/markup/engine/__tests__/remarkup/link-with-punctuation.txt b/src/markup/engine/__tests__/remarkup/link-with-punctuation.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-with-punctuation.txt
@@ -0,0 +1,9 @@
+http://www.example.com/,
+http://www.example.com/..
+http://www.example.com/!!!
+~~~~~~~~~~
+http://www.example.com/,
+http://www.example.com/..
+http://www.example.com/!!!
+~~~~~~~~~~
+http://www.example.com/, http://www.example.com/.. http://www.example.com/!!!
diff --git a/src/markup/engine/__tests__/remarkup/link-with-tilde.txt b/src/markup/engine/__tests__/remarkup/link-with-tilde.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link-with-tilde.txt
@@ -0,0 +1,5 @@
+http://www.example.com/~
+~~~~~~~~~~
+
+~~~~~~~~~~
+http://www.example.com/~
diff --git a/src/markup/engine/__tests__/remarkup/link.txt b/src/markup/engine/__tests__/remarkup/link.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/link.txt
@@ -0,0 +1,5 @@
+http://www.example.com/
+~~~~~~~~~~
+
+~~~~~~~~~~
+http://www.example.com/
diff --git a/src/markup/engine/__tests__/remarkup/list-alternate-style.txt b/src/markup/engine/__tests__/remarkup/list-alternate-style.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-alternate-style.txt
@@ -0,0 +1,15 @@
+- a
+-- b
+--- c
+~~~~~~~~~~
+
+- a
+- b
+- c
+
+
+
+~~~~~~~~~~
+- a
+ - b
+ - c
diff --git a/src/markup/engine/__tests__/remarkup/list-blow-stack.txt b/src/markup/engine/__tests__/remarkup/list-blow-stack.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-blow-stack.txt
@@ -0,0 +1,138 @@
+- a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+
+
+derp
+~~~~~~~~~~
+
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+- a
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+derp
+~~~~~~~~~~
+- a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+ - a
+
+derp
diff --git a/src/markup/engine/__tests__/remarkup/list-checkboxes.txt b/src/markup/engine/__tests__/remarkup/list-checkboxes.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-checkboxes.txt
@@ -0,0 +1,41 @@
+- [] a
+- [ ] b
+- [X] c
+- d
+
+[ ] A
+[X] B
+ [ ] C
+ [ ] D
+
+[1] footnote
+
+~~~~~~~~~~
+
+- a
+- b
+- c
+- d
+
+
+
+- A
+- B
+- C
+- D
+
+
+
+[1] footnote
+~~~~~~~~~~
+[ ] a
+[ ] b
+[X] c
+- d
+
+[ ] A
+[X] B
+ [ ] C
+ [ ] D
+
+[1] footnote
diff --git a/src/markup/engine/__tests__/remarkup/list-crazystairs.txt b/src/markup/engine/__tests__/remarkup/list-crazystairs.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-crazystairs.txt
@@ -0,0 +1,15 @@
+## Fruit
+- Apple
+- Banana
+~~~~~~~~~~
+
+
+- Fruit
+
- Apple
+- Banana
+
+~~~~~~~~~~
+ 1. Fruit
+- Apple
+- Banana
diff --git a/src/markup/engine/__tests__/remarkup/list-first-style-wins.txt b/src/markup/engine/__tests__/remarkup/list-first-style-wins.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-first-style-wins.txt
@@ -0,0 +1,19 @@
+# item
+- item
+- item
+
+derp
+~~~~~~~~~~
+
+- item
+- item
+- item
+
+
+derp
+~~~~~~~~~~
+1. item
+2. item
+3. item
+
+derp
diff --git a/src/markup/engine/__tests__/remarkup/list-hash.txt b/src/markup/engine/__tests__/remarkup/list-hash.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-hash.txt
@@ -0,0 +1,19 @@
+# item
+# item
+# item
+
+derp
+~~~~~~~~~~
+
+- item
+- item
+- item
+
+
+derp
+~~~~~~~~~~
+1. item
+2. item
+3. item
+
+derp
diff --git a/src/markup/engine/__tests__/remarkup/list-header-last.txt b/src/markup/engine/__tests__/remarkup/list-header-last.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-header-last.txt
@@ -0,0 +1,7 @@
+# At the end of a block, this should be a list.
+~~~~~~~~~~
+
+- At the end of a block, this should be a list.
+
+~~~~~~~~~~
+1. At the end of a block, this should be a list.
diff --git a/src/markup/engine/__tests__/remarkup/list-header.txt b/src/markup/engine/__tests__/remarkup/list-header.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-header.txt
@@ -0,0 +1,12 @@
+## Small Header
+
+This should be a small header.
+~~~~~~~~~~
+Small Header
+
+This should be a small header.
+~~~~~~~~~~
+Small Header
+------------
+
+This should be a small header.
diff --git a/src/markup/engine/__tests__/remarkup/list-mixed-styles.txt b/src/markup/engine/__tests__/remarkup/list-mixed-styles.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-mixed-styles.txt
@@ -0,0 +1,15 @@
+ - a
+ -- b
+ --- c
+~~~~~~~~~~
+
+- a
+- b
+- c
+
+
+
+~~~~~~~~~~
+- a
+ - b
+ - c
diff --git a/src/markup/engine/__tests__/remarkup/list-multi.txt b/src/markup/engine/__tests__/remarkup/list-multi.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-multi.txt
@@ -0,0 +1,14 @@
+- a
+ -- b
+ -- c
+~~~~~~~~~~
+
+- a
+- b
+- c
+
+
+~~~~~~~~~~
+- a
+ - b
+ - c
diff --git a/src/markup/engine/__tests__/remarkup/list-multiline.txt b/src/markup/engine/__tests__/remarkup/list-multiline.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-multiline.txt
@@ -0,0 +1,16 @@
+- a
+ a
+- b
+b
+~~~~~~~~~~
+
+- a a
+- b
+
+
+b
+~~~~~~~~~~
+- a a
+- b
+
+b
diff --git a/src/markup/engine/__tests__/remarkup/list-nest.txt b/src/markup/engine/__tests__/remarkup/list-nest.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-nest.txt
@@ -0,0 +1,30 @@
+- item
+ - sub
+- item
+ # sub
+ # sub
+- item
+
+derp
+~~~~~~~~~~
+
+- item
+- sub
+
+- item
+- sub
+- sub
+
+- item
+
+
+derp
+~~~~~~~~~~
+- item
+ - sub
+- item
+ 1. sub
+ 2. sub
+- item
+
+derp
diff --git a/src/markup/engine/__tests__/remarkup/list-paragraphs.txt b/src/markup/engine/__tests__/remarkup/list-paragraphs.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-paragraphs.txt
@@ -0,0 +1,27 @@
+- This is a list item
+ with several paragraphs.
+
+ This is the second paragraph
+ of the first list item.
+- This is the second item
+ in the list.
+ - This is a sublist.
+- This is the third item in the list.
+
+~~~~~~~~~~
+
+- This is a list item with several paragraphs.
+
+This is the second paragraph of the first list item.
+- This is the second item in the list.
+- This is a sublist.
+
+- This is the third item in the list.
+
+~~~~~~~~~~
+- This is a list item with several paragraphs.
+
+ This is the second paragraph of the first list item.
+- This is the second item in the list.
+ - This is a sublist.
+- This is the third item in the list.
diff --git a/src/markup/engine/__tests__/remarkup/list-staircase.txt b/src/markup/engine/__tests__/remarkup/list-staircase.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-staircase.txt
@@ -0,0 +1,23 @@
+ - top
+ - mid
+# bot
+
+derp
+~~~~~~~~~~
+
+
+
+- top
+
- mid
+
- bot
+
+
+derp
+~~~~~~~~~~
+ - top
+ - mid
+1. bot
+
+derp
diff --git a/src/markup/engine/__tests__/remarkup/list-star.txt b/src/markup/engine/__tests__/remarkup/list-star.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-star.txt
@@ -0,0 +1,19 @@
+* item
+* item
+* item
+
+derp
+~~~~~~~~~~
+
+- item
+- item
+- item
+
+
+derp
+~~~~~~~~~~
+- item
+- item
+- item
+
+derp
diff --git a/src/markup/engine/__tests__/remarkup/list-then-a-list.txt b/src/markup/engine/__tests__/remarkup/list-then-a-list.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-then-a-list.txt
@@ -0,0 +1,15 @@
+1) one
+
+- a
+~~~~~~~~~~
+
+- one
+
+
+
+- a
+
+~~~~~~~~~~
+1. one
+
+- a
diff --git a/src/markup/engine/__tests__/remarkup/list-vs-codeblock.txt b/src/markup/engine/__tests__/remarkup/list-vs-codeblock.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list-vs-codeblock.txt
@@ -0,0 +1,17 @@
+This should be a list:
+
+ - apple
+ - banana
+
+~~~~~~~~~~
+This should be a list:
+
+
+- apple
+- banana
+
+~~~~~~~~~~
+This should be a list:
+
+- apple
+- banana
diff --git a/src/markup/engine/__tests__/remarkup/list.txt b/src/markup/engine/__tests__/remarkup/list.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/list.txt
@@ -0,0 +1,13 @@
+ - < > & "
+
+text block
+~~~~~~~~~~
+
+- < > & "
+
+
+text block
+~~~~~~~~~~
+- < > & "
+
+text block
diff --git a/src/markup/engine/__tests__/remarkup/monospaced-in-monospaced.txt b/src/markup/engine/__tests__/remarkup/monospaced-in-monospaced.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/monospaced-in-monospaced.txt
@@ -0,0 +1,18 @@
+query ##SELECT * FROM `table`##
+
+`SELECT * FROM ##table##`
+
+`**x**`
+
+~~~~~~~~~~
+query SELECT * FROM `table`
+
+SELECT * FROM ##table##
+
+**x**
+~~~~~~~~~~
+query ##SELECT * FROM `table`##
+
+`SELECT * FROM ##table##`
+
+`**x**`
diff --git a/src/markup/engine/__tests__/remarkup/monospaced-plural.txt b/src/markup/engine/__tests__/remarkup/monospaced-plural.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/monospaced-plural.txt
@@ -0,0 +1,11 @@
+`Zebra`s
+
+I can`t and I won`t.
+~~~~~~~~~~
+Zebras
+
+I can`t and I won`t.
+~~~~~~~~~~
+`Zebra`s
+
+I can`t and I won`t.
diff --git a/src/markup/engine/__tests__/remarkup/monospaced.txt b/src/markup/engine/__tests__/remarkup/monospaced.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/monospaced.txt
@@ -0,0 +1,5 @@
+cmd ##ls --color > /dev/null##
+~~~~~~~~~~
+cmd ls --color > /dev/null
+~~~~~~~~~~
+cmd ##ls --color > /dev/null##
diff --git a/src/markup/engine/__tests__/remarkup/newline-then-block.txt b/src/markup/engine/__tests__/remarkup/newline-then-block.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/newline-then-block.txt
@@ -0,0 +1,30 @@
+This is a paragraph.
+
+
+ lang=txt
+ First line of code block.
+ Second line of code block.
+
+
+
+
+ Cell 1
+ Cell 2
+
+
+~~~~~~~~~~
+This is a paragraph.
+
+First line of code block.
+Second line of code block.
+
+
+Cell 1 Cell 2
+~~~~~~~~~~
+This is a paragraph.
+
+ First line of code block.
+ Second line of code block.
+
+| Cell 1 | Cell 2 |
diff --git a/src/markup/engine/__tests__/remarkup/note-multiline.txt b/src/markup/engine/__tests__/remarkup/note-multiline.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/note-multiline.txt
@@ -0,0 +1,14 @@
+NOTE: a
+a
+
+b
+~~~~~~~~~~
+NOTE: a
+a
+
+b
+~~~~~~~~~~
+NOTE: a
+a
+
+b
diff --git a/src/markup/engine/__tests__/remarkup/note.txt b/src/markup/engine/__tests__/remarkup/note.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/note.txt
@@ -0,0 +1,15 @@
+NOTE: interesting **stuff**
+
+(NOTE) interesting **stuff**
+~~~~~~~~~~
+NOTE: interesting stuff
+
+
+
+interesting stuff
+~~~~~~~~~~
+NOTE: interesting **stuff**
+
+
+
+(NOTE) interesting **stuff**
diff --git a/src/markup/engine/__tests__/remarkup/ordered-list-with-numbers.txt b/src/markup/engine/__tests__/remarkup/ordered-list-with-numbers.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/ordered-list-with-numbers.txt
@@ -0,0 +1,64 @@
+# aasdx
+# asdf
+
+1. asa
+ # asdf
+234) asdf
+
+234) asd
+
+1. asd
+234) asd
+
+10. ten
+11. eleven
+12. twelve
+
+1/ This explicitly should not be formatted as a list.
+~~~~~~~~~~
+
+- aasdx
+- asdf
+
+
+
+- asa
+- asdf
+
+- asdf
+
+
+
+- asd
+
+
+
+- asd
+- asd
+
+
+
+- ten
+- eleven
+- twelve
+
+
+1/ This explicitly should not be formatted as a list.
+~~~~~~~~~~
+1. aasdx
+2. asdf
+
+1. asa
+ 1. asdf
+2. asdf
+
+234. asd
+
+1. asd
+2. asd
+
+10. ten
+11. eleven
+12. twelve
+
+1/ This explicitly should not be formatted as a list.
diff --git a/src/markup/engine/__tests__/remarkup/percent-block-adjacent.txt b/src/markup/engine/__tests__/remarkup/percent-block-adjacent.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/percent-block-adjacent.txt
@@ -0,0 +1,29 @@
+%%%a%%%
+%%%b%%%
+
+%%%a
+b%%%
+
+%%%a%%%
+
+%%%b%%%
+~~~~~~~~~~
+a
+
b
+
+a
+
b
+
+a
+
+b
+~~~~~~~~~~
+a
+b
+
+a
+b
+
+a
+
+b
diff --git a/src/markup/engine/__tests__/remarkup/percent-block-multiline.txt b/src/markup/engine/__tests__/remarkup/percent-block-multiline.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/percent-block-multiline.txt
@@ -0,0 +1,21 @@
+**foo**
+%%%- first
+- second
+- third%%%
+[[http://hello | world]]
+~~~~~~~~~~
+foo
+
+- first
+
- second
+
- third
+
+
+~~~~~~~~~~
+**foo**
+
+- first
+- second
+- third
+
+world
diff --git a/src/markup/engine/__tests__/remarkup/percent-block-oneline.txt b/src/markup/engine/__tests__/remarkup/percent-block-oneline.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/percent-block-oneline.txt
@@ -0,0 +1,11 @@
+%%%[[http://hello | world]] **bold**%%%
+
+ %%%[[http://hello | world]] **bold**%%%
+~~~~~~~~~~
+[[http://hello | world]] **bold**
+
+[[http://hello | world]] **bold**
+~~~~~~~~~~
+[[http://hello | world]] **bold**
+
+[[http://hello | world]] **bold**
diff --git a/src/markup/engine/__tests__/remarkup/percent-block-solo.txt b/src/markup/engine/__tests__/remarkup/percent-block-solo.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/percent-block-solo.txt
@@ -0,0 +1,8 @@
+%%%
+**x**%%%
+~~~~~~~~~~
+
+
**x**
+~~~~~~~~~~
+
+**x**
diff --git a/src/markup/engine/__tests__/remarkup/quoted-angry.txt b/src/markup/engine/__tests__/remarkup/quoted-angry.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/quoted-angry.txt
@@ -0,0 +1,5 @@
+>>> REQUESTING CHANGES BECAUSE I'M ANGRY!
+~~~~~~~~~~
+REQUESTING CHANGES BECAUSE I'M ANGRY!
+~~~~~~~~~~
+>>> REQUESTING CHANGES BECAUSE I'M ANGRY!
diff --git a/src/markup/engine/__tests__/remarkup/quoted-code-block.txt b/src/markup/engine/__tests__/remarkup/quoted-code-block.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/quoted-code-block.txt
@@ -0,0 +1,16 @@
+> This should be a code block:
+>
+> ```lang=php
+> $foo = 'bar';
+> ```
+~~~~~~~~~~
+This should be a code block:
+
+<?php
+$foo = 'bar';
+~~~~~~~~~~
+> This should be a code block:
+>
+> $foo = 'bar';
diff --git a/src/markup/engine/__tests__/remarkup/quotes.txt b/src/markup/engine/__tests__/remarkup/quotes.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/quotes.txt
@@ -0,0 +1,9 @@
+> Dear Sir,
+> I am utterly disgusted with the quality
+> of your inflight food service.
+~~~~~~~~~~
+Dear Sir,
+ I am utterly disgusted with the quality
+ of your inflight food service.
+~~~~~~~~~~
+> Dear Sir, I am utterly disgusted with the quality of your inflight food service.
diff --git a/src/markup/engine/__tests__/remarkup/raw-escape.txt b/src/markup/engine/__tests__/remarkup/raw-escape.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/raw-escape.txt
@@ -0,0 +1,17 @@
+~1~
+
+~2Z
+
+~a
+~~~~~~~~~~
+~1~
+
+~2Z
+
+~a
+~~~~~~~~~~
+~1~
+
+~2Z
+
+~a
diff --git a/src/markup/engine/__tests__/remarkup/reply-basic.txt b/src/markup/engine/__tests__/remarkup/reply-basic.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/reply-basic.txt
@@ -0,0 +1,12 @@
+>>! In comment #123, alincoln wrote:
+> Four score and twenty years ago...
+~~~~~~~~~~
+
+~~~~~~~~~~
+In comment #123, alincoln wrote:
+
+> Four score and twenty years ago...
+
diff --git a/src/markup/engine/__tests__/remarkup/reply-nested.txt b/src/markup/engine/__tests__/remarkup/reply-nested.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/reply-nested.txt
@@ -0,0 +1,50 @@
+>>! Previously, fruit:
+>
+> - Apple
+> - Banana
+> - Cherry
+>
+>>>! More previously, vegetables:
+>>
+>> - Potato
+>> - Potato
+>> - Potato
+>
+> The end.
+
+~~~~~~~~~~
+
+~~~~~~~~~~
+Previously, fruit:
+
+> - Apple
+> - Banana
+> - Cherry
+>
+> More previously, vegetables:
+>
+> > - Potato
+> > - Potato
+> > - Potato
+>
+>
+> The end.
+
diff --git a/src/markup/engine/__tests__/remarkup/simple-table-with-empty-row.txt b/src/markup/engine/__tests__/remarkup/simple-table-with-empty-row.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/simple-table-with-empty-row.txt
@@ -0,0 +1,13 @@
+| Alpaca |
+| |
+| Zebra |
+~~~~~~~~~~
+
+Alpaca Zebra
+~~~~~~~~~~
+| Alpaca |
+| |
+| Zebra |
diff --git a/src/markup/engine/__tests__/remarkup/simple-table-with-leading-space.txt b/src/markup/engine/__tests__/remarkup/simple-table-with-leading-space.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/simple-table-with-leading-space.txt
@@ -0,0 +1,7 @@
+ |a|b|
+~~~~~~~~~~
+
+a b
+~~~~~~~~~~
+| a | b |
diff --git a/src/markup/engine/__tests__/remarkup/simple-table-with-link.txt b/src/markup/engine/__tests__/remarkup/simple-table-with-link.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/simple-table-with-link.txt
@@ -0,0 +1,7 @@
+| [[ http://example.com | name ]] | [x] |
+~~~~~~~~~~
+
+name [x]
+~~~~~~~~~~
+| name | [x] |
diff --git a/src/markup/engine/__tests__/remarkup/simple-table.txt b/src/markup/engine/__tests__/remarkup/simple-table.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/simple-table.txt
@@ -0,0 +1,24 @@
+| analyze_resources | original | mobile only | www only | both |
+| | -------- | ----------- | -------- | ---- |
+| //real// | 31 s | 24 s | 31 s | 31 s
+| --------
+| //user// | 49 s | 25 s | 31 s | 49 s
+| --------
+| //sys// | 24 s | 12 s | 13 s | 24 s
+| -------
+~~~~~~~~~~
+
+analyze_resources original mobile only www only both real 31 s 24 s 31 s 31 s user 49 s 25 s 31 s 49 s sys 24 s 12 s 13 s 24 s
+~~~~~~~~~~
+| analyze_resources | original | mobile only | www only | both |
+| | -------- | ----------- | -------- | ---- |
+| //real// | 31 s | 24 s | 31 s | 31 s |
+| ----------------- | | | | |
+| //user// | 49 s | 25 s | 31 s | 49 s |
+| ----------------- | | | | |
+| //sys// | 24 s | 12 s | 13 s | 24 s |
+| ----------------- | | | | |
diff --git a/src/markup/engine/__tests__/remarkup/simple.txt b/src/markup/engine/__tests__/remarkup/simple.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/simple.txt
@@ -0,0 +1,5 @@
+hello
+~~~~~~~~~~
+hello
+~~~~~~~~~~
+hello
diff --git a/src/markup/engine/__tests__/remarkup/table-with-leading-space.txt b/src/markup/engine/__tests__/remarkup/table-with-leading-space.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/table-with-leading-space.txt
@@ -0,0 +1,7 @@
+ cell
+~~~~~~~~~~
+
+cell
+~~~~~~~~~~
+| cell |
diff --git a/src/markup/engine/__tests__/remarkup/table-with-long-header.txt b/src/markup/engine/__tests__/remarkup/table-with-long-header.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/table-with-long-header.txt
@@ -0,0 +1,8 @@
+|x|
+||--
+~~~~~~~~~~
+
+x
+~~~~~~~~~~
+| x |
diff --git a/src/markup/engine/__tests__/remarkup/table.txt b/src/markup/engine/__tests__/remarkup/table.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/table.txt
@@ -0,0 +1,16 @@
+
+Table Storage `differential_diff` InnoDB `edge` ?
+~~~~~~~~~~
+
+Table Storage differential_diff InnoDB edge ?
+~~~~~~~~~~
+| Table | Storage |
+| ------------------- | ------- |
+| `differential_diff` | InnoDB |
+| `edge` | ? |
diff --git a/src/markup/engine/__tests__/remarkup/tick-block-multi.txt b/src/markup/engine/__tests__/remarkup/tick-block-multi.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/tick-block-multi.txt
@@ -0,0 +1,18 @@
+```code
+
+more code
+
+more code```
+
+~~~~~~~~~~
+code
+
+more code
+
+more code
+~~~~~~~~~~
+ code
+
+ more code
+
+ more code
diff --git a/src/markup/engine/__tests__/remarkup/tick-block.txt b/src/markup/engine/__tests__/remarkup/tick-block.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/tick-block.txt
@@ -0,0 +1,5 @@
+```code```
+~~~~~~~~~~
+code
+~~~~~~~~~~
+ code
diff --git a/src/markup/engine/__tests__/remarkup/toc.txt b/src/markup/engine/__tests__/remarkup/toc.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/toc.txt
@@ -0,0 +1,29 @@
+= [[ http://www.example.com/ | link_name ]] =
+
+== **bold** ==
+
+= http://www.example.com =
+
+~~~~~~~~~~
+
+- link_name
+
+- bold
+
+- http://www.example.com
+
+
+link_name
+
+bold
+
+http://www.example.com
+~~~~~~~~~~
+[[ http://www.example.com/ | link_name ]]
+=========================================
+
+**bold**
+--------
+
+http://www.example.com
+======================
diff --git a/src/markup/engine/__tests__/remarkup/trailing-whitespace-codeblock.txt b/src/markup/engine/__tests__/remarkup/trailing-whitespace-codeblock.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/trailing-whitespace-codeblock.txt
@@ -0,0 +1,39 @@
+ lang=txt
+ code block
+ code block
+
+
+
+
+ code block
+
+
+
+
+ code block
+~~~~~~~~~~
+code block
+code block
+
+
+
+
+code block
+
+
+
+
+code block
+~~~~~~~~~~
+ code block
+ code block
+
+
+
+
+ code block
+
+
+
+
+ code block
diff --git a/src/markup/engine/__tests__/remarkup/underline.txt b/src/markup/engine/__tests__/remarkup/underline.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/underline.txt
@@ -0,0 +1,13 @@
+omg__ wtf_____ bbq___ lol__
+__underlined text__
+__This is a great idea___ die forever please
+__
+/__notunderlined__/ and also /__notunderlined__.c
+~~~~~~~~~~
+omg__ wtf_____ bbq___ lol__
+underlined text
+This is a great idea_ die forever please
+__
+/__notunderlined__/ and also /__notunderlined__.c
+~~~~~~~~~~
+omg__ wtf_____ bbq___ lol__ __underlined text__ __This is a great idea___ die forever please __ /__notunderlined__/ and also /__notunderlined__.c
diff --git a/src/markup/engine/__tests__/remarkup/warning.txt b/src/markup/engine/__tests__/remarkup/warning.txt
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/__tests__/remarkup/warning.txt
@@ -0,0 +1,15 @@
+WARNING: interesting **stuff**
+
+(WARNING) interesting **stuff**
+~~~~~~~~~~
+WARNING: interesting stuff
+
+
+
+interesting stuff
+~~~~~~~~~~
+WARNING: interesting **stuff**
+
+
+
+(WARNING) interesting **stuff**
diff --git a/src/markup/engine/remarkup/PhutilRemarkupBlockStorage.php b/src/markup/engine/remarkup/PhutilRemarkupBlockStorage.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/PhutilRemarkupBlockStorage.php
@@ -0,0 +1,77 @@
+\11Z
+ *
+ * Then:
+ *
+ * ...
+ *
+ * If we didn't do this, the italics rule could match the "//" in "http://",
+ * or any other number of processing mistakes could occur, some of which create
+ * security risks.
+ *
+ * This class generates keys, and stores the map of keys to replacement text.
+ */
+final class PhutilRemarkupBlockStorage extends Phobject {
+
+ const MAGIC_BYTE = "\1";
+
+ private $map = array();
+ private $index;
+
+ public function store($text) {
+ $key = self::MAGIC_BYTE.(++$this->index).'Z';
+ $this->map[$key] = $text;
+ return $key;
+ }
+
+ public function restore($corpus, $text_mode = false) {
+ if ($this->map) {
+ if ($text_mode) {
+ $corpus = str_replace(
+ array_reverse(array_keys($this->map)),
+ array_reverse($this->map),
+ $corpus);
+ } else {
+ $corpus = phutil_safe_html(str_replace(
+ array_reverse(array_keys($this->map)),
+ array_map('phutil_escape_html', array_reverse($this->map)),
+ phutil_escape_html($corpus)));
+ }
+ }
+ return $corpus;
+ }
+
+ public function overwrite($key, $new_text) {
+ $this->map[$key] = $new_text;
+ return $this;
+ }
+
+ public function getMap() {
+ return $this->map;
+ }
+
+ public function setMap(array $map) {
+ $this->map = $map;
+ return $this;
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupBlockInterpreter.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupBlockInterpreter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupBlockInterpreter.php
@@ -0,0 +1,36 @@
+engine = $engine;
+ return $this;
+ }
+
+ final public function getEngine() {
+ return $this->engine;
+ }
+
+ /**
+ * @return string
+ */
+ abstract public function getInterpreterName();
+
+ abstract public function markupContent($content, array $argv);
+
+ protected function markupError($string) {
+ if ($this->getEngine()->isTextMode()) {
+ return '('.$string.')';
+ } else {
+ return phutil_tag(
+ 'div',
+ array(
+ 'class' => 'remarkup-interpreter-error',
+ ),
+ $string);
+ }
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupBlockRule.php
@@ -0,0 +1,170 @@
+addInt($this->getPriority())
+ ->addString(get_class($this));
+ }
+
+ abstract public function markupText($text, $children);
+
+ /**
+ * This will get an array of unparsed lines and return the number of lines
+ * from the first array value that it can parse.
+ *
+ * @param array $lines
+ * @param int $cursor
+ *
+ * @return int
+ */
+ abstract public function getMatchingLineCount(array $lines, $cursor);
+
+ protected function didMarkupText() {
+ return;
+ }
+
+ final public function setEngine(PhutilRemarkupEngine $engine) {
+ $this->engine = $engine;
+ $this->updateRules();
+ return $this;
+ }
+
+ final protected function getEngine() {
+ return $this->engine;
+ }
+
+ public function setMarkupRules(array $rules) {
+ assert_instances_of($rules, 'PhutilRemarkupRule');
+ $this->rules = $rules;
+ $this->updateRules();
+ return $this;
+ }
+
+ private function updateRules() {
+ $engine = $this->getEngine();
+ if ($engine) {
+ $this->rules = msort($this->rules, 'getPriority');
+ foreach ($this->rules as $rule) {
+ $rule->setEngine($engine);
+ }
+ }
+ return $this;
+ }
+
+ final public function getMarkupRules() {
+ return $this->rules;
+ }
+
+ final public function postprocess() {
+ $this->didMarkupText();
+ }
+
+ final protected function applyRules($text) {
+ foreach ($this->getMarkupRules() as $rule) {
+ $text = $rule->apply($text);
+ }
+ return $text;
+ }
+
+ public function supportsChildBlocks() {
+ return false;
+ }
+
+ public function extractChildText($text) {
+ throw new PhutilMethodNotImplementedException();
+ }
+
+ protected function renderRemarkupTable(array $out_rows) {
+ assert_instances_of($out_rows, 'array');
+
+ if ($this->getEngine()->isTextMode()) {
+ $lengths = array();
+ foreach ($out_rows as $r => $row) {
+ foreach ($row['content'] as $c => $cell) {
+ $text = $this->getEngine()->restoreText($cell['content']);
+ $lengths[$c][$r] = phutil_utf8_strlen($text);
+ }
+ }
+ $max_lengths = array_map('max', $lengths);
+
+ $out = array();
+ foreach ($out_rows as $r => $row) {
+ $headings = false;
+ foreach ($row['content'] as $c => $cell) {
+ $length = $max_lengths[$c] - $lengths[$c][$r];
+ $out[] = '| '.$cell['content'].str_repeat(' ', $length).' ';
+ if ($cell['type'] == 'th') {
+ $headings = true;
+ }
+ }
+ $out[] = "|\n";
+
+ if ($headings) {
+ foreach ($row['content'] as $c => $cell) {
+ $char = ($cell['type'] == 'th' ? '-' : ' ');
+ $out[] = '| '.str_repeat($char, $max_lengths[$c]).' ';
+ }
+ $out[] = "|\n";
+ }
+ }
+
+ return rtrim(implode('', $out), "\n");
+ }
+
+ if ($this->getEngine()->isHTMLMailMode()) {
+ $table_attributes = array(
+ 'style' => 'border-collapse: separate;
+ border-spacing: 1px;
+ background: #d3d3d3;
+ margin: 12px 0;',
+ );
+ $cell_attributes = array(
+ 'style' => 'background: #ffffff;
+ padding: 3px 6px;',
+ );
+ } else {
+ $table_attributes = array(
+ 'class' => 'remarkup-table',
+ );
+ $cell_attributes = array();
+ }
+
+ $out = array();
+ $out[] = "\n";
+ foreach ($out_rows as $row) {
+ $cells = array();
+ foreach ($row['content'] as $cell) {
+ $cells[] = phutil_tag(
+ $cell['type'],
+ $cell_attributes,
+ $cell['content']);
+ }
+ $out[] = phutil_tag($row['type'], array(), $cells);
+ $out[] = "\n";
+ }
+
+ $table = phutil_tag('table', $table_attributes, $out);
+ return phutil_tag_div('remarkup-table-wrap', $table);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupCodeBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupCodeBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupCodeBlockRule.php
@@ -0,0 +1,252 @@
+ false,
+ 'lang' => null,
+ 'name' => null,
+ 'lines' => null,
+ );
+
+ $parser = new PhutilSimpleOptions();
+ $custom = $parser->parse(head($lines));
+ if ($custom) {
+ $valid = true;
+ foreach ($custom as $key => $value) {
+ if (!array_key_exists($key, $options)) {
+ $valid = false;
+ break;
+ }
+ }
+ if ($valid) {
+ array_shift($lines);
+ $options = $custom + $options;
+ }
+ }
+
+ // Normalize the text back to a 0-level indent.
+ $min_indent = 80;
+ foreach ($lines as $line) {
+ for ($ii = 0; $ii < strlen($line); $ii++) {
+ if ($line[$ii] != ' ') {
+ $min_indent = min($ii, $min_indent);
+ break;
+ }
+ }
+ }
+
+ $text = implode("\n", $lines);
+ if ($min_indent) {
+ $indent_string = str_repeat(' ', $min_indent);
+ $text = preg_replace('/^'.$indent_string.'/m', '', $text);
+ }
+
+ if ($this->getEngine()->isTextMode()) {
+ $out = array();
+
+ $header = array();
+ if ($options['counterexample']) {
+ $header[] = 'counterexample';
+ }
+ if ($options['name'] != '') {
+ $header[] = 'name='.$options['name'];
+ }
+ if ($header) {
+ $out[] = implode(', ', $header);
+ }
+
+ $text = preg_replace('/^/m', ' ', $text);
+ $out[] = $text;
+
+ return implode("\n", $out);
+ }
+
+ if (empty($options['lang'])) {
+ // If the user hasn't specified "lang=..." explicitly, try to guess the
+ // language. If we fail, fall back to configured defaults.
+ $lang = PhutilLanguageGuesser::guessLanguage($text);
+ if (!$lang) {
+ $lang = nonempty(
+ $this->getEngine()->getConfig('phutil.codeblock.language-default'),
+ 'text');
+ }
+ $options['lang'] = $lang;
+ }
+
+ $code_body = $this->highlightSource($text, $options);
+
+ $name_header = null;
+ $block_style = null;
+ if ($this->getEngine()->isHTMLMailMode()) {
+ $map = $this->getEngine()->getConfig('phutil.codeblock.style-map');
+
+ if ($map) {
+ $raw_body = id(new PhutilPygmentizeParser())
+ ->setMap($map)
+ ->parse((string)$code_body);
+ $code_body = phutil_safe_html($raw_body);
+ }
+
+ $style_rules = array(
+ 'padding: 6px 12px;',
+ 'font-size: 13px;',
+ 'font-weight: bold;',
+ 'display: inline-block;',
+ 'border-top-left-radius: 3px;',
+ 'border-top-right-radius: 3px;',
+ 'color: rgba(0,0,0,.75);',
+ );
+
+ if ($options['counterexample']) {
+ $style_rules[] = 'background: #f7e6e6';
+ } else {
+ $style_rules[] = 'background: rgba(71, 87, 120, 0.08);';
+ }
+
+ $header_attributes = array(
+ 'style' => implode(' ', $style_rules),
+ );
+
+ $block_style = 'margin: 12px 0;';
+ } else {
+ $header_attributes = array(
+ 'class' => 'remarkup-code-header',
+ );
+ }
+
+ if ($options['name']) {
+ $name_header = phutil_tag(
+ 'div',
+ $header_attributes,
+ $options['name']);
+ }
+
+ $class = 'remarkup-code-block';
+ if ($options['counterexample']) {
+ $class = 'remarkup-code-block code-block-counterexample';
+ }
+
+ $attributes = array(
+ 'class' => $class,
+ 'style' => $block_style,
+ 'data-code-lang' => $options['lang'],
+ 'data-sigil' => 'remarkup-code-block',
+ );
+
+ return phutil_tag(
+ 'div',
+ $attributes,
+ array($name_header, $code_body));
+ }
+
+ private function highlightSource($text, array $options) {
+ if ($options['counterexample']) {
+ $aux_class = ' remarkup-counterexample';
+ } else {
+ $aux_class = null;
+ }
+
+ $aux_style = null;
+
+ if ($this->getEngine()->isHTMLMailMode()) {
+ $aux_style = array(
+ 'font: 11px/15px "Menlo", "Consolas", "Monaco", monospace;',
+ 'padding: 12px;',
+ 'margin: 0;',
+ );
+
+ if ($options['counterexample']) {
+ $aux_style[] = 'background: #f7e6e6;';
+ } else {
+ $aux_style[] = 'background: rgba(71, 87, 120, 0.08);';
+ }
+
+ $aux_style = implode(' ', $aux_style);
+ }
+
+ if ($options['lines']) {
+ // Put a minimum size on this because the scrollbar is otherwise
+ // unusable.
+ $height = max(6, (int)$options['lines']);
+ $aux_style = $aux_style
+ .' '
+ .'max-height: '
+ .(2 * $height)
+ .'em; overflow: auto;';
+ }
+
+ $engine = $this->getEngine()->getConfig('syntax-highlighter.engine');
+ if (!$engine) {
+ $engine = 'PhutilDefaultSyntaxHighlighterEngine';
+ }
+ $engine = newv($engine, array());
+ $engine->setConfig(
+ 'pygments.enabled',
+ $this->getEngine()->getConfig('pygments.enabled'));
+ return phutil_tag(
+ 'pre',
+ array(
+ 'class' => 'remarkup-code'.$aux_class,
+ 'style' => $aux_style,
+ ),
+ PhutilSafeHTML::applyFunction(
+ 'rtrim',
+ $engine->highlightSource($options['lang'], $text)));
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupDefaultBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupDefaultBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupDefaultBlockRule.php
@@ -0,0 +1,44 @@
+getEngine();
+
+ $text = trim($text);
+ $text = $this->applyRules($text);
+
+ if ($engine->isTextMode()) {
+ if (!$this->getEngine()->getConfig('preserve-linebreaks')) {
+ $text = preg_replace('/ *\n */', ' ', $text);
+ }
+ return $text;
+ }
+
+ if ($engine->getConfig('preserve-linebreaks')) {
+ $text = phutil_escape_html_newlines($text);
+ }
+
+ if (!strlen($text)) {
+ return null;
+ }
+
+ $default_attributes = $engine->getConfig('default.p.attributes');
+ if ($default_attributes) {
+ $attributes = $default_attributes;
+ } else {
+ $attributes = array();
+ }
+
+ return phutil_tag('p', $attributes, $text);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupHeaderBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupHeaderBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupHeaderBlockRule.php
@@ -0,0 +1,162 @@
+ 1) {
+ $level = ($lines[1][0] == '=') ? 1 : 2;
+ $text = trim($lines[0]);
+ } else {
+ $level = 0;
+ for ($ii = 0; $ii < min(5, strlen($text)); $ii++) {
+ if ($text[$ii] == '=' || $text[$ii] == '#') {
+ ++$level;
+ } else {
+ break;
+ }
+ }
+ $text = trim($text, ' =#');
+ }
+
+ $engine = $this->getEngine();
+
+ if ($engine->isTextMode()) {
+ $char = ($level == 1) ? '=' : '-';
+ return $text."\n".str_repeat($char, phutil_utf8_strlen($text));
+ }
+
+ $use_anchors = $engine->getConfig('header.generate-toc');
+
+ $anchor = null;
+ if ($use_anchors) {
+ $anchor = $this->generateAnchor($level, $text);
+ }
+
+ $text = phutil_tag(
+ 'h'.($level + 1),
+ array(
+ 'class' => 'remarkup-header',
+ ),
+ array($anchor, $this->applyRules($text)));
+
+ return $text;
+ }
+
+ private function generateAnchor($level, $text) {
+ $anchor = strtolower($text);
+ $anchor = preg_replace('/[^a-z0-9]/', '-', $anchor);
+ $anchor = preg_replace('/--+/', '-', $anchor);
+ $anchor = trim($anchor, '-');
+ $anchor = substr($anchor, 0, 24);
+ $anchor = trim($anchor, '-');
+ $base = $anchor;
+
+ $key = self::KEY_HEADER_TOC;
+ $engine = $this->getEngine();
+ $anchors = $engine->getTextMetadata($key, array());
+
+ $suffix = 1;
+ while (!strlen($anchor) || isset($anchors[$anchor])) {
+ $anchor = $base.'-'.$suffix;
+ $anchor = trim($anchor, '-');
+ $suffix++;
+ }
+
+ // When a document contains a link inside a header, like this:
+ //
+ // = [[ http://wwww.example.com/ | example ]] =
+ //
+ // ...we want to generate a TOC entry with just "example", but link the
+ // header itself. We push the 'toc' state so all the link rules generate
+ // just names.
+ $engine->pushState('toc');
+ $text = $this->applyRules($text);
+ $text = $engine->restoreText($text);
+
+ $anchors[$anchor] = array($level, $text);
+ $engine->popState('toc');
+
+ $engine->setTextMetadata($key, $anchors);
+
+ return phutil_tag(
+ 'a',
+ array(
+ 'name' => $anchor,
+ ),
+ '');
+ }
+
+ public static function renderTableOfContents(PhutilRemarkupEngine $engine) {
+
+ $key = self::KEY_HEADER_TOC;
+ $anchors = $engine->getTextMetadata($key, array());
+
+ if (count($anchors) < 2) {
+ // Don't generate a TOC if there are no headers, or if there's only
+ // one header (since such a TOC would be silly).
+ return null;
+ }
+
+ $depth = 0;
+ $toc = array();
+ foreach ($anchors as $anchor => $info) {
+ list($level, $name) = $info;
+
+ while ($depth < $level) {
+ $toc[] = hsprintf('');
+ $depth++;
+ }
+ while ($depth > $level) {
+ $toc[] = hsprintf('
');
+ $depth--;
+ }
+
+ $toc[] = phutil_tag(
+ 'li',
+ array(),
+ phutil_tag(
+ 'a',
+ array(
+ 'href' => '#'.$anchor,
+ ),
+ $name));
+ }
+ while ($depth > 0) {
+ $toc[] = hsprintf('');
+ $depth--;
+ }
+
+ return phutil_implode_html("\n", $toc);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupHorizontalRuleBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupHorizontalRuleBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupHorizontalRuleBlockRule.php
@@ -0,0 +1,37 @@
+getEngine()->isTextMode()) {
+ return rtrim($text);
+ }
+
+ return phutil_tag('hr', array('class' => 'remarkup-hr'));
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupInlineBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupInlineBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupInlineBlockRule.php
@@ -0,0 +1,13 @@
+applyRules($text);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupInterpreterBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupInterpreterBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupInterpreterBlockRule.php
@@ -0,0 +1,89 @@
+parse($matches[2]);
+ }
+
+ $interpreters = id(new PhutilClassMapQuery())
+ ->setAncestorClass('PhutilRemarkupBlockInterpreter')
+ ->execute();
+
+ foreach ($interpreters as $interpreter) {
+ $interpreter->setEngine($this->getEngine());
+ }
+
+ $lines[$first_key] = preg_replace(
+ self::START_BLOCK_PATTERN,
+ '',
+ $lines[$first_key]);
+ $lines[$last_key] = preg_replace(
+ self::END_BLOCK_PATTERN,
+ '',
+ $lines[$last_key]);
+
+ if (trim($lines[$first_key]) === '') {
+ unset($lines[$first_key]);
+ }
+ if (trim($lines[$last_key]) === '') {
+ unset($lines[$last_key]);
+ }
+
+ $content = implode("\n", $lines);
+
+ $interpreters = mpull($interpreters, null, 'getInterpreterName');
+
+ if (isset($interpreters[$matches[1]])) {
+ return $interpreters[$matches[1]]->markupContent($content, $argv);
+ }
+
+ $message = pht('No interpreter found: %s', $matches[1]);
+
+ if ($this->getEngine()->isTextMode()) {
+ return '('.$message.')';
+ }
+
+ return phutil_tag(
+ 'div',
+ array(
+ 'class' => 'remarkup-interpreter-error',
+ ),
+ $message);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupListBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupListBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupListBlockRule.php
@@ -0,0 +1,567 @@
+ $line) {
+ $matches = null;
+ if (preg_match($regex, $line)) {
+ $regex = self::CONT_BLOCK_PATTERN;
+ if (preg_match('/^(\s+)/', $line, $matches)) {
+ $space = strlen($matches[1]);
+ } else {
+ $space = 0;
+ }
+ $min_space = min($min_space, $space);
+ }
+ }
+
+ $regex = self::START_BLOCK_PATTERN;
+ if ($min_space) {
+ foreach ($lines as $key => $line) {
+ if (preg_match($regex, $line)) {
+ $regex = self::CONT_BLOCK_PATTERN;
+ $lines[$key] = substr($line, $min_space);
+ }
+ }
+ }
+
+
+ // The input text may have linewraps in it, like this:
+ //
+ // - derp derp derp derp
+ // derp derp derp derp
+ // - blarp blarp blarp blarp
+ //
+ // Group text lines together into list items, stored in $items. So the
+ // result in the above case will be:
+ //
+ // array(
+ // array(
+ // "- derp derp derp derp",
+ // " derp derp derp derp",
+ // ),
+ // array(
+ // "- blarp blarp blarp blarp",
+ // ),
+ // );
+
+ $item = array();
+ $starts_at = null;
+ $regex = self::START_BLOCK_PATTERN;
+ foreach ($lines as $line) {
+ $match = null;
+ if (preg_match($regex, $line, $match)) {
+ if (!$starts_at && !empty($match[1])) {
+ $starts_at = $match[1];
+ }
+ $regex = self::CONT_BLOCK_PATTERN;
+ if ($item) {
+ $items[] = $item;
+ $item = array();
+ }
+ }
+ $item[] = $line;
+ }
+ if ($item) {
+ $items[] = $item;
+ }
+ if (!$starts_at) {
+ $starts_at = 1;
+ }
+
+
+ // Process each item to normalize the text, remove line wrapping, and
+ // determine its depth (indentation level) and style (ordered vs unordered).
+ //
+ // We preserve consecutive linebreaks and interpret them as paragraph
+ // breaks.
+ //
+ // Given the above example, the processed array will look like:
+ //
+ // array(
+ // array(
+ // 'text' => 'derp derp derp derp derp derp derp derp',
+ // 'depth' => 0,
+ // 'style' => '-',
+ // ),
+ // array(
+ // 'text' => 'blarp blarp blarp blarp',
+ // 'depth' => 0,
+ // 'style' => '-',
+ // ),
+ // );
+
+ $has_marks = false;
+ foreach ($items as $key => $item) {
+ // Trim space around newlines, to strip trailing whitespace and formatting
+ // indentation.
+ $item = preg_replace('/ *(\n+) */', '\1', implode("\n", $item));
+
+ // Replace single newlines with a space. Preserve multiple newlines as
+ // paragraph breaks.
+ $item = preg_replace('/(? $text,
+ 'depth' => $depth,
+ 'style' => $style,
+ 'mark' => $mark,
+ );
+ }
+ $items = array_values($items);
+
+
+ // Users can create a sub-list by indenting any deeper amount than the
+ // previous list, so these are both valid:
+ //
+ // - a
+ // - b
+ //
+ // - a
+ // - b
+ //
+ // In the former case, we'll have depths (0, 2). In the latter case, depths
+ // (0, 4). We don't actually care about how many spaces there are, only
+ // how many list indentation levels (that is, we want to map both of
+ // those cases to (0, 1), indicating "outermost list" and "first sublist").
+ //
+ // This is made more complicated because lists at two different indentation
+ // levels might be at the same list level:
+ //
+ // - a
+ // - b
+ // - c
+ // - d
+ //
+ // Here, 'b' and 'd' are at the same list level (2) but different indent
+ // levels (2, 4).
+ //
+ // Users can also create "staircases" like this:
+ //
+ // - a
+ // - b
+ // # c
+ //
+ // While this is silly, we'd like to render it as faithfully as possible.
+ //
+ // In order to do this, we convert the list of nodes into a tree,
+ // normalizing indentation levels and inserting dummy nodes as necessary to
+ // make the tree well-formed. See additional notes at buildTree().
+ //
+ // In the case above, the result is a tree like this:
+ //
+ // -
+ // -
+ // - a
+ // - b
+ // # c
+
+ $l = 0;
+ $r = count($items);
+ $tree = $this->buildTree($items, $l, $r, $cur_level = 0);
+
+
+ // We may need to open a list on a node, but they do not have
+ // list style information yet. We need to propagate list style information
+ // backward through the tree. In the above example, the tree now looks
+ // like this:
+ //
+ // -
+ // -
+ // - a
+ // - b
+ // # c
+
+ $this->adjustTreeStyleInformation($tree);
+
+ // Finally, we have enough information to render the tree.
+
+ $out = $this->renderTree($tree, 0, $has_marks, $starts_at);
+
+ if ($this->getEngine()->isTextMode()) {
+ $out = implode('', $out);
+ $out = rtrim($out, "\n");
+ $out = preg_replace('/ +$/m', '', $out);
+ return $out;
+ }
+
+ return phutil_implode_html('', $out);
+ }
+
+ /**
+ * See additional notes in @{method:markupText}.
+ */
+ private function buildTree(array $items, $l, $r, $cur_level) {
+ if ($l == $r) {
+ return array();
+ }
+
+ if ($cur_level > self::MAXIMUM_LIST_NESTING_DEPTH) {
+ // This algorithm is recursive and we don't need you blowing the stack
+ // with your oh-so-clever 50,000-item-deep list. Cap indentation levels
+ // at a reasonable number and just shove everything deeper up to this
+ // level.
+ $nodes = array();
+ for ($ii = $l; $ii < $r; $ii++) {
+ $nodes[] = array(
+ 'level' => $cur_level,
+ 'items' => array(),
+ ) + $items[$ii];
+ }
+ return $nodes;
+ }
+
+ $min = $l;
+ for ($ii = $r - 1; $ii >= $l; $ii--) {
+ if ($items[$ii]['depth'] <= $items[$min]['depth']) {
+ $min = $ii;
+ }
+ }
+
+ $min_depth = $items[$min]['depth'];
+
+ $nodes = array();
+ if ($min != $l) {
+ $nodes[] = array(
+ 'text' => null,
+ 'level' => $cur_level,
+ 'style' => null,
+ 'mark' => null,
+ 'items' => $this->buildTree($items, $l, $min, $cur_level + 1),
+ );
+ }
+
+ $last = $min;
+ for ($ii = $last + 1; $ii < $r; $ii++) {
+ if ($items[$ii]['depth'] == $min_depth) {
+ $nodes[] = array(
+ 'level' => $cur_level,
+ 'items' => $this->buildTree($items, $last + 1, $ii, $cur_level + 1),
+ ) + $items[$last];
+ $last = $ii;
+ }
+ }
+ $nodes[] = array(
+ 'level' => $cur_level,
+ 'items' => $this->buildTree($items, $last + 1, $r, $cur_level + 1),
+ ) + $items[$last];
+
+ return $nodes;
+ }
+
+
+ /**
+ * See additional notes in @{method:markupText}.
+ */
+ private function adjustTreeStyleInformation(array &$tree) {
+ // The effect here is just to walk backward through the nodes at this level
+ // and apply the first style in the list to any empty nodes we inserted
+ // before it. As we go, also recurse down the tree.
+
+ $style = '-';
+ for ($ii = count($tree) - 1; $ii >= 0; $ii--) {
+ if ($tree[$ii]['style'] !== null) {
+ // This is the earliest node we've seen with style, so set the
+ // style to its style.
+ $style = $tree[$ii]['style'];
+ } else {
+ // This node has no style, so apply the current style.
+ $tree[$ii]['style'] = $style;
+ }
+ if ($tree[$ii]['items']) {
+ $this->adjustTreeStyleInformation($tree[$ii]['items']);
+ }
+ }
+ }
+
+
+ /**
+ * See additional notes in @{method:markupText}.
+ */
+ private function renderTree(
+ array $tree,
+ $level,
+ $has_marks,
+ $starts_at = 1) {
+
+ $style = idx(head($tree), 'style');
+
+ $out = array();
+
+ if (!$this->getEngine()->isTextMode()) {
+ switch ($style) {
+ case '#':
+ $tag = 'ol';
+ break;
+ case '-':
+ $tag = 'ul';
+ break;
+ }
+
+ $start_attr = null;
+ if (ctype_digit($starts_at) && $starts_at > 1) {
+ $start_attr = hsprintf(' start="%d"', $starts_at);
+ }
+
+ if ($has_marks) {
+ $out[] = hsprintf(
+ '<%s class="remarkup-list remarkup-list-with-checkmarks"%s>',
+ $tag,
+ $start_attr);
+ } else {
+ $out[] = hsprintf(
+ '<%s class="remarkup-list"%s>',
+ $tag,
+ $start_attr);
+ }
+
+ $out[] = "\n";
+ }
+
+ $number = $starts_at;
+ foreach ($tree as $item) {
+ if ($this->getEngine()->isTextMode()) {
+ if ($item['text'] === null) {
+ // Don't render anything.
+ } else {
+ $indent = str_repeat(' ', 2 * $level);
+ $out[] = $indent;
+ if ($item['mark'] !== null) {
+ if ($item['mark']) {
+ $out[] = '[X] ';
+ } else {
+ $out[] = '[ ] ';
+ }
+ } else {
+ switch ($style) {
+ case '#':
+ $out[] = $number.'. ';
+ $number++;
+ break;
+ case '-':
+ $out[] = '- ';
+ break;
+ }
+ }
+
+ $parts = preg_split('/\n{2,}/', $item['text']);
+ foreach ($parts as $key => $part) {
+ if ($key != 0) {
+ $out[] = "\n\n ".$indent;
+ }
+ $out[] = $this->applyRules($part);
+ }
+ $out[] = "\n";
+ }
+ } else {
+ if ($item['text'] === null) {
+ $out[] = hsprintf('');
+ } else {
+ if ($item['mark'] !== null) {
+ if ($item['mark'] == true) {
+ $out[] = hsprintf(
+ ' ');
+ } else {
+ $out[] = hsprintf(
+ ' ');
+ }
+ $out[] = phutil_tag(
+ 'input',
+ array(
+ 'type' => 'checkbox',
+ 'checked' => ($item['mark'] ? 'checked' : null),
+ 'disabled' => 'disabled',
+ ));
+ $out[] = ' ';
+ } else {
+ $out[] = hsprintf(' ');
+ }
+
+ $parts = preg_split('/\n{2,}/', $item['text']);
+ foreach ($parts as $key => $part) {
+ if ($key != 0) {
+ $out[] = array(
+ "\n",
+ phutil_tag('br'),
+ phutil_tag('br'),
+ "\n",
+ );
+ }
+ $out[] = $this->applyRules($part);
+ }
+ }
+ }
+
+ if ($item['items']) {
+ $subitems = $this->renderTree($item['items'], $level + 1, $has_marks);
+ foreach ($subitems as $i) {
+ $out[] = $i;
+ }
+ }
+ if (!$this->getEngine()->isTextMode()) {
+ $out[] = hsprintf(" \n");
+ }
+ }
+
+ if (!$this->getEngine()->isTextMode()) {
+ switch ($style) {
+ case '#':
+ $out[] = hsprintf('');
+ break;
+ case '-':
+ $out[] = hsprintf('');
+ break;
+ }
+ }
+
+ return $out;
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupLiteralBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupLiteralBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupLiteralBlockRule.php
@@ -0,0 +1,93 @@
+ $line) {
+ $line = preg_replace('/^\s*%%%/', '', $line);
+ $line = preg_replace('/%%%(\s*)\z/', '\1', $line);
+ $text[$key] = $line;
+ }
+
+ if ($this->getEngine()->isTextMode()) {
+ return implode('', $text);
+ }
+
+ return phutil_tag(
+ 'p',
+ array(
+ 'class' => 'remarkup-literal',
+ ),
+ phutil_implode_html(phutil_tag('br', array()), $text));
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupNoteBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupNoteBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupNoteBlockRule.php
@@ -0,0 +1,121 @@
+getRegEx(), $lines[$cursor])) {
+ $num_lines++;
+ $cursor++;
+
+ while (isset($lines[$cursor])) {
+ if (trim($lines[$cursor])) {
+ $num_lines++;
+ $cursor++;
+ continue;
+ }
+ break;
+ }
+ }
+
+ return $num_lines;
+ }
+
+ public function markupText($text, $children) {
+ $matches = array();
+ preg_match($this->getRegEx(), $text, $matches);
+
+ if (idx($matches, 'showword')) {
+ $word = $matches['showword'];
+ $show = true;
+ } else {
+ $word = $matches['hideword'];
+ $show = false;
+ }
+
+ $class_suffix = phutil_utf8_strtolower($word);
+
+ // This is the "(IMPORTANT)" or "NOTE:" part.
+ $word_part = rtrim(substr($text, 0, strlen($matches[0])));
+
+ // This is the actual text.
+ $text_part = substr($text, strlen($matches[0]));
+ $text_part = $this->applyRules(rtrim($text_part));
+
+ $text_mode = $this->getEngine()->isTextMode();
+ $html_mail_mode = $this->getEngine()->isHTMLMailMode();
+ if ($text_mode) {
+ return $word_part.' '.$text_part;
+ }
+
+ if ($show) {
+ $content = array(
+ phutil_tag(
+ 'span',
+ array(
+ 'class' => 'remarkup-note-word',
+ ),
+ $word_part),
+ ' ',
+ $text_part,
+ );
+ } else {
+ $content = $text_part;
+ }
+
+ if ($html_mail_mode) {
+ if ($class_suffix == 'important') {
+ $attributes = array(
+ 'style' => 'margin: 16px 0;
+ padding: 12px;
+ border-left: 3px solid #c0392b;
+ background: #f4dddb;',
+ );
+ } else if ($class_suffix == 'note') {
+ $attributes = array(
+ 'style' => 'margin: 16px 0;
+ padding: 12px;
+ border-left: 3px solid #2980b9;
+ background: #daeaf3;',
+ );
+ } else if ($class_suffix == 'warning') {
+ $attributes = array(
+ 'style' => 'margin: 16px 0;
+ padding: 12px;
+ border-left: 3px solid #f1c40f;
+ background: #fdf5d4;',
+ );
+ }
+ } else {
+ $attributes = array(
+ 'class' => 'remarkup-'.$class_suffix,
+ );
+ }
+
+ return phutil_tag(
+ 'div',
+ $attributes,
+ $content);
+ }
+
+ private function getRegEx() {
+ $words = array(
+ 'NOTE',
+ 'IMPORTANT',
+ 'WARNING',
+ );
+
+ foreach ($words as $k => $word) {
+ $words[$k] = preg_quote($word, '/');
+ }
+ $words = implode('|', $words);
+
+ return
+ '/^(?:'.
+ '(?:\((?P'.$words.')\))'.
+ '|'.
+ '(?:(?P'.$words.'):))\s*'.
+ '/';
+ }
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupQuotesBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupQuotesBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupQuotesBlockRule.php
@@ -0,0 +1,65 @@
+/', $lines[$pos])) {
+ do {
+ ++$pos;
+ } while (isset($lines[$pos]) && preg_match('/^>/', $lines[$pos]));
+ }
+
+ return ($pos - $cursor);
+ }
+
+ public function supportsChildBlocks() {
+ return true;
+ }
+
+ public function extractChildText($text) {
+ $text = phutil_split_lines($text, true);
+ foreach ($text as $key => $line) {
+ $text[$key] = substr($line, 1);
+ }
+
+ return array('', implode('', $text));
+ }
+
+ public function markupText($text, $children) {
+ if ($this->getEngine()->isTextMode()) {
+ $lines = rtrim($children, "\n");
+ $lines = phutil_split_lines($lines);
+ foreach ($lines as $key => $line) {
+ if (isset($line[0]) && ($line[0] == '>')) {
+ $line = '>'.$line;
+ } else {
+ $line = '> '.$line;
+ }
+ $lines[$key] = $line;
+ }
+ return implode('', $lines);
+ }
+
+ $attributes = array();
+ if ($this->getEngine()->isHTMLMailMode()) {
+ $style = array(
+ 'border-left: 3px solid #a7b5bf;',
+ 'color: #464c5c;',
+ 'font-style: italic;',
+ 'margin: 4px 0 12px 0;',
+ 'padding: 4px 12px;',
+ 'background-color: #f8f9fc;',
+ );
+
+ $attributes['style'] = implode(' ', $style);
+ }
+
+ return phutil_tag(
+ 'blockquote',
+ $attributes,
+ $children);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupReplyBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupReplyBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupReplyBlockRule.php
@@ -0,0 +1,117 @@
+>!/', $lines[$pos])) {
+ do {
+ ++$pos;
+ } while (isset($lines[$pos]) && preg_match('/^>/', $lines[$pos]));
+ }
+
+ return ($pos - $cursor);
+ }
+
+ public function supportsChildBlocks() {
+ return true;
+ }
+
+ public function extractChildText($text) {
+ $text = phutil_split_lines($text, true);
+
+ $head = array();
+ $body = array();
+
+ $head = substr(reset($text), 3);
+
+ $body = array_slice($text, 1);
+
+ // Remove the carets.
+ foreach ($body as $key => $line) {
+ $body[$key] = substr($line, 1);
+ }
+
+ // Strip leading empty lines.
+ foreach ($body as $key => $line) {
+ if (strlen(trim($line))) {
+ break;
+ }
+ unset($body[$key]);
+ }
+
+ return array(trim($head), implode('', $body));
+ }
+
+ public function markupText($text, $children) {
+ $text = $this->applyRules($text);
+
+ if ($this->getEngine()->isTextMode()) {
+ $children = phutil_split_lines($children, true);
+ foreach ($children as $key => $child) {
+ if (strlen(trim($child))) {
+ $children[$key] = '> '.$child;
+ } else {
+ $children[$key] = '>'.$child;
+ }
+ }
+ $children = implode('', $children);
+
+ return $text."\n\n".$children;
+ }
+
+ if ($this->getEngine()->isHTMLMailMode()) {
+ $block_attributes = array(
+ 'style' => 'border-left: 3px solid #8C98B8;
+ color: #6B748C;
+ font-style: italic;
+ margin: 4px 0 12px 0;
+ padding: 8px 12px;
+ background-color: #F8F9FC;',
+ );
+ $head_attributes = array(
+ 'style' => 'font-style: normal;
+ padding-bottom: 4px;',
+ );
+ $reply_attributes = array(
+ 'style' => 'margin: 0;
+ padding: 0;
+ border: 0;
+ color: rgb(107, 116, 140);',
+ );
+ } else {
+ $block_attributes = array(
+ 'class' => 'remarkup-reply-block',
+ );
+ $head_attributes = array(
+ 'class' => 'remarkup-reply-head',
+ );
+ $reply_attributes = array(
+ 'class' => 'remarkup-reply-body',
+ );
+ }
+
+ return phutil_tag(
+ 'blockquote',
+ $block_attributes,
+ array(
+ "\n",
+ phutil_tag(
+ 'div',
+ $head_attributes,
+ $text),
+ "\n",
+ phutil_tag(
+ 'div',
+ $reply_attributes,
+ $children),
+ "\n",
+ ));
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupSimpleTableBlockRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupSimpleTableBlockRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupSimpleTableBlockRule.php
@@ -0,0 +1,96 @@
+ cells
+ // instead of cells.
+
+ // If it has other types of cells, it's always a content row.
+
+ // If it has only empty cells, it's an empty row.
+
+ if (strlen($cell)) {
+ if (preg_match('/^--+\z/', $cell)) {
+ $any_header = true;
+ } else {
+ $any_content = true;
+ }
+ }
+
+ $cells[] = array('type' => 'td', 'content' => $this->applyRules($cell));
+ }
+
+ $is_header = ($any_header && !$any_content);
+
+ if (!$is_header) {
+ $rows[] = array('type' => 'tr', 'content' => $cells);
+ } else if ($rows) {
+ // Mark previous row with headings.
+ foreach ($cells as $i => $cell) {
+ if ($cell['content']) {
+ $last_key = last_key($rows);
+ if (!isset($rows[$last_key]['content'][$i])) {
+ // If this row has more cells than the previous row, there may
+ // not be a cell above this one to turn into a (.*)
$@si', $text, $matches)) {
+ return $this->fail(
+ $text,
+ pht('Bad table (expected %s)', '...
'));
+ }
+
+ $body = $matches[1];
+
+ $row_fragment = '(?:\s*(.*) \s*)';
+ $cell_fragment = '(?:\s*<(td|th)>(.*)\s*)';
+
+ // Test that the body contains only valid rows.
+ if (!preg_match('@^'.$row_fragment.'+$@Usi', $body)) {
+ return $this->fail(
+ $body,
+ pht('Bad table syntax (expected rows %s)', '... '));
+ }
+
+ // Capture the rows.
+ $row_regex = '@'.$row_fragment.'@Usi';
+ if (!preg_match_all($row_regex, $body, $matches, PREG_SET_ORDER)) {
+ throw new Exception(
+ pht('Bug in Remarkup tables, parsing fails for input: %s', $text));
+ }
+
+ $out_rows = array();
+
+ $rows = $matches;
+ foreach ($rows as $row) {
+ $content = $row[1];
+
+ // Test that the row contains only valid cells.
+ if (!preg_match('@^'.$cell_fragment.'+$@Usi', $content)) {
+ return $this->fail(
+ $content,
+ pht('Bad table syntax (expected cells %s)', '... '));
+ }
+
+ // Capture the cells.
+ $cell_regex = '@'.$cell_fragment.'@Usi';
+ if (!preg_match_all($cell_regex, $content, $matches, PREG_SET_ORDER)) {
+ throw new Exception(
+ pht('Bug in Remarkup tables, parsing fails for input: %s', $text));
+ }
+
+ $out_cells = array();
+ foreach ($matches as $cell) {
+ $cell_type = $cell[1];
+ $cell_content = $cell[2];
+
+ $out_cells[] = array(
+ 'type' => $cell_type,
+ 'content' => $this->applyRules($cell_content),
+ );
+ }
+
+ $out_rows[] = array(
+ 'type' => 'tr',
+ 'content' => $out_cells,
+ );
+ }
+
+ return $this->renderRemarkupTable($out_rows);
+ }
+
+ private function fail($near, $message) {
+ $message = sprintf(
+ '%s near: %s',
+ $message,
+ id(new PhutilUTF8StringTruncator())
+ ->setMaximumGlyphs(32000)
+ ->truncateString($near));
+
+ if ($this->getEngine()->isTextMode()) {
+ return '('.$message.')';
+ }
+
+ return hsprintf('%s', $message);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/PhutilRemarkupTestInterpreterRule.php b/src/markup/engine/remarkup/blockrule/PhutilRemarkupTestInterpreterRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/PhutilRemarkupTestInterpreterRule.php
@@ -0,0 +1,17 @@
+getEngine()->isTextMode()) {
+ return $text;
+ }
+
+ return $this->replaceHTML(
+ '@\\*\\*(.+?)\\*\\*@s',
+ array($this, 'applyCallback'),
+ $text);
+ }
+
+ protected function applyCallback(array $matches) {
+ return hsprintf('%s', $matches[1]);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupDelRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupDelRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupDelRule.php
@@ -0,0 +1,24 @@
+getEngine()->isTextMode()) {
+ return $text;
+ }
+
+ return $this->replaceHTML(
+ '@(?%s', $matches[1]);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupDocumentLinkRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupDocumentLinkRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupDocumentLinkRule.php
@@ -0,0 +1,175 @@
+getEngine();
+
+ $is_anchor = false;
+ if (strncmp($link, '/', 1) == 0) {
+ $base = $engine->getConfig('uri.base');
+ $base = rtrim($base, '/');
+ $link = $base.$link;
+ } else if (strncmp($link, '#', 1) == 0) {
+ $here = $engine->getConfig('uri.here');
+ $link = $here.$link;
+
+ $is_anchor = true;
+ }
+
+ if ($engine->isTextMode()) {
+ // If present, strip off "mailto:" or "tel:".
+ $link = preg_replace('/^(?:mailto|tel):/', '', $link);
+
+ if (!strlen($name)) {
+ return $link;
+ }
+
+ return $name.' <'.$link.'>';
+ }
+
+ if (!strlen($name)) {
+ $name = $link;
+ $name = preg_replace('/^(?:mailto|tel):/', '', $name);
+ }
+
+ if ($engine->getState('toc')) {
+ return $name;
+ }
+
+ $same_window = $engine->getConfig('uri.same-window', false);
+ if ($same_window) {
+ $target = null;
+ } else {
+ $target = '_blank';
+ }
+
+ // For anchors on the same page, always stay here.
+ if ($is_anchor) {
+ $target = null;
+ }
+
+ return phutil_tag(
+ 'a',
+ array(
+ 'href' => $link,
+ 'class' => 'remarkup-link',
+ 'target' => $target,
+ 'rel' => 'noreferrer',
+ ),
+ $name);
+ }
+
+ public function markupAlternateLink(array $matches) {
+ $uri = trim($matches[2]);
+
+ // NOTE: We apply some special rules to avoid false positives here. The
+ // major concern is that we do not want to convert `x[0][1](y)` in a
+ // discussion about C source code into a link. To this end, we:
+ //
+ // - Don't match at word boundaries;
+ // - require the URI to contain a "/" character or "@" character; and
+ // - reject URIs which being with a quote character.
+
+ if ($uri[0] == '"' || $uri[0] == "'" || $uri[0] == '`') {
+ return $matches[0];
+ }
+
+ if (!strlen($uri[0])) {
+ return $matches[0];
+ }
+
+ if (strpos($uri, '/') === false &&
+ strpos($uri, '@') === false &&
+ strncmp($uri, 'tel:', 4)) {
+ return $matches[0];
+ }
+
+ return $this->markupDocumentLink(
+ array(
+ $matches[0],
+ $matches[2],
+ $matches[1],
+ ));
+ }
+
+ public function markupDocumentLink(array $matches) {
+ $uri = trim($matches[1]);
+ $name = trim(idx($matches, 2));
+
+ // If whatever is being linked to begins with "/" or "#", or has "://",
+ // or is "mailto:" or "tel:", treat it as a URI instead of a wiki page.
+ $is_uri = preg_match('@(^/)|(://)|(^#)|(^(?:mailto|tel):)@', $uri);
+
+ if ($is_uri && strncmp('/', $uri, 1) && strncmp('#', $uri, 1)) {
+ $protocols = $this->getEngine()->getConfig(
+ 'uri.allowed-protocols',
+ array());
+
+ try {
+ $protocol = id(new PhutilURI($uri))->getProtocol();
+ if (!idx($protocols, $protocol)) {
+ // Don't treat this as a URI if it's not an allowed protocol.
+ $is_uri = false;
+ }
+ } catch (Exception $ex) {
+ // We can end up here if we try to parse an ambiguous URI, see
+ // T12796.
+ $is_uri = false;
+ }
+ }
+
+ // As a special case, skip "[[ / ]]" so that Phriction picks it up as a
+ // link to the Phriction root. It is more useful to be able to use this
+ // syntax to link to the root document than the home page of the install.
+ if ($uri == '/') {
+ $is_uri = false;
+ }
+
+ if (!$is_uri) {
+ return $matches[0];
+ }
+
+ return $this->getEngine()->storeText($this->renderHyperlink($uri, $name));
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupEscapeRemarkupRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupEscapeRemarkupRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupEscapeRemarkupRule.php
@@ -0,0 +1,19 @@
+getEngine()->storeText("\1");
+
+ return str_replace("\1", $replace, $text);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupHighlightRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupHighlightRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupHighlightRule.php
@@ -0,0 +1,37 @@
+getEngine()->isTextMode()) {
+ return $text;
+ }
+
+ return $this->replaceHTML(
+ '@!!(.+?)(!{2,})@',
+ array($this, 'applyCallback'),
+ $text);
+ }
+
+ protected function applyCallback(array $matches) {
+ // Remove the two exclamation points that represent syntax.
+ $excitement = substr($matches[2], 2);
+
+ // If the internal content consists of ONLY exclamation points, leave it
+ // untouched so "!!!!!" is five exclamation points instead of one
+ // highlighted exclamation point.
+ if (preg_match('/^!+\z/', $matches[1])) {
+ return $matches[0];
+ }
+
+ // $excitement now has two fewer !'s than we started with.
+ return hsprintf('%s%s',
+ $matches[1], $excitement);
+
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupHyperlinkRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupHyperlinkRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupHyperlinkRule.php
@@ -0,0 +1,122 @@
+" around them get linked exactly, without
+ // the "<>". Angle brackets are basically special and mean "this is a URL
+ // with weird characters". This is assumed to be reasonable because they
+ // don't appear in normal text or normal URLs.
+ $text = preg_replace_callback(
+ '@<(\w{3,}://[^\s'.PhutilRemarkupBlockStorage::MAGIC_BYTE.']+?)>@',
+ array($this, 'markupHyperlink'),
+ $text);
+
+ // Anything else we match "ungreedily", which means we'll look for
+ // stuff that's probably puncutation or otherwise not part of the URL and
+ // not link it. This lets someone write "QuicK! Go to
+ // http://www.example.com/!". We also apply some paren balancing rules.
+
+ // NOTE: We're explicitly avoiding capturing stored blocks, so text like
+ // `http://www.example.com/[[x | y]]` doesn't get aggressively captured.
+ $text = preg_replace_callback(
+ '@(\w{3,}://[^\s'.PhutilRemarkupBlockStorage::MAGIC_BYTE.']+)@',
+ array($this, 'markupHyperlinkUngreedy'),
+ $text);
+
+ return $text;
+ }
+
+ protected function markupHyperlink(array $matches) {
+ try {
+ $uri = new PhutilURI($matches[1]);
+ } catch (Exception $ex) {
+ return $matches[0];
+ }
+
+ $protocol = $uri->getProtocol();
+
+ $protocols = $this->getEngine()->getConfig(
+ 'uri.allowed-protocols',
+ array());
+
+ if (!idx($protocols, $protocol)) {
+ // If this URI doesn't use a whitelisted protocol, don't link it. This
+ // is primarily intended to prevent javascript:// silliness.
+ return $this->getEngine()->storeText($matches[1]);
+ }
+
+ return $this->storeRenderedHyperlink($matches[1]);
+ }
+
+ protected function storeRenderedHyperlink($link) {
+ return $this->getEngine()->storeText($this->renderHyperlink($link));
+ }
+
+ protected function renderHyperlink($link) {
+ $engine = $this->getEngine();
+
+ if ($engine->isTextMode()) {
+ return $link;
+ }
+
+ if ($engine->getState('toc')) {
+ return $link;
+ }
+
+ $same_window = $engine->getConfig('uri.same-window', false);
+ if ($same_window) {
+ $target = null;
+ } else {
+ $target = '_blank';
+ }
+
+ return phutil_tag(
+ 'a',
+ array(
+ 'href' => $link,
+ 'class' => 'remarkup-link',
+ 'target' => $target,
+ 'rel' => 'noreferrer',
+ ),
+ $link);
+ }
+
+ protected function markupHyperlinkUngreedy($matches) {
+ $match = $matches[1];
+ $tail = null;
+ $trailing = null;
+ if (preg_match('/[;,.:!?]+$/', $match, $trailing)) {
+ $tail = $trailing[0];
+ $match = substr($match, 0, -strlen($tail));
+ }
+
+ // If there's a closing paren at the end but no balancing open paren in
+ // the URL, don't link the close paren. This is an attempt to gracefully
+ // handle the two common paren cases, Wikipedia links and English language
+ // parentheticals, e.g.:
+ //
+ // http://en.wikipedia.org/wiki/Noun_(disambiguation)
+ // (see also http://www.example.com)
+ //
+ // We could apply a craftier heuristic here which tries to actually balance
+ // the parens, but this is probably sufficient.
+ if (preg_match('/\\)$/', $match) && !preg_match('/\\(/', $match)) {
+ $tail = ')'.$tail;
+ $match = substr($match, 0, -1);
+ }
+
+ try {
+ $uri = new PhutilURI($match);
+ } catch (Exception $ex) {
+ return $matches[0];
+ }
+
+ return hsprintf('%s%s', $this->markupHyperlink(array(null, $match)), $tail);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupItalicRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupItalicRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupItalicRule.php
@@ -0,0 +1,24 @@
+getEngine()->isTextMode()) {
+ return $text;
+ }
+
+ return $this->replaceHTML(
+ '@(?%s', $matches[1]);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupLinebreaksRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupLinebreaksRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupLinebreaksRule.php
@@ -0,0 +1,13 @@
+getEngine()->isTextMode()) {
+ return $text;
+ }
+
+ return phutil_escape_html_newlines($text);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupMonospaceRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupMonospaceRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupMonospaceRule.php
@@ -0,0 +1,49 @@
+getEngine()->isTextMode()) {
+ $result = $matches[0];
+
+ } else
+ if ($this->getEngine()->isHTMLMailMode()) {
+ $match = isset($matches[2]) ? $matches[2] : $matches[1];
+ $result = phutil_tag(
+ 'tt',
+ array(
+ 'style' => 'background: #ebebeb; font-size: 13px;',
+ ),
+ $match);
+
+ } else {
+ $match = isset($matches[2]) ? $matches[2] : $matches[1];
+ $result = phutil_tag(
+ 'tt',
+ array(
+ 'class' => 'remarkup-monospaced',
+ ),
+ $match);
+ }
+
+ return $this->getEngine()->storeText($result);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupRule.php
@@ -0,0 +1,109 @@
+engine = $engine;
+ return $this;
+ }
+
+ public function getEngine() {
+ return $this->engine;
+ }
+
+ public function getPriority() {
+ return 500.0;
+ }
+
+ abstract public function apply($text);
+
+ public function getPostprocessKey() {
+ return spl_object_hash($this);
+ }
+
+ public function didMarkupText() {
+ return;
+ }
+
+ protected function replaceHTML($pattern, $callback, $text) {
+ $this->replaceCallback = $callback;
+ return phutil_safe_html(preg_replace_callback(
+ $pattern,
+ array($this, 'replaceHTMLCallback'),
+ phutil_escape_html($text)));
+ }
+
+ private function replaceHTMLCallback(array $match) {
+ return phutil_escape_html(call_user_func(
+ $this->replaceCallback,
+ array_map('phutil_safe_html', $match)));
+ }
+
+
+ /**
+ * Safely generate a tag.
+ *
+ * In Remarkup contexts, it's not safe to use arbitrary text in tag
+ * attributes: even though it will be escaped, it may contain replacement
+ * tokens which are then replaced with markup.
+ *
+ * This method acts as @{function:phutil_tag}, but checks attributes before
+ * using them.
+ *
+ * @param string Tag name.
+ * @param dict Tag attributes.
+ * @param wild Tag content.
+ * @return PhutilSafeHTML Tag object.
+ */
+ protected function newTag($name, array $attrs, $content = null) {
+ foreach ($attrs as $key => $attr) {
+ if ($attr !== null) {
+ $attrs[$key] = $this->assertFlatText($attr);
+ }
+ }
+
+ return phutil_tag($name, $attrs, $content);
+ }
+
+ /**
+ * Assert that a text token is flat (it contains no replacement tokens).
+ *
+ * Because tokens can be replaced with markup, it is dangerous to use
+ * arbitrary input text in tag attributes. Normally, rule precedence should
+ * prevent this. Asserting that text is flat before using it as an attribute
+ * provides an extra layer of security.
+ *
+ * Normally, you can call @{method:newTag} rather than calling this method
+ * directly. @{method:newTag} will check attributes for you.
+ *
+ * @param wild Ostensibly flat text.
+ * @return string Flat text.
+ */
+ protected function assertFlatText($text) {
+ $text = (string)hsprintf('%s', phutil_safe_html($text));
+ $rich = (strpos($text, PhutilRemarkupBlockStorage::MAGIC_BYTE) !== false);
+ if ($rich) {
+ throw new Exception(
+ pht(
+ 'Remarkup rule precedence is dangerous: rendering text with tokens '.
+ 'as flat text!'));
+ }
+
+ return $text;
+ }
+
+ /**
+ * Check whether text is flat (contains no replacement tokens) or not.
+ *
+ * @param wild Ostensibly flat text.
+ * @return bool True if the text is flat.
+ */
+ protected function isFlatText($text) {
+ $text = (string)hsprintf('%s', phutil_safe_html($text));
+ return (strpos($text, PhutilRemarkupBlockStorage::MAGIC_BYTE) === false);
+ }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/PhutilRemarkupUnderlineRule.php b/src/markup/engine/remarkup/markuprule/PhutilRemarkupUnderlineRule.php
new file mode 100644
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/PhutilRemarkupUnderlineRule.php
@@ -0,0 +1,24 @@
+getEngine()->isTextMode()) {
+ return $text;
+ }
+
+ return $this->replaceHTML(
+ '@(?%s', $matches[1]);
+ }
+
+}
diff --git a/src/markup/render.php b/src/markup/render.php
new file mode 100644
--- /dev/null
+++ b/src/markup/render.php
@@ -0,0 +1,251 @@
+` tags, if the `rel` attribute is not specified, it
+ * is interpreted as `rel="noreferrer"`.
+ * - When rendering `` tags, the `href` attribute may not begin with
+ * `javascript:`.
+ *
+ * These special cases can not be disabled.
+ *
+ * IMPORTANT: The `$tag` attribute and the keys of the `$attributes` array are
+ * trusted blindly, and not escaped. You should not pass user data in these
+ * parameters.
+ *
+ * @param string The name of the tag, like `a` or `div`.
+ * @param map A map of tag attributes.
+ * @param wild Content to put in the tag.
+ * @return PhutilSafeHTML Tag object.
+ */
+function phutil_tag($tag, array $attributes = array(), $content = null) {
+ // If the `href` attribute is present, make sure it is not a "javascript:"
+ // URI. We never permit these.
+ if (!empty($attributes['href'])) {
+ // This might be a URI object, so cast it to a string.
+ $href = (string)$attributes['href'];
+
+ if (isset($href[0])) {
+ // Block 'javascript:' hrefs at the tag level: no well-designed
+ // application should ever use them, and they are a potent attack vector.
+
+ // This function is deep in the core and performance sensitive, so we're
+ // doing a cheap version of this test first to avoid calling preg_match()
+ // on URIs which begin with '/' or `#`. These cover essentially all URIs
+ // in Phabricator.
+ if (($href[0] !== '/') && ($href[0] !== '#')) {
+ // Chrome 33 and IE 11 both interpret "javascript\n:" as a Javascript
+ // URI, and all browsers interpret " javascript:" as a Javascript URI,
+ // so be aggressive about looking for "javascript:" in the initial
+ // section of the string.
+
+ $normalized_href = preg_replace('([^a-z0-9/:]+)i', '', $href);
+ if (preg_match('/^javascript:/i', $normalized_href)) {
+ throw new Exception(
+ pht(
+ "Attempting to render a tag with an '%s' attribute that begins ".
+ "with '%s'. This is either a serious security concern or a ".
+ "serious architecture concern. Seek urgent remedy.",
+ 'href',
+ 'javascript:'));
+ }
+ }
+ }
+ }
+
+ // For tags which can't self-close, treat null as the empty string -- for
+ // example, always render ``, never ``.
+ static $self_closing_tags = array(
+ 'area' => true,
+ 'base' => true,
+ 'br' => true,
+ 'col' => true,
+ 'command' => true,
+ 'embed' => true,
+ 'frame' => true,
+ 'hr' => true,
+ 'img' => true,
+ 'input' => true,
+ 'keygen' => true,
+ 'link' => true,
+ 'meta' => true,
+ 'param' => true,
+ 'source' => true,
+ 'track' => true,
+ 'wbr' => true,
+ );
+
+ $attr_string = '';
+ foreach ($attributes as $k => $v) {
+ if ($v === null) {
+ continue;
+ }
+ $v = phutil_escape_html($v);
+ $attr_string .= ' '.$k.'="'.$v.'"';
+ }
+
+ if ($content === null) {
+ if (isset($self_closing_tags[$tag])) {
+ return new PhutilSafeHTML('<'.$tag.$attr_string.' />');
+ } else {
+ $content = '';
+ }
+ } else {
+ $content = phutil_escape_html($content);
+ }
+
+ return new PhutilSafeHTML('<'.$tag.$attr_string.'>'.$content.'');
+}
+
+function phutil_tag_div($class, $content = null) {
+ return phutil_tag('div', array('class' => $class), $content);
+}
+
+function phutil_escape_html($string) {
+ if ($string instanceof PhutilSafeHTML) {
+ return $string;
+ } else if ($string instanceof PhutilSafeHTMLProducerInterface) {
+ $result = $string->producePhutilSafeHTML();
+ if ($result instanceof PhutilSafeHTML) {
+ return phutil_escape_html($result);
+ } else if (is_array($result)) {
+ return phutil_escape_html($result);
+ } else if ($result instanceof PhutilSafeHTMLProducerInterface) {
+ return phutil_escape_html($result);
+ } else {
+ try {
+ assert_stringlike($result);
+ return phutil_escape_html((string)$result);
+ } catch (Exception $ex) {
+ throw new Exception(
+ pht(
+ "Object (of class '%s') implements %s but did not return anything ".
+ "renderable from %s.",
+ get_class($string),
+ 'PhutilSafeHTMLProducerInterface',
+ 'producePhutilSafeHTML()'));
+ }
+ }
+ } else if (is_array($string)) {
+ $result = '';
+ foreach ($string as $item) {
+ $result .= phutil_escape_html($item);
+ }
+ return $result;
+ }
+
+ return htmlspecialchars($string, ENT_QUOTES, 'UTF-8');
+}
+
+function phutil_escape_html_newlines($string) {
+ return PhutilSafeHTML::applyFunction('nl2br', $string);
+}
+
+/**
+ * Mark string as safe for use in HTML.
+ */
+function phutil_safe_html($string) {
+ if ($string == '') {
+ return $string;
+ } else if ($string instanceof PhutilSafeHTML) {
+ return $string;
+ } else {
+ return new PhutilSafeHTML($string);
+ }
+}
+
+/**
+ * HTML safe version of `implode()`.
+ */
+function phutil_implode_html($glue, array $pieces) {
+ $glue = phutil_escape_html($glue);
+
+ foreach ($pieces as $k => $piece) {
+ $pieces[$k] = phutil_escape_html($piece);
+ }
+
+ return phutil_safe_html(implode($glue, $pieces));
+}
+
+/**
+ * Format a HTML code. This function behaves like `sprintf()`, except that all
+ * the normal conversions (like %s) will be properly escaped.
+ */
+function hsprintf($html /* , ... */) {
+ $args = func_get_args();
+ array_shift($args);
+ return new PhutilSafeHTML(
+ vsprintf($html, array_map('phutil_escape_html', $args)));
+}
+
+
+/**
+ * Escape text for inclusion in a URI or a query parameter. Note that this
+ * method does NOT escape '/', because "%2F" is invalid in paths and Apache
+ * will automatically 404 the page if it's present. This will produce correct
+ * (the URIs will work) and desirable (the URIs will be readable) behavior in
+ * these cases:
+ *
+ * '/path/?param='.phutil_escape_uri($string); # OK: Query Parameter
+ * '/path/to/'.phutil_escape_uri($string); # OK: URI Suffix
+ *
+ * It will potentially produce the WRONG behavior in this special case:
+ *
+ * COUNTEREXAMPLE
+ * '/path/to/'.phutil_escape_uri($string).'/thing/'; # BAD: URI Infix
+ *
+ * In this case, any '/' characters in the string will not be escaped, so you
+ * will not be able to distinguish between the string and the suffix (unless
+ * you have more information, like you know the format of the suffix). For infix
+ * URI components, use @{function:phutil_escape_uri_path_component} instead.
+ *
+ * @param string Some string.
+ * @return string URI encoded string, except for '/'.
+ */
+function phutil_escape_uri($string) {
+ return str_replace('%2F', '/', rawurlencode($string));
+}
+
+
+/**
+ * Escape text for inclusion as an infix URI substring. See discussion at
+ * @{function:phutil_escape_uri}. This function covers an unusual special case;
+ * @{function:phutil_escape_uri} is usually the correct function to use.
+ *
+ * This function will escape a string into a format which is safe to put into
+ * a URI path and which does not contain '/' so it can be correctly parsed when
+ * embedded as a URI infix component.
+ *
+ * However, you MUST decode the string with
+ * @{function:phutil_unescape_uri_path_component} before it can be used in the
+ * application.
+ *
+ * @param string Some string.
+ * @return string URI encoded string that is safe for infix composition.
+ */
+function phutil_escape_uri_path_component($string) {
+ return rawurlencode(rawurlencode($string));
+}
+
+
+/**
+ * Unescape text that was escaped by
+ * @{function:phutil_escape_uri_path_component}. See
+ * @{function:phutil_escape_uri} for discussion.
+ *
+ * Note that this function is NOT the inverse of
+ * @{function:phutil_escape_uri_path_component}! It undoes additional escaping
+ * which is added to survive the implied unescaping performed by the webserver
+ * when interpreting the request.
+ *
+ * @param string Some string emitted
+ * from @{function:phutil_escape_uri_path_component} and
+ * then accessed via a web server.
+ * @return string Original string.
+ */
+function phutil_unescape_uri_path_component($string) {
+ return rawurldecode($string);
+}
diff --git a/src/markup/syntax/engine/PhutilDefaultSyntaxHighlighterEngine.php b/src/markup/syntax/engine/PhutilDefaultSyntaxHighlighterEngine.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/engine/PhutilDefaultSyntaxHighlighterEngine.php
@@ -0,0 +1,115 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getLanguageFromFilename($filename) {
+ static $default_map = array(
+ // All files which have file extensions that we haven't already matched
+ // map to their extensions.
+ '@\\.([^./]+)$@' => 1,
+ );
+
+ $maps = array();
+ if (!empty($this->config['filename.map'])) {
+ $maps[] = $this->config['filename.map'];
+ }
+ $maps[] = $default_map;
+
+ foreach ($maps as $map) {
+ foreach ($map as $regexp => $lang) {
+ $matches = null;
+ if (preg_match($regexp, $filename, $matches)) {
+ if (is_numeric($lang)) {
+ return idx($matches, $lang);
+ } else {
+ return $lang;
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public function getHighlightFuture($language, $source) {
+ if ($language === null) {
+ $language = PhutilLanguageGuesser::guessLanguage($source);
+ }
+
+ $have_pygments = !empty($this->config['pygments.enabled']);
+
+ if ($language == 'php' && PhutilXHPASTBinary::isAvailable()) {
+ return id(new PhutilXHPASTSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'console') {
+ return id(new PhutilConsoleSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'diviner' || $language == 'remarkup') {
+ return id(new PhutilDivinerSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'rainbow') {
+ return id(new PhutilRainbowSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'php') {
+ return id(new PhutilLexerSyntaxHighlighter())
+ ->setConfig('lexer', new PhutilPHPFragmentLexer())
+ ->setConfig('language', 'php')
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'py') {
+ return id(new PhutilLexerSyntaxHighlighter())
+ ->setConfig('lexer', new PhutilPythonFragmentLexer())
+ ->setConfig('language', 'py')
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'java') {
+ return id(new PhutilLexerSyntaxHighlighter())
+ ->setConfig('lexer', new PhutilJavaFragmentLexer())
+ ->setConfig('language', 'java')
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'json') {
+ return id(new PhutilLexerSyntaxHighlighter())
+ ->setConfig('lexer', new PhutilJSONFragmentLexer())
+ ->getHighlightFuture($source);
+ }
+
+ if ($language == 'invisible') {
+ return id(new PhutilInvisibleSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+ // Don't invoke Pygments for plain text, since it's expensive and has
+ // no effect.
+ if ($language !== 'text' && $language !== 'txt') {
+ if ($have_pygments) {
+ return id(new PhutilPygmentsSyntaxHighlighter())
+ ->setConfig('language', $language)
+ ->getHighlightFuture($source);
+ }
+ }
+
+ return id(new PhutilDefaultSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+}
diff --git a/src/markup/syntax/engine/PhutilSyntaxHighlighterEngine.php b/src/markup/syntax/engine/PhutilSyntaxHighlighterEngine.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/engine/PhutilSyntaxHighlighterEngine.php
@@ -0,0 +1,19 @@
+getHighlightFuture($language, $source)->resolve();
+ } catch (PhutilSyntaxHighlighterException $ex) {
+ return id(new PhutilDefaultSyntaxHighlighter())
+ ->getHighlightFuture($source)
+ ->resolve();
+ }
+ }
+
+}
diff --git a/src/markup/syntax/engine/__tests__/PhutilDefaultSyntaxHighlighterEngineTestCase.php b/src/markup/syntax/engine/__tests__/PhutilDefaultSyntaxHighlighterEngineTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/engine/__tests__/PhutilDefaultSyntaxHighlighterEngineTestCase.php
@@ -0,0 +1,28 @@
+ 'php',
+ '/x.php' => 'php',
+ 'x.y.php' => 'php',
+ '/x.y/z.php' => 'php',
+ '/x.php/' => null,
+ );
+
+ $engine = new PhutilDefaultSyntaxHighlighterEngine();
+ foreach ($names as $path => $language) {
+ $detect = $engine->getLanguageFromFilename($path);
+ $this->assertEqual(
+ $language,
+ $detect,
+ pht('Language detect for %s', $path));
+ }
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilConsoleSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilConsoleSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilConsoleSyntaxHighlighter.php
@@ -0,0 +1,51 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getHighlightFuture($source) {
+ $in_command = false;
+ $lines = explode("\n", $source);
+ foreach ($lines as $key => $line) {
+ $matches = null;
+
+ // Parse commands like this:
+ //
+ // some/path/ $ ./bin/example # Do things
+ //
+ // ...into path, command, and comment components.
+
+ $pattern =
+ '@'.
+ ($in_command ? '()(.*?)' : '^(\S+[\\\\/] )?([$] .*?)').
+ '(#.*|\\\\)?$@';
+
+ if (preg_match($pattern, $line, $matches)) {
+ $lines[$key] = hsprintf(
+ '%s%s%s',
+ $matches[1],
+ $matches[2],
+ (!empty($matches[3])
+ ? hsprintf('%s', $matches[3])
+ : ''));
+ $in_command = (idx($matches, 3) == '\\');
+ } else {
+ $lines[$key] = hsprintf('%s', $line);
+ }
+ }
+ $lines = phutil_implode_html("\n", $lines);
+
+ return new ImmediateFuture($lines);
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilDefaultSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilDefaultSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilDefaultSyntaxHighlighter.php
@@ -0,0 +1,14 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getHighlightFuture($source) {
+ $source = phutil_escape_html($source);
+
+ // This highlighter isn't perfect but tries to do an okay job at getting
+ // some of the basics at least. There's lots of room for improvement.
+
+ $blocks = explode("\n\n", $source);
+ foreach ($blocks as $key => $block) {
+ if (preg_match('/^[^ ](?! )/m', $block)) {
+ $blocks[$key] = $this->highlightBlock($block);
+ }
+ }
+ $source = implode("\n\n", $blocks);
+
+ $source = phutil_safe_html($source);
+ return new ImmediateFuture($source);
+ }
+
+ private function highlightBlock($source) {
+ // Highlight "@{class:...}" links to other documentation pages.
+ $source = $this->highlightPattern('/@{([\w@]+?):([^}]+?)}/', $source, 'nc');
+
+ // Highlight "@title", "@group", etc.
+ $source = $this->highlightPattern('/^@(\w+)/m', $source, 'k');
+
+ // Highlight bold, italic and monospace.
+ $source = $this->highlightPattern('@\\*\\*(.+?)\\*\\*@s', $source, 's');
+ $source = $this->highlightPattern('@(?highlightPattern(
+ '@##([\s\S]+?)##|\B`(.+?)`\B@',
+ $source,
+ 's');
+
+ // Highlight stuff that looks like headers.
+ $source = $this->highlightPattern('/^=(.*)$/m', $source, 'nv');
+
+ return $source;
+ }
+
+ private function highlightPattern($regexp, $source, $class) {
+ $this->replaceClass = $class;
+ $source = preg_replace_callback(
+ $regexp,
+ array($this, 'replacePattern'),
+ $source);
+
+ return $source;
+ }
+
+ public function replacePattern($matches) {
+
+ // NOTE: The goal here is to make sure a never crosses a newline.
+
+ $content = $matches[0];
+ $content = explode("\n", $content);
+ foreach ($content as $key => $line) {
+ $content[$key] =
+ ''.
+ $line.
+ '';
+ }
+ return implode("\n", $content);
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilInvisibleSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilInvisibleSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilInvisibleSyntaxHighlighter.php
@@ -0,0 +1,43 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getHighlightFuture($source) {
+ $keys = array_map('chr', range(0x0, 0x1F));
+ $vals = array_map(
+ array($this, 'decimalToHtmlEntityDecoded'), range(0x2400, 0x241F));
+
+ $invisible = array_combine($keys, $vals);
+
+ $result = array();
+ foreach (str_split($source) as $character) {
+ if (isset($invisible[$character])) {
+ $result[] = phutil_tag(
+ 'span',
+ array('class' => 'invisible'),
+ $invisible[$character]);
+
+ if ($character === "\n") {
+ $result[] = $character;
+ }
+ } else {
+ $result[] = $character;
+ }
+ }
+
+ $result = phutil_implode_html('', $result);
+ return new ImmediateFuture($result);
+ }
+
+ private function decimalToHtmlEntityDecoded($dec) {
+ return html_entity_decode("&#{$dec};");
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilLexerSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilLexerSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilLexerSyntaxHighlighter.php
@@ -0,0 +1,72 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getHighlightFuture($source) {
+ $strip = false;
+ $state = 'start';
+ $lang = idx($this->config, 'language');
+
+ if ($lang == 'php') {
+ if (strpos($source, 'config, 'lexer');
+ $tokens = $lexer->getTokens($source, $state);
+ $tokens = $lexer->mergeTokens($tokens);
+
+ $result = array();
+ foreach ($tokens as $token) {
+ list($type, $value, $context) = $token;
+
+ $data_name = null;
+ switch ($type) {
+ case 'nc':
+ case 'nf':
+ case 'na':
+ $data_name = $value;
+ break;
+ }
+
+ if (strpos($value, "\n") !== false) {
+ $value = explode("\n", $value);
+ } else {
+ $value = array($value);
+ }
+ foreach ($value as $part) {
+ if (strlen($part)) {
+ if ($type) {
+ $result[] = phutil_tag(
+ 'span',
+ array(
+ 'class' => $type,
+ 'data-symbol-context' => $context,
+ 'data-symbol-name' => $data_name,
+ ),
+ $part);
+ } else {
+ $result[] = $part;
+ }
+ }
+ $result[] = "\n";
+ }
+
+ // Throw away the last "\n".
+ array_pop($result);
+ }
+
+ $result = phutil_implode_html('', $result);
+
+ return new ImmediateFuture($result);
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilPygmentsSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilPygmentsSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilPygmentsSyntaxHighlighter.php
@@ -0,0 +1,216 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getHighlightFuture($source) {
+ $language = idx($this->config, 'language');
+
+ if (preg_match('/\r(?!\n)/', $source)) {
+ // TODO: Pygments converts "\r" newlines into "\n" newlines, so we can't
+ // use it on files with "\r" newlines. If we have "\r" not followed by
+ // "\n" in the file, skip highlighting.
+ $language = null;
+ }
+
+ if ($language) {
+ $language = $this->getPygmentsLexerNameFromLanguageName($language);
+ $future = new ExecFuture(
+ 'pygmentize -O encoding=utf-8 -O stripnl=False -f html -l %s',
+ $language);
+ $scrub = false;
+ if ($language == 'php' && strpos($source, 'write($source);
+ return new PhutilDefaultSyntaxHighlighterEnginePygmentsFuture(
+ $future,
+ $source,
+ $scrub);
+ }
+
+ return id(new PhutilDefaultSyntaxHighlighter())
+ ->getHighlightFuture($source);
+ }
+
+ private function getPygmentsLexerNameFromLanguageName($language) {
+ static $map = array(
+ 'adb' => 'ada',
+ 'ads' => 'ada',
+ 'ahkl' => 'ahk',
+ 'as' => 'as3',
+ 'asax' => 'aspx-vb',
+ 'ascx' => 'aspx-vb',
+ 'ashx' => 'aspx-vb',
+ 'ASM' => 'nasm',
+ 'asm' => 'nasm',
+ 'asmx' => 'aspx-vb',
+ 'aspx' => 'aspx-vb',
+ 'autodelegate' => 'myghty',
+ 'autohandler' => 'mason',
+ 'aux' => 'tex',
+ 'axd' => 'aspx-vb',
+ 'b' => 'brainfuck',
+ 'bas' => 'vb.net',
+ 'bf' => 'brainfuck',
+ 'bmx' => 'blitzmax',
+ 'c++' => 'cpp',
+ 'c++-objdump' => 'cpp-objdump',
+ 'cc' => 'cpp',
+ 'cfc' => 'cfm',
+ 'cfg' => 'ini',
+ 'cfml' => 'cfm',
+ 'cl' => 'common-lisp',
+ 'clj' => 'clojure',
+ 'cmd' => 'bat',
+ 'coffee' => 'coffee-script',
+ 'cs' => 'csharp',
+ 'csh' => 'tcsh',
+ 'cw' => 'redcode',
+ 'cxx' => 'cpp',
+ 'cxx-objdump' => 'cpp-objdump',
+ 'darcspatch' => 'dpatch',
+ 'def' => 'modula2',
+ 'dhandler' => 'mason',
+ 'di' => 'd',
+ 'duby' => 'rb',
+ 'dyl' => 'dylan',
+ 'ebuild' => 'bash',
+ 'eclass' => 'bash',
+ 'el' => 'common-lisp',
+ 'eps' => 'postscript',
+ 'erl' => 'erlang',
+ 'erl-sh' => 'erl',
+ 'f' => 'fortran',
+ 'f90' => 'fortran',
+ 'feature' => 'Cucumber',
+ 'fhtml' => 'velocity',
+ 'flx' => 'felix',
+ 'flxh' => 'felix',
+ 'frag' => 'glsl',
+ 'g' => 'antlr-ruby',
+ 'G' => 'antlr-ruby',
+ 'gdc' => 'gooddata-cl',
+ 'gemspec' => 'rb',
+ 'geo' => 'glsl',
+ 'GNUmakefile' => 'make',
+ 'h' => 'c',
+ 'h++' => 'cpp',
+ 'hh' => 'cpp',
+ 'hpp' => 'cpp',
+ 'hql' => 'sql',
+ 'hrl' => 'erlang',
+ 'hs' => 'haskell',
+ 'htaccess' => 'apacheconf',
+ 'htm' => 'html',
+ 'html' => 'html+evoque',
+ 'hxx' => 'cpp',
+ 'hy' => 'hybris',
+ 'hyb' => 'hybris',
+ 'ik' => 'ioke',
+ 'inc' => 'pov',
+ 'j' => 'objective-j',
+ 'jbst' => 'duel',
+ 'kid' => 'genshi',
+ 'ksh' => 'bash',
+ 'less' => 'css',
+ 'lgt' => 'logtalk',
+ 'lisp' => 'common-lisp',
+ 'll' => 'llvm',
+ 'm' => 'objective-c',
+ 'mak' => 'make',
+ 'Makefile' => 'make',
+ 'makefile' => 'make',
+ 'man' => 'groff',
+ 'mao' => 'mako',
+ 'mc' => 'mason',
+ 'md' => 'minid',
+ 'mhtml' => 'mason',
+ 'mi' => 'mason',
+ 'ml' => 'ocaml',
+ 'mli' => 'ocaml',
+ 'mll' => 'ocaml',
+ 'mly' => 'ocaml',
+ 'mm' => 'objective-c',
+ 'mo' => 'modelica',
+ 'mod' => 'modula2',
+ 'moo' => 'moocode',
+ 'mu' => 'mupad',
+ 'myt' => 'myghty',
+ 'ns2' => 'newspeak',
+ 'pas' => 'delphi',
+ 'patch' => 'diff',
+ 'phtml' => 'html+php',
+ 'pl' => 'prolog',
+ 'plot' => 'gnuplot',
+ 'plt' => 'gnuplot',
+ 'pm' => 'perl',
+ 'po' => 'pot',
+ 'pp' => 'puppet',
+ 'pro' => 'prolog',
+ 'proto' => 'protobuf',
+ 'ps' => 'postscript',
+ 'pxd' => 'cython',
+ 'pxi' => 'cython',
+ 'py' => 'python',
+ 'pyw' => 'python',
+ 'pyx' => 'cython',
+ 'R' => 'splus',
+ 'r' => 'rebol',
+ 'r3' => 'rebol',
+ 'rake' => 'rb',
+ 'Rakefile' => 'rb',
+ 'rbw' => 'rb',
+ 'rbx' => 'rb',
+ 'rest' => 'rst',
+ 'rl' => 'ragel-em',
+ 'robot' => 'robotframework',
+ 'Rout' => 'rconsole',
+ 'rss' => 'xml',
+ 's' => 'gas',
+ 'S' => 'splus',
+ 'sc' => 'python',
+ 'scm' => 'scheme',
+ 'SConscript' => 'python',
+ 'SConstruct' => 'python',
+ 'scss' => 'css',
+ 'sh' => 'bash',
+ 'sh-session' => 'console',
+ 'spt' => 'cheetah',
+ 'sqlite3-console' => 'sqlite3',
+ 'st' => 'smalltalk',
+ 'sv' => 'v',
+ 'tac' => 'python',
+ 'tmpl' => 'cheetah',
+ 'toc' => 'tex',
+ 'tpl' => 'smarty',
+ 'txt' => 'text',
+ 'vapi' => 'vala',
+ 'vb' => 'vb.net',
+ 'vert' => 'glsl',
+ 'vhd' => 'vhdl',
+ 'vimrc' => 'vim',
+ 'vm' => 'velocity',
+ 'weechatlog' => 'irc',
+ 'wlua' => 'lua',
+ 'wsdl' => 'xml',
+ 'xhtml' => 'html',
+ 'xml' => 'xml+evoque',
+ 'xqy' => 'xquery',
+ 'xsd' => 'xml',
+ 'xsl' => 'xslt',
+ 'xslt' => 'xml',
+ 'yml' => 'yaml',
+ );
+
+ return idx($map, $language, $language);
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilRainbowSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilRainbowSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilRainbowSyntaxHighlighter.php
@@ -0,0 +1,46 @@
+config[$key] = $value;
+ return $this;
+ }
+
+ public function getHighlightFuture($source) {
+
+ $color = 0;
+ $colors = array(
+ 'rbw_r',
+ 'rbw_o',
+ 'rbw_y',
+ 'rbw_g',
+ 'rbw_b',
+ 'rbw_i',
+ 'rbw_v',
+ );
+
+ $result = array();
+ foreach (phutil_utf8v($source) as $character) {
+ if ($character == ' ' || $character == "\n") {
+ $result[] = $character;
+ continue;
+ }
+ $result[] = phutil_tag(
+ 'span',
+ array('class' => $colors[$color]),
+ $character);
+ $color = ($color + 1) % count($colors);
+ }
+
+ $result = phutil_implode_html('', $result);
+ return new ImmediateFuture($result);
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/PhutilSyntaxHighlighter.php b/src/markup/syntax/highlighter/PhutilSyntaxHighlighter.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/PhutilSyntaxHighlighter.php
@@ -0,0 +1,6 @@
+setConfig('language', 'json')
+ ->setConfig('lexer', new PhutilJSONFragmentLexer());
+
+ $path = dirname(__FILE__).'/data/jsonfragment/';
+ foreach (Filesystem::listDirectory($path, $include_hidden = false) as $f) {
+ if (preg_match('/.test$/', $f)) {
+ $expect = preg_replace('/.test$/', '.expect', $f);
+ $source = Filesystem::readFile($path.'/'.$f);
+
+ $this->assertEqual(
+ Filesystem::readFile($path.'/'.$expect),
+ (string)$highlighter->getHighlightFuture($source)->resolve(),
+ $f);
+ }
+ }
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/__tests__/PhutilPHPFragmentLexerHighlighterTestCase.php b/src/markup/syntax/highlighter/__tests__/PhutilPHPFragmentLexerHighlighterTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/PhutilPHPFragmentLexerHighlighterTestCase.php
@@ -0,0 +1,25 @@
+setConfig('language', 'php');
+ $highlighter->setConfig('lexer', new PhutilPHPFragmentLexer());
+
+
+ $path = dirname(__FILE__).'/phpfragment/';
+ foreach (Filesystem::listDirectory($path, $include_hidden = false) as $f) {
+ if (preg_match('/.test$/', $f)) {
+ $expect = preg_replace('/.test$/', '.expect', $f);
+ $source = Filesystem::readFile($path.'/'.$f);
+
+ $this->assertEqual(
+ Filesystem::readFile($path.'/'.$expect),
+ (string)$highlighter->getHighlightFuture($source)->resolve(),
+ $f);
+ }
+ }
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/__tests__/PhutilXHPASTSyntaxHighlighterTestCase.php b/src/markup/syntax/highlighter/__tests__/PhutilXHPASTSyntaxHighlighterTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/PhutilXHPASTSyntaxHighlighterTestCase.php
@@ -0,0 +1,39 @@
+getHighlightFuture($source);
+ return $future->resolve();
+ }
+
+ private function read($file) {
+ $path = dirname(__FILE__).'/xhpast/'.$file;
+ return Filesystem::readFile($path);
+ }
+
+ public function testBuiltinClassnames() {
+ $this->assertEqual(
+ $this->read('builtin-classname.expect'),
+ (string)$this->highlight($this->read('builtin-classname.source')),
+ pht('Builtin classnames should not be marked as linkable symbols.'));
+ $this->assertEqual(
+ rtrim($this->read('trailing-comment.expect')),
+ (string)$this->highlight($this->read('trailing-comment.source')),
+ pht('Trailing comments should not be dropped.'));
+ $this->assertEqual(
+ $this->read('multiline-token.expect'),
+ (string)$this->highlight($this->read('multiline-token.source')),
+ pht('Multi-line tokens should be split across lines.'));
+ $this->assertEqual(
+ $this->read('leading-whitespace.expect'),
+ (string)$this->highlight($this->read('leading-whitespace.source')),
+ pht('Snippets with leading whitespace should be preserved.'));
+ $this->assertEqual(
+ $this->read('no-leading-whitespace.expect'),
+ (string)$this->highlight($this->read('no-leading-whitespace.source')),
+ pht('Snippets with no leading whitespace should be preserved.'));
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/__tests__/data/jsonfragment/basics.expect b/src/markup/syntax/highlighter/__tests__/data/jsonfragment/basics.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/data/jsonfragment/basics.expect
@@ -0,0 +1,12 @@
+{
+ "key": 3.5,
+ "true": true,
+ "false": false,
+ "null": null,
+ "list": [1, 2, 3],
+ "object": {
+ "k1": "v1"
+ },
+ "numbers": [0e1, 1e-1, -1e-1, -1e+1],
+ "\"\u1234'abc[]{}..."
+}
diff --git a/src/markup/syntax/highlighter/__tests__/data/jsonfragment/basics.test b/src/markup/syntax/highlighter/__tests__/data/jsonfragment/basics.test
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/data/jsonfragment/basics.test
@@ -0,0 +1,12 @@
+{
+ "key": 3.5,
+ "true": true,
+ "false": false,
+ "null": null,
+ "list": [1, 2, 3],
+ "object": {
+ "k1": "v1"
+ },
+ "numbers": [0e1, 1e-1, -1e-1, -1e+1],
+ "\"\u1234'abc[]{}..."
+}
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/abuse.expect b/src/markup/syntax/highlighter/__tests__/phpfragment/abuse.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/abuse.expect
@@ -0,0 +1,16 @@
+<?
+
+// comment? comment! ?>
+
+data
+
+<?php
+
+__halt_compiler /* ! */ ( // )
+) /* ;;;; */
+
+;
+
+data data
+<?php
+data
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/abuse.test b/src/markup/syntax/highlighter/__tests__/phpfragment/abuse.test
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/abuse.test
@@ -0,0 +1,16 @@
+
+
+data
+
+public function f() {
+ ExampleClass::EXAMPLE_CONSTANT;
+ ExampleClass::exampleMethod();
+ example_function();
+}
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/basics.test b/src/markup/syntax/highlighter/__tests__/phpfragment/basics.test
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/basics.test
@@ -0,0 +1,5 @@
+public function f() {
+ ExampleClass::EXAMPLE_CONSTANT;
+ ExampleClass::exampleMethod();
+ example_function();
+}
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/leading-whitespace.expect b/src/markup/syntax/highlighter/__tests__/phpfragment/leading-whitespace.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/leading-whitespace.expect
@@ -0,0 +1,3 @@
+ foreach ($x as $y) {
+ z();
+ }
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/leading-whitespace.test b/src/markup/syntax/highlighter/__tests__/phpfragment/leading-whitespace.test
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/leading-whitespace.test
@@ -0,0 +1,3 @@
+ foreach ($x as $y) {
+ z();
+ }
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/no-leading-whitespace.expect b/src/markup/syntax/highlighter/__tests__/phpfragment/no-leading-whitespace.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/no-leading-whitespace.expect
@@ -0,0 +1,3 @@
+foreach ($x as $y) {
+ z();
+}
diff --git a/src/markup/syntax/highlighter/__tests__/phpfragment/no-leading-whitespace.test b/src/markup/syntax/highlighter/__tests__/phpfragment/no-leading-whitespace.test
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/phpfragment/no-leading-whitespace.test
@@ -0,0 +1,3 @@
+foreach ($x as $y) {
+ z();
+}
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/builtin-classname.expect b/src/markup/syntax/highlighter/__tests__/xhpast/builtin-classname.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/builtin-classname.expect
@@ -0,0 +1,10 @@
+<?php
+
+class C {
+ public function f() {
+ D::X;
+ self::X;
+ parent::X;
+ static::X;
+ }
+}
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/builtin-classname.source b/src/markup/syntax/highlighter/__tests__/xhpast/builtin-classname.source
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/builtin-classname.source
@@ -0,0 +1,10 @@
+foreach ($x as $y) {
+ z();
+ }
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/leading-whitespace.source b/src/markup/syntax/highlighter/__tests__/xhpast/leading-whitespace.source
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/leading-whitespace.source
@@ -0,0 +1,3 @@
+ foreach ($x as $y) {
+ z();
+ }
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/multiline-token.expect b/src/markup/syntax/highlighter/__tests__/xhpast/multiline-token.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/multiline-token.expect
@@ -0,0 +1,5 @@
+<?php
+
+/* this comment
+extends across
+multiple lines */
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/multiline-token.source b/src/markup/syntax/highlighter/__tests__/xhpast/multiline-token.source
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/multiline-token.source
@@ -0,0 +1,5 @@
+foreach ($x as $y) {
+ z();
+}
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/no-leading-whitespace.source b/src/markup/syntax/highlighter/__tests__/xhpast/no-leading-whitespace.source
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/no-leading-whitespace.source
@@ -0,0 +1,3 @@
+foreach ($x as $y) {
+ z();
+}
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/trailing-comment.expect b/src/markup/syntax/highlighter/__tests__/xhpast/trailing-comment.expect
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/trailing-comment.expect
@@ -0,0 +1,3 @@
+<?php
+// xyz
+
diff --git a/src/markup/syntax/highlighter/__tests__/xhpast/trailing-comment.source b/src/markup/syntax/highlighter/__tests__/xhpast/trailing-comment.source
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/__tests__/xhpast/trailing-comment.source
@@ -0,0 +1,2 @@
+source = $source;
+ $this->scrub = $scrub;
+ }
+
+ protected function didReceiveResult($result) {
+ list($err, $stdout, $stderr) = $result;
+
+ if (!$err && strlen($stdout)) {
+ // Strip off fluff Pygments adds.
+ $stdout = preg_replace(
+ '@^(.*)
\s*$@s',
+ '\1',
+ $stdout);
+ if ($this->scrub) {
+ $stdout = preg_replace('/^.*\n/', '', $stdout);
+ }
+ return phutil_safe_html($stdout);
+ }
+
+ throw new PhutilSyntaxHighlighterException($stderr, $err);
+ }
+
+}
diff --git a/src/markup/syntax/highlighter/xhpast/PhutilXHPASTSyntaxHighlighterFuture.php b/src/markup/syntax/highlighter/xhpast/PhutilXHPASTSyntaxHighlighterFuture.php
new file mode 100644
--- /dev/null
+++ b/src/markup/syntax/highlighter/xhpast/PhutilXHPASTSyntaxHighlighterFuture.php
@@ -0,0 +1,262 @@
+source = $source;
+ $this->scrub = $scrub;
+ }
+
+ protected function didReceiveResult($result) {
+ try {
+ return $this->applyXHPHighlight($result);
+ } catch (Exception $ex) {
+ // XHP can't highlight source that isn't syntactically valid. Fall back
+ // to the fragment lexer.
+ $source = ($this->scrub
+ ? preg_replace('/^.*\n/', '', $this->source)
+ : $this->source);
+ return id(new PhutilLexerSyntaxHighlighter())
+ ->setConfig('lexer', new PhutilPHPFragmentLexer())
+ ->setConfig('language', 'php')
+ ->getHighlightFuture($source)
+ ->resolve();
+ }
+ }
+
+ private function applyXHPHighlight($result) {
+
+ // We perform two passes here: one using the AST to find symbols we care
+ // about -- particularly, class names and function names. These are used
+ // in the crossreference stuff to link into Diffusion. After we've done our
+ // AST pass, we do a followup pass on the token stream to catch all the
+ // simple stuff like strings and comments.
+
+ $tree = XHPASTTree::newFromDataAndResolvedExecFuture(
+ $this->source,
+ $result);
+
+ $root = $tree->getRootNode();
+
+ $tokens = $root->getTokens();
+ $interesting_symbols = $this->findInterestingSymbols($root);
+
+
+ if ($this->scrub) {
+ // If we're scrubbing, we prepended "= 2) {
+ if ($tokens[0]->getTypeName() === 'T_OPEN_TAG') {
+ if ($tokens[1]->getTypeName() === 'T_WHITESPACE') {
+ $ok = true;
+ }
+ }
+ }
+
+ if (!$ok) {
+ throw new Exception(
+ pht(
+ 'Expected T_OPEN_TAG, T_WHITESPACE tokens at head of results '.
+ 'for highlighting parse of PHP snippet.'));
+ }
+
+ // Remove the "getValue();
+ if ((strlen($value) < 1) || ($value[0] != "\n")) {
+ throw new Exception(
+ pht(
+ 'Expected "\\n" at beginning of T_WHITESPACE token at head of '.
+ 'tokens for highlighting parse of PHP snippet.'));
+ }
+
+ $value = substr($value, 1);
+ $tokens[1]->overwriteValue($value);
+ }
+
+ $out = array();
+ foreach ($tokens as $key => $token) {
+ $value = $token->getValue();
+ $class = null;
+ $multi = false;
+ $attrs = array();
+ if (isset($interesting_symbols[$key])) {
+ $sym = $interesting_symbols[$key];
+ $class = $sym[0];
+ $attrs['data-symbol-context'] = idx($sym, 'context');
+ $attrs['data-symbol-name'] = idx($sym, 'symbol');
+ } else {
+ switch ($token->getTypeName()) {
+ case 'T_WHITESPACE':
+ break;
+ case 'T_DOC_COMMENT':
+ $class = 'dc';
+ $multi = true;
+ break;
+ case 'T_COMMENT':
+ $class = 'c';
+ $multi = true;
+ break;
+ case 'T_CONSTANT_ENCAPSED_STRING':
+ case 'T_ENCAPSED_AND_WHITESPACE':
+ case 'T_INLINE_HTML':
+ $class = 's';
+ $multi = true;
+ break;
+ case 'T_VARIABLE':
+ $class = 'nv';
+ break;
+ case 'T_OPEN_TAG':
+ case 'T_OPEN_TAG_WITH_ECHO':
+ case 'T_CLOSE_TAG':
+ $class = 'o';
+ break;
+ case 'T_LNUMBER':
+ case 'T_DNUMBER':
+ $class = 'm';
+ break;
+ case 'T_STRING':
+ static $magic = array(
+ 'true' => true,
+ 'false' => true,
+ 'null' => true,
+ );
+ if (isset($magic[strtolower($value)])) {
+ $class = 'k';
+ break;
+ }
+ $class = 'nx';
+ break;
+ default:
+ $class = 'k';
+ break;
+ }
+ }
+
+ if ($class) {
+ $attrs['class'] = $class;
+ if ($multi) {
+ // If the token may have multiple lines in it, make sure each
+ // crosses no more than one line so the lines can be put
+ // in a table, etc., later.
+ $value = phutil_split_lines($value, $retain_endings = true);
+ } else {
+ $value = array($value);
+ }
+ foreach ($value as $val) {
+ $out[] = phutil_tag('span', $attrs, $val);
+ }
+ } else {
+ $out[] = $value;
+ }
+ }
+
+ return phutil_implode_html('', $out);
+ }
+
+ private function findInterestingSymbols(XHPASTNode $root) {
+ // Class name symbols appear in:
+ // class X extends X implements X, X { ... }
+ // new X();
+ // $x instanceof X
+ // catch (X $x)
+ // function f(X $x)
+ // X::f();
+ // X::$m;
+ // X::CONST;
+
+ // These are PHP builtin tokens which can appear in a classname context.
+ // Don't link them since they don't go anywhere useful.
+ static $builtin_class_tokens = array(
+ 'self' => true,
+ 'parent' => true,
+ 'static' => true,
+ );
+
+ // Fortunately XHPAST puts all of these in a special node type so it's
+ // easy to find them.
+ $result_map = array();
+ $class_names = $root->selectDescendantsOfType('n_CLASS_NAME');
+ foreach ($class_names as $class_name) {
+ foreach ($class_name->getTokens() as $key => $token) {
+ if (isset($builtin_class_tokens[$token->getValue()])) {
+ // This is something like "self::method()".
+ continue;
+ }
+ $result_map[$key] = array(
+ 'nc', // "Name, Class"
+ 'symbol' => $class_name->getConcreteString(),
+ );
+ }
+ }
+
+ // Function name symbols appear in:
+ // f()
+
+ $function_calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
+ foreach ($function_calls as $call) {
+ $call = $call->getChildByIndex(0);
+ if ($call->getTypeName() == 'n_SYMBOL_NAME') {
+ // This is a normal function call, not some $f() shenanigans.
+ foreach ($call->getTokens() as $key => $token) {
+ $result_map[$key] = array(
+ 'nf', // "Name, Function"
+ 'symbol' => $call->getConcreteString(),
+ );
+ }
+ }
+ }
+
+ // Upon encountering $x->y, link y without context, since $x is unknown.
+
+ $prop_access = $root->selectDescendantsOfType('n_OBJECT_PROPERTY_ACCESS');
+ foreach ($prop_access as $access) {
+ $right = $access->getChildByIndex(1);
+ if ($right->getTypeName() == 'n_INDEX_ACCESS') {
+ // otherwise $x->y[0] doesn't get highlighted
+ $right = $right->getChildByIndex(0);
+ }
+ if ($right->getTypeName() == 'n_STRING') {
+ foreach ($right->getTokens() as $key => $token) {
+ $result_map[$key] = array(
+ 'na', // "Name, Attribute"
+ 'symbol' => $right->getConcreteString(),
+ );
+ }
+ }
+ }
+
+ // Upon encountering x::y, try to link y with context x.
+
+ $static_access = $root->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
+ foreach ($static_access as $access) {
+ $class = $access->getChildByIndex(0);
+ $right = $access->getChildByIndex(1);
+ if ($class->getTypeName() == 'n_CLASS_NAME' &&
+ ($right->getTypeName() == 'n_STRING' ||
+ $right->getTypeName() == 'n_VARIABLE')) {
+ $classname = head($class->getTokens())->getValue();
+ $result = array(
+ 'na',
+ 'symbol' => ltrim($right->getConcreteString(), '$'),
+ );
+ if (!isset($builtin_class_tokens[$classname])) {
+ $result['context'] = $classname;
+ }
+ foreach ($right->getTokens() as $key => $token) {
+ $result_map[$key] = $result;
+ }
+ }
+ }
+
+ return $result_map;
+ }
+
+}
diff --git a/src/moduleutils/PhutilBootloader.php b/src/moduleutils/PhutilBootloader.php
new file mode 100644
--- /dev/null
+++ b/src/moduleutils/PhutilBootloader.php
@@ -0,0 +1,338 @@
+classTree;
+ }
+
+ public function registerInMemoryLibrary($name, $map) {
+ $this->registeredLibraries[$name] = "memory:$name";
+ $this->inMemoryMaps[$name] = $map;
+
+ $this->getLibraryMap($name);
+ }
+
+ public function registerLibrary($name, $path) {
+ if (basename($path) != '__phutil_library_init__.php') {
+ throw new PhutilBootloaderException(
+ 'Only directories with a __phutil_library_init__.php file may be '.
+ 'registered as libphutil libraries.');
+ }
+
+ $path = dirname($path);
+
+ // Detect attempts to load the same library multiple times from different
+ // locations. This might mean you're doing something silly like trying to
+ // include two different versions of something, or it might mean you're
+ // doing something subtle like running a different version of 'arc' on a
+ // working copy of Arcanist.
+ if (isset($this->registeredLibraries[$name])) {
+ $old_path = $this->registeredLibraries[$name];
+ if ($old_path != $path) {
+ throw new PhutilLibraryConflictException($name, $old_path, $path);
+ }
+ }
+
+ $this->registeredLibraries[$name] = $path;
+
+ // For libphutil v2 libraries, load all functions when we load the library.
+
+ if (!class_exists('PhutilSymbolLoader', false)) {
+ $root = $this->getLibraryRoot('arcanist');
+ $this->executeInclude($root.'/symbols/PhutilSymbolLoader.php');
+ }
+
+ $loader = new PhutilSymbolLoader();
+ $loader
+ ->setLibrary($name)
+ ->setType('function');
+
+ try {
+ $loader->selectAndLoadSymbols();
+ } catch (PhutilBootloaderException $ex) {
+ // Ignore this, it happens if a global function's file is removed or
+ // similar. Worst case is that we fatal when calling the function, which
+ // is no worse than fataling here.
+ } catch (PhutilMissingSymbolException $ex) {
+ // Ignore this, it happens if a global function is removed. Everything
+ // else loaded so proceed forward: worst case is a fatal when we
+ // hit a function call to a function which no longer exists, which is
+ // no worse than fataling here.
+ }
+
+ if (empty($_SERVER['PHUTIL_DISABLE_RUNTIME_EXTENSIONS'])) {
+ $extdir = $path.DIRECTORY_SEPARATOR.'extensions';
+ if (Filesystem::pathExists($extdir)) {
+ $extensions = id(new FileFinder($extdir))
+ ->withSuffix('php')
+ ->withType('f')
+ ->withFollowSymlinks(true)
+ ->setForceMode('php')
+ ->find();
+
+ foreach ($extensions as $extension) {
+ $this->loadExtension(
+ $name,
+ $path,
+ $extdir.DIRECTORY_SEPARATOR.$extension);
+ }
+ }
+ }
+
+ return $this;
+ }
+
+ public function registerLibraryMap(array $map) {
+ $this->libraryMaps[$this->currentLibrary] = $map;
+ return $this;
+ }
+
+ public function getLibraryMap($name) {
+ if (isset($this->extendedMaps[$name])) {
+ return $this->extendedMaps[$name];
+ }
+
+ if (empty($this->libraryMaps[$name])) {
+ $root = $this->getLibraryRoot($name);
+ $this->currentLibrary = $name;
+
+ if (isset($this->inMemoryMaps[$name])) {
+ $this->libraryMaps[$name] = $this->inMemoryMaps[$name];
+ } else {
+ $okay = include $root.'/__phutil_library_map__.php';
+ if (!$okay) {
+ throw new PhutilBootloaderException(
+ "Include of '{$root}/__phutil_library_map__.php' failed!");
+ }
+ }
+
+ $map = $this->libraryMaps[$name];
+
+ $version = isset($map['__library_version__'])
+ ? $map['__library_version__']
+ : 1;
+
+ switch ($version) {
+ case 1:
+ throw new Exception(
+ 'libphutil v1 libraries are no longer supported.');
+ case 2:
+ // NOTE: In version 2 of the library format, all parents (both
+ // classes and interfaces) are stored in the 'xmap'. The value is
+ // either a string for a single parent (the common case) or an array
+ // for multiple parents.
+ foreach ($map['xmap'] as $child => $parents) {
+ foreach ((array)$parents as $parent) {
+ $this->classTree[$parent][] = $child;
+ }
+ }
+ break;
+ default:
+ throw new Exception("Unsupported library version '{$version}'!");
+ }
+ }
+
+ $map = $this->libraryMaps[$name];
+
+ // If there's an extension map for this library, merge the maps.
+ if (isset($this->extensionMaps[$name])) {
+ $emap = $this->extensionMaps[$name];
+ foreach (array('function', 'class', 'xmap') as $dict_key) {
+ if (!isset($emap[$dict_key])) {
+ continue;
+ }
+ $map[$dict_key] += $emap[$dict_key];
+ }
+ }
+
+ $this->extendedMaps[$name] = $map;
+
+ return $map;
+ }
+
+ public function getLibraryMapWithoutExtensions($name) {
+ // This just does all the checks to make sure the library is valid, then
+ // we throw away the result.
+ $this->getLibraryMap($name);
+
+ return $this->libraryMaps[$name];
+ }
+
+ public function getLibraryRoot($name) {
+ if (empty($this->registeredLibraries[$name])) {
+ throw new PhutilBootloaderException(
+ "The phutil library '{$name}' has not been loaded!");
+ }
+ return $this->registeredLibraries[$name];
+ }
+
+ public function getAllLibraries() {
+ return array_keys($this->registeredLibraries);
+ }
+
+ public function loadLibrary($path) {
+ $root = null;
+ if (!empty($_SERVER['PHUTIL_LIBRARY_ROOT'])) {
+ if ($path[0] != '/') {
+ $root = $_SERVER['PHUTIL_LIBRARY_ROOT'];
+ }
+ }
+
+ $this->executeInclude($root.$path.'/__phutil_library_init__.php');
+ }
+
+ public function loadLibrarySource($library, $source) {
+ $path = $this->getLibraryRoot($library).'/'.$source;
+ $this->executeInclude($path);
+ }
+
+ private function executeInclude($path) {
+ // Include the source using `include_once`, but convert any warnings or
+ // recoverable errors into exceptions.
+
+ // Some messages, including "Declaration of X should be compatible with Y",
+ // do not cause `include_once` to return an error code. Use
+ // error_get_last() to make sure we're catching everything in every PHP
+ // version.
+
+ // (Also, the severity of some messages changed between versions of PHP.)
+
+ // Note that we may enter this method after some earlier, unrelated error.
+ // In this case, error_get_last() will return information for that error.
+ // In PHP7 and later we could use error_clear_last() to clear that error,
+ // but the function does not exist in earlier versions of PHP. Instead,
+ // check if the value has changed.
+
+ // Some parser-like errors, including "class must implement all abstract
+ // methods", cause PHP to fatal immediately with an E_ERROR. In these
+ // cases, include_once() does not throw and never returns. We leave
+ // reporting enabled for these errors since we don't have a way to do
+ // anything more graceful.
+
+ // Likewise, some errors, including "cannot redeclare Class::method()"
+ // cause PHP to fatal immediately with E_COMPILE_ERROR. Treat these like
+ // the similar errors which raise E_ERROR.
+
+ // See also T12190.
+
+ $old_last = error_get_last();
+
+ try {
+ $old = error_reporting(E_ERROR | E_COMPILE_ERROR);
+ $okay = include_once $path;
+ error_reporting($old);
+ } catch (Exception $ex) {
+ throw $ex;
+ } catch (ParseError $throwable) {
+ // NOTE: As of PHP7, syntax errors may raise a ParseError (which is a
+ // Throwable, not an Exception) with a useless message (like "syntax
+ // error, unexpected ':'") and a trace which ends a level above this.
+
+ // Treating this object normally results in an unusable message which
+ // does not identify where the syntax error occurred. Converting it to
+ // a string and taking the first line gives us something reasonable,
+ // however.
+ $message = (string)$throwable;
+ $message = preg_split("/\n/", $message);
+ $message = reset($message);
+
+ throw new Exception($message);
+ }
+
+ if (!$okay) {
+ throw new Exception("Source file \"{$path}\" failed to load.");
+ }
+
+ $new_last = error_get_last();
+ if ($new_last !== null) {
+ if ($new_last !== $old_last) {
+ $message = $new_last['message'];
+ throw new Exception(
+ "Error while loading file \"{$path}\": {$message}");
+ }
+ }
+ }
+
+ private function loadExtension($library, $root, $path) {
+ $old_functions = get_defined_functions();
+ $old_functions = array_fill_keys($old_functions['user'], true);
+ $old_classes = array_fill_keys(get_declared_classes(), true);
+ $old_interfaces = array_fill_keys(get_declared_interfaces(), true);
+
+ $this->executeInclude($path);
+
+ $new_functions = get_defined_functions();
+ $new_functions = array_fill_keys($new_functions['user'], true);
+ $new_classes = array_fill_keys(get_declared_classes(), true);
+ $new_interfaces = array_fill_keys(get_declared_interfaces(), true);
+
+ $add_functions = array_diff_key($new_functions, $old_functions);
+ $add_classes = array_diff_key($new_classes, $old_classes);
+ $add_interfaces = array_diff_key($new_interfaces, $old_interfaces);
+
+ // NOTE: We can't trust the path we loaded to be the location of these
+ // symbols, because it might have loaded other paths.
+
+ foreach ($add_functions as $func => $ignored) {
+ $rfunc = new ReflectionFunction($func);
+ $fpath = Filesystem::resolvePath($rfunc->getFileName(), $root);
+ $this->extensionMaps[$library]['function'][$func] = $fpath;
+ }
+
+ foreach ($add_classes + $add_interfaces as $class => $ignored) {
+ $rclass = new ReflectionClass($class);
+ $cpath = Filesystem::resolvePath($rclass->getFileName(), $root);
+ $this->extensionMaps[$library]['class'][$class] = $cpath;
+
+ $xmap = $rclass->getInterfaceNames();
+ $parent = $rclass->getParentClass();
+ if ($parent) {
+ $xmap[] = $parent->getName();
+ }
+
+ if ($xmap) {
+ foreach ($xmap as $parent_class) {
+ $this->classTree[$parent_class][] = $class;
+ }
+
+ if (count($xmap) == 1) {
+ $xmap = head($xmap);
+ }
+
+ $this->extensionMaps[$library]['xmap'][$class] = $xmap;
+ }
+ }
+
+ // Clear the extended library cache (should one exist) so we know that
+ // we need to rebuild it.
+ unset($this->extendedMaps[$library]);
+ }
+
+}
diff --git a/src/moduleutils/PhutilBootloaderException.php b/src/moduleutils/PhutilBootloaderException.php
new file mode 100644
--- /dev/null
+++ b/src/moduleutils/PhutilBootloaderException.php
@@ -0,0 +1,3 @@
+library = $library;
+ $this->oldPath = $old_path;
+ $this->newPath = $new_path;
+
+ parent::__construct(pht(
+ "Library conflict! The library '%s' has already been loaded (from '%s') ".
+ "but is now being loaded again from a new location ('%s'). You can not ".
+ "load multiple copies of the same library into a program.",
+ $library,
+ $old_path,
+ $new_path));
+ }
+
+ /**
+ * Retrieve the name of the library in conflict.
+ *
+ * @return string The name of the library which conflicts with an existing
+ * library.
+ * @task info
+ */
+ public function getLibrary() {
+ return $this->library;
+ }
+
+ /**
+ * Get the path to the library which has already been loaded earlier in the
+ * program's execution.
+ *
+ * @return string The path of the already-loaded library.
+ * @task info
+ */
+ public function getOldPath() {
+ return $this->oldPath;
+ }
+
+ /**
+ * Get the path to the library which is causing this conflict.
+ *
+ * @return string The path of the attempting-to-load library.
+ * @task info
+ */
+ public function getNewPath() {
+ return $this->newPath;
+ }
+
+}
diff --git a/src/moduleutils/PhutilLibraryMapBuilder.php b/src/moduleutils/PhutilLibraryMapBuilder.php
new file mode 100644
--- /dev/null
+++ b/src/moduleutils/PhutilLibraryMapBuilder.php
@@ -0,0 +1,511 @@
+root = $root;
+ }
+
+ /**
+ * Control status output. Use `--quiet` to set this.
+ *
+ * @param bool If true, don't show status output.
+ * @return this
+ *
+ * @task map
+ */
+ public function setQuiet($quiet) {
+ $this->quiet = $quiet;
+ return $this;
+ }
+
+ /**
+ * Control subprocess parallelism limit. Use `--limit` to set this.
+ *
+ * @param int Maximum number of subprocesses to run in parallel.
+ * @return this
+ *
+ * @task map
+ */
+ public function setSubprocessLimit($limit) {
+ $this->subprocessLimit = $limit;
+ return $this;
+ }
+
+ /**
+ * Get the map of symbols in this library, analyzing the library to build it
+ * if necessary.
+ *
+ * @return map Information about symbols in this library.
+ *
+ * @task map
+ */
+ public function buildMap() {
+ if ($this->librarySymbolMap === null) {
+ $this->analyzeLibrary();
+ }
+ return $this->librarySymbolMap;
+ }
+
+
+ /**
+ * Get the map of files in this library, analyzing the library to build it
+ * if necessary.
+ *
+ * Returns a map of file paths to information about symbols used and defined
+ * in the file.
+ *
+ * @return map Information about files in this library.
+ *
+ * @task map
+ */
+ public function buildFileSymbolMap() {
+ if ($this->fileSymbolMap === null) {
+ $this->analyzeLibrary();
+ }
+ return $this->fileSymbolMap;
+ }
+
+ /**
+ * Build and update the library map.
+ *
+ * @return void
+ *
+ * @task map
+ */
+ public function buildAndWriteMap() {
+ $library_map = $this->buildMap();
+
+ $this->log(pht('Writing map...'));
+ $this->writeLibraryMap($library_map);
+ }
+
+ /**
+ * Write a status message to the user, if not running in quiet mode.
+ *
+ * @param string Message to write.
+ * @return this
+ *
+ * @task map
+ */
+ private function log($message) {
+ if (!$this->quiet) {
+ @fwrite(STDERR, "%s\n", $message);
+ }
+ return $this;
+ }
+
+
+/* -( Path Management )---------------------------------------------------- */
+
+ /**
+ * Get the path to some file in the library.
+ *
+ * @param string A library-relative path. If omitted, returns the library
+ * root path.
+ * @return string An absolute path.
+ *
+ * @task path
+ */
+ private function getPath($path = '') {
+ return $this->root.'/'.$path;
+ }
+
+ /**
+ * Get the path to the symbol cache file.
+ *
+ * @return string Absolute path to symbol cache.
+ *
+ * @task path
+ */
+ private function getPathForSymbolCache() {
+ return $this->getPath('.phutil_module_cache');
+ }
+
+ /**
+ * Get the path to the map file.
+ *
+ * @return string Absolute path to the library map.
+ *
+ * @task path
+ */
+ private function getPathForLibraryMap() {
+ return $this->getPath('__phutil_library_map__.php');
+ }
+
+ /**
+ * Get the path to the library init file.
+ *
+ * @return string Absolute path to the library init file
+ *
+ * @task path
+ */
+ private function getPathForLibraryInit() {
+ return $this->getPath('__phutil_library_init__.php');
+ }
+
+
+/* -( Symbol Analysis and Caching )---------------------------------------- */
+
+ /**
+ * Load the library symbol cache, if it exists and is readable and valid.
+ *
+ * @return dict Map of content hashes to cache of output from
+ * `phutil_symbols.php`.
+ *
+ * @task symbol
+ */
+ private function loadSymbolCache() {
+ $cache_file = $this->getPathForSymbolCache();
+
+ try {
+ $cache = Filesystem::readFile($cache_file);
+ } catch (Exception $ex) {
+ $cache = null;
+ }
+
+ $symbol_cache = array();
+ if ($cache) {
+ try {
+ $symbol_cache = phutil_json_decode($cache);
+ } catch (PhutilJSONParserException $ex) {
+ $symbol_cache = array();
+ }
+ }
+
+ $version = idx($symbol_cache, self::SYMBOL_CACHE_VERSION_KEY);
+ if ($version != self::SYMBOL_CACHE_VERSION) {
+ // Throw away caches from a different version of the library.
+ $symbol_cache = array();
+ }
+ unset($symbol_cache[self::SYMBOL_CACHE_VERSION_KEY]);
+
+ return $symbol_cache;
+ }
+
+ /**
+ * Write a symbol map to disk cache.
+ *
+ * @param dict Symbol map of relative paths to symbols.
+ * @param dict Source map (like @{method:loadSourceFileMap}).
+ * @return void
+ *
+ * @task symbol
+ */
+ private function writeSymbolCache(array $symbol_map, array $source_map) {
+ $cache_file = $this->getPathForSymbolCache();
+
+ $cache = array(
+ self::SYMBOL_CACHE_VERSION_KEY => self::SYMBOL_CACHE_VERSION,
+ );
+
+ foreach ($symbol_map as $file => $symbols) {
+ $cache[$source_map[$file]] = $symbols;
+ }
+
+ $json = json_encode($cache);
+ try {
+ Filesystem::writeFile($cache_file, $json);
+ } catch (FilesystemException $ex) {
+ $this->log(pht('Unable to save the cache!'));
+ }
+ }
+
+ /**
+ * Drop the symbol cache, forcing a clean rebuild.
+ *
+ * @return this
+ *
+ * @task symbol
+ */
+ public function dropSymbolCache() {
+ $this->log(pht('Dropping symbol cache...'));
+ Filesystem::remove($this->getPathForSymbolCache());
+ }
+
+ /**
+ * Build a future which returns a `phutil_symbols.php` analysis of a source
+ * file.
+ *
+ * @param string Relative path to the source file to analyze.
+ * @return Future Analysis future.
+ *
+ * @task symbol
+ */
+ private function buildSymbolAnalysisFuture($file) {
+ $absolute_file = $this->getPath($file);
+ $bin = dirname(__FILE__).'/../../scripts/phutil_symbols.php';
+
+ return new ExecFuture('php %s --ugly -- %s', $bin, $absolute_file);
+ }
+
+
+/* -( Source Management )-------------------------------------------------- */
+
+ /**
+ * Build a map of all source files in a library to hashes of their content.
+ * Returns an array like this:
+ *
+ * array(
+ * 'src/parser/ExampleParser.php' => '60b725f10c9c85c70d97880dfe8191b3',
+ * // ...
+ * );
+ *
+ * @return dict Map of library-relative paths to content hashes.
+ * @task source
+ */
+ private function loadSourceFileMap() {
+ $root = $this->getPath();
+
+ $init = $this->getPathForLibraryInit();
+ if (!Filesystem::pathExists($init)) {
+ throw new Exception(
+ pht(
+ "Provided path '%s' is not a %s library.",
+ $root,
+ 'phutil'));
+ }
+
+ $files = id(new FileFinder($root))
+ ->withType('f')
+ ->withSuffix('php')
+ ->excludePath('*/.*')
+ ->setGenerateChecksums(true)
+ ->find();
+
+ $map = array();
+ foreach ($files as $file => $hash) {
+ $file = Filesystem::readablePath($file, $root);
+ $file = ltrim($file, '/');
+
+ if (dirname($file) == '.') {
+ // We don't permit normal source files at the root level, so just ignore
+ // them; they're special library files.
+ continue;
+ }
+
+ if (dirname($file) == 'extensions') {
+ // Ignore files in the extensions/ directory.
+ continue;
+ }
+
+ // We include also filename in the hash to handle cases when the file is
+ // moved without modifying its content.
+ $map[$file] = md5($hash.$file);
+ }
+
+ return $map;
+ }
+
+ /**
+ * Convert the symbol analysis of all the source files in the library into
+ * a library map.
+ *
+ * @param dict Symbol analysis of all source files.
+ * @return dict Library map.
+ * @task source
+ */
+ private function buildLibraryMap(array $symbol_map) {
+ $library_map = array(
+ 'class' => array(),
+ 'function' => array(),
+ 'xmap' => array(),
+ );
+
+ // Detect duplicate symbols within the library.
+ foreach ($symbol_map as $file => $info) {
+ foreach ($info['have'] as $type => $symbols) {
+ foreach ($symbols as $symbol => $declaration) {
+ $lib_type = ($type == 'interface') ? 'class' : $type;
+ if (!empty($library_map[$lib_type][$symbol])) {
+ $prior = $library_map[$lib_type][$symbol];
+ throw new Exception(
+ pht(
+ "Definition of %s '%s' in file '%s' duplicates prior ".
+ "definition in file '%s'. You can not declare the ".
+ "same symbol twice.",
+ $type,
+ $symbol,
+ $file,
+ $prior));
+ }
+ $library_map[$lib_type][$symbol] = $file;
+ }
+ }
+ $library_map['xmap'] += $info['xmap'];
+ }
+
+ // Simplify the common case (one parent) to make the file a little easier
+ // to deal with.
+ foreach ($library_map['xmap'] as $class => $extends) {
+ if (count($extends) == 1) {
+ $library_map['xmap'][$class] = reset($extends);
+ }
+ }
+
+ // Sort the map so it is relatively stable across changes.
+ foreach ($library_map as $key => $symbols) {
+ ksort($symbols);
+ $library_map[$key] = $symbols;
+ }
+ ksort($library_map);
+
+ return $library_map;
+ }
+
+ /**
+ * Write a finalized library map.
+ *
+ * @param dict Library map structure to write.
+ * @return void
+ *
+ * @task source
+ */
+ private function writeLibraryMap(array $library_map) {
+ $map_file = $this->getPathForLibraryMap();
+ $version = self::LIBRARY_MAP_VERSION;
+
+ $library_map = array(
+ self::LIBRARY_MAP_VERSION_KEY => $version,
+ ) + $library_map;
+
+ $library_map = phutil_var_export($library_map);
+ $at = '@';
+
+ $source_file = <<log(pht('Finding source files...'));
+ $source_map = $this->loadSourceFileMap();
+ $this->log(
+ pht('Found %s files.', new PhutilNumber(count($source_map))));
+
+ // Load the symbol cache with existing parsed symbols. This allows us
+ // to remap libraries quickly by analyzing only changed files.
+ $this->log(pht('Loading symbol cache...'));
+ $symbol_cache = $this->loadSymbolCache();
+
+ // If the XHPAST binary is not up-to-date, build it now. Otherwise,
+ // `phutil_symbols.php` will attempt to build the binary and will fail
+ // miserably because it will be trying to build the same file multiple
+ // times in parallel.
+ if (!PhutilXHPASTBinary::isAvailable()) {
+ PhutilXHPASTBinary::build();
+ }
+
+ // Build out the symbol analysis for all the files in the library. For
+ // each file, check if it's in cache. If we miss in the cache, do a fresh
+ // analysis.
+ $symbol_map = array();
+ $futures = array();
+ foreach ($source_map as $file => $hash) {
+ if (!empty($symbol_cache[$hash])) {
+ $symbol_map[$file] = $symbol_cache[$hash];
+ continue;
+ }
+ $futures[$file] = $this->buildSymbolAnalysisFuture($file);
+ }
+ $this->log(
+ pht('Found %s files in cache.', new PhutilNumber(count($symbol_map))));
+
+ // Run the analyzer on any files which need analysis.
+ if ($futures) {
+ $limit = $this->subprocessLimit;
+
+ $this->log(
+ pht(
+ 'Analyzing %s file(s) with %s subprocess(es)...',
+ phutil_count($futures),
+ new PhutilNumber($limit)));
+
+ $progress = new PhutilConsoleProgressBar();
+ if ($this->quiet) {
+ $progress->setQuiet(true);
+ }
+ $progress->setTotal(count($futures));
+
+ $futures = id(new FutureIterator($futures))
+ ->limit($limit);
+ foreach ($futures as $file => $future) {
+ $result = $future->resolveJSON();
+ if (empty($result['error'])) {
+ $symbol_map[$file] = $result;
+ } else {
+ $progress->done(false);
+ throw new XHPASTSyntaxErrorException(
+ $result['line'],
+ $file.': '.$result['error']);
+ }
+ $progress->update(1);
+ }
+ $progress->done();
+ }
+
+ $this->fileSymbolMap = $symbol_map;
+
+ // We're done building the cache, so write it out immediately. Note that
+ // we've only retained entries for files we found, so this implicitly cleans
+ // out old cache entries.
+ $this->writeSymbolCache($symbol_map, $source_map);
+
+ // Our map is up to date, so either show it on stdout or write it to disk.
+ $this->log(pht('Building library map...'));
+
+ $this->librarySymbolMap = $this->buildLibraryMap($symbol_map);
+ }
+
+
+}
diff --git a/src/moduleutils/__tests__/PhutilModuleUtilsTestCase.php b/src/moduleutils/__tests__/PhutilModuleUtilsTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/moduleutils/__tests__/PhutilModuleUtilsTestCase.php
@@ -0,0 +1,9 @@
+assertEqual('phutil', phutil_get_current_library_name());
+ }
+
+}
diff --git a/src/moduleutils/core.php b/src/moduleutils/core.php
new file mode 100644
--- /dev/null
+++ b/src/moduleutils/core.php
@@ -0,0 +1,13 @@
+registerLibrary($library, $path);
+}
+
+function phutil_register_library_map(array $map) {
+ PhutilBootloader::getInstance()->registerLibraryMap($map);
+}
+
+function phutil_load_library($path) {
+ PhutilBootloader::getInstance()->loadLibrary($path);
+}
diff --git a/src/moduleutils/moduleutils.php b/src/moduleutils/moduleutils.php
new file mode 100644
--- /dev/null
+++ b/src/moduleutils/moduleutils.php
@@ -0,0 +1,49 @@
+getLibraryRoot($library);
+}
+
+function phutil_get_library_root_for_path($path) {
+ foreach (Filesystem::walkToRoot($path) as $dir) {
+ if (Filesystem::pathExists($dir.'/__phutil_library_init__.php')) {
+ return $dir;
+ }
+ }
+ return null;
+}
+
+function phutil_get_library_name_for_root($path) {
+ $path = rtrim(Filesystem::resolvePath($path), '/');
+
+ $bootloader = PhutilBootloader::getInstance();
+ $libraries = $bootloader->getAllLibraries();
+ foreach ($libraries as $library) {
+ $root = $bootloader->getLibraryRoot($library);
+ if (rtrim(Filesystem::resolvePath($root), '/') == $path) {
+ return $library;
+ }
+ }
+
+ return null;
+}
+
+function phutil_get_current_library_name() {
+ $caller = head(debug_backtrace(false));
+
+ $root = phutil_get_library_root_for_path($caller['file']);
+ return phutil_get_library_name_for_root($root);
+}
+
+/**
+ * Warns about use of deprecated behavior.
+ */
+function phutil_deprecated($what, $why) {
+ PhutilErrorHandler::dispatchErrorMessage(
+ PhutilErrorHandler::DEPRECATED,
+ $what,
+ array(
+ 'why' => $why,
+ ));
+}
diff --git a/src/object/Phobject.php b/src/object/Phobject.php
new file mode 100644
--- /dev/null
+++ b/src/object/Phobject.php
@@ -0,0 +1,104 @@
+throwOnAttemptedIteration();
+ }
+
+ public function key() {
+ $this->throwOnAttemptedIteration();
+ }
+
+ public function next() {
+ $this->throwOnAttemptedIteration();
+ }
+
+ public function rewind() {
+ $this->throwOnAttemptedIteration();
+ }
+
+ public function valid() {
+ $this->throwOnAttemptedIteration();
+ }
+
+ private function throwOnAttemptedIteration() {
+ throw new DomainException(
+ pht(
+ 'Attempting to iterate an object (of class %s) which is not iterable.',
+ get_class($this)));
+ }
+
+
+ /**
+ * Read the value of a class constant.
+ *
+ * This is the same as just typing `self::CONSTANTNAME`, but throws a more
+ * useful message if the constant is not defined and allows the constant to
+ * be limited to a maximum length.
+ *
+ * @param string Name of the constant.
+ * @param int|null Maximum number of bytes permitted in the value.
+ * @return string Value of the constant.
+ */
+ public function getPhobjectClassConstant($key, $byte_limit = null) {
+ $class = new ReflectionClass($this);
+
+ $const = $class->getConstant($key);
+ if ($const === false) {
+ throw new Exception(
+ pht(
+ '"%s" class "%s" must define a "%s" constant.',
+ __CLASS__,
+ get_class($this),
+ $key));
+ }
+
+ if ($byte_limit !== null) {
+ if (!is_string($const) || (strlen($const) > $byte_limit)) {
+ throw new Exception(
+ pht(
+ '"%s" class "%s" has an invalid "%s" property. Field constants '.
+ 'must be strings and no more than %s bytes in length.',
+ __CLASS__,
+ get_class($this),
+ $key,
+ new PhutilNumber($byte_limit)));
+ }
+ }
+
+ return $const;
+ }
+
+}
diff --git a/src/object/__tests__/PhobjectTestCase.php b/src/object/__tests__/PhobjectTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/object/__tests__/PhobjectTestCase.php
@@ -0,0 +1,40 @@
+duck;
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof DomainException);
+
+ $caught = null;
+ try {
+ $object->duck = 'quack';
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof DomainException);
+ }
+
+ public function testThrowOnIteration() {
+ $object = new PhutilTestPhobject();
+
+ $caught = null;
+ try {
+ foreach ($object as $item) {
+ // ...
+ }
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof DomainException);
+ }
+
+}
diff --git a/src/object/__tests__/PhutilTestPhobject.php b/src/object/__tests__/PhutilTestPhobject.php
new file mode 100644
--- /dev/null
+++ b/src/object/__tests__/PhutilTestPhobject.php
@@ -0,0 +1,3 @@
+setBugtraqPattern('http://bugs.com/%BUGID%')
+ * ->setBugtraqCaptureExpression('/[Ii]ssues?:?(\s*,?\s*#\d+)+/')
+ * ->setBugtraqSelectExpression('/(\d+)/')
+ * ->processCorpus($message);
+ *
+ * This will produce:
+ *
+ * Issues: http://bugs.com/123, http://bugs.com/345
+ *
+ */
+final class PhutilBugtraqParser extends Phobject {
+
+ private $bugtraqPattern;
+ private $bugtraqCaptureExpression;
+ private $bugtraqSelectExpression;
+
+ public function setBugtraqPattern($pattern) {
+ $this->bugtraqPattern = $pattern;
+ return $this;
+ }
+
+ public function setBugtraqCaptureExpression($regex) {
+ PhutilTypeSpec::newFromString('regex')->check($regex);
+
+ $this->bugtraqCaptureExpression = $regex;
+ return $this;
+ }
+
+ public function setBugtraqSelectExpression($regex) {
+ PhutilTypeSpec::newFromString('regex')->check($regex);
+
+ $this->bugtraqSelectExpression = $regex;
+ return $this;
+ }
+
+ public function processCorpus($corpus) {
+ $regexp = $this->bugtraqCaptureExpression;
+ $matches = null;
+ $flags = PREG_SET_ORDER | PREG_OFFSET_CAPTURE;
+
+ // First, find all the matching text ranges. We do this up front because
+ // when we do the replacement pass at the end, the whole thing needs to go
+ // in reverse order.
+
+ preg_match_all($regexp, $corpus, $matches, $flags);
+ $captures = array();
+ foreach ($matches as $match) {
+ list($captured_text, $captured_offset) = $match[0];
+ $captures[] = array(
+ 'text' => $captured_text,
+ 'at' => $captured_offset,
+ );
+ }
+
+ // Find the actual bug IDs. If there's a selection expression, we use that
+ // to pick bug IDs out of a larger context. For example, the syntax may be:
+ //
+ // Issues: 123, 124
+ //
+ // In this case, "123" and "124" are the issue IDs, and could be selected
+ // with an expression like:
+ //
+ // /(\d+)/
+ //
+ // If there's no selection expression, we use the entire match.
+
+ $bug_ids = array();
+ $select_regexp = $this->bugtraqSelectExpression;
+ foreach ($captures as $capture) {
+ $captured_text = $capture['text'];
+ $captured_offset = $capture['at'];
+
+ if (strlen($select_regexp)) {
+ $selections = null;
+ preg_match_all(
+ $select_regexp,
+ $captured_text,
+ $selections,
+ PREG_OFFSET_CAPTURE);
+
+ foreach ($selections[1] as $selection) {
+ $bug_ids[] = array(
+ 'text' => $selection[0],
+ 'at' => $captured_offset + $selection[1],
+ );
+ }
+ } else {
+ $bug_ids[] = array(
+ 'text' => $captured_text,
+ 'at' => $captured_offset,
+ );
+ }
+ }
+
+ // Now that we have all the bug IDs to replace, replace them (in reverse
+ // order, so the offsets don't get messed up).
+ $bug_ids = array_reverse($bug_ids);
+ foreach ($bug_ids as $bug) {
+ $new_text = str_replace(
+ '%BUGID%',
+ $bug['text'],
+ $this->bugtraqPattern);
+
+ $corpus = substr_replace(
+ $corpus,
+ $new_text,
+ $bug['at'],
+ strlen($bug['text']));
+ }
+
+ return $corpus;
+ }
+
+}
diff --git a/src/parser/PhutilDocblockParser.php b/src/parser/PhutilDocblockParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilDocblockParser.php
@@ -0,0 +1,163 @@
+ line number.
+ $map = array();
+ $lines = explode("\n", $text);
+ $num = 1;
+ foreach ($lines as $line) {
+ $len = strlen($line) + 1;
+ for ($jj = 0; $jj < $len; $jj++) {
+ $map[] = $num;
+ }
+ ++$num;
+ }
+
+ foreach ($matches[0] as $match) {
+ list($data, $offset) = $match;
+ $blocks[] = array($data, $map[$offset]);
+ }
+
+ return $blocks;
+ }
+
+ public function parse($docblock) {
+ // Strip off comments.
+ $docblock = trim($docblock);
+ $docblock = preg_replace('@^/\*\*@', '', $docblock);
+ $docblock = preg_replace('@\*/$@', '', $docblock);
+ $docblock = preg_replace('@^\s*\*@m', '', $docblock);
+
+ // Normalize multi-line @specials.
+ $lines = explode("\n", $docblock);
+ $last = false;
+ foreach ($lines as $k => $line) {
+
+ // NOTE: We allow "@specials" to be preceded by up to two whitespace
+ // characters; more than that and we assume the block is a code block.
+ // Broadly, there's ambiguity between a special like:
+ //
+ // <... lots of indentation ...> @author alincoln
+ //
+ // ...and a code block like:
+ //
+ // <... lots of indentation ...> @def square(x, y):
+ //
+ // Because standard practice is to indent the entire block one level,
+ // we allow that and one additional space before assuming something is
+ // a code block.
+
+ if (preg_match('/^\s{0,2}@\w/i', $line)) {
+ $last = $k;
+ $lines[$last] = trim($line);
+ } else if (preg_match('/^\s*$/', $line)) {
+ $last = false;
+ } else if ($last !== false) {
+ $lines[$last] = $lines[$last].' '.trim($line);
+ unset($lines[$k]);
+ }
+ }
+
+ $docblock = implode("\n", $lines);
+
+ $special = array();
+
+ // Parse @specials.
+ $matches = null;
+ $have_specials = preg_match_all(
+ '/^@([\w-]+)[ \t]*([^\n]*)/m',
+ $docblock,
+ $matches,
+ PREG_SET_ORDER);
+
+ if ($have_specials) {
+ $docblock = preg_replace(
+ '/^@([\w-]+)[ \t]*([^\n]*)?\n*/m',
+ '',
+ $docblock);
+ foreach ($matches as $match) {
+ list($_, $type, $data) = $match;
+ $data = trim($data);
+
+ // For flags like "@stable" which don't have any string data, set the
+ // value to true.
+ if (!strlen($data)) {
+ $data = true;
+ }
+
+ if (!isset($special[$type])) {
+ $special[$type] = $data;
+ } else {
+ if (!is_array($special[$type])) {
+ $special[$type] = (array)$special[$type];
+ }
+ $special[$type][] = $data;
+ }
+ }
+ }
+
+ // Convert `array(true, true, true)` to `true`.
+ foreach ($special as $type => $data) {
+ if (is_array($data)) {
+ $all_trues = true;
+
+ foreach ($data as $value) {
+ if ($value !== true) {
+ $all_trues = false;
+ break;
+ }
+ }
+
+ if ($all_trues) {
+ $special[$type] = true;
+ }
+ }
+ }
+
+ $docblock = str_replace("\t", ' ', $docblock);
+
+ // Smush the whole docblock to the left edge.
+ $min_indent = 80;
+ $indent = 0;
+ foreach (array_filter(explode("\n", $docblock)) as $line) {
+ for ($ii = 0; $ii < strlen($line); $ii++) {
+ if ($line[$ii] != ' ') {
+ break;
+ }
+ $indent++;
+ }
+ $min_indent = min($indent, $min_indent);
+ }
+
+ $docblock = preg_replace(
+ '/^'.str_repeat(' ', $min_indent).'/m',
+ '',
+ $docblock);
+ $docblock = rtrim($docblock);
+ // Trim any empty lines off the front, but leave the indent level if there
+ // is one.
+ $docblock = preg_replace('/^\s*\n/', '', $docblock);
+
+ return array($docblock, $special);
+ }
+
+}
diff --git a/src/parser/PhutilEditorConfig.php b/src/parser/PhutilEditorConfig.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilEditorConfig.php
@@ -0,0 +1,195 @@
+ array(
+ 'latin1',
+ 'utf-8',
+ 'utf-8-bom',
+ 'utf-16be',
+ 'utf-16le',
+ ),
+ self::END_OF_LINE => array('lf', 'cr', 'crlf'),
+ self::INDENT_SIZE => 'int|string',
+ self::INDENT_STYLE => array('space', 'tab'),
+ self::FINAL_NEWLINE => 'bool',
+ self::LINE_LENGTH => 'int',
+ self::TAB_WIDTH => 'int',
+ self::TRAILING_WHITESPACE => 'bool',
+ );
+
+ private $root;
+
+ /**
+ * Constructor.
+ *
+ * @param string The root directory.
+ */
+ public function __construct($root) {
+ $this->root = $root;
+ }
+
+ /**
+ * Get the specified EditorConfig property for the specified path.
+ *
+ * @param string
+ * @param string
+ * @return wild
+ */
+ public function getProperty($path, $key) {
+ if (!idx(self::$knownProperties, $key)) {
+ throw new InvalidArgumentException(pht('Invalid EditorConfig property.'));
+ }
+
+ $props = $this->getProperties($path);
+
+ switch ($key) {
+ case self::INDENT_SIZE:
+ if (idx($props, self::INDENT_SIZE) === null &&
+ idx($props, self::INDENT_STYLE) === 'tab') {
+ return 'tab';
+ } else if (idx($props, self::INDENT_SIZE) === 'tab' &&
+ idx($props, self::TAB_WIDTH) === null) {
+ return idx($props, self::TAB_WIDTH);
+ }
+ break;
+
+ case self::TAB_WIDTH:
+ if (idx($props, self::TAB_WIDTH) === null &&
+ idx($props, self::INDENT_SIZE) !== null &&
+ idx($props, self::INDENT_SIZE) !== 'tab') {
+ return idx($props, self::INDENT_SIZE);
+ }
+ break;
+ }
+
+ return idx($props, $key);
+ }
+
+ /**
+ * Get the EditorConfig properties for the specified path.
+ *
+ * Returns a map containing all of the EditorConfig properties which apply
+ * to the specified path. The following rules are applied when processing
+ * EditorConfig files:
+ *
+ * - If a glob does not contain `/`, it can match a path in any subdirectory.
+ * - If the first character of a glob is `/`, it will only match files in the
+ * same directory as the `.editorconfig` file.
+ * - Properties and values are case-insensitive.
+ * - Unknown properties will be silently ignored.
+ * - Values are not validated against the specification (this may change in
+ * the future).
+ * - Invalid glob patterns will be silently ignored.
+ *
+ * @param string
+ * @return map
+ */
+ public function getProperties($path) {
+ $configs = $this->getEditorConfigs($path);
+ $matches = array();
+
+ foreach ($configs as $config) {
+ list($path_prefix, $editorconfig) = $config;
+
+ foreach ($editorconfig as $glob => $properties) {
+ if (!$glob) {
+ continue;
+ }
+
+ if (strpos($glob, '/') === false) {
+ $glob = '**/'.$glob;
+ } else if (strncmp($glob, '/', 0)) {
+ $glob = substr($glob, 1);
+ }
+
+ $glob = $path_prefix.'/'.$glob;
+ try {
+ if (!phutil_fnmatch($glob, $path)) {
+ continue;
+ }
+ } catch (Exception $ex) {
+ // Invalid glob pattern... ignore it.
+ continue;
+ }
+
+ foreach ($properties as $property => $value) {
+ $property = strtolower($property);
+
+ if (!idx(self::$knownProperties, $property)) {
+ // Unknown property... ignore it.
+ continue;
+ }
+
+ if (is_string($value)) {
+ $value = strtolower($value);
+ }
+ if ($value === '') {
+ $value = null;
+ }
+ $matches[$property] = $value;
+ }
+ }
+ }
+
+ return $matches;
+ }
+
+ /**
+ * Returns the EditorConfig files which affect the specified path.
+ *
+ * Find and parse all `.editorconfig` files between the specified path and
+ * the root directory. The results are returned in the same order that they
+ * should be matched.
+ *
+ * return list>
+ */
+ private function getEditorConfigs($path) {
+ $configs = array();
+ $found_root = false;
+ $root = $this->root;
+
+ do {
+ $path = dirname($path);
+ $file = $path.'/.editorconfig';
+
+ if (!Filesystem::pathExists($file)) {
+ continue;
+ }
+
+ $contents = Filesystem::readFile($file);
+ $config = phutil_ini_decode($contents);
+
+ if (idx($config, 'root') === true) {
+ $found_root = true;
+ }
+ unset($config['root']);
+ array_unshift($configs, array($path, $config));
+
+ if ($found_root) {
+ break;
+ }
+ } while ($path != $root && Filesystem::isDescendant($path, $root));
+
+ return $configs;
+ }
+
+}
diff --git a/src/parser/PhutilEmailAddress.php b/src/parser/PhutilEmailAddress.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilEmailAddress.php
@@ -0,0 +1,114 @@
+$/', $email_address, $matches)) {
+ $display_name = trim($matches[1], '\'" ');
+ if (strpos($matches[2], '@') !== false) {
+ list($local_part, $domain_name) = explode('@', $matches[2], 2);
+ } else {
+ $local_part = $matches[2];
+ $domain_name = null;
+ }
+ } else if (preg_match('/^(.*)@(.*)$/', $email_address, $matches)) {
+ $display_name = null;
+ $local_part = $matches[1];
+ $domain_name = $matches[2];
+ } else {
+ $display_name = null;
+ $local_part = $email_address;
+ $domain_name = null;
+ }
+
+ $this->displayName = $display_name;
+ $this->localPart = $local_part;
+ $this->domainName = $domain_name;
+ }
+
+ public function __toString() {
+ $address = $this->getAddress();
+ if (strlen($this->displayName)) {
+ $display_name = $this->encodeDisplayName($this->displayName);
+ return $display_name.' <'.$address.'>';
+ } else {
+ return $address;
+ }
+ }
+
+ public function setDisplayName($display_name) {
+ $this->displayName = $display_name;
+ return $this;
+ }
+
+ public function getDisplayName() {
+ return $this->displayName;
+ }
+
+ public function setLocalPart($local_part) {
+ $this->localPart = $local_part;
+ return $this;
+ }
+
+ public function getLocalPart() {
+ return $this->localPart;
+ }
+
+ public function setDomainName($domain_name) {
+ $this->domainName = $domain_name;
+ return $this;
+ }
+
+ public function getDomainName() {
+ return $this->domainName;
+ }
+
+ public function setAddress($address) {
+ $parts = explode('@', $address, 2);
+
+ $this->localPart = $parts[0];
+ if (isset($parts[1])) {
+ $this->domainName = $parts[1];
+ }
+
+ return $this;
+ }
+
+ public function getAddress() {
+ $address = $this->localPart;
+ if (strlen($this->domainName)) {
+ $address .= '@'.$this->domainName;
+ }
+ return $address;
+ }
+
+ private function encodeDisplayName($name) {
+ // NOTE: This is a reasonable effort based on a cursory reading of
+ // RFC2822, but may be significantly misguided.
+
+ // Newlines are not permitted, even when escaped. Discard them.
+ $name = preg_replace("/\s*[\r\n]+\s*/", ' ', $name);
+
+ // Escape double quotes and backslashes.
+ $name = addcslashes($name, '\\"');
+
+ // Quote the string.
+ $name = '"'.$name.'"';
+
+ return $name;
+ }
+
+}
diff --git a/src/parser/PhutilGitURI.php b/src/parser/PhutilGitURI.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilGitURI.php
@@ -0,0 +1,92 @@
+parseURI($uri);
+ if ($parts) {
+ $this->user = $parts[1];
+ $this->domain = $parts[2];
+ $this->path = $parts[3];
+ }
+ }
+
+ private static function parseURI($uri) {
+ // See T4913. Fail the parse if there is leading whitespace; stricter
+ // systems will not accept these URIs.
+ if (ltrim($uri) !== $uri) {
+ return null;
+ }
+
+ $user = '(?:([^@]+)@)?';
+ $domain = '([^:]+)';
+ $path = ':(.*)';
+
+ $regexp = '/^'.$user.$domain.$path.'$/';
+ $matches = null;
+ $ok = preg_match($regexp, $uri, $matches);
+ if ($ok) {
+ return array_pad($matches, 4, '');
+ }
+
+ return null;
+ }
+
+ public function __toString() {
+ $user = null;
+ if ($this->user) {
+ $user = $this->user.'@';
+ }
+
+ $domain = $this->domain;
+ $path = $this->path;
+
+ return $user.$domain.':'.$path;
+ }
+
+ public function setDomain($domain) {
+ $this->domain = $domain;
+ return $this;
+ }
+
+ public function getDomain() {
+ return $this->domain;
+ }
+
+ public function setPath($path) {
+ $this->path = $path;
+ return $this;
+ }
+
+ public function getPath() {
+ return $this->path;
+ }
+
+ public function setUser($user) {
+ $this->user = $user;
+ return $this;
+ }
+
+ public function getUser() {
+ return $this->user;
+ }
+
+}
diff --git a/src/parser/PhutilJSON.php b/src/parser/PhutilJSON.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilJSON.php
@@ -0,0 +1,155 @@
+encodeFormattedObject($object, 0)."\n";
+ }
+
+
+ /**
+ * Encode a list in JSON and pretty-print it, discarding keys.
+ *
+ * @param list List to encode in JSON.
+ * @return string Pretty-printed list representation.
+ */
+ public function encodeAsList(array $list) {
+ return $this->encodeFormattedArray($list, 0)."\n";
+ }
+
+
+/* -( Internals )---------------------------------------------------------- */
+
+
+ /**
+ * Pretty-print a JSON object.
+ *
+ * @param dict Object to format.
+ * @param int Current depth, for indentation.
+ * @return string Pretty-printed value.
+ * @task internal
+ */
+ private function encodeFormattedObject($object, $depth) {
+ if (empty($object)) {
+ return '{}';
+ }
+
+ $pre = $this->getIndent($depth);
+ $key_pre = $this->getIndent($depth + 1);
+ $keys = array();
+ $vals = array();
+ $max = 0;
+ foreach ($object as $key => $val) {
+ $ekey = $this->encodeFormattedValue((string)$key, 0);
+ $max = max($max, strlen($ekey));
+ $keys[] = $ekey;
+ $vals[] = $this->encodeFormattedValue($val, $depth + 1);
+ }
+ $key_lines = array();
+ foreach ($keys as $k => $key) {
+ $key_lines[] = $key_pre.$key.': '.$vals[$k];
+ }
+ $key_lines = implode(",\n", $key_lines);
+
+ $out = "{\n";
+ $out .= $key_lines;
+ $out .= "\n";
+ $out .= $pre.'}';
+
+ return $out;
+ }
+
+
+ /**
+ * Pretty-print a JSON list.
+ *
+ * @param list List to format.
+ * @param int Current depth, for indentation.
+ * @return string Pretty-printed value.
+ * @task internal
+ */
+ private function encodeFormattedArray($array, $depth) {
+ if (empty($array)) {
+ return '[]';
+ }
+
+ $pre = $this->getIndent($depth);
+ $val_pre = $this->getIndent($depth + 1);
+
+ $vals = array();
+ foreach ($array as $val) {
+ $vals[] = $val_pre.$this->encodeFormattedValue($val, $depth + 1);
+ }
+ $val_lines = implode(",\n", $vals);
+
+ $out = "[\n";
+ $out .= $val_lines;
+ $out .= "\n";
+ $out .= $pre.']';
+
+ return $out;
+ }
+
+
+ /**
+ * Pretty-print a JSON value.
+ *
+ * @param dict Value to format.
+ * @param int Current depth, for indentation.
+ * @return string Pretty-printed value.
+ * @task internal
+ */
+ private function encodeFormattedValue($value, $depth) {
+ if (is_array($value)) {
+ if (empty($value) || array_keys($value) === range(0, count($value) - 1)) {
+ return $this->encodeFormattedArray($value, $depth);
+ } else {
+ return $this->encodeFormattedObject($value, $depth);
+ }
+ } else {
+ if (defined('JSON_UNESCAPED_SLASHES')) {
+ // If we have a new enough version of PHP, disable escaping of slashes
+ // when pretty-printing values. Escaping slashes can defuse an attack
+ // where the attacker embeds "" inside a JSON string, but that
+ // isn't relevant when rendering JSON for human viewers.
+ return json_encode($value, JSON_UNESCAPED_SLASHES);
+ } else {
+ return json_encode($value);
+ }
+ }
+ }
+
+
+ /**
+ * Render a string corresponding to the current indent depth.
+ *
+ * @param int Current depth.
+ * @return string Indentation.
+ * @task internal
+ */
+ private function getIndent($depth) {
+ if (!$depth) {
+ return '';
+ } else {
+ return str_repeat(' ', $depth);
+ }
+ }
+
+}
diff --git a/src/parser/PhutilJSONParser.php b/src/parser/PhutilJSONParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilJSONParser.php
@@ -0,0 +1,62 @@
+allowDuplicateKeys = $allow_duplicate_keys;
+ return $this;
+ }
+
+ public function parse($json) {
+ $jsonlint_root = phutil_get_library_root('phutil').'/../externals/jsonlint';
+ require_once $jsonlint_root.'/src/Seld/JsonLint/JsonParser.php';
+ require_once $jsonlint_root.'/src/Seld/JsonLint/Lexer.php';
+ require_once $jsonlint_root.'/src/Seld/JsonLint/ParsingException.php';
+ require_once $jsonlint_root.'/src/Seld/JsonLint/Undefined.php';
+
+ $parser = new JsonLintJsonParser();
+ try {
+ $output = $parser->parse($json, $this->getFlags());
+ } catch (JsonLintParsingException $ex) {
+ $details = $ex->getDetails();
+ $message = preg_replace("/^Parse error .*\\^\n/s", '', $ex->getMessage());
+
+ throw new PhutilJSONParserException(
+ $message,
+ idx(idx($details, 'loc', array()), 'last_line'),
+ idx(idx($details, 'loc', array()), 'last_column'),
+ idx($details, 'token'),
+ idx($details, 'expected'));
+ }
+
+ if (!is_array($output)) {
+ throw new PhutilJSONParserException(
+ pht(
+ '%s is not a valid JSON object.',
+ PhutilReadableSerializer::printShort($json)));
+ }
+
+ return $output;
+ }
+
+ private function getFlags() {
+ $flags = JsonLintJsonParser::PARSE_TO_ASSOC;
+
+ if ($this->allowDuplicateKeys) {
+ $flags |= JsonLintJsonParser::ALLOW_DUPLICATE_KEYS;
+ } else {
+ $flags |= JsonLintJsonParser::DETECT_KEY_CONFLICTS;
+ }
+
+ return $flags;
+ }
+
+}
diff --git a/src/parser/PhutilLanguageGuesser.php b/src/parser/PhutilLanguageGuesser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilLanguageGuesser.php
@@ -0,0 +1,47 @@
+ 1,
+ // Capture "#!/usr/bin/php" sorts of things.
+ '@^#!.*bin/(\S+)@' => 1,
+ // Capture initial " 1,
+ // Capture emacs "mode" header.
+ '@^.*-[*]-.*mode\s*:\s*(\S+).*-[*]-.*$@m' => 1,
+ // Look for things that seem to be diffs.
+ '/^---.*$\n^[+]{3}.*$\n^@@/m' => 'diff',
+ '/^diff --git/' => 'diff',
+ // Look for plausible console output.
+ '@^(?:\S+[\\\\/] )?[$] @' => 'console',
+ );
+
+ foreach ($patterns as $pattern => $language) {
+ $matches = null;
+ if (preg_match($pattern, $source, $matches)) {
+ if (is_numeric($language)) {
+ return $matches[$language];
+ } else {
+ return $language;
+ }
+ }
+ }
+
+ return null;
+ }
+
+}
diff --git a/src/parser/PhutilParserGenerator.php b/src/parser/PhutilParserGenerator.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilParserGenerator.php
@@ -0,0 +1,910 @@
+setTerminals(array('a', 'b'))
+ * ->setStartRule('S')
+ * ->setRules(
+ * array(
+ * 'S' => 'A b',
+ * 'A' => array(
+ * 'A a',
+ * 'a',
+ * )))
+ * ->processGrammar();
+ *
+ * To actually parse token streams, use @{method:parseTokens}.
+ *
+ * $tokens = get_tokens(); // Usually from PhutilLexer
+ * $callback = 'some_callback';
+ * $tree = $parser->parseTokens($tokens, $callback);
+ *
+ * The callback is invoked when a grammar rule matches. It should have this
+ * signature:
+ *
+ * function parser_callback($rule, $production, array $tokens) {
+ * // ...
+ * }
+ *
+ * The `$rule` is the matching rule; the `$production` is the matching
+ * production, and `$tokens` is the matching tokens (for terminal rules) or the
+ * return value of previous parse callbacks (for nonterminal rules).
+ *
+ * You should either return a result of evaluation, or some sort of abstract
+ * representation of the parse tree (this is more likely to be useful for more
+ * complex grammars).
+ *
+ * NOTE: This class generates LR(1) parsers, which perform less-than-optimally
+ * on large grammars. Worse, it is written in PHP. It is suitable only for
+ * very simple grammars with few states.
+ *
+ * NOTE: These parsers silently resolve reduce/reduce conflicts by choosing the
+ * first reduction, and silently resolve shift/reduce conflicts by shifting.
+ * These are the same rules used by Yacc, but are implicit.
+ *
+ * @task rules Grammar Rules
+ * @task rvalidation Rule Validation
+ * @task first Computing First()
+ * @task tables Computing Action and Goto Tables
+ * @task inspect Inspecting Generator State
+ */
+final class PhutilParserGenerator extends Phobject {
+
+ private $terminals;
+ private $rules;
+ private $startRule = 'start';
+ private $states = array();
+ private $sets = array();
+ private $successor = array();
+ private $setHashes = array();
+ private $actionTable;
+ private $gotoTable;
+
+ private $rulesValidated = false;
+ private $eofSymbol;
+ private $initSymbol;
+ private $epsilonSymbol;
+ private $endSymbol;
+
+ private $firstTable;
+
+ public function processGrammar() {
+ $this->validateRules();
+ $this->buildFirstTable();
+
+ $init = $this->getInitSymbol();
+ $eof = $this->getEOFSymbol();
+ $end = $this->getEndSymbol();
+
+ $this->rules[$init] = array(
+ array($this->startRule, $end),
+ );
+ list($is_new, $state) = $this->addState(
+ array(
+ array($this->getInitSymbol(), 0, 0, $eof),
+ ));
+ $this->buildSuccessors($state);
+
+ $this->buildTables();
+
+ return $this;
+ }
+
+
+/* -( Grammar Rules )------------------------------------------------------ */
+
+
+ public function setTerminals(array $terminals) {
+ $this->terminals = array_fill_keys($terminals, true);
+ return $this;
+ }
+
+ public function setRules(array $rules) {
+ $this->rules = $rules;
+ return $this;
+ }
+
+ public function setStartRule($rule_name) {
+ $this->startRule = $rule_name;
+ return $this;
+ }
+
+ public function getStartRule() {
+ return $this->startRule;
+ }
+
+ public function getEOFSymbol() {
+ if ($this->eofSymbol === null) {
+ throw new PhutilInvalidStateException('processGrammar');
+ }
+ return $this->eofSymbol;
+ }
+
+ public function getInitSymbol() {
+ if ($this->initSymbol === null) {
+ throw new PhutilInvalidStateException('processGrammar');
+ }
+ return $this->initSymbol;
+ }
+
+ public function getEpsilonSymbol() {
+ if ($this->epsilonSymbol === null) {
+ throw new PhutilInvalidStateException('processGrammar');
+ }
+ return $this->epsilonSymbol;
+ }
+
+ public function getEndSymbol() {
+ if ($this->endSymbol === null) {
+ throw new PhutilInvalidStateException('processGrammar');
+ }
+ return $this->endSymbol;
+ }
+
+ public function isTerminal($symbol) {
+ return isset($this->terminals[$symbol]);
+ }
+
+ public function isRule($symbol) {
+ return isset($this->rules[$symbol]);
+ }
+
+
+/* -( Rule Validation )---------------------------------------------------- */
+
+
+ /**
+ * Perform a battery of tests on the provided rules to detect problems which
+ * would prevent us from generating a parser.
+ *
+ * @return void
+ * @task rvalidation
+ */
+ private function validateRules() {
+ // Rules must be specified in the right format.
+ $this->parseRules();
+
+ // Rules must contain only known symbols.
+ $this->validateRuleSymbols();
+
+ // The start rule must exist and be valid.
+ $this->validateStartRule();
+
+ // Now, we select printable names for special symbols (EOF, epsilon, etc)
+ // that don't conflict with any symbols in the grammar.
+ $this->chooseSpecialSymbols();
+
+ // Make sure every terminal can be reached by some rule.
+ $this->validateAllTerminalsReachable();
+
+ // Make sure every rule can be reached.
+ $this->validateAllRulesReachable();
+
+ // Make sure every rule has some valid reduction.
+ $this->validateAllRulesReducible();
+
+ $this->rulesValidated = true;
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function parseRules() {
+ foreach ($this->rules as $rule_name => $rule_variants) {
+ if (!is_array($rule_variants)) {
+ $rule_variants = array($rule_variants);
+ $this->rules[$rule_name] = $rule_variants;
+ }
+ foreach ($rule_variants as $vkey => $variant) {
+ if ($variant === null) {
+ $variant = array(null);
+ } else if (!is_array($variant)) {
+ $variant = preg_split('/\s+/', $variant);
+ } else {
+ foreach ($variant as $symbol) {
+ if (($symbol === null) && count($variant) > 1) {
+ throw new PhutilInvalidRuleParserGeneratorException(
+ pht(
+ "Rule '%s' contains a production '%s' which is ".
+ "nonempty but has a null in it. A rule with other ".
+ "may not contain null.",
+ $rule_name,
+ $vkey));
+ }
+ }
+ }
+ $this->rules[$rule_name][$vkey] = array_values($variant);
+ }
+ }
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function validateRuleSymbols() {
+ foreach ($this->rules as $rule => $productions) {
+ foreach ($productions as $production_name => $production) {
+ foreach ($production as $symbol) {
+ if ($symbol === null) {
+ continue;
+ }
+ if ($this->isTerminal($symbol)) {
+ continue;
+ }
+ if ($this->isRule($symbol)) {
+ continue;
+ }
+ $production_string = implode(' ', $production);
+ throw new PhutilUnknownSymbolParserGeneratorException(
+ pht(
+ "Symbol '%s' in production '%s' ('%s') of rule '%s' does not ".
+ "name a rule or terminal. Did you misspell a symbol, fail to ".
+ "specify a terminal, or forget a rule?",
+ $symbol,
+ $production_name,
+ $production_string,
+ $rule));
+ }
+ }
+ }
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function validateStartRule() {
+ $start_rule = $this->getStartRule();
+ if (!$this->isRule($start_rule)) {
+ throw new PhutilUnknownSymbolParserGeneratorException(
+ pht(
+ "Start rule '%s' does not appear in the rules for the grammar. Use ".
+ "%s to choose a different start rule, or add a rule named '%s'.",
+ $start_rule,
+ 'setStartRule()',
+ $start_rule));
+ }
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function chooseSpecialSymbols() {
+ $special = array(
+ 'eofSymbol' => '(end-of-file)',
+ 'epsilonSymbol' => '(epsilon)',
+ 'initSymbol' => '(init)',
+ 'endSymbol' => '(end)',
+ );
+
+ foreach ($special as $key => $value) {
+ while ($this->isRule($value) || $this->isTerminal($value)) {
+ $value .= "'";
+ }
+ $special[$key] = $value;
+ }
+
+ $this->eofSymbol = $special['eofSymbol'];
+ $this->epsilonSymbol = $special['epsilonSymbol'];
+ $this->initSymbol = $special['initSymbol'];
+ $this->endSymbol = $special['endSymbol'];
+
+ foreach ($this->rules as $rule => $productions) {
+ foreach ($productions as $production_name => $production) {
+ foreach ($production as $key => $symbol) {
+ if ($symbol === null) {
+ $this->rules[$rule][$production_name][$key] = $this->epsilonSymbol;
+ }
+ }
+ $this->rules[$rule][$production_name][] = $this->endSymbol;
+ }
+ }
+
+ $this->terminals[$this->getEOFSymbol()] = true;
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function validateAllTerminalsReachable() {
+ $seen = array();
+ foreach ($this->rules as $rule => $productions) {
+ foreach ($productions as $production) {
+ foreach ($production as $symbol) {
+ $seen[$symbol] = true;
+ }
+ }
+ }
+
+ $missing = array_diff_key($this->terminals, $seen);
+ unset($missing[$this->getEOFSymbol()]);
+ if ($missing) {
+ $missing_terminals = array_keys($missing);
+ $missing_terminals = implode(', ', $missing_terminals);
+ throw new PhutilUnreachableTerminalParserGeneratorException(
+ pht(
+ 'Some terminals do not appear in any rule: %s',
+ $missing_terminals));
+ }
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function validateAllRulesReachable() {
+ $stack = array();
+ $reachable = $this->computeReachableRules($this->getStartRule(), $stack);
+
+ $missing = array_diff_key($this->rules, $reachable);
+ unset($missing[$this->getStartRule()]);
+
+ if ($missing) {
+ $missing_rules = array_keys($missing);
+ $missing_rules = implode(', ', $missing_rules);
+ throw new PhutilUnreachableRuleParserGeneratorException(
+ pht(
+ 'Some rules can never be reached from any production: %s',
+ $missing_rules));
+ }
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function computeReachableRules($rule, array &$stack) {
+ if (isset($stack[$rule])) {
+ return $stack[$rule];
+ }
+
+ $stack[$rule] = array();
+
+ foreach ($this->rules[$rule] as $production) {
+ foreach ($production as $symbol) {
+ if ($this->isRule($symbol)) {
+ $stack[$rule][$symbol] = true;
+ $stack[$rule] += $this->computeReachableRules($symbol, $stack);
+ }
+ }
+ }
+
+ return $stack[$rule];
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function validateAllRulesReducible() {
+ $reducible = array();
+ foreach ($this->rules as $rule => $productions) {
+ if (!$this->isRuleReducible($rule, $reducible)) {
+ throw new PhutilIrreducibleRuleParserGeneratorException(
+ pht(
+ "Rule '%s' can never be reduced: it recurses indefinitely ".
+ "and reaches no production of terminals.",
+ $rule));
+ }
+ }
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function isRuleReducible($rule, array &$reducible) {
+ if (isset($reducible[$rule])) {
+ return $reducible[$rule];
+ }
+
+ // Set this ahead of time so we don't end up in an infinite loop if
+ // rules recurse. We'll overwrite it if we find a reduction.
+ $reducible[$rule] = false;
+ $reducible[$rule] = $this->computeRuleReducible($rule, $reducible);
+ return $reducible[$rule];
+ }
+
+
+ /**
+ * @task rvalidation
+ */
+ private function computeRuleReducible($rule, array &$reducible) {
+ $epsilon = $this->getEpsilonSymbol();
+ $end = $this->getEndSymbol();
+
+ $productions = $this->rules[$rule];
+
+ // In the first pass, try to find a trivially reducible production, e.g. one
+ // with epsilon or only terminals. Also, remove recursive productions (those
+ // which directly involve the rule itself) because we know we won't be able
+ // to reduce them. If we're lucky, this will allow us to determine that the
+ // rule is reducible without recursion. For example, we can immediately
+ // reduce these productions:
+ //
+ // R -> a
+ // R -> b c d
+ // R -> (epsilon)
+ //
+ // We can never reduce these productions:
+ //
+ // R -> R
+ // R -> a R b
+ //
+ // We might be able to reduce these productions, but they aren't as cheap
+ // or easy to figure out, since we need to first determine if other rules
+ // can be reduced:
+ //
+ // R -> X Y
+ // R -> X a
+ //
+ // If we find a reduction, we return immediately.
+
+ foreach ($productions as $key => $production) {
+ $has_only_terminals = true;
+ foreach ($production as $symbol) {
+ if ($symbol == $end) {
+ break;
+ } else if ($symbol == $epsilon) {
+ // The rule contains an epsilon production, which can always reduce
+ // it.
+ return true;
+ } else if ($symbol == $rule) {
+ // The rule contains itself; this production is never reducible. We
+ // must find another reducible production.
+ unset($productions[$key]);
+ continue 2;
+ } else if ($this->isTerminal($symbol)) {
+ // This is a terminal; keep looking. We'll be able to reduce the
+ // production if it contains only terminals.
+ continue;
+ } else {
+ // This is a rule, so we can't trivially reduce it. We'll keep it
+ // for the next round if we can't find any trivial reductions.
+ $has_only_terminals = false;
+ break;
+ }
+ }
+
+ if ($has_only_terminals) {
+ return true;
+ }
+ }
+
+ // If we have no productions left, this rule can't be reduced.
+ if (empty($productions)) {
+ return false;
+ }
+
+ // We have remaining productions which include other rules. Look for a
+ // nontrivial reduction. For example:
+ //
+ // R -> X Y
+ // X -> x
+ // Y -> y
+ //
+ // In this case, X and Y are both reducible, so "X Y" is reducible and thus
+ // R is reducible.
+ foreach ($productions as $production) {
+ $can_reduce = true;
+ foreach ($production as $symbol) {
+ // NOTE: We don't need to check for epsilon here, because we would
+ // already have determined the rule was reducible if we had an epsilon
+ // production.
+ if ($symbol == $end) {
+ break;
+ } else if ($this->isTerminal($symbol)) {
+ continue;
+ } else if (!$this->isRuleReducible($symbol, $reducible)) {
+ $can_reduce = false;
+ break;
+ }
+ }
+
+ if ($can_reduce) {
+ // The production contained only terminals and reducible rules, so it
+ // is reducible. We're good and don't need to examine remaining
+ // productions.
+ return true;
+ }
+ }
+
+ // We didn't find any reducible productions.
+ return false;
+ }
+
+
+/* -( Computing First() )-------------------------------------------------- */
+
+
+ private function buildFirstTable() {
+ $this->firstTable = array();
+ foreach ($this->rules as $rule => $productions) {
+ $this->buildRuleFirst($rule);
+ }
+ }
+
+ private function buildRuleFirst($rule) {
+ if (isset($this->firstTable[$rule])) {
+ return $this->firstTable[$rule];
+ }
+
+ $this->firstTable[$rule] = array();
+ $productions = $this->rules[$rule];
+ foreach ($productions as $key => $production) {
+ $this->firstTable[$rule] += $this->getFirstForProduction($production);
+ }
+
+ return $this->firstTable[$rule];
+ }
+
+ private function getFirstForProduction(array $production) {
+ $set = array();
+
+ $end = $this->getEndSymbol();
+ $epsilon = $this->getEpsilonSymbol();
+ $eof = $this->getEOFSymbol();
+
+ $accept_epsilon = true;
+ foreach ($production as $symbol) {
+ if ($symbol === $end) {
+ break;
+ } else if ($symbol === $epsilon) {
+ break;
+ } else if ($this->isTerminal($symbol)) {
+ $set[$symbol] = true;
+ $accept_epsilon = false;
+ break;
+ } else {
+ $symbol_set = $this->buildRuleFirst($symbol);
+
+ $has_epsilon = isset($symbol_set[$epsilon]);
+ unset($symbol_set[$epsilon]);
+ $set += $symbol_set;
+ if (!$has_epsilon) {
+ $accept_epsilon = false;
+ break;
+ }
+ }
+ }
+
+ if ($accept_epsilon) {
+ $set[$epsilon] = true;
+ }
+
+ return $set;
+ }
+
+
+/* -( Computing States )--------------------------------------------------- */
+
+
+ private function addState(array $set) {
+ $seen = array();
+ foreach ($set as $item) {
+ $seen[$item[0]][$item[1]][$item[2]][$item[3]] = true;
+ }
+
+ $end = $this->getEndSymbol();
+ $epsilon = $this->getEpsilonSymbol();
+
+ for ($ii = 0; $ii < count($set); $ii++) {
+ $item = $set[$ii];
+
+ $production = $this->rules[$item[0]][$item[1]];
+ $next = $production[$item[2]];
+ if ($this->isTerminal($next)) {
+ continue;
+ } else if ($next === $epsilon) {
+ continue;
+ } else if ($next === $end) {
+ continue;
+ }
+
+ $v = array_slice($production, $item[2] + 1, -1);
+ $v[] = $item[3];
+ $v[] = $end;
+
+ $firsts = $this->getFirstForProduction($v);
+
+ foreach ($firsts as $nfirst => $ignored) {
+ if (!$this->isTerminal($nfirst)) {
+ unset($firsts[$nfirst]);
+ }
+ }
+
+ foreach ($this->rules[$next] as $pkey => $nproduction) {
+ foreach ($firsts as $nfirst => $ignored) {
+ if (isset($seen[$next][$pkey][0][$nfirst])) {
+ continue;
+ }
+ $set[] = array($next, $pkey, 0, $nfirst);
+ $seen[$next][$pkey][0][$nfirst] = true;
+ }
+ }
+ }
+
+ $hash = $this->hashSet($set);
+ if (isset($this->setHashes[$hash])) {
+ return array(false, $this->setHashes[$hash]);
+ }
+
+ $this->states[] = $set;
+ $state = last_key($this->states);
+ $this->setHashes[$hash] = $state;
+
+ return array(true, $state);
+ }
+
+ private function buildSuccessors($start_state) {
+ $end = $this->getEndSymbol();
+
+ $nexts = array();
+ foreach ($this->states[$start_state] as $item) {
+ $next = $this->rules[$item[0]][$item[1]][$item[2]];
+ if ($next === $end) {
+ continue;
+ }
+ $nexts[$next][] = array(
+ $item[0],
+ $item[1],
+ $item[2] + 1,
+ $item[3],
+ );
+ }
+
+ foreach ($nexts as $next => $items) {
+ list($is_new, $state) = $this->addState($items);
+ $this->successor[$start_state][$next] = $state;
+ if ($is_new) {
+ $this->buildSuccessors($state);
+ }
+ }
+ }
+
+ private function hashSet(array $set) {
+ foreach ($set as $k => $item) {
+ $set[$k] = implode("\0", $item);
+ }
+ sort($set);
+ $set = implode("\1", $set);
+
+ return md5($set);
+ }
+
+
+ private function buildTables() {
+ $action = array();
+ $goto = array();
+
+ $end = $this->getEndSymbol();
+ $eof = $this->getEOFSymbol();
+ $init = $this->getInitSymbol();
+
+ foreach ($this->states as $state => $items) {
+ $shift = array();
+ $reduce = array();
+ $accept = false;
+ foreach ($items as $item) {
+ $next = $this->rules[$item[0]][$item[1]][$item[2]];
+ if ($next == $end) {
+ if ($item[0] !== $init) {
+ $reduce[$item[3]][] = $item;
+ } else if ($item[0] === $init && $item[3] === $eof) {
+ $accept = $item;
+ }
+ } else if ($this->isTerminal($next)) {
+ $shift[$next] = $item;
+ } else {
+ $goto[$state][$next] = $this->successor[$state][$next];
+ }
+ }
+
+ foreach ($reduce as $next => $reductions) {
+ if (count($reductions) > 1) {
+ $ways = array();
+ foreach ($reductions as $reduction) {
+ $ways[] = "{$reduction[0]}/{$reduction[1]}";
+ }
+ $ways = implode('; ', $ways);
+
+ // TODO: As below, we should have more explicit handling of
+ // reduce/reduce conflicts. For now, just pick the first one.
+
+ if (false) {
+ throw new Exception(
+ pht(
+ "Reduce/reduce conflict: from state '%s', when a ".
+ "'%s' is encountered, it may be reduced in multiple ".
+ "ways: %s",
+ $state,
+ $next,
+ $ways));
+ }
+ }
+ $reduce[$next] = head($reductions);
+ }
+
+ $srconflicts = array_intersect_key($shift, $reduce);
+ foreach ($srconflicts as $next => $ignored) {
+
+ // TODO: We should probably have better or more explicit handling of
+ // shift/reduce conflicts. For now, we just shift.
+
+ if (false) {
+ $what = $reduce[$next][0];
+ throw new Exception(
+ pht(
+ "Shift/reduce conflict: from state '%s', when a '%s' ".
+ "is encountered, shifting conflicts with reducing '%s'.",
+ $state,
+ $next,
+ $what));
+ } else {
+ // Resolve the shift/reduce by shifting.
+ $reduce = array();
+ }
+ }
+
+ if ($accept && isset($shift[$eof])) {
+ throw new Exception(pht('Accept/shift conflict!'));
+ }
+
+ if ($accept && isset($reduce[$eof])) {
+ throw new Exception(pht('Accept/reduce conflict!'));
+ }
+
+ foreach ($reduce as $next => $item) {
+ $action[$state][$next] = array(
+ 'R',
+ array(
+ $item[0],
+ $item[1],
+ count($this->rules[$item[0]][$item[1]]) - 1,
+ ),
+ );
+ }
+
+ foreach ($shift as $next => $item) {
+ $action[$state][$next] = array(
+ 'S',
+ $this->successor[$state][$next],
+ );
+ }
+
+ if ($accept) {
+ $action[$state][$eof] = array('A');
+ }
+ }
+
+ $this->actionTable = $action;
+ $this->gotoTable = $goto;
+ }
+
+ public function generateParserFunction($name) {
+ $out = array();
+ $out[] = 'function '.$name.'(array $tokens, $callback) {';
+ $out[] = ' return '.__CLASS__.'::parseTokensWithTables(';
+ $out[] = ' '.$this->formatAndIndent($this->actionTable, 4).',';
+ $out[] = ' '.$this->formatAndIndent($this->gotoTable, 4).',';
+ $out[] = ' '.$this->formatAndIndent($this->getEOFSymbol(), 4).',';
+ $out[] = ' $tokens,';
+ $out[] = ' $callback);';
+ $out[] = '}';
+ return implode("\n", $out);
+ }
+
+ private function formatAndIndent($var, $depth) {
+ $var = phutil_var_export($var);
+ $var = str_replace("\n", "\n".str_repeat(' ', $depth), $var);
+
+ return $var;
+ }
+
+ public function parseTokens(array $tokens, $callback) {
+ return self::parseTokensWithTables(
+ $this->actionTable,
+ $this->gotoTable,
+ $this->getEOFSymbol(),
+ $tokens,
+ $callback);
+ }
+
+ public static function parseTokensWithTables(
+ $action_table,
+ $goto_table,
+ $eof_symbol,
+ array $tokens,
+ $callback) {
+
+ $state_stack = array(0);
+ $token_stack = array();
+
+ $tokens = array_reverse($tokens);
+ while (true) {
+ $state = end($state_stack);
+
+ if (empty($tokens)) {
+ $next = $eof_symbol;
+ } else {
+ $next_token = end($tokens);
+ $next = $next_token[0];
+ }
+
+ if (!isset($action_table[$state][$next])) {
+ $expected = implode(', ', array_keys($action_table[$state]));
+ throw new Exception(
+ pht(
+ "Unexpected '%s' in state %s! Expected: %s",
+ $next,
+ $state,
+ $expected));
+ }
+
+ $action = $action_table[$state][$next];
+
+ switch ($action[0]) {
+ case 'S':
+ $state_stack[] = $action[1];
+ $token_stack[] = array_pop($tokens);
+ break;
+ case 'R':
+ $r_rule = $action[1][0];
+ $r_prod = $action[1][1];
+ $r_size = $action[1][2];
+
+ $token_v = array();
+ while ($r_size--) {
+ $token_v[] = array_pop($token_stack);
+ array_pop($state_stack);
+ }
+ $token_v = array_reverse($token_v);
+ $token_stack[] = call_user_func_array(
+ $callback,
+ array($r_rule, $r_prod, $token_v));
+ $goto = $goto_table[end($state_stack)][$r_rule];
+ $state_stack[] = $goto;
+ break;
+ case 'A':
+ break 2;
+ }
+ }
+
+ return head($token_stack);
+ }
+
+
+/* -( Inspecting Generator State )----------------------------------------- */
+
+
+ /**
+ * @task inspect
+ */
+ public function inspectRules() {
+ if (!$this->rulesValidated) {
+ throw new PhutilInvalidStateException('processGrammar');
+ }
+ return $this->rules;
+ }
+
+
+ /**
+ * @task inspect
+ */
+ public function inspectFirstTable() {
+ if ($this->firstTable === null) {
+ throw new PhutilInvalidStateException('processGrammar');
+ }
+ return $this->firstTable;
+ }
+
+
+}
diff --git a/src/parser/PhutilPygmentizeParser.php b/src/parser/PhutilPygmentizeParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilPygmentizeParser.php
@@ -0,0 +1,83 @@
+map = $map;
+ return $this;
+ }
+
+ public function getMap() {
+ return $this->map;
+ }
+
+ public function parse($block) {
+ $class_look = 'class="';
+ $class_len = strlen($class_look);
+
+ $class_start = null;
+
+ $map = $this->map;
+
+ $len = strlen($block);
+ $out = '';
+ $mode = 'text';
+ for ($ii = 0; $ii < $len; $ii++) {
+ $c = $block[$ii];
+ switch ($mode) {
+ case 'text':
+ // We're in general text between tags, and just passing characers
+ // through unmodified.
+ if ($c == '<') {
+ $mode = 'tag';
+ }
+ $out .= $c;
+ break;
+ case 'tag':
+ // We're inside a tag, and looking for `class="` so we can rewrite
+ // it.
+ if ($c == '>') {
+ $mode = 'text';
+ }
+ if ($c == 'c') {
+ if (!substr_compare($block, $class_look, $ii, $class_len)) {
+ $mode = 'class';
+ $ii += $class_len;
+ $class_start = $ii;
+ }
+ }
+
+ if ($mode != 'class') {
+ $out .= $c;
+ }
+ break;
+ case 'class':
+ // We're inside a `class="..."` tag, and looking for the ending quote
+ // so we can replace it.
+ if ($c == '"') {
+ $class = substr($block, $class_start, $ii - $class_start);
+
+ // If this class is present in the map, rewrite it into an inline
+ // style attribute.
+ if (isset($map[$class])) {
+ $out .= 'style="'.phutil_escape_html($map[$class]).'"';
+ } else {
+ $out .= 'class="'.$class.'"';
+ }
+
+ $mode = 'tag';
+ }
+ break;
+ }
+ }
+
+ return $out;
+ }
+
+}
diff --git a/src/parser/PhutilQueryStringParser.php b/src/parser/PhutilQueryStringParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilQueryStringParser.php
@@ -0,0 +1,139 @@
+ 'z',
+ * );
+ *
+ * ...with the `.` replaced with an underscore, `_`. Other characters converted
+ * in this way include space and unmatched opening brackets.
+ *
+ * Broadly, this is part of the terrible legacy of `register_globals`. Since
+ * we'd like to be able to parse all valid query strings without destroying any
+ * data, this class implements a less-encumbered parser.
+ */
+final class PhutilQueryStringParser extends Phobject {
+
+
+ /**
+ * Parses a query string into a dictionary, applying PHP rules for handling
+ * array nomenclature (like `a[]=1`) in parameter names.
+ *
+ * For a more basic parse, see @{method:parseQueryStringToPairList}.
+ *
+ * @param string Query string.
+ * @return map Parsed dictionary.
+ */
+ public function parseQueryString($query_string) {
+ $result = array();
+
+ $list = $this->parseQueryStringToPairList($query_string);
+ foreach ($list as $parts) {
+ list($key, $value) = $parts;
+ if (!strlen($key)) {
+ continue;
+ }
+ $this->parseQueryKeyToArr($key, $value, $result);
+ }
+
+ return $result;
+ }
+
+
+ /**
+ * Parses a query string into a basic list of pairs, without handling any
+ * array information in the keys. For example:
+ *
+ * a[]=1&a[]=2
+ *
+ * ...will parse into:
+ *
+ * array(
+ * array('a[]', '1'),
+ * array('a[]', '2'),
+ * );
+ *
+ * Use @{method:parseQueryString} to produce a more sophisticated parse which
+ * applies array rules and returns a dictionary.
+ *
+ * @param string Query string.
+ * @return list> List of parsed parameters.
+ */
+ public function parseQueryStringToPairList($query_string) {
+ $list = array();
+
+ if (!strlen($query_string)) {
+ return $list;
+ }
+
+ $pairs = explode('&', $query_string);
+ foreach ($pairs as $pair) {
+ if (!strlen($pair)) {
+ continue;
+ }
+ $parts = explode('=', $pair, 2);
+ if (count($parts) < 2) {
+ $parts[] = '';
+ }
+ $list[] = array(
+ urldecode($parts[0]),
+ urldecode($parts[1]),
+ );
+ }
+
+ return $list;
+ }
+
+
+ /**
+ * Treats the key as a flat query that potentially has square brackets. If
+ * there are square brackets we parse them into an array.
+ *
+ * Example input:
+ * $key = "email[0]";
+ * $val = "my@example.com";
+ *
+ * Example output:
+ * array("email" => array(0 => "my@example.com"));
+ *
+ * @param string $key
+ * @param string $val
+ * @param array $input_arr
+ */
+ private function parseQueryKeyToArr($key, $val, array &$input_arr) {
+ if (preg_match('/^[^\[\]]+(?:\[[^\[\]]*\])+$/', $key)) {
+ $key_pieces = preg_split('/\]?\[/', rtrim($key, ']'));
+ if ($key_pieces) {
+ $cursor = &$input_arr;
+ foreach ($key_pieces as $piece) {
+ if (strlen($piece)) {
+ if (empty($cursor[$piece]) || !is_array($cursor[$piece])) {
+ $cursor[$piece] = array();
+ }
+ } else {
+ $cursor[] = array();
+ $piece = last_key($cursor);
+ }
+ $cursor = &$cursor[$piece];
+ }
+
+ $cursor = $val;
+ unset($cursor);
+ }
+ } else {
+ $input_arr[$key] = $val;
+ }
+ }
+}
diff --git a/src/parser/PhutilSimpleOptions.php b/src/parser/PhutilSimpleOptions.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilSimpleOptions.php
@@ -0,0 +1,195 @@
+ '4',
+ * 'eyes' => '2',
+ * );
+ *
+ * @param string Input option list.
+ * @return dict Parsed dictionary.
+ * @task parse
+ */
+ public function parse($input) {
+ $result = array();
+
+ $lexer = new PhutilSimpleOptionsLexer();
+ $tokens = $lexer->getNiceTokens($input);
+
+ $state = 'key';
+ $pairs = array();
+ foreach ($tokens as $token) {
+ list($type, $value) = $token;
+ switch ($state) {
+ case 'key':
+ if ($type != 'word') {
+ return array();
+ }
+ if (!strlen($value)) {
+ return array();
+ }
+ $key = $this->normalizeKey($value);
+ $state = '=';
+ break;
+ case '=':
+ if ($type == '=') {
+ $state = 'value';
+ break;
+ }
+ if ($type == ',') {
+ $pairs[] = array($key, true);
+ $state = 'key';
+ break;
+ }
+ return array();
+ case 'value':
+ if ($type == ',') {
+ $pairs[] = array($key, null);
+ $state = 'key';
+ break;
+ }
+ if ($type != 'word') {
+ return array();
+ }
+ $pairs[] = array($key, $value);
+ $state = ',';
+ break;
+ case ',':
+ if ($type == 'word') {
+ $pair = array_pop($pairs);
+ $pair[1] .= $value;
+ $pairs[] = $pair;
+ break;
+ }
+ if ($type != ',') {
+ return array();
+ }
+ $state = 'key';
+ break;
+ }
+ }
+
+ if ($state == '=') {
+ $pairs[] = array($key, true);
+ }
+ if ($state == 'value') {
+ $pairs[] = array($key, null);
+ }
+
+ $result = array();
+ foreach ($pairs as $pair) {
+ list($key, $value) = $pair;
+ if ($value === null) {
+ unset($result[$key]);
+ } else {
+ $result[$key] = $value;
+ }
+ }
+
+ return $result;
+ }
+
+
+/* -( Unparsing Simple Options )------------------------------------------- */
+
+
+ /**
+ * Convert a dictionary into a simple option list. For example:
+ *
+ * array(
+ * 'legs' => '4',
+ * 'eyes' => '2',
+ * );
+ *
+ * ...becomes:
+ *
+ * legs=4, eyes=2
+ *
+ * @param dict Input dictionary.
+ * @param string Additional characters to escape.
+ * @return string Unparsed option list.
+ */
+ public function unparse(array $options, $escape = '') {
+ $result = array();
+ foreach ($options as $name => $value) {
+ $name = $this->normalizeKey($name);
+ if (!strlen($value)) {
+ continue;
+ }
+ if ($value === true) {
+ $result[] = $this->quoteString($name, $escape);
+ } else {
+ $qn = $this->quoteString($name, $escape);
+ $qv = $this->quoteString($value, $escape);
+ $result[] = $qn.'='.$qv;
+ }
+ }
+ return implode(', ', $result);
+ }
+
+
+/* -( Parser Configuration )----------------------------------------------- */
+
+
+ /**
+ * Configure case sensitivity of the parser. By default, the parser is
+ * case insensitive, so "legs=4" has the same meaning as "LEGS=4". If you
+ * set it to be case sensitive, the keys have different meanings.
+ *
+ * @param bool True to make the parser case sensitive, false (default) to
+ * make it case-insensitive.
+ * @return this
+ * @task config
+ */
+ public function setCaseSensitive($case_sensitive) {
+ $this->caseSensitive = $case_sensitive;
+ return $this;
+ }
+
+
+/* -( Internals )---------------------------------------------------------- */
+
+
+ private function normalizeKey($key) {
+ if (!strlen($key)) {
+ throw new Exception(pht('Empty key is invalid!'));
+ }
+ if (!$this->caseSensitive) {
+ $key = strtolower($key);
+ }
+ return $key;
+ }
+
+ private function quoteString($string, $escape) {
+ if (preg_match('/[^a-zA-Z0-9]/', $string)) {
+ $string = '"'.addcslashes($string, '\\\'"'.$escape).'"';
+ }
+ return $string;
+ }
+
+}
diff --git a/src/parser/PhutilTypeSpec.php b/src/parser/PhutilTypeSpec.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilTypeSpec.php
@@ -0,0 +1,1921 @@
+
+ * map
+ * type|type
+ *
+ * A type may be marked as optional by suffixing it with "?" or prefixing it
+ * with the word "optional":
+ *
+ * int?
+ * optional int
+ *
+ * A type may have a human-readable comment in parentheses, at the end:
+ *
+ * int (must be even)
+ *
+ * For example, these are valid type specifications:
+ *
+ * int|string
+ * map
+ * list>
+ * optional int
+ * string (uppercase)
+ *
+ */
+final class PhutilTypeSpec extends Phobject {
+
+ private $type;
+ private $subtypes = array();
+ private $optional;
+ private $comment;
+
+ private function __construct() {}
+
+ public function getType() {
+ return $this->type;
+ }
+
+ public function check($value, $name = null) {
+ switch ($this->type) {
+ case 'int':
+ if (!is_int($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'float':
+ if (!is_float($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'bool':
+ if (!is_bool($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'string':
+ if (!is_string($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'regex':
+ $trap = new PhutilErrorTrap();
+ $ok = @preg_match($value, '');
+ $err = $trap->getErrorsAsString();
+ $trap->destroy();
+
+ if ($ok === false) {
+ throw new PhutilTypeCheckException($this, $value, $name, $err);
+ }
+ break;
+ case 'null':
+ if (!is_null($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'list':
+ if (!is_array($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ if ($value && (array_keys($value) !== range(0, count($value) - 1))) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ try {
+ foreach ($value as $v) {
+ $this->subtypes[0]->check($v);
+ }
+ } catch (PhutilTypeCheckException $ex) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'map':
+ if (!is_array($value)) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ try {
+ foreach ($value as $k => $v) {
+ $this->subtypes[0]->check($k);
+ $this->subtypes[1]->check($v);
+ }
+ } catch (PhutilTypeCheckException $ex) {
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ break;
+ case 'or':
+ foreach ($this->subtypes as $subtype) {
+ try {
+ $subtype->check($value);
+ return;
+ } catch (PhutilTypeCheckException $ex) {
+ // Ignore.
+ }
+ }
+ throw new PhutilTypeCheckException($this, $value, $name);
+ case 'wild':
+ return;
+ default:
+ if (class_exists($this->type, false)) {
+ if ($value instanceof $this->type) {
+ return;
+ }
+ } else if (interface_exists($this->type, false)) {
+ if ($value instanceof $this->type) {
+ return;
+ }
+ }
+
+ throw new PhutilTypeCheckException($this, $value, $name);
+ }
+ }
+
+ public static function checkMap(array $values, array $types) {
+ $extra = array_diff_key($values, $types);
+ if ($extra) {
+ throw new PhutilTypeExtraParametersException($extra);
+ }
+
+ $missing = array();
+ foreach ($types as $key => $type) {
+ $types[$key] = self::newFromString($type);
+ if (!array_key_exists($key, $values)) {
+ if (!$types[$key]->optional) {
+ $missing[] = $key;
+ }
+ }
+ }
+
+ if ($missing) {
+ throw new PhutilTypeMissingParametersException($missing);
+ }
+
+ foreach ($types as $key => $type) {
+ if (array_key_exists($key, $values)) {
+ $type->check($values[$key], $key);
+ }
+ }
+ }
+
+ public static function getCommonParentClass($class_a, $class_b) {
+ // Make sure both classes are really classes.
+ try {
+ if (!class_exists($class_a) || !class_exists($class_b)) {
+ return null;
+ }
+ } catch (PhutilMissingSymbolException $ex) {
+ return null;
+ }
+
+ $ancestors_a = array();
+ do {
+ $ancestors_a[] = $class_a;
+ } while ($class_a = get_parent_class($class_a));
+
+ $ancestors_b = array();
+ do {
+ $ancestors_b[] = $class_b;
+ } while ($class_b = get_parent_class($class_b));
+
+ return head(array_intersect($ancestors_a, $ancestors_b));
+ }
+
+ public static function getTypeOf($value) {
+ if (is_int($value)) {
+ return 'int';
+ } else if (is_float($value)) {
+ return 'float';
+ } else if (is_bool($value)) {
+ return 'bool';
+ } else if (is_string($value)) {
+ return 'string';
+ } else if (is_null($value)) {
+ return 'null';
+ } else if (is_object($value)) {
+ return get_class($value);
+ } else if (is_array($value)) {
+ $vtype = self::getTypeOfVector($value);
+ if ($value && (array_keys($value) === range(0, count($value) - 1))) {
+ return 'list<'.$vtype.'>';
+ } else {
+ $ktype = self::getTypeOfVector(array_keys($value));
+ return "map<{$ktype}, {$vtype}>";
+ }
+ } else {
+ return 'wild';
+ }
+ }
+
+ private static function getTypeOfVector(array $vector) {
+ if (!$vector) {
+ return 'wild';
+ }
+
+ $type = null;
+ foreach ($vector as $value) {
+ $vtype = self::getTypeOf($value);
+ if ($type === null) {
+ $type = $vtype;
+ } else if ($type === $vtype) {
+ continue;
+ } else {
+ $parent = self::getCommonParentClass($type, $vtype);
+ if ($parent) {
+ $type = $parent;
+ } else {
+ return 'wild';
+ }
+ }
+ }
+
+ return $type;
+ }
+
+ public function toString() {
+ $sub = array();
+ foreach ($this->subtypes as $subtype) {
+ $sub[] = $subtype->toString();
+ }
+
+ switch ($this->type) {
+ case 'map':
+ $string = 'map<'.$sub[0].', '.$sub[1].'>';
+ break;
+ case 'list':
+ $string = 'list<'.$sub[0].'>';
+ break;
+ case 'or':
+ $string = implode('|', $sub);
+ break;
+ default:
+ $string = $this->type;
+ break;
+ }
+
+ if ($this->optional) {
+ $string = 'optional '.$string;
+ }
+
+ if ($this->comment) {
+ $string .= ' ('.$this->comment.')';
+ }
+
+ return $string;
+ }
+
+ public static function newFromString($string) {
+ $lexer = self::getLexer();
+ $tokens = $lexer->getTokens($string);
+
+ // Strip whitespace tokens.
+ foreach ($tokens as $key => $token) {
+ $type = $token[0];
+ if ($type == ' ') {
+ unset($tokens[$key]);
+ }
+ }
+
+ $tokens = array_values($tokens);
+ $callback = array(__CLASS__, 'didReduceTokens');
+ return self::parseTokens($tokens, $callback);
+ }
+
+ public static function didReduceTokens($rule, $production, array $tokens) {
+ switch ($rule) {
+ case 'start':
+ case 'some_type':
+ case 'not_or_type':
+ return $tokens[0];
+ case 'type':
+ if ($production == 'yes') {
+ $tokens[0]->optional = true;
+ }
+ return $tokens[0];
+ case 'basic_type':
+ $obj = new PhutilTypeSpec();
+ $obj->type = $tokens[0][1];
+ return $obj;
+ case 'or_type':
+ $l = $tokens[0];
+ $r = $tokens[2];
+
+ if ($l->type == 'or') {
+ if ($r->type == 'or') {
+ foreach ($r->subtypes as $subtype) {
+ $l->subtypes[] = $subtype;
+ }
+ } else {
+ $l->subtypes[] = $r;
+ }
+ return $l;
+ } else if ($r->type == 'or') {
+ $r->subtypes[] = $l;
+ return $r;
+ } else {
+ $obj = new PhutilTypeSpec();
+ $obj->type = 'or';
+ $obj->subtypes[] = $l;
+ $obj->subtypes[] = $r;
+ return $obj;
+ }
+ break;
+ case 'map_type':
+ $obj = new PhutilTypeSpec();
+ $obj->type = 'map';
+ $obj->subtypes[] = $tokens[2];
+ $obj->subtypes[] = $tokens[4];
+ return $obj;
+ case 'list_type':
+ $obj = new PhutilTypeSpec();
+ $obj->type = 'list';
+ $obj->subtypes[] = $tokens[2];
+ return $obj;
+ case 'maybe_optional':
+ if ($production == 'yes') {
+ $tokens[1]->optional = true;
+ return $tokens[1];
+ } else {
+ return $tokens[0];
+ }
+ break;
+ case 'maybe_comment':
+ if ($production == 'yes') {
+ $tokens[0]->comment = $tokens[1];
+ }
+ return $tokens[0];
+ case 'comment':
+ return $tokens[1];
+ case 'comment_text':
+ $result = '';
+ foreach ($tokens as $token) {
+ if (is_array($token)) {
+ $result .= $token[1];
+ } else {
+ $result .= $token;
+ }
+ }
+ return $result;
+ default:
+ throw new Exception(pht("Unhandled parser rule '%s'!", $rule));
+ }
+ }
+
+ private static function getLexer() {
+ static $lexer;
+ if (!$lexer) {
+ $lexer = new PhutilTypeLexer();
+ }
+ return $lexer;
+ }
+
+ private static function parseTokens(array $tokens, $callback) {
+ // NOTE: This is automatically generated by the script
+ // `support/parser/generate-type-parser.php`.
+
+ return PhutilParserGenerator::parseTokensWithTables(
+ array(
+ 0 => array(
+ 'opt' => array(
+ 0 => 'S',
+ 1 => 3,
+ ),
+ 'k' => array(
+ 0 => 'S',
+ 1 => 20,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 21,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 71,
+ ),
+ ),
+ 1 => array(
+ '(end-of-file)' => array(
+ 0 => 'A',
+ ),
+ ),
+ 2 => array(
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'start',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 3 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 20,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 21,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 71,
+ ),
+ ),
+ 4 => array(
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'maybe_optional',
+ 1 => 'yes',
+ 2 => 2,
+ ),
+ ),
+ ),
+ 5 => array(
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'maybe_comment',
+ 1 => 'no',
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'S',
+ 1 => 7,
+ ),
+ ),
+ 6 => array(
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'maybe_comment',
+ 1 => 'yes',
+ 2 => 2,
+ ),
+ ),
+ ),
+ 7 => array(
+ 'cm' => array(
+ 0 => 'S',
+ 1 => 11,
+ ),
+ ),
+ 8 => array(
+ ')' => array(
+ 0 => 'S',
+ 1 => 9,
+ ),
+ 'cm' => array(
+ 0 => 'S',
+ 1 => 10,
+ ),
+ ),
+ 9 => array(
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'comment',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 10 => array(
+ ')' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'comment_text',
+ 1 => 0,
+ 2 => 2,
+ ),
+ ),
+ 'cm' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'comment_text',
+ 1 => 0,
+ 2 => 2,
+ ),
+ ),
+ ),
+ 11 => array(
+ ')' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'comment_text',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ 'cm' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'comment_text',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 12 => array(
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'no',
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'no',
+ 2 => 1,
+ ),
+ ),
+ '?' => array(
+ 0 => 'S',
+ 1 => 13,
+ ),
+ ),
+ 13 => array(
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'yes',
+ 2 => 2,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'yes',
+ 2 => 2,
+ ),
+ ),
+ ),
+ 14 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'S',
+ 1 => 15,
+ ),
+ ),
+ 15 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 20,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 21,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 71,
+ ),
+ ),
+ 16 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 17 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 18 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 19 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 20 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 21 => array(
+ '<' => array(
+ 0 => 'S',
+ 1 => 22,
+ ),
+ ),
+ 22 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 57,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 58,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 67,
+ ),
+ ),
+ 23 => array(
+ ',' => array(
+ 0 => 'S',
+ 1 => 24,
+ ),
+ ),
+ 24 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 25 => array(
+ '>' => array(
+ 0 => 'S',
+ 1 => 26,
+ ),
+ ),
+ 26 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ ),
+ 27 => array(
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'no',
+ 2 => 1,
+ ),
+ ),
+ '?' => array(
+ 0 => 'S',
+ 1 => 28,
+ ),
+ ),
+ 28 => array(
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'yes',
+ 2 => 2,
+ ),
+ ),
+ ),
+ 29 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'S',
+ 1 => 30,
+ ),
+ ),
+ 30 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 31 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 32 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 33 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 34 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 35 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 36 => array(
+ '<' => array(
+ 0 => 'S',
+ 1 => 37,
+ ),
+ ),
+ 37 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 57,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 58,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 67,
+ ),
+ ),
+ 38 => array(
+ ',' => array(
+ 0 => 'S',
+ 1 => 39,
+ ),
+ ),
+ 39 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 40 => array(
+ '>' => array(
+ 0 => 'S',
+ 1 => 41,
+ ),
+ ),
+ 41 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ ),
+ 42 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'S',
+ 1 => 43,
+ ),
+ ),
+ 43 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 44 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 45 => array(
+ '<' => array(
+ 0 => 'S',
+ 1 => 46,
+ ),
+ ),
+ 46 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 47 => array(
+ '>' => array(
+ 0 => 'S',
+ 1 => 48,
+ ),
+ ),
+ 48 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ '>' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ ),
+ 49 => array(
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'no',
+ 2 => 1,
+ ),
+ ),
+ '?' => array(
+ 0 => 'S',
+ 1 => 50,
+ ),
+ ),
+ 50 => array(
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'type',
+ 1 => 'yes',
+ 2 => 2,
+ ),
+ ),
+ ),
+ 51 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'S',
+ 1 => 52,
+ ),
+ ),
+ 52 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 57,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 58,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 67,
+ ),
+ ),
+ 53 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 0,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 54 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 55 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 56 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'not_or_type',
+ 1 => 2,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 57 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'basic_type',
+ 1 => 0,
+ 2 => 1,
+ ),
+ ),
+ ),
+ 58 => array(
+ '<' => array(
+ 0 => 'S',
+ 1 => 59,
+ ),
+ ),
+ 59 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 57,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 58,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 67,
+ ),
+ ),
+ 60 => array(
+ ',' => array(
+ 0 => 'S',
+ 1 => 61,
+ ),
+ ),
+ 61 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 62 => array(
+ '>' => array(
+ 0 => 'S',
+ 1 => 63,
+ ),
+ ),
+ 63 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'map_type',
+ 1 => 0,
+ 2 => 6,
+ ),
+ ),
+ ),
+ 64 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'S',
+ 1 => 65,
+ ),
+ ),
+ 65 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 57,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 58,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 67,
+ ),
+ ),
+ 66 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 67 => array(
+ '<' => array(
+ 0 => 'S',
+ 1 => 68,
+ ),
+ ),
+ 68 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 69 => array(
+ '>' => array(
+ 0 => 'S',
+ 1 => 70,
+ ),
+ ),
+ 70 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ ',' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ ),
+ 71 => array(
+ '<' => array(
+ 0 => 'S',
+ 1 => 72,
+ ),
+ ),
+ 72 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 35,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 36,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 45,
+ ),
+ ),
+ 73 => array(
+ '>' => array(
+ 0 => 'S',
+ 1 => 74,
+ ),
+ ),
+ 74 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'list_type',
+ 1 => 0,
+ 2 => 4,
+ ),
+ ),
+ ),
+ 75 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'some_type',
+ 1 => 1,
+ 2 => 1,
+ ),
+ ),
+ '|' => array(
+ 0 => 'S',
+ 1 => 76,
+ ),
+ ),
+ 76 => array(
+ 'k' => array(
+ 0 => 'S',
+ 1 => 20,
+ ),
+ 'map' => array(
+ 0 => 'S',
+ 1 => 21,
+ ),
+ 'list' => array(
+ 0 => 'S',
+ 1 => 71,
+ ),
+ ),
+ 77 => array(
+ '?' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ '(' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ '|' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'or_type',
+ 1 => 1,
+ 2 => 3,
+ ),
+ ),
+ ),
+ 78 => array(
+ '(end-of-file)' => array(
+ 0 => 'R',
+ 1 => array(
+ 0 => 'maybe_optional',
+ 1 => 'no',
+ 2 => 1,
+ ),
+ ),
+ ),
+ ),
+ array(
+ 0 => array(
+ 'start' => 1,
+ 'maybe_optional' => 2,
+ 'maybe_comment' => 78,
+ 'type' => 5,
+ 'some_type' => 12,
+ 'or_type' => 14,
+ 'not_or_type' => 75,
+ 'basic_type' => 17,
+ 'map_type' => 18,
+ 'list_type' => 19,
+ ),
+ 3 => array(
+ 'maybe_comment' => 4,
+ 'type' => 5,
+ 'some_type' => 12,
+ 'or_type' => 14,
+ 'not_or_type' => 75,
+ 'basic_type' => 17,
+ 'map_type' => 18,
+ 'list_type' => 19,
+ ),
+ 5 => array(
+ 'comment' => 6,
+ ),
+ 7 => array(
+ 'comment_text' => 8,
+ ),
+ 15 => array(
+ 'not_or_type' => 16,
+ 'basic_type' => 17,
+ 'map_type' => 18,
+ 'list_type' => 19,
+ ),
+ 22 => array(
+ 'type' => 23,
+ 'some_type' => 49,
+ 'or_type' => 51,
+ 'not_or_type' => 64,
+ 'basic_type' => 54,
+ 'map_type' => 55,
+ 'list_type' => 56,
+ ),
+ 24 => array(
+ 'type' => 25,
+ 'some_type' => 27,
+ 'or_type' => 29,
+ 'not_or_type' => 42,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 30 => array(
+ 'not_or_type' => 31,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 37 => array(
+ 'type' => 38,
+ 'some_type' => 49,
+ 'or_type' => 51,
+ 'not_or_type' => 64,
+ 'basic_type' => 54,
+ 'map_type' => 55,
+ 'list_type' => 56,
+ ),
+ 39 => array(
+ 'type' => 40,
+ 'some_type' => 27,
+ 'or_type' => 29,
+ 'not_or_type' => 42,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 43 => array(
+ 'not_or_type' => 44,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 46 => array(
+ 'type' => 47,
+ 'some_type' => 27,
+ 'or_type' => 29,
+ 'not_or_type' => 42,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 52 => array(
+ 'not_or_type' => 53,
+ 'basic_type' => 54,
+ 'map_type' => 55,
+ 'list_type' => 56,
+ ),
+ 59 => array(
+ 'type' => 60,
+ 'some_type' => 49,
+ 'or_type' => 51,
+ 'not_or_type' => 64,
+ 'basic_type' => 54,
+ 'map_type' => 55,
+ 'list_type' => 56,
+ ),
+ 61 => array(
+ 'type' => 62,
+ 'some_type' => 27,
+ 'or_type' => 29,
+ 'not_or_type' => 42,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 65 => array(
+ 'not_or_type' => 66,
+ 'basic_type' => 54,
+ 'map_type' => 55,
+ 'list_type' => 56,
+ ),
+ 68 => array(
+ 'type' => 69,
+ 'some_type' => 27,
+ 'or_type' => 29,
+ 'not_or_type' => 42,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 72 => array(
+ 'type' => 73,
+ 'some_type' => 27,
+ 'or_type' => 29,
+ 'not_or_type' => 42,
+ 'basic_type' => 32,
+ 'map_type' => 33,
+ 'list_type' => 34,
+ ),
+ 76 => array(
+ 'not_or_type' => 77,
+ 'basic_type' => 17,
+ 'map_type' => 18,
+ 'list_type' => 19,
+ ),
+ ),
+ '(end-of-file)',
+ $tokens,
+ $callback);
+ }
+
+}
diff --git a/src/parser/PhutilURI.php b/src/parser/PhutilURI.php
new file mode 100644
--- /dev/null
+++ b/src/parser/PhutilURI.php
@@ -0,0 +1,387 @@
+protocol = $uri->protocol;
+ $this->user = $uri->user;
+ $this->pass = $uri->pass;
+ $this->domain = $uri->domain;
+ $this->port = $uri->port;
+ $this->path = $uri->path;
+ $this->query = $uri->query;
+ $this->fragment = $uri->fragment;
+ $this->type = $uri->type;
+ return;
+ }
+
+ $uri = (string)$uri;
+
+ $type = self::TYPE_URI;
+
+ // Reject ambiguous URIs outright. Different versions of different clients
+ // parse these in different ways. See T12526 for discussion.
+ if (preg_match('(^[^/:]*://[^/]*[#?].*:)', $uri)) {
+ throw new Exception(
+ pht(
+ 'Rejecting ambiguous URI "%s". This URI is not formatted or '.
+ 'encoded properly.',
+ $uri));
+ }
+
+ $matches = null;
+ if (preg_match('(^([^/:]*://[^/]*)(\\?.*)\z)', $uri, $matches)) {
+ // If the URI is something like `idea://open?file=/path/to/file`, the
+ // `parse_url()` function will parse `open?file=` as the host. This is
+ // not the expected result. Break the URI into two pieces, stick a slash
+ // in between them, parse that, then remove the path. See T6106.
+
+ $parts = parse_url($matches[1].'/'.$matches[2]);
+ unset($parts['path']);
+ } else if ($this->isGitURIPattern($uri)) {
+ // Handle Git/SCP URIs in the form "user@domain:relative/path".
+
+ $user = '(?:(?P[^/@]+)@)?';
+ $host = '(?P[^/:]+)';
+ $path = ':(?P.*)';
+
+ $ok = preg_match('(^'.$user.$host.$path.'\z)', $uri, $matches);
+ if (!$ok) {
+ throw new Exception(
+ pht(
+ 'Failed to parse URI "%s" as a Git URI.',
+ $uri));
+ }
+
+ $parts = $matches;
+ $parts['scheme'] = 'ssh';
+
+ $type = self::TYPE_GIT;
+ } else {
+ $parts = parse_url($uri);
+ }
+
+ // The parse_url() call will accept URIs with leading whitespace, but many
+ // other tools (like git) will not. See T4913 for a specific example. If
+ // the input string has leading whitespace, fail the parse.
+ if ($parts) {
+ if (ltrim($uri) != $uri) {
+ $parts = false;
+ }
+ }
+
+ // NOTE: `parse_url()` is very liberal about host names; fail the parse if
+ // the host looks like garbage. In particular, we do not allow hosts which
+ // begin with "." or "-". See T12961 for a specific attack which relied on
+ // hosts beginning with "-".
+ if ($parts) {
+ $host = idx($parts, 'host', '');
+ if (strlen($host)) {
+ if (!preg_match('/^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-]*\z/', $host)) {
+ $parts = false;
+ }
+ }
+ }
+
+ if (!$parts) {
+ $parts = array();
+ }
+
+ // stringyness is to preserve API compatibility and
+ // allow the tests to continue passing
+ $this->protocol = idx($parts, 'scheme', '');
+ $this->user = rawurldecode(idx($parts, 'user', ''));
+ $this->pass = rawurldecode(idx($parts, 'pass', ''));
+ $this->domain = idx($parts, 'host', '');
+ $this->port = (string)idx($parts, 'port', '');
+ $this->path = idx($parts, 'path', '');
+ $query = idx($parts, 'query');
+ if ($query) {
+ $this->query = id(new PhutilQueryStringParser())->parseQueryString(
+ $query);
+ }
+ $this->fragment = idx($parts, 'fragment', '');
+
+ $this->type = $type;
+ }
+
+ public function __toString() {
+ $prefix = null;
+
+ if ($this->isGitURI()) {
+ $port = null;
+ } else {
+ $port = $this->port;
+ }
+
+ $domain = $this->domain;
+
+ $user = $this->user;
+ $pass = $this->pass;
+ if (strlen($user) && strlen($pass)) {
+ $auth = rawurlencode($user).':'.rawurlencode($pass).'@';
+ } else if (strlen($user)) {
+ $auth = rawurlencode($user).'@';
+ } else {
+ $auth = null;
+ }
+
+ $protocol = $this->protocol;
+ if ($this->isGitURI()) {
+ $protocol = null;
+ } else {
+ if (strlen($auth)) {
+ $protocol = nonempty($this->protocol, 'http');
+ }
+ }
+
+ if (strlen($protocol) || strlen($auth) || strlen($domain)) {
+ if ($this->isGitURI()) {
+ $prefix = "{$auth}{$domain}";
+ } else {
+ $prefix = "{$protocol}://{$auth}{$domain}";
+ }
+
+ if (strlen($port)) {
+ $prefix .= ':'.$port;
+ }
+ }
+
+ if ($this->query) {
+ $query = '?'.http_build_query($this->query, '', '&');
+ } else {
+ $query = null;
+ }
+
+ if (strlen($this->getFragment())) {
+ $fragment = '#'.$this->getFragment();
+ } else {
+ $fragment = null;
+ }
+
+ $path = $this->getPath();
+ if ($this->isGitURI()) {
+ if (strlen($path)) {
+ $path = ':'.$path;
+ }
+ }
+
+ return $prefix.$path.$query.$fragment;
+ }
+
+ public function setQueryParam($key, $value) {
+ if ($value === null) {
+ unset($this->query[$key]);
+ } else {
+ $this->query[$key] = $value;
+ }
+ return $this;
+ }
+
+ public function setQueryParams(array $params) {
+ $this->query = $params;
+ return $this;
+ }
+
+ public function getQueryParams() {
+ return $this->query;
+ }
+
+ public function setProtocol($protocol) {
+ $this->protocol = $protocol;
+ return $this;
+ }
+
+ public function getProtocol() {
+ return $this->protocol;
+ }
+
+ public function setDomain($domain) {
+ $this->domain = $domain;
+ return $this;
+ }
+
+ public function getDomain() {
+ return $this->domain;
+ }
+
+ public function setPort($port) {
+ $this->port = $port;
+ return $this;
+ }
+ public function getPort() {
+ return $this->port;
+ }
+
+ public function getPortWithProtocolDefault() {
+ static $default_ports = array(
+ 'http' => '80',
+ 'https' => '443',
+ 'ssh' => '22',
+ );
+
+ return nonempty(
+ $this->getPort(),
+ idx($default_ports, $this->getProtocol()),
+ '');
+ }
+
+ public function setPath($path) {
+ if ($this->isGitURI()) {
+ // Git URIs use relative paths which do not need to begin with "/".
+ } else {
+ if ($this->domain && strlen($path) && $path[0] !== '/') {
+ $path = '/'.$path;
+ }
+ }
+
+ $this->path = $path;
+ return $this;
+ }
+
+ public function appendPath($path) {
+ $first = strlen($path) ? $path[0] : null;
+ $last = strlen($this->path) ? $this->path[strlen($this->path) - 1] : null;
+
+ if (!$this->path) {
+ return $this->setPath($path);
+ } else if ($first === '/' && $last === '/') {
+ $path = substr($path, 1);
+ } else if ($first !== '/' && $last !== '/') {
+ $path = '/'.$path;
+ }
+
+ $this->path .= $path;
+ return $this;
+ }
+
+ public function getPath() {
+ return $this->path;
+ }
+
+ public function setFragment($fragment) {
+ $this->fragment = $fragment;
+ return $this;
+ }
+
+ public function getFragment() {
+ return $this->fragment;
+ }
+
+ public function setUser($user) {
+ $this->user = $user;
+ return $this;
+ }
+
+ public function getUser() {
+ return $this->user;
+ }
+
+ public function setPass($pass) {
+ $this->pass = $pass;
+ return $this;
+ }
+
+ public function getPass() {
+ return $this->pass;
+ }
+
+ public function alter($key, $value) {
+ $altered = clone $this;
+ $altered->setQueryParam($key, $value);
+ return $altered;
+ }
+
+ public function isGitURI() {
+ return ($this->type == self::TYPE_GIT);
+ }
+
+ public function setType($type) {
+
+ if ($type == self::TYPE_URI) {
+ $path = $this->getPath();
+ if (strlen($path) && ($path[0] !== '/')) {
+ // Try to catch this here because we are not allowed to throw from
+ // inside __toString() so we don't have a reasonable opportunity to
+ // react properly if we catch it later.
+ throw new Exception(
+ pht(
+ 'Unable to convert URI "%s" into a standard URI because the '.
+ 'path is relative. Standard URIs can not represent relative '.
+ 'paths.',
+ $this));
+ }
+ }
+
+ $this->type = $type;
+ return $this;
+ }
+
+ public function getType() {
+ return $this->type;
+ }
+
+ private function isGitURIPattern($uri) {
+ $matches = null;
+
+ $ok = preg_match('(^(?P[^/]+):(?P(?!//).*)\z)', $uri, $matches);
+ if (!$ok) {
+ return false;
+ }
+
+ $head = $matches['head'];
+ $last = $matches['last'];
+
+ // If any part of this has spaces in it, it's not a Git URI. We fail here
+ // so we fall back and don't fail more abruptly later.
+ if (preg_match('(\s)', $head.$last)) {
+ return false;
+ }
+
+ // If the second part only contains digits, assume we're looking at
+ // casually specified "domain.com:123" URI, not a Git URI pointed at an
+ // entirely numeric relative path.
+ if (preg_match('(^\d+\z)', $last)) {
+ return false;
+ }
+
+ // If the first part has a "." or an "@" in it, interpret it as a domain
+ // or a "user@host" string.
+ if (preg_match('([.@])', $head)) {
+ return true;
+ }
+
+ // Otherwise, interpret the URI conservatively as a "javascript:"-style
+ // URI. This means that "localhost:path" is parsed as a normal URI instead
+ // of a Git URI, but we can't tell which the user intends and it's safer
+ // to treat it as a normal URI.
+ return false;
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilBugtraqParserTestCase.php b/src/parser/__tests__/PhutilBugtraqParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilBugtraqParserTestCase.php
@@ -0,0 +1,61 @@
+setBugtraqPattern('http://bugs.com/%BUGID%')
+ ->setBugtraqCaptureExpression('/[Ii]ssues?:?(\s*,?\s*\d+)+/')
+ ->setBugtraqSelectExpression('/(\d+)/')
+ ->processCorpus('Issues: 123, 345');
+ $this->assertEqual(
+ 'Issues: http://bugs.com/123, http://bugs.com/345',
+ $actual);
+
+ $actual = id(new PhutilBugtraqParser())
+ ->setBugtraqPattern('<%BUGID%>')
+ ->setBugtraqCaptureExpression('/([A-Z]{2,}-\d+)/')
+ ->processCorpus('AB-1 BC-2 CD-3');
+ $this->assertEqual(
+ ' ',
+ $actual);
+
+ $actual = id(new PhutilBugtraqParser())
+ ->setBugtraqPattern('<%BUGID%>')
+ ->setBugtraqCaptureExpression('/\d+/')
+ ->processCorpus('This text has no bugs in it.');
+ $this->assertEqual(
+ 'This text has no bugs in it.',
+ $actual);
+
+ $actual = id(new PhutilBugtraqParser())
+ ->setBugtraqPattern('<%BUGID%>')
+ ->setBugtraqCaptureExpression('/.*/')
+ ->setBugtraqSelectExpression('/(\d+)/')
+ ->processCorpus('This text captures but does not select.');
+ $this->assertEqual(
+ 'This text captures but does not select.',
+ $actual);
+
+ $caught = null;
+ try {
+ id(new PhutilBugtraqParser())
+ ->setBugtraqCaptureExpression('!');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof PhutilTypeCheckException);
+
+
+ $caught = null;
+ try {
+ id(new PhutilBugtraqParser())
+ ->setBugtraqSelectExpression('!');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof PhutilTypeCheckException);
+ }
+
+
+}
diff --git a/src/parser/__tests__/PhutilDocblockParserTestCase.php b/src/parser/__tests__/PhutilDocblockParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilDocblockParserTestCase.php
@@ -0,0 +1,127 @@
+parseDocblock($root.$file);
+ }
+ }
+
+ private function parseDocblock($doc_file) {
+ $contents = Filesystem::readFile($doc_file);
+ $file = basename($doc_file);
+
+ $parser = new PhutilDocblockParser();
+ list($docblock, $specials) = $parser->parse($contents);
+
+ switch ($file) {
+ case 'embedded-specials.docblock':
+ $this->assertEqual(array(), $specials);
+ $this->assertEqual(
+ "So long as a @special does not appear at the beginning of a line,\n".
+ "it is parsed as normal text.",
+ $docblock);
+ break;
+ case 'indented-block.docblock':
+ $this->assertEqual(array(), $specials);
+ $this->assertEqual(
+ 'Cozy lummox gives smart squid who asks for job pen.',
+ $docblock);
+ break;
+ case 'indented-text.docblock':
+ $this->assertEqual(array(), $specials);
+ $this->assertEqual(
+ 'Cozy lummox gives smart squid who asks for job pen.',
+ $docblock);
+ break;
+ case 'multiline-special.docblock':
+ $this->assertEqual(
+ array(
+ 'special' => 'x y z',
+ ),
+ $specials);
+ $this->assertEqual(
+ '',
+ $docblock);
+ break;
+ case 'multi-specials.docblock':
+ $this->assertEqual(
+ array(
+ 'special' => array('north', 'south'),
+ 'stable' => true,
+ ),
+ $specials);
+ $this->assertEqual(
+ '',
+ $docblock);
+ break;
+ case 'specials.docblock':
+ $this->assertEqual(
+ array(
+ 'type' => 'type',
+ 'task' => 'task',
+ 'special' => array('dot', 'dot', 'dash'),
+ ),
+ $specials);
+ $this->assertEqual(
+ '',
+ $docblock);
+ break;
+ case 'linebreak-breaks-specials.docblock':
+ $this->assertEqual(
+ array(
+ 'title' => 'title',
+ ),
+ $specials);
+ $this->assertEqual(
+ 'This is normal text, not part of the @title.',
+ $docblock);
+ break;
+ case 'specials-with-hyphen.docblock':
+ $this->assertEqual(
+ array(
+ 'repeat-hyphen' => array('a', 'b'),
+ 'multiline-hyphen' => 'mmm nnn',
+ 'normal-hyphen' => 'x',
+ ),
+ $specials);
+ break;
+ case 'indented-specials.docblock':
+ $this->assertEqual(
+ array(
+ 'title' => 'sendmail',
+ 'special' => 'only a little bit indented',
+ ),
+ $specials);
+ break;
+ case 'flag-specials.docblock':
+ $this->assertEqual(
+ "stuff above\n\nstuff in the middle\n\nstuff below",
+ $docblock);
+ $this->assertEqual(
+ array(
+ 'flag' => true,
+ 'stuff' => true,
+ 'zebra' => true,
+ 'apple' => true,
+ ),
+ $specials);
+ break;
+ case 'mixed-types.docblock':
+ $this->assertEqual(
+ array(
+ 'special' => array('squirrels', true),
+ ),
+ $specials);
+ break;
+ default:
+ throw new Exception(pht("No test case to handle file '%s'!", $file));
+ }
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilEditorConfigTestCase.php b/src/parser/__tests__/PhutilEditorConfigTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilEditorConfigTestCase.php
@@ -0,0 +1,106 @@
+getTestFile());
+
+ $tests = array(
+ 'default' => array(
+ array(
+ 'indent_style' => 'space',
+ 'indent_size' => 2,
+ 'charset' => 'utf-8',
+ 'trim_trailing_whitespace' => true,
+ 'insert_final_newline' => true,
+ ),
+ array(),
+ ),
+ 'file' => array(
+ array(
+ 'indent_style' => 'space',
+ 'indent_size' => 3,
+ 'charset' => 'utf-8',
+ 'trim_trailing_whitespace' => true,
+ 'insert_final_newline' => true,
+ ),
+ array(),
+ ),
+ 'file.txt' => array(
+ array(
+ 'indent_style' => 'space',
+ 'indent_size' => 3,
+ 'charset' => 'latin1',
+ 'trim_trailing_whitespace' => true,
+ 'insert_final_newline' => true,
+ ),
+ array(),
+ ),
+ 'externals/README' => array(
+ array(
+ 'indent_style' => null,
+ 'indent_size' => null,
+ 'charset' => 'utf-8',
+ 'trim_trailing_whitespace' => false,
+ 'insert_final_newline' => false,
+ ),
+ array(),
+ ),
+ 'subdir/file' => array(
+ array(
+ 'indent_style' => 'tab',
+ 'indent_size' => 3,
+ 'charset' => 'utf-8-bom',
+ 'trim_trailing_whitespace' => true,
+ 'insert_final_newline' => true,
+ ),
+ array(),
+ ),
+ 'empty/file' => array(
+ array(),
+ array(
+ 'indent_style' => null,
+ 'indent_size' => null,
+ 'charset' => null,
+ 'trim_trailing_whitespace' => null,
+ 'insert_final_newline' => null,
+ ),
+ ),
+ );
+
+ foreach ($tests as $path => $expected) {
+ list($properties, $property) = $expected;
+ $property = array_merge($properties, $property);
+
+ $this->assertEqual(
+ $properties,
+ $parser->getProperties($this->getTestFile($path)));
+
+ foreach ($property as $key => $value) {
+ $this->assertEqual(
+ $value,
+ $parser->getProperty($this->getTestFile($path), $key));
+ }
+ }
+
+ $invalid_properties = array(
+ 'invalid',
+ );
+
+ foreach ($invalid_properties as $invalid_property) {
+ $caught = null;
+ try {
+ $parser->getProperty('', $invalid_property);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+ }
+ }
+
+ private function getTestFile($path = null) {
+ return dirname(__FILE__).'/editorconfig/'.$path;
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilEmailAddressTestCase.php b/src/parser/__tests__/PhutilEmailAddressTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilEmailAddressTestCase.php
@@ -0,0 +1,130 @@
+');
+ $this->assertEqual(
+ 'Abraham Lincoln',
+ $email->getDisplayName());
+ $this->assertEqual(
+ 'alincoln',
+ $email->getLocalPart());
+ $this->assertEqual(
+ 'logcabin.com',
+ $email->getDomainName());
+ $this->assertEqual(
+ 'alincoln@logcabin.com',
+ $email->getAddress());
+
+ $email = new PhutilEmailAddress('alincoln@logcabin.com');
+ $this->assertEqual(
+ null,
+ $email->getDisplayName());
+ $this->assertEqual(
+ 'alincoln',
+ $email->getLocalPart());
+ $this->assertEqual(
+ 'logcabin.com',
+ $email->getDomainName());
+ $this->assertEqual(
+ 'alincoln@logcabin.com',
+ $email->getAddress());
+
+ $email = new PhutilEmailAddress('"Abraham" ');
+ $this->assertEqual(
+ 'Abraham',
+ $email->getDisplayName());
+ $this->assertEqual(
+ 'alincoln',
+ $email->getLocalPart());
+ $this->assertEqual(
+ 'logcabin.com',
+ $email->getDomainName());
+ $this->assertEqual(
+ 'alincoln@logcabin.com',
+ $email->getAddress());
+
+ $email = new PhutilEmailAddress(' alincoln@logcabin.com ');
+ $this->assertEqual(
+ null,
+ $email->getDisplayName());
+ $this->assertEqual(
+ 'alincoln',
+ $email->getLocalPart());
+ $this->assertEqual(
+ 'logcabin.com',
+ $email->getDomainName());
+ $this->assertEqual(
+ 'alincoln@logcabin.com',
+ $email->getAddress());
+
+ $email = new PhutilEmailAddress('alincoln');
+ $this->assertEqual(
+ null,
+ $email->getDisplayName());
+ $this->assertEqual(
+ 'alincoln',
+ $email->getLocalPart());
+ $this->assertEqual(
+ null,
+ $email->getDomainName());
+ $this->assertEqual(
+ 'alincoln',
+ $email->getAddress());
+
+ $email = new PhutilEmailAddress('alincoln ');
+ $this->assertEqual(
+ 'alincoln',
+ $email->getDisplayName());
+ $this->assertEqual(
+ 'alincoln at logcabin dot com',
+ $email->getLocalPart());
+ $this->assertEqual(
+ null,
+ $email->getDomainName());
+ $this->assertEqual(
+ 'alincoln at logcabin dot com',
+ $email->getAddress());
+ }
+
+ public function testEmailEncoding() {
+ $cases = array(
+ array(
+ 'Tangerine Q. Hawthorne',
+ 'thawthorne@blackspire.bunker',
+ '"Tangerine Q. Hawthorne" ',
+ ),
+ array(
+ 'Hector "\\" Backslash',
+ 'hector@backslash',
+ '"Hector \\"\\\\\\" Backslash" ',
+ ),
+ array(
+ 'My Middle Name "" Is My Email',
+ 'name@domain',
+ '"My Middle Name \\"\\" Is My Email" ',
+ ),
+ array(
+ "My Legal Name\nContains A Newline",
+ 'newline@example',
+ '"My Legal Name Contains A Newline" ',
+ ),
+ );
+
+ foreach ($cases as $case) {
+ list($name, $address, $expect) = $case;
+ $actual = (string)id(new PhutilEmailAddress())
+ ->setDisplayName($name)
+ ->setAddress($address);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('Email: %s + %s -> %s', $name, $address, $expect));
+ }
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilGitURITestCase.php b/src/parser/__tests__/PhutilGitURITestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilGitURITestCase.php
@@ -0,0 +1,28 @@
+assertEqual('git', $uri->getUser());
+ $this->assertEqual('host.com', $uri->getDomain());
+ $this->assertEqual('path/to/something', $uri->getPath());
+ $this->assertEqual('git@host.com:path/to/something', (string)$uri);
+
+ $uri = new PhutilGitURI('host.com:path/to/something');
+ $this->assertEqual('', $uri->getUser());
+ $this->assertEqual('host.com', $uri->getDomain());
+ $this->assertEqual('path/to/something', $uri->getPath());
+ $this->assertEqual('host.com:path/to/something', (string)$uri);
+ }
+
+ public function testStrictGitURIParsingOfLeadingWhitespace() {
+ $uri = new PhutilURI(' user@example.com');
+ $this->assertEqual('', $uri->getDomain());
+ }
+
+
+}
diff --git a/src/parser/__tests__/PhutilJSONParserTestCase.php b/src/parser/__tests__/PhutilJSONParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilJSONParserTestCase.php
@@ -0,0 +1,139 @@
+ array(),
+ '[]' => array(),
+ '{"foo": "bar"}' => array('foo' => 'bar'),
+ '[1, "foo", true, null]' => array(1, 'foo', true, null),
+ '{"foo": {"bar": "baz"}}' => array('foo' => array('bar' => 'baz')),
+ '{"foo": "bar", "bar": ["baz"]}'
+ => array('foo' => 'bar', 'bar' => array('baz')),
+ '{"foo": "bar", "bar": {"baz": "foo"}}'
+ => array('foo' => 'bar', 'bar' => array('baz' => 'foo')),
+ '{"": ""}' => array('' => ''),
+ '{"test":"\u00c9v\u00e9nement"}'
+ => array('test' => "\xC3\x89v\xC3\xA9nement"),
+ '["\u00c9v\u00e9nement"]' => array("\xC3\x89v\xC3\xA9nement"),
+ '{"test":"http:\/\/foo\\\\zomg"}'
+ => array('test' => 'http://foo\\zomg'),
+ '["http:\/\/foo\\\\zomg"]' => array('http://foo\\zomg'),
+ Filesystem::readFile(dirname(__FILE__).'/json/base64.json') => array(
+ 'action' => 'candidate.create',
+ 'actionId' => '80653a26cc46357ff79ff83b47e27c3cb7a668bd',
+ 'params' => array(
+ 'attachments' => array(
+ Filesystem::readFile(dirname(__FILE__).'/json/base64.data'),
+ ),
+ ),
+ ),
+ );
+
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ $parser->parse($input),
+ pht('Parsing JSON: %s', $input));
+ }
+ }
+
+ public function testInvalidJSON() {
+ $parser = new PhutilJSONParser();
+
+ $tests = array(
+ '{' => array(
+ 'line' => 1,
+ 'char' => 1,
+ 'token' => 'EOF',
+ ),
+ '[' => array(
+ 'line' => 1,
+ 'char' => 1,
+ 'token' => 'EOF',
+ ),
+ '{"foo":' => array(
+ 'line' => 1,
+ 'char' => 7,
+ 'token' => 'EOF',
+ ),
+ '{"foo":"bar",}' => array(
+ 'line' => 1,
+ 'char' => 13,
+ 'token' => '}',
+ ),
+ '{{}' => array(
+ 'line' => 1,
+ 'char' => 1,
+ 'token' => '{',
+ ),
+ '{}}' => array(
+ 'line' => 1,
+ 'char' => 2,
+ 'token' => '}',
+ ),
+ "{\"foo\":\"bar\",\n\"bar\":\"baz\",}" => array(
+ 'line' => 2,
+ 'char' => 12,
+ 'token' => '}',
+ ),
+ "{'foo': 'bar'}" => array(
+ 'line' => 1,
+ 'char' => 1,
+ 'token' => 'INVALID',
+ ),
+ "{\"foo\": \"bar\nbaz\"}" => array(
+ 'line' => 1,
+ 'char' => 7,
+ 'token' => 'INVALID',
+ ),
+ '{"foo": "bar\z"}' => array(
+ 'line' => 1,
+ 'char' => 7,
+ 'token' => 'INVALID',
+ ),
+ );
+
+ foreach ($tests as $input => $expected) {
+ $caught = null;
+ try {
+ $parser->parse($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof PhutilJSONParserException);
+ $this->assertEqual($expected['line'], $caught->getSourceLine());
+ $this->assertEqual($expected['char'], $caught->getSourceChar());
+ $this->assertEqual($expected['token'], $caught->getSourceToken());
+ }
+ }
+
+ public function testDuplicateKeys() {
+ $parser = new PhutilJSONParser();
+
+ $tests = array(
+ '{"foo": "bar", "foo": "baz"}' => array('foo' => 'baz'),
+ );
+
+ foreach ($tests as $input => $expect) {
+ $parser->setAllowDuplicateKeys(true);
+ $this->assertEqual(
+ $expect,
+ $parser->parse($input),
+ pht('Parsing JSON: %s', $input));
+
+ $parser->setAllowDuplicateKeys(false);
+ $caught = null;
+ try {
+ $parser->parse($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof PhutilJSONParserException);
+ }
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilJSONTestCase.php b/src/parser/__tests__/PhutilJSONTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilJSONTestCase.php
@@ -0,0 +1,21 @@
+assertEqual(
+ $expect,
+ $serializer->encodeFormatted(array('x' => array())),
+ pht('Empty arrays should serialize as `%s`, not `%s`.', '[]', '{}'));
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilLanguageGuesserTestCase.php b/src/parser/__tests__/PhutilLanguageGuesserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilLanguageGuesserTestCase.php
@@ -0,0 +1,23 @@
+assertEqual(
+ $expect,
+ PhutilLanguageGuesser::guessLanguage($source),
+ pht("Guessed language for '%s'.", $test));
+ }
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilParserGeneratorTestCase.php b/src/parser/__tests__/PhutilParserGeneratorTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilParserGeneratorTestCase.php
@@ -0,0 +1,330 @@
+setTerminals(array('a'))
+ ->setStartRule('S')
+ ->setRules(
+ array(
+ 'S' => 'a b',
+ ));
+
+ $caught = null;
+ try {
+ // Expect "b is not a rule or terminal".
+ $generator->processGrammar();
+ } catch (PhutilUnknownSymbolParserGeneratorException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testBadStartRule() {
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals(array('a'))
+ ->setStartRule('Q')
+ ->setRules(
+ array(
+ 'S' => 'a',
+ ));
+
+ $caught = null;
+ try {
+ // Expect "no start rule Q".
+ $generator->processGrammar();
+ } catch (PhutilUnknownSymbolParserGeneratorException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testMessySymbols() {
+ // This is testing that internal defaults are correctly changed when they
+ // would conflict with the provided grammar. This is a messy test which
+ // relies on a lot of implementation details.
+
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals(array('(init)', 'x', 'y', 'start', '(end)'))
+ ->setStartRule('(epsilon)')
+ ->setRules(
+ array(
+ '(epsilon)' => array(
+ array('s p a c e s'),
+ ),
+ 's p a c e s' => '(init) x start (end-of-file) y',
+ '(end-of-file)' => array(
+ '(end)',
+ null,
+ ),
+ ))
+ ->processGrammar();
+
+ $rules = $generator->inspectRules();
+
+ $init = $generator->getInitSymbol();
+ $eof = $generator->getEOFSymbol();
+ $epsilon = $generator->getEpsilonSymbol();
+ $end = $generator->getEndSymbol();
+
+ $this->assertFalse($init == '(init)');
+ $this->assertFalse($eof == '(end-of-file)');
+ $this->assertFalse($epsilon == '(epsilon)');
+ $this->assertFalse($end == '(end)');
+
+ $keys = array_keys($rules);
+ $expect = array('(end-of-file)', '(epsilon)', 's p a c e s', $init);
+ sort($keys);
+ sort($expect);
+ $this->assertEqual($keys, $expect);
+
+ $this->assertEqual(
+ array(
+ array('s p a c e s', $end),
+ ),
+ $rules['(epsilon)']);
+
+ $this->assertEqual(
+ array(
+ array('(end)', $end),
+ array($epsilon, $end),
+ ),
+ $rules['(end-of-file)']);
+ }
+
+ public function testUnreachableTerminal() {
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals(array('x', 'y'))
+ ->setStartRule('S')
+ ->setRules(
+ array(
+ 'S' => 'x',
+ ));
+
+ $caught = null;
+ try {
+ $generator->processGrammar();
+ } catch (PhutilUnreachableTerminalParserGeneratorException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testUnreachableRule() {
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals(array('x'))
+ ->setStartRule('S')
+ ->setRules(
+ array(
+ 'S' => 'x',
+ 'A' => 'B',
+ 'B' => 'x',
+ ));
+
+ $caught = null;
+ try {
+ $generator->processGrammar();
+ } catch (PhutilUnreachableRuleParserGeneratorException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testIrreducibleGrammars() {
+ $tests = array(
+ 'trivially irreducible' => array(
+ true,
+ array(
+ 'S' => array('E', 'x'),
+ 'E' => 'E',
+ ),
+ ),
+ 'nontrivially irreducible' => array(
+ true,
+ array(
+ 'S' => array('X', 'x'),
+ 'X' => 'Y',
+ 'Y' => 'Z',
+ 'Z' => 'X',
+ ),
+ ),
+ 'left-recursive reducible' => array(
+ false,
+ array(
+ 'S' => 'E',
+ 'E' => array('E x', 'x'),
+ ),
+ ),
+ 'right-recursive reducible' => array(
+ false,
+ array(
+ 'S' => 'E',
+ 'E' => array('x', 'x E'),
+ ),
+ ),
+ );
+
+ foreach ($tests as $test) {
+ list($expect, $rules) = $test;
+
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals(array('x'))
+ ->setStartRule('S')
+ ->setRules($rules);
+
+ $caught = null;
+ try {
+ $generator->processGrammar();
+ } catch (PhutilIrreducibleRuleParserGeneratorException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual($expect, ($caught instanceof Exception));
+ }
+ }
+
+ public function testFirst() {
+ $generator = $this->buildABCGenerator()->processGrammar();
+
+ $first = $generator->inspectFirstTable();
+ ksort($first);
+
+ foreach ($first as $key => $table) {
+ ksort($table);
+ $first[$key] = $table;
+ }
+
+ $this->assertEqual(
+ array(
+ 'A' => array(
+ '(epsilon)' => true,
+ 'a' => true,
+ 'b' => true,
+ ),
+ 'B' => array(
+ 'c' => true,
+ ),
+ 'C' => array(
+ '(epsilon)' => true,
+ 'b' => true,
+ ),
+ 'S' => array(
+ 'a' => true,
+ 'b' => true,
+ 'c' => true,
+ ),
+ ),
+ $first);
+ }
+
+ public function testStates() {
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals(array('a', 'b'))
+ ->setStartRule('S')
+ ->setRules(
+ array(
+ 'S' => 'X X',
+ 'X' => array(
+ 'a X',
+ 'b',
+ ),
+ ))
+ ->processGrammar();
+
+ $this->assertTrue(true);
+ }
+
+ public function testETParser() {
+ $generator = $this->buildETGenerator()->processGrammar();
+
+ $result = $generator->parseTokens(
+ array(
+ array('n', 3),
+ array('+', '+'),
+ array('n', 5),
+ ),
+ array($this, 'didReduceET'));
+
+ $this->assertEqual(8, $result);
+ }
+
+ public function didReduceET($rule, $production, array $tokens) {
+ switch ($rule) {
+ case 'S':
+ return $tokens[0];
+ case 'E':
+ switch ($production) {
+ case 0:
+ return $tokens[0] + $tokens[2];
+ case 1:
+ return $tokens[0];
+ }
+ break;
+ case 'T':
+ switch ($production) {
+ case 0:
+ return $tokens[1];
+ case 1:
+ return $tokens[0][1];
+ }
+ break;
+ }
+
+ throw new Exception(pht('Unexpected rule in ET grammar.'));
+ }
+
+ private function buildABCGenerator() {
+ $terminals = array(
+ 'a',
+ 'b',
+ 'c',
+ );
+
+ $rules = array(
+ 'S' => 'A B',
+ 'A' => array('C a', null),
+ 'B' => array('B a A C', 'c'),
+ 'C' => array('b', null),
+ );
+
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals($terminals)
+ ->setStartRule('S')
+ ->setRules($rules);
+
+ return $generator;
+ }
+
+ private function buildETGenerator() {
+ // This grammar and the corresponding tests are based on:
+ // http://dragonbook.stanford.edu/lecture-notes/Stanford-CS143/08-Bottom-Up-Parsing.pdf
+ // http://dragonbook.stanford.edu/lecture-notes/Stanford-CS143/09-SLR-Parsing.pdf
+
+ $terminals = array(
+ '(',
+ 'n',
+ ')',
+ '+',
+ );
+
+ $rules = array(
+ 'S' => 'E',
+ 'E' => array('E + T', 'T'),
+ 'T' => array('( E )', 'n'),
+ );
+
+ $generator = id(new PhutilParserGenerator())
+ ->setTerminals($terminals)
+ ->setStartRule('S')
+ ->setRules($rules);
+
+ return $generator;
+ }
+
+
+}
diff --git a/src/parser/__tests__/PhutilPygmentizeParserTestCase.php b/src/parser/__tests__/PhutilPygmentizeParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilPygmentizeParserTestCase.php
@@ -0,0 +1,43 @@
+tryParser(
+ '',
+ '',
+ array(),
+ pht('Empty'));
+
+ $this->tryParser(
+ '1',
+ '1',
+ array(
+ 'mi' => 'color: #ff0000',
+ ),
+ pht('Simple'));
+
+ $this->tryParser(
+ '1',
+ '1',
+ array(),
+ pht('Missing Class'));
+
+ $this->tryParser(
+ 'X',
+ 'X',
+ array(
+ 'nc' => 'color: #ff0000',
+ ),
+ pht('Extra Attribute'));
+ }
+
+ private function tryParser($input, $expect, array $map, $label) {
+ $actual = id(new PhutilPygmentizeParser())
+ ->setMap($map)
+ ->parse($input);
+
+ $this->assertEqual($expect, $actual, pht('Pygmentize Parser: %s', $label));
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilQueryStringParserTestCase.php b/src/parser/__tests__/PhutilQueryStringParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilQueryStringParserTestCase.php
@@ -0,0 +1,140 @@
+ array(),
+ 'foo=bar&foobar=barfoo' => array(
+ 'foo' => 'bar',
+ 'foobar' => 'barfoo',
+ ),
+ 'a]b[]=1&a]=2&a[[]=3&a[b]b=4&[][a]=5' => array(
+ 'a]b[]' => '1',
+ 'a]' => '2',
+ 'a[[]' => '3',
+ 'a[b]b' => '4',
+ '[][a]' => '5',
+ ),
+ 'foo[][]=bar&bar[1][3]=foo' => array(
+ 'foo' => array(
+ 0 => array(
+ 0 => 'bar',
+ ),
+ ),
+ 'bar' => array(
+ 1 => array(
+ 3 => 'foo',
+ ),
+ ),
+ ),
+ 'foo[][]=bar&a]b[]=1' => array(
+ 'foo' => array(
+ 0 => array(
+ 0 => 'bar',
+ ),
+ ),
+ 'a]b[]' => '1',
+ ),
+ 'a&&b' => array(
+ 'a' => '',
+ 'b' => '',
+ ),
+ 'a[b][]=foo&a[b][]=bar' => array(
+ 'a' => array(
+ 'b' => array(
+ 0 => 'foo',
+ 1 => 'bar',
+ ),
+ ),
+ ),
+ 'a=1&a=2' => array(
+ 'a' => '2',
+ ),
+ 'a=1&a[]=2' => array(
+ 'a' => array(
+ 0 => '2',
+ ),
+ ),
+ 'a=1&a[b]=2&a[]=3' => array(
+ 'a' => array(
+ 'b' => '2',
+ 0 => '3',
+ ),
+ ),
+ 'a%20b=%20' => array(
+ 'a b' => ' ',
+ ),
+ 'a.b=c' => array(
+ 'a.b' => 'c',
+ ),
+ 'a=b=c' => array(
+ 'a' => 'b=c',
+ ),
+ );
+
+ $parser = new PhutilQueryStringParser();
+
+ foreach ($map as $query_string => $expected) {
+ $this->assertEqual(
+ $expected,
+ $parser->parseQueryString($query_string));
+ }
+ }
+
+ public function testQueryStringListParsing() {
+ $map = array(
+ '' => array(),
+ '&' => array(),
+ '=' => array(
+ array('', ''),
+ ),
+ '=&' => array(
+ array('', ''),
+ ),
+ 'a=b' => array(
+ array('a', 'b'),
+ ),
+ 'a[]=b' => array(
+ array('a[]', 'b'),
+ ),
+ 'a=' => array(
+ array('a', ''),
+ ),
+ '. [=1' => array(
+ array('. [', '1'),
+ ),
+ 'a=b&c=d' => array(
+ array('a', 'b'),
+ array('c', 'd'),
+ ),
+ 'a=b&a=c' => array(
+ array('a', 'b'),
+ array('a', 'c'),
+ ),
+ '&a=b&' => array(
+ array('a', 'b'),
+ ),
+ '=a' => array(
+ array('', 'a'),
+ ),
+ '&&&' => array(
+ ),
+ 'a%20b=c%20d' => array(
+ array('a b', 'c d'),
+ ),
+ );
+
+ $parser = new PhutilQueryStringParser();
+
+ foreach ($map as $query_string => $expected) {
+ $this->assertEqual(
+ $expected,
+ $parser->parseQueryStringToPairList($query_string));
+ }
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilSimpleOptionsTestCase.php b/src/parser/__tests__/PhutilSimpleOptionsTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilSimpleOptionsTestCase.php
@@ -0,0 +1,143 @@
+ array(),
+
+ // Basic parsing.
+ 'legs=4' => array('legs' => '4'),
+ 'legs=4,eyes=2' => array('legs' => '4', 'eyes' => '2'),
+
+ // Repeated keys mean last specification wins.
+ 'legs=4,legs=3' => array('legs' => '3'),
+
+ // Keys with no value should map to true.
+ 'flag' => array('flag' => true),
+ 'legs=4,flag' => array('legs' => '4', 'flag' => true),
+
+ // Leading and trailing spaces should be ignored.
+ ' flag ' => array('flag' => true),
+ ' legs = 4 , eyes = 2' => array('legs' => '4', 'eyes' => '2'),
+
+ // Unescaped spaces inside values are OK.
+ 'legs=a b c d' => array('legs' => 'a b c d'),
+
+ // Case should be ignored.
+ 'LEGS=4' => array('legs' => '4'),
+ 'legs=4, LEGS=4' => array('legs' => '4'),
+
+ // Empty values should be absent.
+ 'legs=' => array(),
+ 'legs=4,legs=,eyes=2' => array('eyes' => '2'),
+
+ // Quoted values should allow parsing comma, equals, etc.
+ 'punctuation=",="' => array('punctuation' => ',='),
+
+ // Quoted keys can also have that stuff.
+ '"backslash\\\\quote\\""=1' => array('backslash\\quote"' => '1'),
+ ' "," = "," , "=" = "=" ' => array(',' => ',', '=' => '='),
+
+ // Strings like this should not parse as simpleoptions.
+ 'SELECT id, name, size FROM table' => array(),
+ '"a""b"' => array(),
+ '=a' => array(),
+ ',a' => array(),
+ 'a==' => array(),
+ 'a=b=' => array(),
+ );
+
+ foreach ($map as $string => $expect) {
+ $parser = new PhutilSimpleOptions();
+ $this->assertEqual(
+ $expect,
+ $parser->parse($string),
+ pht("Correct parse of '%s'", $string));
+ }
+ }
+
+ public function testSimpleOptionsCaseParse() {
+ $map = array(
+ 'legs=4, LEGS=8, LeGs' => array(
+ 'legs' => '4',
+ 'LEGS' => '8',
+ 'LeGs' => true,
+ ),
+ );
+
+ foreach ($map as $string => $expect) {
+ $parser = new PhutilSimpleOptions();
+ $parser->setCaseSensitive(true);
+ $this->assertEqual(
+ $expect,
+ $parser->parse($string),
+ pht("Correct case-sensitive parse of '%s'", $string));
+ }
+ }
+
+ public function testSimpleOptionsUnterminatedStrings() {
+ $list = array(
+ '"',
+ "'",
+ 'a="',
+ "a='",
+ 'a="\\',
+ "a='\\",
+ );
+
+ foreach ($list as $input) {
+ $parser = new PhutilSimpleOptions();
+ $this->assertEqual(
+ array(),
+ $parser->parse($input),
+ pht('Correct failing parse of invalid input: %s', $input));
+ }
+ }
+
+ public function testSimpleOptionsUnparse() {
+ $map = array(
+ '' => array(),
+ 'legs=4' => array('legs' => '4'),
+ 'legs=4, eyes=2' => array('legs' => '4', 'eyes' => '2'),
+ 'eyes=2, legs=4' => array('eyes' => '2', 'legs' => '4'),
+ 'legs=4, head' => array('legs' => '4', 'head' => true),
+ 'eyes=2' => array('legs' => '', 'eyes' => '2'),
+ '"thousands separator"=","' => array('thousands separator' => ','),
+ );
+
+ foreach ($map as $expect => $dict) {
+ $parser = new PhutilSimpleOptions();
+ $this->assertEqual(
+ $expect,
+ $parser->unparse($dict),
+ pht('Correct unparse of %s', print_r($dict, true)));
+ }
+
+ $bogus = array(
+ array('' => ''),
+ array('' => 'x'),
+ );
+
+ foreach ($bogus as $bad_input) {
+ $caught = null;
+ try {
+ $parser = new PhutilSimpleOptions();
+ $parser->unparse($bad_input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue(
+ $caught instanceof Exception,
+ pht('Correct throw on unparse of bad input.'));
+ }
+
+ $parser = new PhutilSimpleOptions();
+ $this->assertEqual(
+ 'a="\\}"',
+ $parser->unparse(array('a' => '}'), '}'),
+ pht('Unparse with extra escape.'));
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilTypeSpecTestCase.php b/src/parser/__tests__/PhutilTypeSpecTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilTypeSpecTestCase.php
@@ -0,0 +1,320 @@
+',
+ 'int | null',
+ 'list < string >',
+ 'int (must be even)',
+ 'optional int',
+ 'int?',
+ 'int|null?',
+ 'optional int? (minimum 300)',
+ 'list',
+ 'list>>> (easy)',
+ '\\SomeClass',
+ '\\Namespace\\SomeClass',
+ '\\NamespaceA\\NamespaceB\\NamespaceC',
+ 'NamespaceA\\NamespaceB\\NamespaceC',
+ );
+
+ $bad = array(
+ '',
+ 'list<>',
+ 'list',
+ 'map|map',
+ 'int optional',
+ '(derp)',
+ 'list',
+ 'int?|string',
+ '\\',
+ '\\\\',
+ '\\SomeClass\\',
+ 'SomeClass\\',
+ );
+
+ $good = array_fill_keys($good, true);
+ $bad = array_fill_keys($bad, false);
+
+ foreach ($good + $bad as $input => $expect) {
+ $caught = null;
+ try {
+ PhutilTypeSpec::newFromString($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual(
+ $expect,
+ ($caught === null),
+ $input);
+ }
+ }
+
+ public function testTypeSpecStringify() {
+ $types = array(
+ 'int',
+ 'list',
+ 'map',
+ 'list>',
+ 'map>',
+ 'int|null',
+ 'int|string|null',
+ 'list',
+ 'list',
+ 'optional int',
+ 'int (even)',
+ );
+
+ foreach ($types as $type) {
+ $this->assertEqual(
+ $type,
+ PhutilTypeSpec::newFromString($type)->toString());
+ }
+ }
+
+ public function testCanonicalize() {
+ $tests = array(
+ 'int?' => 'optional int',
+ 'int | null' => 'int|null',
+ 'list < map < int , string > > ?' => 'optional list>',
+ 'int ( x )' => 'int ( x )',
+ );
+
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ PhutilTypeSpec::newFromString($input)->toString(),
+ $input);
+ }
+ }
+
+ public function testGetCommonParentClass() {
+ $map = array(
+ 'stdClass' => array(
+ array('stdClass', 'stdClass'),
+ ),
+ false => array(
+ array('Exception', 'stdClass'),
+ ),
+ 'Exception' => array(
+ array('Exception', 'RuntimeException'),
+ array('LogicException', 'RuntimeException'),
+ array('BadMethodCallException', 'OutOfBoundsException'),
+ ),
+ );
+
+ foreach ($map as $expect => $tests) {
+ if (is_int($expect)) {
+ $expect = (bool)$expect;
+ }
+
+ foreach ($tests as $input) {
+ list($class_a, $class_b) = $input;
+
+ $this->assertEqual(
+ $expect,
+ PhutilTypeSpec::getCommonParentClass($class_a, $class_b),
+ print_r($input, true));
+ }
+ }
+ }
+
+ public function testGetTypeOf() {
+ $map = array(
+ 'int' => 1,
+ 'string' => 'asdf',
+ 'float' => 1.5,
+ 'bool' => true,
+ 'null' => null,
+ 'map' => array(),
+ 'list' => array('a', 'b'),
+ 'list' => array(1, 2, 3),
+ 'map' => array('x' => 3),
+ 'map>' => array(1 => array('x', 'y')),
+ 'stdClass' => new stdClass(),
+ 'list' => array(
+ new Exception(),
+ new LogicException(),
+ new RuntimeException(),
+ ),
+ 'map' => array('x' => new stdClass()),
+ );
+
+ foreach ($map as $expect => $input) {
+ $this->assertEqual(
+ $expect,
+ PhutilTypeSpec::getTypeOf($input),
+ print_r($input, true));
+
+ PhutilTypeSpec::newFromString($expect)->check($input);
+ }
+ }
+
+ public function testTypeCheckFailures() {
+ $map = array(
+ 'int' => 'string',
+ 'string' => 32,
+ 'null' => true,
+ 'bool' => null,
+ 'map' => 16,
+ 'list' => array('y' => 'z'),
+ 'int|null' => 'ducks',
+ 'stdClass' => new Exception(),
+ 'list' => array(new Exception()),
+ );
+
+ foreach ($map as $type => $value) {
+ $caught = null;
+ try {
+ PhutilTypeSpec::newFromString($type)->check($value);
+ } catch (PhutilTypeCheckException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof PhutilTypeCheckException);
+ }
+ }
+
+ public function testCheckMap() {
+ $spec = array(
+ 'count' => 'int',
+ 'color' => 'optional string',
+ );
+
+ // Valid
+
+ PhutilTypeSpec::checkMap(
+ array(
+ 'count' => 1,
+ ),
+ $spec);
+
+ // Valid, with optional parameter.
+
+ PhutilTypeSpec::checkMap(
+ array(
+ 'count' => 3,
+ 'color' => 'red',
+ ),
+ $spec);
+
+ // Parameter "count" is required but missing.
+
+ $caught = null;
+ try {
+ PhutilTypeSpec::checkMap(
+ array(),
+ $spec);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof PhutilTypeMissingParametersException);
+
+ // Parameter "size" is specified but does not exist.
+
+ $caught = null;
+ try {
+ PhutilTypeSpec::checkMap(
+ array(
+ 'count' => 4,
+ 'size' => 'large',
+ ),
+ $spec);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof PhutilTypeExtraParametersException);
+ }
+
+ public function testRegexValidation() {
+ PhutilTypeSpec::checkMap(
+ array(
+ 'regex' => '/.*/',
+ ),
+ array(
+ 'regex' => 'regex',
+ ));
+
+ $caught = null;
+ try {
+ PhutilTypeSpec::checkMap(
+ array(
+ 'regex' => '.*',
+ ),
+ array(
+ 'regex' => 'regex',
+ ));
+ } catch (PhutilTypeCheckException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof PhutilTypeCheckException);
+ }
+
+ public function testScalarOrListRegexp() {
+ PhutilTypeSpec::checkMap(
+ array(
+ 'regex' => '/.*/',
+ ),
+ array(
+ 'regex' => 'regex | list',
+ ));
+
+ PhutilTypeSpec::checkMap(
+ array(
+ 'regex' => array('/.*/'),
+ ),
+ array(
+ 'regex' => 'regex | list',
+ ));
+
+ PhutilTypeSpec::checkMap(
+ array(
+ 'regex' => '/.*/',
+ ),
+ array(
+ 'regex' => 'list | regex',
+ ));
+
+ PhutilTypeSpec::checkMap(
+ array(
+ 'regex' => array('/.*/'),
+ ),
+ array(
+ 'regex' => 'list | regex',
+ ));
+
+ $this->assertTrue(true);
+ }
+
+ public function testMixedVector() {
+ // This is a test case for an issue where we would not infer the type
+ // of a vector containing a mixture of scalar and nonscalar elements
+ // correctly.
+
+ $caught = null;
+ try {
+ PhutilTypeSpec::checkMap(
+ array(
+ 'key' => array('!', (object)array()),
+ ),
+ array(
+ 'key' => 'list',
+ ));
+ } catch (PhutilTypeCheckException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof PhutilTypeCheckException);
+ }
+
+}
diff --git a/src/parser/__tests__/PhutilURITestCase.php b/src/parser/__tests__/PhutilURITestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/PhutilURITestCase.php
@@ -0,0 +1,278 @@
+assertEqual('http', $uri->getProtocol(), pht('protocol'));
+ $this->assertEqual('user', $uri->getUser(), pht('user'));
+ $this->assertEqual('pass', $uri->getPass(), pht('password'));
+ $this->assertEqual('host', $uri->getDomain(), pht('domain'));
+ $this->assertEqual('99', $uri->getPort(), pht('port'));
+
+ $this->assertEqual('/path/', $uri->getPath(), pht('path'));
+ $this->assertEqual(
+ array(
+ 'query' => 'value',
+ ),
+ $uri->getQueryParams(),
+ 'query params');
+ $this->assertEqual('fragment', $uri->getFragment(), pht('fragment'));
+ $this->assertEqual(
+ 'http://user:pass@host:99/path/?query=value#fragment',
+ (string)$uri,
+ 'uri');
+
+
+ $uri = new PhutilURI('ssh://git@example.com/example/example.git');
+ $this->assertEqual('ssh', $uri->getProtocol(), pht('protocol'));
+ $this->assertEqual('git', $uri->getUser(), pht('user'));
+ $this->assertEqual('', $uri->getPass(), pht('password'));
+ $this->assertEqual('example.com', $uri->getDomain(), pht('domain'));
+ $this->assertEqual('', $uri->getPort(), 'port');
+
+ $this->assertEqual('/example/example.git', $uri->getPath(), pht('path'));
+ $this->assertEqual(
+ array(),
+ $uri->getQueryParams(),
+ pht('query parameters'));
+ $this->assertEqual('', $uri->getFragment(), pht('fragment'));
+ $this->assertEqual(
+ 'ssh://git@example.com/example/example.git',
+ (string)$uri,
+ 'uri');
+
+
+ $uri = new PhutilURI('http://0@domain.com/');
+ $this->assertEqual('0', $uri->getUser());
+ $this->assertEqual('http://0@domain.com/', (string)$uri);
+
+ $uri = new PhutilURI('http://0:0@domain.com/');
+ $this->assertEqual('0', $uri->getUser());
+ $this->assertEqual('0', $uri->getPass());
+ $this->assertEqual('http://0:0@domain.com/', (string)$uri);
+
+ $uri = new PhutilURI('http://%20:%20@domain.com/');
+ $this->assertEqual(' ', $uri->getUser());
+ $this->assertEqual(' ', $uri->getPass());
+ $this->assertEqual('http://%20:%20@domain.com/', (string)$uri);
+
+ $uri = new PhutilURI('http://%40:%40@domain.com/');
+ $this->assertEqual('@', $uri->getUser());
+ $this->assertEqual('@', $uri->getPass());
+ $this->assertEqual('http://%40:%40@domain.com/', (string)$uri);
+
+ $uri = new PhutilURI('http://%2F:%2F@domain.com/');
+ $this->assertEqual('/', $uri->getUser());
+ $this->assertEqual('/', $uri->getPass());
+ $this->assertEqual('http://%2F:%2F@domain.com/', (string)$uri);
+
+ // These tests are covering cases where cURL and parse_url() behavior
+ // may differ in potentially dangerous ways. See T6755 for discussion.
+
+ // In general, we defuse these attacks by emitting URIs which escape
+ // special characters so that they are interpreted unambiguously by
+ // cURL in the same way that parse_url() interpreted them.
+
+ $uri = new PhutilURI('http://u:p@evil.com?@good.com');
+ $this->assertEqual('u', $uri->getUser());
+ $this->assertEqual('p', $uri->getPass());
+ $this->assertEqual('evil.com', $uri->getDomain());
+ $this->assertEqual('http://u:p@evil.com?%40good.com=', (string)$uri);
+
+ // The behavior of URLs in these forms differs for different versions
+ // of cURL, PHP, and other software. Because safe parsing is a tricky
+ // proposition and these URIs are almost certainly malicious, we just
+ // reject them. See T12526 for discussion.
+
+ $dangerous = array(
+ // Ambiguous encoding.
+ 'http://good.com#u:p@evil.com/' => true,
+ 'http://good.com?u:p@evil.com/' => true,
+
+ // Unambiguous encoding: with a trailing slash.
+ 'http://good.com/#u:p@evil.com/' => false,
+ 'http://good.com/?u:p@evil.com/' => false,
+
+ // Unambiguous encoding: with escaping.
+ 'http://good.com%23u:p@evil.com/' => false,
+ 'http://good.com%40u:p@evil.com/' => false,
+ );
+
+ foreach ($dangerous as $input => $expect) {
+ $caught = null;
+ try {
+ new PhutilURI($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertEqual(
+ $expect,
+ ($caught instanceof $ex),
+ pht('Unexpected parse result for dangerous URI "%s".', $input));
+ }
+
+ $uri = new PhutilURI('www.example.com');
+ $this->assertEqual('', $uri->getProtocol());
+ $this->assertEqual('www.example.com', (string)$uri);
+ }
+
+ public function testURIGeneration() {
+ $uri = new PhutilURI('http://example.com');
+ $uri->setPath('bar');
+ $this->assertEqual('http://example.com/bar', $uri->__toString());
+ }
+
+ public function testStrictURIParsingOfHosts() {
+ $uri = new PhutilURI('http://&/');
+ $this->assertEqual('', $uri->getDomain());
+
+ // See T12961 for more discussion of these hosts which begin with "-".
+ $uri = new PhutilURI('ssh://-oProxyCommand/');
+ $this->assertEqual('', $uri->getDomain());
+ $uri = new PhutilURI('ssh://-oProxyCommand=curl/');
+ $this->assertEqual('', $uri->getDomain());
+ $uri = new PhutilURI('ssh://.com/');
+ $this->assertEqual('', $uri->getDomain());
+
+ // Make sure newlines are rejected.
+ $uri = new PhutilURI("ssh://example.com\n.domain.us/");
+ $this->assertEqual('', $uri->getDomain());
+ $uri = new PhutilURI("ssh://example.com\n");
+ $this->assertEqual('', $uri->getDomain());
+ }
+
+ public function testStrictURIParsingOfLeadingWhitespace() {
+ $uri = new PhutilURI(' http://example.com/');
+ $this->assertEqual('', $uri->getDomain());
+ }
+
+ public function testAppendPath() {
+ $uri = new PhutilURI('http://example.com');
+ $uri->appendPath('foo');
+ $this->assertEqual('http://example.com/foo', $uri->__toString());
+ $uri->appendPath('bar');
+ $this->assertEqual('http://example.com/foo/bar', $uri->__toString());
+
+ $uri = new PhutilURI('http://example.com');
+ $uri->appendPath('/foo/');
+ $this->assertEqual('http://example.com/foo/', $uri->__toString());
+ $uri->appendPath('/bar/');
+ $this->assertEqual('http://example.com/foo/bar/', $uri->__toString());
+
+ $uri = new PhutilURI('http://example.com');
+ $uri->appendPath('foo');
+ $this->assertEqual('http://example.com/foo', $uri->__toString());
+ $uri->appendPath('/bar/');
+ $this->assertEqual('http://example.com/foo/bar/', $uri->__toString());
+ }
+
+ public function testUnusualURIs() {
+ $uri = new PhutilURI('file:///path/to/file');
+ $this->assertEqual('file', $uri->getProtocol(), pht('protocol'));
+ $this->assertEqual('', $uri->getDomain(), pht('domain'));
+ $this->assertEqual('/path/to/file', $uri->getPath(), pht('path'));
+
+ $uri = new PhutilURI('idea://open?x=/');
+ $this->assertEqual('idea', $uri->getProtocol(), pht('protocol'));
+ $this->assertEqual('open', $uri->getDomain(), pht('domain'));
+ $this->assertEqual('', $uri->getPath(), pht('path'));
+ $this->assertEqual(
+ array(
+ 'x' => '/',
+ ),
+ $uri->getQueryParams());
+
+ // This is not a legitimate URI and should not parse as one.
+ $uri = new PhutilURI('fruit.list: apple banana cherry');
+ $this->assertEqual('', $uri->getDomain());
+ }
+
+ public function testAmbiguousURIs() {
+ // It's important that this be detected as a Javascript URI, because that
+ // is how browsers will treat it.
+ $uri = new PhutilURI('javascript:evil');
+ $this->assertEqual('javascript', $uri->getProtocol());
+
+
+ // This is "wrong", in that the user probably intends for this to be a
+ // Git-style URI, but we can not easily parse it as one without making the
+ // "javascript" case above unsafe.
+ $uri = new PhutilURI('localhost:todo.txt');
+ $this->assertEqual('localhost', $uri->getProtocol());
+
+
+ // These variants are unambiguous and safe.
+ $uri = new PhutilURI('localhost.com:todo.txt');
+ $this->assertEqual('localhost.com', $uri->getDomain());
+
+ $uri = new PhutilURI('user@localhost:todo.txt');
+ $this->assertEqual('localhost', $uri->getDomain());
+
+ // This could either be a Git URI with relative path "22", or a normal URI
+ // with port "22". We should assume it is a port number because this is
+ // relatively common, while relative Git URIs pointing at numeric filenames
+ // are bizarre.
+ $uri = new PhutilURI('domain.com:22');
+ $this->assertEqual('domain.com', $uri->getDomain());
+ $this->assertEqual('22', $uri->getPort());
+ }
+
+ public function testDefaultPorts() {
+ $uri = new PhutilURI('http://www.example.com');
+ $this->assertEqual('80', $uri->getPortWithProtocolDefault());
+
+ $uri = new PhutilURI('https://www.example.com');
+ $this->assertEqual('443', $uri->getPortWithProtocolDefault());
+
+ $uri = new PhutilURI('ssh://git@example.com/example/example.git');
+ $this->assertEqual('22', $uri->getPortWithProtocolDefault());
+
+ $uri = new PhutilURI('unknown://www.example.com');
+ $this->assertEqual('', $uri->getPortWithProtocolDefault());
+ }
+
+ public function testGitURIParsing() {
+ $uri = new PhutilURI('git@host.com:path/to/something');
+ $this->assertEqual('ssh', $uri->getProtocol());
+ $this->assertEqual('git', $uri->getUser());
+ $this->assertEqual('host.com', $uri->getDomain());
+ $this->assertEqual('path/to/something', $uri->getPath());
+ $this->assertEqual('git@host.com:path/to/something', (string)$uri);
+
+ $uri = new PhutilURI('host.com:path/to/something');
+ $this->assertEqual('ssh', $uri->getProtocol());
+ $this->assertEqual('', $uri->getUser());
+ $this->assertEqual('host.com', $uri->getDomain());
+ $this->assertEqual('path/to/something', $uri->getPath());
+ $this->assertEqual('host.com:path/to/something', (string)$uri);
+
+ $uri_1 = new PhutilURI('host.com:path/to/something');
+ $uri_2 = new PhutilURI($uri_1);
+
+ $this->assertEqual((string)$uri_1, (string)$uri_2);
+ }
+
+ public function testStrictGitURIParsingOfLeadingWhitespace() {
+ $uri = new PhutilURI(' user@example.com:path');
+ $this->assertEqual('', $uri->getDomain());
+ }
+
+ public function testNoRelativeURIPaths() {
+ $uri = new PhutilURI('user@example.com:relative_path');
+
+ $caught = null;
+ try {
+ $uri->setType(PhutilURI::TYPE_URI);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+}
diff --git a/src/parser/__tests__/docblock/embedded-specials.docblock b/src/parser/__tests__/docblock/embedded-specials.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/embedded-specials.docblock
@@ -0,0 +1,4 @@
+/**
+ * So long as a @special does not appear at the beginning of a line,
+ * it is parsed as normal text.
+ */
diff --git a/src/parser/__tests__/docblock/flag-specials.docblock b/src/parser/__tests__/docblock/flag-specials.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/flag-specials.docblock
@@ -0,0 +1,15 @@
+/**
+ * stuff above
+ *
+ * @flag
+ * @stuff
+ * @stuff
+ *
+ * @zebra
+ *
+ * stuff in the middle
+ *
+ * @apple
+ *
+ * stuff below
+ */
diff --git a/src/parser/__tests__/docblock/indented-block.docblock b/src/parser/__tests__/docblock/indented-block.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/indented-block.docblock
@@ -0,0 +1,3 @@
+ /**
+ * Cozy lummox gives smart squid who asks for job pen.
+ */
diff --git a/src/parser/__tests__/docblock/indented-specials.docblock b/src/parser/__tests__/docblock/indented-specials.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/indented-specials.docblock
@@ -0,0 +1,11 @@
+/**
+ * @title sendmail
+ *
+ * Blah blah add this configuration:
+ *
+ * @notspecial.com =~+> do sendmail magic
+ *
+ * @special only a
+ * little bit
+ * indented
+ */
diff --git a/src/parser/__tests__/docblock/indented-text.docblock b/src/parser/__tests__/docblock/indented-text.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/indented-text.docblock
@@ -0,0 +1,3 @@
+/**
+ * Cozy lummox gives smart squid who asks for job pen.
+ */
diff --git a/src/parser/__tests__/docblock/linebreak-breaks-specials.docblock b/src/parser/__tests__/docblock/linebreak-breaks-specials.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/linebreak-breaks-specials.docblock
@@ -0,0 +1,5 @@
+/**
+ * @title title
+ *
+ * This is normal text, not part of the @title.
+ */
diff --git a/src/parser/__tests__/docblock/mixed-types.docblock b/src/parser/__tests__/docblock/mixed-types.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/mixed-types.docblock
@@ -0,0 +1,4 @@
+/**
+ * @special squirrels
+ * @special
+ */
diff --git a/src/parser/__tests__/docblock/multi-specials.docblock b/src/parser/__tests__/docblock/multi-specials.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/multi-specials.docblock
@@ -0,0 +1,8 @@
+/**
+ * @special north
+ * @special south
+ *
+ * @stable
+ * @stable
+ * @stable
+ */
diff --git a/src/parser/__tests__/docblock/multiline-special.docblock b/src/parser/__tests__/docblock/multiline-special.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/multiline-special.docblock
@@ -0,0 +1,5 @@
+/**
+ * @special x
+ * y
+ * z
+ */
diff --git a/src/parser/__tests__/docblock/specials-with-hyphen.docblock b/src/parser/__tests__/docblock/specials-with-hyphen.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/specials-with-hyphen.docblock
@@ -0,0 +1,7 @@
+/**
+ * @repeat-hyphen a
+ * @repeat-hyphen b
+ * @multiline-hyphen mmm
+ * nnn
+ * @normal-hyphen x
+ */
diff --git a/src/parser/__tests__/docblock/specials.docblock b/src/parser/__tests__/docblock/specials.docblock
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/docblock/specials.docblock
@@ -0,0 +1,8 @@
+/**
+ * @type type
+ * @task task
+ *
+ * @special dot
+ * @special dot
+ * @special dash
+ */
diff --git a/src/parser/__tests__/editorconfig/.editorconfig b/src/parser/__tests__/editorconfig/.editorconfig
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/editorconfig/.editorconfig
@@ -0,0 +1,23 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[file*]
+indent_size = 3
+
+[*.txt]
+charset = latin1
+
+[{invalid_glob]
+indent_size = 1
+
+[externals/**]
+indent_style =
+indent_size =
+trim_trailing_whitespace = false
+insert_final_newline = false
diff --git a/src/parser/__tests__/editorconfig/empty/.editorconfig b/src/parser/__tests__/editorconfig/empty/.editorconfig
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/editorconfig/empty/.editorconfig
@@ -0,0 +1 @@
+root = true
diff --git a/src/parser/__tests__/editorconfig/externals/.editorconfig b/src/parser/__tests__/editorconfig/externals/.editorconfig
new file mode 100644
diff --git a/src/parser/__tests__/editorconfig/subdir/.editorconfig b/src/parser/__tests__/editorconfig/subdir/.editorconfig
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/editorconfig/subdir/.editorconfig
@@ -0,0 +1,3 @@
+[*]
+indent_style = tab
+charset = utf-8-bom
diff --git a/src/parser/__tests__/json/base64.data b/src/parser/__tests__/json/base64.data
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/json/base64.data
@@ -0,0 +1 @@
+fileName:Resume.doc;base64stream:0M8R4KGxGuEAAAAAAAAAAAAAAAAAAAAAOwADAP7/CQAGAAAAAAAAAAAAAAABAAAALgAAAAAAAAAAEAAAAgAAAAEAAAD+////AAAAAAAAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////9//////////7///8tAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAAAAEQAAABIAAAATAAAAFAAAAP7///8WAAAAFwAAABgAAAAZAAAAGgAAABsAAAAcAAAAHQAAAB4AAAAfAAAAIAAAACEAAAAiAAAAIwAAACQAAAAlAAAAJgAAACcAAAAoAAAAKQAAACoAAAArAAAALAAAAP7////+////LwAAAP7//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////1IAbwBvAHQAIABFAG4AdAByAHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAUA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v///wAAAAAAAAAAAQAAAP7////+////BAAAAAUAAAAGAAAA/v///wgAAAD+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8BAP7/AwoAAP////8GCQIAAAAAAMAAAAAAAABGGAAAAE1pY3Jvc29mdCBXb3JkLURva3VtZW50AAoAAABNU1dvcmREb2MAEAAAAFdvcmQuRG9jdW1lbnQuOAD0ObJxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+/wAAAQACAAAAAAAAAAAAAAAAAAAAAAABAAAA4IWf8vlPaBCrkQgAKyez2TAAAAC8AAAACAAAAAEAAABIAAAABAAAAFAAAAAIAAAAaAAAAAkAAACAAAAACgAAAIwAAAALAAAAmAAAAAwAAACkAAAADQAAALAAAAACAAAA6f0AAB4AAAAOAAAAQXByaWwgVmlzbmljawAAAB4AAAAOAAAAQXByaWwgVmlzbmljawAAAB4AAAACAAAAMQAAAEAAAAAAgRssAAAAAEAAAAAAAAAAAAAAAEAAAAAA1pEh62jLAUAAAAAAhXEJ8mjLAQAAAAAAAAAAAAAAAAAAAAAAAAAA/v8AAAEAAgAAAAAAAAAAAAAAAAAAAAAAAgAAAALVzdWcLhsQk5cIACss+a5EAAAABdXN1ZwuGxCTlwgAKyz5rhIANQAKAAEAWwAPAAIAAAAAAAAAbgAAEPH/AgBuAAAABwBEAGUAZgBhAHUAbAB0AAAAGgAAAAMkAGEkADEkACokATckATUkATMkAUEkADMAQioAT0oAAFFKAABDShgAbUgJBHNICQRLSAEAUEoEAG5I/wBeSgUAYUoYAF9I/wB0SP8AAAAAAAAAAAAAAAAAAAAAAAAAAEIAQUDy/6EAQgAAABkAQQBiAHMAYQB0AHoALQBTAHQAYQBuAGQAYQByAGQAcwBjAGgAcgBpAGYAdABhAHIAdAAAAAAAAAAAAAAAAAAuAP4f8v/xAC4AAAAJAFcAVwA4AE4AdQBtADEAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v8BAS4AAAAJAFcAVwA4AE4AdQBtADEAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v8RAS4AAAAJAFcAVwA4AE4AdQBtADIAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v8hAS4AAAAJAFcAVwA4AE4AdQBtADIAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v8xAS4AAAAJAFcAVwA4AE4AdQBtADMAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v9BAS4AAAAJAFcAVwA4AE4AdQBtADMAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v9RAS4AAAAJAFcAVwA4AE4AdQBtADQAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v9hAS4AAAAJAFcAVwA4AE4AdQBtADQAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v9xAS4AAAAJAFcAVwA4AE4AdQBtADUAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v+BAS4AAAAJAFcAVwA4AE4AdQBtADUAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v+RAS4AAAAJAFcAVwA4AE4AdQBtADYAegAwAAAADABPSgYAUUoGAF5KBwA2AP4f8v+hATYAAAAJAFcAVwA4AE4AdQBtADcAegAwAAAAFABPSgYAUUoGAENKHABeSgcAYUocADYA/h/y/7EBNgAAAAkAVwBXADgATgB1AG0ANwB6ADEAAAAUAE9KCQBRSgkAQ0ocAF5KBwBhShwAQgD+H/L/wQFCAAAAGQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0AAAAAABIAP4f8v/RAUgAAAAcAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAAAAAAC4A/h/y/+EBLgAAAAkAVwBXADgATgB1AG0ANgB6ADEAAAAMAE9KCABRSggAXkoHADYA/h/y//EBNgAAAAkAVwBXADgATgB1AG0AOAB6ADAAAAAUAE9KBgBRSgYAQ0ocAF5KBwBhShwANgD+H/L/AQI2AAAACQBXAFcAOABOAHUAbQA4AHoAMQAAABQAT0oIAFFKCABDShwAXkoHAGFKHABKAP4f8v8RAkoAAAAdAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAAAAAATAD+H/L/IQJMAAAAHgBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAAAAAATgD+H/L/MQJOAAAAHwBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxAAAAAABQAP4f8v9BAlAAAAAgAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAAAAAAUgD+H/L/UQJSAAAAIQBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAAAAAAVAD+H/L/YQJUAAAAIgBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxAAAAAABWAP4f8v9xAlYAAAAjAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAxADEAMQAAAAAAWAD+H/L/gQJYAAAAJABXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAAAAAAWgD+H/L/kQJaAAAAJQBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxAAAAAABcAP4f8v+hAlwAAAAmAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAxADEAMQAxADEAMQAAAAAAXgD+H/L/sQJeAAAAJwBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxADEAMQAAAAAAYAD+H/L/wQJgAAAAKABXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxADEAMQAxAAAAAABiAP4f8v/RAmIAAAApAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAxADEAMQAxADEAMQAxADEAMQAAAAAAZAD+H/L/4QJkAAAAKgBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxADEAMQAxADEAMQAAAAAANgD+H/L/8QI2AAAABwBCAHUAbABsAGUAdABzAAAAGABPSgcAUUoHAENKHABQSgcAXkoHAGFKHABGAP4fAQASA0YAAAAHAEgAZQBhAGQAaQBuAGcAAAANADAAE6TwABSkeAAGJAEAGABPSgIAUUoCAENKHABQSgoAXkoFAGFKHAAuAEIQAQASAy4AAAAJAFQAZQB4AHQAIABiAG8AZAB5AAAACgAxABOkAAAUpHgAAAAgAC8QEQMiAyAAAAAEAEwAaQBzAHQAAAACADIABABeSgsAQAD+HwEAMgNAAAAABwBDAGEAcAB0AGkAbwBuAAAADQAzABOkeAAUpHgADCQBABIAQ0oYADYIAV5KCwBhShgAXQgBJgD+HwEAQgMmAAAABQBJAG4AZABlAHgAAAAFADQADCQBAAQAXkoLAAAAAACxDAAABAAALgAAAAD/////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAWGQAAYiEAABEAAAASAAAAAAgAAGYLAABiEQAAFhkAAGIhAAATAAAAFAAAABUAAAAWAAAABwABAAAAAQAAAP8P/w//D/8P/w//D/8P/w//DwAAAgAAAAIAAAD/D/8P/w//D/8P/w//D/8P/w8AAAMAAAADAAAA/w//D/8P/w//D/8P/w//D/8PAAAEAAAABAAAAP8P/w//D/8P/w//D/8P/w//DwAABQAAAAUAAAD/D/8P/w//D/8P/w//D/8P/w8AAAYAAAAGAAAA/w//D/8P/w//D/8P/w//D/8PAAAHAAAABwAAAP8P/w//D/8P/w//D/8P/w//DwAAAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAAFBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAENKHABeSgcAYUocAAEAt/ABAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAUEAAAXoTYCWCEmP4VxgUAAdgJBk9KCABRSggAQ0ocAF5KBwBhShwAAQDmJQEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAABQQAABehEALYISY/hXGBQABQAsGT0oIAFFKCABDShwAXkoHAGFKHAABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAAFBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAENKHABeSgcAYUocAAEAt/ABAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAUEAAAXoQQDmCEmP4VxgUAARAOBk9KCABRSggAQ0ocAF5KBwBhShwAAQDmJQEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAABQQAABehHgPYISY/hXGBQABeA8GT0oIAFFKCABDShwAXkoHAGFKHAABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAAFBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAENKHABeSgcAYUocAAEAt/ABAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAUEAAAXoRIEmCEmP4VxgUAAUgSBk9KCABRSggAQ0ocAF5KBwBhShwAAQDmJQEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAABQQAABehLATYISY/hXGBQABsBMGT0oIAFFKCABDShwAXkoHAGFKHAABAKolAQAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAABAAAF6EsAFghFD+FcYFAAGwAQYAAAEAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAQAABehEACYITA/RXGBQABQAIGAAABAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAXoTQAmCEMP0VxgUAAdACBgAAAQAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAABAAAF6EYANghKD8FcYFAAFgAwYAAAEAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAQAABehPADYIQQ/BXGBQAB8AMGAAABAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAXoSABGCEgPsVxgUAAYAEBgAAAQAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAABAAAF6EEAVghPD6FcYFAAEQBQYAAAEAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAQAABehKAFYIRg+hXGBQABoAUGAAABAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAXoQwBmCE0PkVxgUAATAGBgAABwAAAAEAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////8HAAAABwBXAFcAOABOAHUAbQAxAAcAVwBXADgATgB1AG0AMwAHAFcAVwA4AE4AdQBtADQABwBXAFcAOABOAHUAbQA1AAcAVwBXADgATgB1AG0ANgAHAFcAVwA4AE4AdQBtADcAAAAAAAAAsQwAAAAAAAACEAAAAAAAAACxDAAAUAAACAAAAAAMAAAARxaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAaQBtAGUAcwAgAE4AZQB3ACAAUgBvAG0AYQBuAAAANRaQAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFMAeQBtAGIAbwBsAAAAMyaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEAcgBpAGEAbAAAAEEmkAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAHIAZQBiAHUAYwBoAGUAdAAgAE0AUwAAAEkmkAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAHIAaQBhAGwAIABVAG4AaQBjAG8AZABlACAATQBTAAAANQaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAYQBoAG8AbQBhAAAANQSQAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFMAeQBtAGIAbwBsAAAAXwSQAQALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE8AcABlAG4AUwB5AG0AYgBvAGwAAABBAHIAaQBhAGwAIABVAG4AaQBjAG8AZABlACAATQBTAAAAXwSQAYALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE8AcABlAG4AUwB5AG0AYgBvAGwAAABBAHIAaQBhAGwAIABVAG4AaQBjAG8AZABlACAATQBTAAAAOwSQAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFcAaQBuAGcAZABpAG4AZwBzAAAAOwaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE0AUwAgAE0AaQBuAGMAaABvAAAANQSQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAYQBoAG8AbQBhAAAAQgAEAAEIjRgAAMUCAABoAQAAAACWVeoGy1XqBgAAAAABAAAAAAAMAgAAgQwAAAIAPQAAAAQAg5A9AAAADAIAAIEMAAACAD0AAAA9AAAAAAAAACcDACAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAgAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADspQEBTSAJBAAAABK/AAAAAAAAMAAAAAAACAAAYiEAAA4AQ2FvbGFuODAAAAAAAAAAAAAAAAAAAAAAAAAJBBYAMi4AAAAAAAAAAAAAsQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//w8AEQAAAAIAAAD//w8AEwAAAAQAAAD//w8AAAAAAAAAAAAAAAAAAAAAAIgAAAAAAKoKAAAAAAAAqgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqgoAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL4KAAA0AAAA8goAABQAAAAGCwAAJAAAAAAAAAAAAAAAlxsAABwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdhsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACzHgAAYgIAAAAAAAAAAAAAghsAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqCwAAxgAAAH4aAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOGwAAaAAAAAAAAAAAAAAAdhsAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEAcAByAGkAbAAgAFYAaQBzAG4AaQBjAGsADQAxADQAMAAgAEwAbwBuAGcAIABEAHIAaQB2AGUADQBJAHIAdwBpAG4ALAAgAFAAQQAgADEANQA2ADQAMgANACgANwAyADQAKQAgADYAMQAwAC0AMQA0ADgAMAANAA0ADQBDAG8AbQBwAHUAdABlAHIAIABTAGsAaQBsAGwAcwANAA0ACQAJAEkAIABhAG0AIABlAHgAcABlAHIAaQBlAG4AYwBlAGQAIAB3AGkAdABoACAATQBpAGMAcgBvAHMAbwBmAHQAIABXAG8AcgBkACAAYQBuAGQAIABFAHgAYwBlAGwALgANAA0ACQAJAEkAIABjAGEAbgAgAHUAcwBlACAASQBuAHQAZQByAG4AZQB0ACAARQB4AHAAbABvAHIAZQByACAAdABvACAAZABvAHcAbgBsAG8AYQBkACAAdQBwAGQAYQB0AGUAcwAgAGYAbwByACAATQBpAGMAcgBvAHMAbwBmAHQAIABXAG8AcgBkACAAYQBuAGQAIABFAHgAYwBlAGwALAAgAHMAZQBhAHIAYwBoAA0ACQAJAGQAaQByAGUAYwB0AGkAbwBuAHMAIAB0AG8AIABhAG4AZAAgAGYAcgBvAG0AIABkAGkAZgBmAGUAcgBlAG4AdAAgAGwAbwBjAGEAdABpAG8AbgBzACwAIABjAGEAbgAgAHMAZQBhAHIAYwBoACAAZgBvAHIAIABwAGgAeQBzAGkAYwBhAGwAIABhAGQAZAByAGUAcwBzAGUAcwAgAGYAbwByAA0ACQAJAGMAbwBtAHAAYQBuAGkAZQBzACAAbwByACAAaQBuAGQAaQB2AGkAZAB1AGEAbABzACwAIABhAG4AZAAgAGUAbQBhAGkAbAAuAA0ADQBFAGQAdQBjAGEAdABpAG8AbgANAA0ACQAJAEIAcgBhAGQAZgBvAHIAZAAgAEIAdQBzAGkAbgBlAHMAcwAsACAAUABpAHQAdABzAGIAdQByAGcAaAAsACAAUABBAAkACQAJAAkACQAJACgAOQAvADAAMAAtADEAMAAvADAAMQApAA0ACQAJAEEAUwBCACwAIABPAGYAZgBpAGMAZQAgAEEAZABtAGkAbgBpAHMAdAByAGEAdABpAG8AbgANAEMAbwB1AHIAcwBlACAAdwBvAHIAawAgAGkAbgBjAGwAdQBkAGUAZAA6ACAARQBzAHMAZQBuAHQAaQBhAGwAcwAgAG8AZgAgAE0AYQBuAGEAZwBlAG0AZQBuAHQALAAgAEQAYQB0AGEAIABBAG4AYQBsAHkAcwBpAHMALAAgAEMAbwBuAGMAZQBwAHQAcwAgAG8AZgAgAEQAZQBzAGsAdABvAHAAIABQAHUAYgBsAGkAcwBoAGkAbgBnACwAIABBAGQAdgBhAG4AYwBlAGQAIABFAGwAZQBjAHQAcgBvAG4AaQBjACAAUwBwAHIAZQBhAGQAcwBoAGUAZQB0AHMALgANAA0ACQAJAFAAZQBuAG4AIABUAHIAYQBmAGYAbwByAGQAIABIAGkAZwBoACAAUwBjAGgAbwBvAGwALAAgAEgAYQByAHIAaQBzAG8AbgAgAEMAaQB0AHkALAAgAFAAQQAJAAkACQAJAAkAKAAxADkAOQA2AC0AMgAwADAAMAApAA0ACQAJAEQAaQBwAGwAbwBtAGEALQAgAEcAZQBuAGUAcgBhAGwAIABTAHQAdQBkAGkAZQBzAA0ARwBlAG4AZQByAGEAbAAgAEMAbwB1AHIAcwBlAHMAIABvAGYAIABzAHQAdQBkAHkAIAB3AGUAcgBlACAATQBhAHQAaAAsACAARQBuAGcAbABpAHMAaAAgAGEAbgBkACAAUwBjAGkAZQBuAGMAZQAuAA0AVABvAG8AawAgAFMAcABlAGUAZAB3AHIAaQB0AGkAbgBnACwAIABTAHAAZQBlAGQAdwByAGkAdABpAG4AZwAgAEkASQAsACAAUABvAHQAdABlAHIAeQAgAGEAbgBkACAASgBlAHcAZQBsAHIAeQAgAGEAcwAgAGEAZABkAGUAZAAgAGMAbwB1AHIAcwBlAHMALgANAFAAZQByAGYAbwByAG0AZQBkACAAaQBuACAAdABoAGUAIABtAGEAcgBjAGgAaQBuAGcAIABiAGEAbgBkACAAYQBuAGQAIABjAG8AbgBjAGUAcgB0ACAAYgBhAG4AZAAgAGEAbABsACAAZgBvAHUAcgAgAHkAZQBhAHIAcwAuAA0AVwBhAHMAIABhACAAbQBlAG0AYgBlAHIAIABvAGYAIABDAG8AbQBtAHUAbgBpAHQAeQAgAEEAYwB0AGkAbwBuACAAUAByAG8AZwByAGEAbQAgACgAQwBBAFAAKQANAEgAZQBsAHAAZQBkACAAbwB1AHQAIABiAGEAYwBrAHMAdABhAGcAZQAgAHcAaQB0AGgAIAB0AGgAZQAgAHMAcAByAGkAbgBnACAAbQB1AHMAaQBjAGEAbAAgAHQAdwBvACAAeQBlAGEAcgBzACAAaQBuACAAYQAgAHIAbwB3AC4ADQANAA0ARQBtAHAAbABvAHkAbQBlAG4AdAAgAEgAaQBzAHQAbwByAHkADQANAAkASwBlAHkAcwB0AG8AbgBlACAAQwBvAGwAbABlAGMAdABpAG8AbgBzACwAIABJAHIAdwBpAG4ALAAgAFAAQQAJAAkACQAJAAkACQAJACgANgAvADEANAAtAFAAcgBlAHMAZQBuAHQAKQANAAkARABhAHQAYQAgAEUAbgB0AHIAeQANAE8AbgAgAGEAIABkAGEAaQBsAHkAIABiAGEAcwBpAHMAIABJACAAdgBlAHIAaQBmAHkAIABmAGkAbgBhAGwAIABsAG8AYwBhAGwAIAByAGUAdAB1AHIAbgBzACAAYQBuAGQAIAB2AGUAcgBpAGYAeQAgAHQAaABlACAAaQBuAGYAbwByAG0AYQB0AGkAbwBuACAAdABoAGEAdAAgAGkAcwAgAGkAbgANAHQAaABlACAAcwB5AHMAdABlAG0ALgANAAkADQAJAEMAYQB0AGMAaAAtAFUAcAAgAEwAbwBnAGkAcwB0AGkAYwBzACwAIABHAHIAZQBlAG4AcwBiAHUAcgBnACwAIABQAEEACQAJAAkACQAJAAkAKAA0AC8AMQA0AC0ANQAvADEANAApAA0ACQBTAGgAaQBwAHAAaQBuAGcALwBSAGUAYwBlAGkAdgBpAG4AZwAgAEMAbABlAHIAawANAE8AbgAgAGEAIABkAGEAaQBsAHkAIABiAGEAcwBpAHMAIABJACAAcABlAHIAZgBvAHIAbQAgAHQAaABlACAASQBuACAAJgAgAE8AdQB0ACAAYwBvAHUAbgB0ACAAZgBvAHIAIAB0AGgAZQAgAHAAcgBlAHYAaQBvAHUAcwAgAGQAYQB5AC4ADQBPAG4AIABhACAAZABhAGkAbAB5ACAAYgBhAHMAaQBzACAASQAgAHAAcgBvAGMAZQBzAHMAIABCAGkAbABsAHMAIABvAGYAIABMAGEAZABpAG4AZwAgAGYAbwByACAAUwBoAGkAcABtAGUAbgB0AHMAIAB1AHMAaQBuAGcAIAAzAFAATAAuAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABwAHIAbwBjAGUAcwBzACAAcgBlAGMAZQBpAHAAdABzACAAZgBvAHIAIABpAHQAZQBtAHMAIABkAGUAbABpAHYAZQByAGUAZAAgAHUAcwBpAG4AZwAgADMAUABMAC4ADQBPAG4AIABhACAAZABhAGkAbAB5ACAAYgBhAHMAaQBzACAASQAgAGMAYQBsAGwAIABjAGEAcgByAGkAZQByAHMAIAB0AG8AIABhAHIAcgBhAG4AZwBlACAAcABpAGMAawAgAHUAcABzACAAZgBvAHIAIABzAGgAaQBwAG0AZQBuAHQAcwAuAA0ADQANAAkATABvAGQAbwB2AGkAYwBvACAAJgAgAEEAcwBzAG8AYwBpAGEAdABlAHMALAAgAEYAbwByAGUAcwB0ACAASABpAGwAbABzACwAIABQAEEACQAJAAkACQAJAAkAKAAxAC8AMQAzAC0AMgAvADEANAApAA0ACQBQAHIAbwBjAGUAcwBzAG8AcgANAEQAdQByAGkAbgBnACAAdABhAHgAIABzAGUAYQBzAG8AbgAgAEkAIABwAHIAbwBjAGUAcwBzACAAYwBsAGkAZQBuAHQAcwAgAHQAYQB4ACAAcgBlAHQAdQByAG4AcwAgAGIAeQAgAG0AYQBrAGkAbgBnACAAYwBvAHAAaQBlAHMAIABvAGYAIAB0AGgAZQAgAGMAbABpAGUAbgB0AHMAIAB0AGEAeAAgAHIAZQB0AHUAcgBuACAAZgBvAHIAIAB0AGgAZQAgAGMAbABpAGUAbgB0ACAAdABvACAAawBlAGUAcAAgAGYAbwByACAAdABoAGUAaQByACAAcgBlAGMAbwByAGQAcwAuAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABwAGUAcgBmAG8AcgBtACAAZwBlAG4AZQByAGEAbAAgAG8AZgBmAGkAYwBlACAAZAB1AHQAaQBlAHMALgANAA0ADQAJAA0ACQBBAG0AZQByAGkAcwBvAHUAcgBjAGUAYgBlAHIAZwBlAG4ALQAgAFQAaABlAHIAYQBjAG8AbQAsACAATQBvAG4AcgBvAGUAdgBpAGwAbABlACwAIABQAEEACQAJAAkACQAoADEAMgAvADEAMQAtADEAMAAvADEAMgApAA0ACQBTAGUAbgBpAG8AcgAgAEQAYQB0AGEAIABFAG4AdAByAHkALQBYAGEAcgBlAGwAdABvAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABwAGUAcgBmAG8AcgBtACAAZABhAHQAYQAgAGUAbgB0AHIAeQAgAGYAbwByACAAYgBlAG4AZQBmAGkAdAAgAGkAbgB2AGUAcwB0AGkAZwBhAHQAaQBvAG4AcwAgAGYAbwByACAAdABoAGUAIABkAHIAdQBnACAAYwBhAGwAbABlAGQAIABYAGEAcgBlAGwAdABvAC4ADQBFAG4AdABlAHIAIABCAHUAcwBpAG4AZQBzAHMAIABBAHMAcwBvAGMAaQBhAHQAZQBzACAAQQBnAHIAZQBlAG0AZQBuAHQAcwAgAGYAbwByACAAcABoAHkAcwBpAGMAaQBhAG4AcwAgAG8AZgBmAGkAYwBlAHMAIABmAG8AcgAgAHQAaABlACAAZAByAHUAZwAgAGMAYQBsAGwAZQBkACAAWABhAHIAZQBsAHQAbwAuAA0AUwBlAGEAcgBjAGgAIABwAGgAeQBzAGkAYwBpAGEAbgBzACAATgBQAEkAIABuAHUAbQBiAGUAcgBzACAAdQBzAGkAbgBnACAASQBuAHQAZQByAG4AZQB0ACAARQB4AHAAbABvAHIAZQByAC4ADQBMAGkAbgBrACAAaQBtAGEAZwBlAHMAIAB0AG8AIABjAGEAcwBlAHMAIAB1AHMAaQBuAGcAIABLAG8AZgBhAHgALgANAEYAYQB4ACAAaQBuACAAVgBlAHIAYgBhAGwAIABCAGUAbgBlAGYAaQB0ACAASQBuAHYAZQBzAHQAaQBnAGEAdABpAG8AbgAgAGYAbwByAG0AcwAgAHQAbwAgAEsAbwBmAGEAeAAgAHQAbwAgAGwAaQBuAGsAIAB0AG8AIABjAGEAcwBlAHMALgANAA0ADQAJAFQAaABlACAATgBlAHcAIABNAG8AbgByAG8AZQB2AGkAbABsAGUAIABEAG8AZABnAGUAIABDAG8AbABsAGkAcwBpAG8AbgAgAEMAZQBuAHQAZQByACwAIABNAG8AbgByAG8AZQB2AGkAbABsAGUALAAgAFAAQQAJAAkAKAAxAC8AMQAxAC0AMQAyAC8AMQAxACkAIAAJAFIAZQBjAGUAcAB0AGkAbwBuAGkAcwB0AA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABhAG4AcwB3AGUAcgAgAHAAaABvAG4AZQBzAC4ADQBPAG4AIABhACAAZABhAGkAbAB5ACAAYgBhAHMAaQBzACAASQAgAGMAYQBsAGwAIABjAHUAcwB0AG8AbQBlAHIAcwAgACAAdwBpAHQAaAAgAGkAbgBzAHUAcgBhAG4AYwBlACAAYQBzAHMAaQBnAG4AbQBlAG4AdABzACAASQAgAHIAZQBjAGUAaQB2AGUAZAAgAHYAaQBhACAAQwBDAEMAIABPAG4AZQAgAHQAbwAgAHMAYwBoAGUAZAB1AGwAZQAgAGYAbwByACAAZQBzAHQAaQBtAGEAdABlAHMALgANAEkAIABlAG4AdABlAHIAIABiAG8AZAB5ACAAcwBoAG8AcAAgAHQAZQBjAGgAbgBpAGMAaQBhAG4AJwBzACAAdABpAG0AZQAgAGMAYQByAGQAcwAgAHUAcwBpAG4AZwAgAEEARABQAC4ADQBJACAAbwByAGQAZQByACAAJgAgAGMAaABlAGMAawAgAGkAbgAgAHAAYQByAHQAcwAuAA0ASQAgAHcAcgBpAHQAZQAgAHIAZQBwAGEAaQByACAAbwByAGQAZQByAHMAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ASQAgAGMAbABvAHMAZQAgAHIAZQBwAGEAaQByACAAbwByAGQAZQByAHMAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ATwBuACAAbwBjAGMAYQBzAGkAbwBuACAASQAgAGgAYQB2AGUAIABmAGkAbABsAGUAZAAgAGkAbgAgAGYAbwByACAAdABoAGUAIABjAGEAcwBoAGkAZQByACAAYQB0ACAASwBpAGEALwBNAGEAegBkAGEALgANAA0ACQANAAkARABhAHkAIABGAG8AcgBkACwAIABNAG8AbgByAG8AZQB2AGkAbABsAGUALAAgAFAAQQAJAAkACQAJAAkACQAJACgAMQAxAC8AMAA1AC0ANgAvADEAMAApAA0ACQBSAGUAYwBlAHAAdABpAG8AbgBpAHMAdAAvAEMAYQBzAGgAaQBlAHIALwBDAHUAcwB0AG8AbQBlAHIAIABTAGUAcgB2AGkAYwBlAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABhAG4AcwB3AGUAcgBlAGQAIABwAGgAbwBuAGUAcwAsACAAdABhAGsAZQAgAGMAYQByAGUAIABvAGYAIABzAGUAcgB2AGkAYwBlACAAYwB1AHMAdABvAG0AZQByAHMALAAgAGIAYQBsAGEAbgBjAGUAIABiAG8AdABoACAAYwBhAHMAaAAgAGQAcgBhAHcAZQByAHMALAAgAGEAbgBkACAAZABvACAAYQAgAGQAZQBwAG8AcwBpAHQALgANAEkAIABzAHQAbwBjAGsAZQBkACAAaQBuACAAbgBlAHcAIABhAG4AZAAgAHUAcwBlAGQAIAB2AGUAaABpAGMAbABlAHMAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ASQAgAHcAYQBzACAAcwBvAGwAZQBsAHkAIAByAGUAcwBwAG8AbgBzAGkAYgBsAGUAIABmAG8AcgAgAGUAbgB0AGUAcgBpAG4AZwAgAGkAbgB2AG8AaQBjAGUAcwAgAGYAbwByACAAYQBjAGMAbwB1AG4AdABzACAAcABhAHkAYQBiAGwAZQAgAGEAbgBkACAAcAByAGkAbgB0AGkAbgBnACAAYwBoAGUAYwBrAHMAIABmAG8AcgAgAGEAYwBjAG8AdQBuAHQAcwAgAHAAYQB5AGEAYgBsAGUAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ASQAgAGUAbgB0AGUAcgBlAGQAIABzAHQAbwBjAGsAIABuAHUAbQBiAGUAcgBzACAAZgBvAHIAIABuAGUAdwAgAHYAZQBoAGkAYwBsAGUAcwAgAG8AbgBsAGkAbgBlACAAdQBzAGkAbgBnACAASQBuAHQAZQByAG4AZQB0ACAARQB4AHAAbABvAHIAZQByACAAbwBuACAARABlAGEAbABlAHIAIABBAGMAYwBlAHMAcwAgAFMAeQBzAHQAZQBtACAAZgBvAHIAIABQAE4AQwAuAA0ASQAgAFMAdQBiAG0AaQB0AHQAZQBkACAAdwBhAHIAcgBhAG4AdAB5ACAAYwBsAGEAaQBtAHMAIABmAG8AcgAgAEoATQAmAEEAIABvAG4AbABpAG4AZQAgAHUAcwBpAG4AZwAgAEkAbgB0AGUAcgBuAGUAdAAgAEUAeABwAGwAbwByAGUAcgAuAA0ASQAgAFMAdQBiAG0AaQB0AHQAZQBkACAAdAByAGEAbgBzAGYAZQByACAAcABhAHAAZQByAHcAbwByAGsAIABmAG8AcgAgAGQAZQBhAGwAZQByACAAdAByAGEAZABlAHMAIAB1AHMAaQBuAGcAIABDAG8AbgBjAGUAcABzACAAbwBuACAARgBNAEMAIABEAGUAYQBsAGUAcgAuAA0ADQANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAABwIAAA6CAAAWggAAHgIAAB6CAAAfAgAAJwIAACeCAAAAgkAAAQJAACyCQAAWgoAAKgKAACqCgAAvgoAAMAKAAAsCwAAMAsAAGYLAABoDAAAagwAAOgMAADsDAAAHg0AAJANAAAkDgAApA4AAAIPAACEDwAAhg8AAIgPAACuDwAAsA8AABwQAAAeEAAANBAAANwQAAD0EAAA+BAAAPoQAABiEQAAZBEAAJYRAAAeEgAAphIAACwTAAC0EwAAthMAALgTAAAsFAAAQhQAAEwVAACwFQAAshUAALQVAAC4FQAANhYAADgWAABsFgAAKBcAANoXAABIGAAAjBgAABYZAAD06+vr39/Q39/f39/f39DBwcHQwcHBwdDBwcHBwbKy0N/f39DBp9DQ39/QwcHBwaMA39Df39/f39/f0N/f39/fAAAGNQgAXAgAABQ2CAE1CABdCAFcCABPSgMAUUoDAAAcQ0ocADYIATUIAGFKHABdCAFcCABPSgMAUUoDAAAcQ0oYADYIATUIAGFKGABdCAFcCABPSgMAUUoDAAAcQ0oYADYIATUIAWFKGABdCAFcCAFPSgMAUUoDAAAWQ0oYADYIAWFKGABdCAFPSgMAUUoDAAAQQ0ocAGFKHABPSgMAUUoDAAAWQ0owADUIAWFKMABcCAFPSgMAUUoDAEAWGQAAGBkAABoZAACyGQAAzBkAABAaAADwGgAAWhsAAI4bAADQGwAAEhwAAIgcAACKHAAAjhwAAJAcAADqHAAAOB0AABoeAAB2HgAAZh8AADggAADCIAAAXiEAAGAhAABiIQAA9/fr3M3Nzc3Nzc3Nzc3c3Nzc3Nzc3M3NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxDShgANggBNQgAYUoYAF0IAVwIAE9KAwBRSgMAABxDShgANggBNQgBYUoYAF0IAVwIAU9KAwBRSgMAABZDShgANggBYUoYAF0IAU9KAwBRSgMAABBDShgAYUoYAE9KAwBRSgMAGAAIAAAcCAAAOggAAFoIAAB4CAAAeggAAHwIAACcCAAAnggAAAIJAAAECQAAsgkAAFoKAACoCgAAqgoAAL4KAADACgAALAsAAGYLAAD6AAAAAAAAAAAAAAAA9QAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAADrAAAAAAAAAAAAAAAA5gAAAAAAAAAAAAAAAOEAAAAAAAAAAAAAAADcAAAAAAAAAAAAAAAA1wAAAAAAAAAAAAAAANIAAAAAAAAAAAAAAADNAAAAAAAAAAAAAAAAyAAAAAAAAAAAAAAAAMMAAAAAAAAAAAAAAAC+AAAAAAAAAAAAAAAAuQAAAAAAAAAAAAAAALQAAAAAAAAAAAAAAACvAAAAAAAAAAAAAAAAqgAAAAAAAAAAAAAAAKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQBYSQBAAQAAAMkAWEkAQAEAAADJAFhJAEABAAAAyQBYSQBAAQAAAMkAWEkAQASZgsAAGgMAABqDAAA6AwAAB4NAACQDQAAJA4AAKQOAAACDwAAhA8AAIYPAACIDwAArg8AALAPAAAcEAAANBAAANwQAAD0EAAA+BAAAGIRAAD3AAAAAAAAAAAAAAAA8gAAAAAAAAAAAAAAAO0AAAAAAAAAAAAAAADoAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAAADgAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAAADbAAAAAAAAAAAAAAAA1gAAAAAAAAAAAAAAANEAAAAAAAAAAAAAAADMAAAAAAAAAAAAAAAAxwAAAAAAAAAAAAAAAMIAAAAAAAAAAAAAAAC9AAAAAAAAAAAAAAAAuAAAAAAAAAAAAAAAALMAAAAAAAAAAAAAAACuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAMkAGEkAAAEAAADJABhJAAFAAAKJgALRgAABQAACiYAC0YBAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAgAAAomAAtGAwADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAIAAAKJgALRgIAAyQAYSQAABNiEQAAlhEAAB4SAACmEgAALBMAALQTAAC2EwAAuBMAACwUAABCFAAATBUAALAVAACyFQAAtBUAALgVAAA2FgAAbBYAACgXAADaFwAASBgAAIwYAAAWGQAA+gAAAAAAAAAAAAAAAPUAAAAAAAAAAAAAAAD1AAAAAAAAAAAAAAAA9QAAAAAAAAAAAAAAAPUAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAA6wAAAAAAAAAAAAAAAOYAAAAAAAAAAAAAAADhAAAAAAAAAAAAAAAA2QAAAAAAAAAAAAAAANkAAAAAAAAAAAAAAADUAAAAAAAAAAAAAAAAzwAAAAAAAAAAAAAAAMoAAAAAAAAAAAAAAADFAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAALgAAAAAAAAAAAAAAAC4AAAAAAAAAAAAAAAAuAAAAAAAAAAAAAAAALgAAAAAAAAAAAAAAAC4AAAAAAAAAAAAAAAAAAAAAAAAAAgAAAomAAtGBQADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAgAAAomAAtGBgADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQABQAACiYAC0YBAAAEAAADJABhJAAAFRYZAAAYGQAAGhkAAMwZAAAQGgAA8BoAAFobAACOGwAA0BsAABIcAACIHAAAihwAAI4cAADqHAAAOB0AABoeAAB2HgAAZh8AADggAADCIAAAXiEAAGAhAABiIQAA+gAAAAAAAAAAAAAAAPUAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAA6AAAAAAAAAAAAAAAAOgAAAAAAAAAAAAAAADoAAAAAAAAAAAAAAAA6AAAAAAAAAAAAAAAAOgAAAAAAAAAAAAAAADoAAAAAAAAAAAAAAAA6AAAAAAAAAAAAAAAAOMAAAAAAAAAAAAAAADeAAAAAAAAAAAAAAAA2QAAAAAAAAAAAAAAANQAAAAAAAAAAAAAAADMAAAAAAAAAAAAAAAAzAAAAAAAAAAAAAAAAMwAAAAAAAAAAAAAAADMAAAAAAAAAAAAAAAAzAAAAAAAAAAAAAAAAMwAAAAAAAAAAAAAAADHAAAAAAAAAAAAAAAAwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAyQAYSQAAAQAAAMkAGEkAAgAAAomAAtGAQADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQACAAACiYAC0YEAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAWMAAfsNAvILDgPSGwwgIisMICI5CwASSQAAAyUAAAMZBoATBwAAAAADNQAAAoMgAOMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAAAGAAAAAEAAAABAAAAEAAAAAIAAADp/QAAGAAAAAEAAAABAAAAEAAAAAIAAADp/QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIAbwBvAHQAIABFAG4AdAByAHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAUA//////////8BAAAABgkCAAAAAADAAAAAAAAARgAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAEACAAAAAAAAAQBDAG8AbQBwAE8AYgBqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAgACAAAABAAAAP////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAagAAAAAAAAABAE8AbABlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgACAP////8DAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAUAAAAAAAAADEAVABhAGIAbABlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAIA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABUhAAAAAAAABQBTAHUAbQBtAGEAcgB5AEkAbgBmAG8AcgBtAGEAdABpAG8AbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAgAFAAAABgAAAP////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAA7AAAAAAAAABXAG8AcgBkAEQAbwBjAHUAbQBlAG4AdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgACAP///////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAyLgAAAAAAAAUARABvAGMAdQBtAGUAbgB0AFMAdQBtAG0AYQByAHkASQBuAGYAbwByAG0AYQB0AGkAbwBuAAAAAAAAAAAAAAA4AAIA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+////AAAAAAAAAAA=;type:2
\ No newline at end of file
diff --git a/src/parser/__tests__/json/base64.json b/src/parser/__tests__/json/base64.json
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/json/base64.json
@@ -0,0 +1 @@
+{"action":"candidate.create","actionId":"80653a26cc46357ff79ff83b47e27c3cb7a668bd","params":{"attachments":["fileName:Resume.doc;base64stream:0M8R4KGxGuEAAAAAAAAAAAAAAAAAAAAAOwADAP7/CQAGAAAAAAAAAAAAAAABAAAALgAAAAAAAAAAEAAAAgAAAAEAAAD+////AAAAAAAAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////9//////////7///8tAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAAAAEQAAABIAAAATAAAAFAAAAP7///8WAAAAFwAAABgAAAAZAAAAGgAAABsAAAAcAAAAHQAAAB4AAAAfAAAAIAAAACEAAAAiAAAAIwAAACQAAAAlAAAAJgAAACcAAAAoAAAAKQAAACoAAAArAAAALAAAAP7////+////LwAAAP7//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////1IAbwBvAHQAIABFAG4AdAByAHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAUA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v///wAAAAAAAAAAAQAAAP7////+////BAAAAAUAAAAGAAAA/v///wgAAAD+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8BAP7/AwoAAP////8GCQIAAAAAAMAAAAAAAABGGAAAAE1pY3Jvc29mdCBXb3JkLURva3VtZW50AAoAAABNU1dvcmREb2MAEAAAAFdvcmQuRG9jdW1lbnQuOAD0ObJxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+/wAAAQACAAAAAAAAAAAAAAAAAAAAAAABAAAA4IWf8vlPaBCrkQgAKyez2TAAAAC8AAAACAAAAAEAAABIAAAABAAAAFAAAAAIAAAAaAAAAAkAAACAAAAACgAAAIwAAAALAAAAmAAAAAwAAACkAAAADQAAALAAAAACAAAA6f0AAB4AAAAOAAAAQXByaWwgVmlzbmljawAAAB4AAAAOAAAAQXByaWwgVmlzbmljawAAAB4AAAACAAAAMQAAAEAAAAAAgRssAAAAAEAAAAAAAAAAAAAAAEAAAAAA1pEh62jLAUAAAAAAhXEJ8mjLAQAAAAAAAAAAAAAAAAAAAAAAAAAA/v8AAAEAAgAAAAAAAAAAAAAAAAAAAAAAAgAAAALVzdWcLhsQk5cIACss+a5EAAAABdXN1ZwuGxCTlwgAKyz5rhIANQAKAAEAWwAPAAIAAAAAAAAAbgAAEPH/AgBuAAAABwBEAGUAZgBhAHUAbAB0AAAAGgAAAAMkAGEkADEkACokATckATUkATMkAUEkADMAQioAT0oAAFFKAABDShgAbUgJBHNICQRLSAEAUEoEAG5I/wBeSgUAYUoYAF9I/wB0SP8AAAAAAAAAAAAAAAAAAAAAAAAAAEIAQUDy/6EAQgAAABkAQQBiAHMAYQB0AHoALQBTAHQAYQBuAGQAYQByAGQAcwBjAGgAcgBpAGYAdABhAHIAdAAAAAAAAAAAAAAAAAAuAP4f8v/xAC4AAAAJAFcAVwA4AE4AdQBtADEAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v8BAS4AAAAJAFcAVwA4AE4AdQBtADEAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v8RAS4AAAAJAFcAVwA4AE4AdQBtADIAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v8hAS4AAAAJAFcAVwA4AE4AdQBtADIAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v8xAS4AAAAJAFcAVwA4AE4AdQBtADMAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v9BAS4AAAAJAFcAVwA4AE4AdQBtADMAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v9RAS4AAAAJAFcAVwA4AE4AdQBtADQAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v9hAS4AAAAJAFcAVwA4AE4AdQBtADQAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v9xAS4AAAAJAFcAVwA4AE4AdQBtADUAegAwAAAADABPSgYAUUoGAF5KBwAuAP4f8v+BAS4AAAAJAFcAVwA4AE4AdQBtADUAegAxAAAADABPSggAUUoIAF5KBwAuAP4f8v+RAS4AAAAJAFcAVwA4AE4AdQBtADYAegAwAAAADABPSgYAUUoGAF5KBwA2AP4f8v+hATYAAAAJAFcAVwA4AE4AdQBtADcAegAwAAAAFABPSgYAUUoGAENKHABeSgcAYUocADYA/h/y/7EBNgAAAAkAVwBXADgATgB1AG0ANwB6ADEAAAAUAE9KCQBRSgkAQ0ocAF5KBwBhShwAQgD+H/L/wQFCAAAAGQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0AAAAAABIAP4f8v/RAUgAAAAcAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAAAAAAC4A/h/y/+EBLgAAAAkAVwBXADgATgB1AG0ANgB6ADEAAAAMAE9KCABRSggAXkoHADYA/h/y//EBNgAAAAkAVwBXADgATgB1AG0AOAB6ADAAAAAUAE9KBgBRSgYAQ0ocAF5KBwBhShwANgD+H/L/AQI2AAAACQBXAFcAOABOAHUAbQA4AHoAMQAAABQAT0oIAFFKCABDShwAXkoHAGFKHABKAP4f8v8RAkoAAAAdAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAAAAAATAD+H/L/IQJMAAAAHgBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAAAAAATgD+H/L/MQJOAAAAHwBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxAAAAAABQAP4f8v9BAlAAAAAgAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAAAAAAUgD+H/L/UQJSAAAAIQBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAAAAAAVAD+H/L/YQJUAAAAIgBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxAAAAAABWAP4f8v9xAlYAAAAjAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAxADEAMQAAAAAAWAD+H/L/gQJYAAAAJABXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAAAAAAWgD+H/L/kQJaAAAAJQBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxAAAAAABcAP4f8v+hAlwAAAAmAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAxADEAMQAxADEAMQAAAAAAXgD+H/L/sQJeAAAAJwBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxADEAMQAAAAAAYAD+H/L/wQJgAAAAKABXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxADEAMQAxAAAAAABiAP4f8v/RAmIAAAApAFcAVwAtAEEAYgBzAGEAdAB6AC0AUwB0AGEAbgBkAGEAcgBkAHMAYwBoAHIAaQBmAHQAYQByAHQAMQAxADEAMQAxADEAMQAxADEAMQAxADEAMQAAAAAAZAD+H/L/4QJkAAAAKgBXAFcALQBBAGIAcwBhAHQAegAtAFMAdABhAG4AZABhAHIAZABzAGMAaAByAGkAZgB0AGEAcgB0ADEAMQAxADEAMQAxADEAMQAxADEAMQAxADEAMQAAAAAANgD+H/L/8QI2AAAABwBCAHUAbABsAGUAdABzAAAAGABPSgcAUUoHAENKHABQSgcAXkoHAGFKHABGAP4fAQASA0YAAAAHAEgAZQBhAGQAaQBuAGcAAAANADAAE6TwABSkeAAGJAEAGABPSgIAUUoCAENKHABQSgoAXkoFAGFKHAAuAEIQAQASAy4AAAAJAFQAZQB4AHQAIABiAG8AZAB5AAAACgAxABOkAAAUpHgAAAAgAC8QEQMiAyAAAAAEAEwAaQBzAHQAAAACADIABABeSgsAQAD+HwEAMgNAAAAABwBDAGEAcAB0AGkAbwBuAAAADQAzABOkeAAUpHgADCQBABIAQ0oYADYIAV5KCwBhShgAXQgBJgD+HwEAQgMmAAAABQBJAG4AZABlAHgAAAAFADQADCQBAAQAXkoLAAAAAACxDAAABAAALgAAAAD/////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAWGQAAYiEAABEAAAASAAAAAAgAAGYLAABiEQAAFhkAAGIhAAATAAAAFAAAABUAAAAWAAAABwABAAAAAQAAAP8P/w//D/8P/w//D/8P/w//DwAAAgAAAAIAAAD/D/8P/w//D/8P/w//D/8P/w8AAAMAAAADAAAA/w//D/8P/w//D/8P/w//D/8PAAAEAAAABAAAAP8P/w//D/8P/w//D/8P/w//DwAABQAAAAUAAAD/D/8P/w//D/8P/w//D/8P/w8AAAYAAAAGAAAA/w//D/8P/w//D/8P/w//D/8PAAAHAAAABwAAAP8P/w//D/8P/w//D/8P/w//DwAAAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSggAUUoIAF5KBwABAOYlAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSggAUUoIAF5KBwABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSgkAUUoJAF5KBwABAGzwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E2AlghJj+FcYFAAHYCQZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EQAtghJj+FcYFAAFACwZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EEA5ghJj+FcYFAAEQDgZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EeA9ghJj+FcYFAAF4DwZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6ESBJghJj+FcYFAAFIEgZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAADBAAAF6EsBNghJj+FcYFAAGwEwZPSgYAUUoGAF5KBwABALfwAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAAFBAAAF6EcAhghJj+FcYFAAFwCAZPSgYAUUoGAENKHABeSgcAYUocAAEAt/ABAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAUEAAAXoTYCWCEmP4VxgUAAdgJBk9KCABRSggAQ0ocAF5KBwBhShwAAQDmJQEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAABQQAABehEALYISY/hXGBQABQAsGT0oIAFFKCABDShwAXkoHAGFKHAABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAAFBAAAF6EqAxghJj+FcYFAAGoDAZPSgYAUUoGAENKHABeSgcAYUocAAEAt/ABAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAUEAAAXoQQDmCEmP4VxgUAARAOBk9KCABRSggAQ0ocAF5KBwBhShwAAQDmJQEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAABQQAABehHgPYISY/hXGBQABeA8GT0oIAFFKCABDShwAXkoHAGFKHAABAKolAQAAABcAAAAAAAAAAAAAAAAAAAAAAAAAFBAAAF6E4BBghJj+FcYFAAHgEAZPSgYAUUoGAENKHABeSgcAYUocAAEAt/ABAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAUEAAAXoRIEmCEmP4VxgUAAUgSBk9KCABRSggAQ0ocAF5KBwBhShwAAQDmJQEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAABQQAABehLATYISY/hXGBQABsBMGT0oIAFFKCABDShwAXkoHAGFKHAABAKolAQAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAABAAAF6EsAFghFD+FcYFAAGwAQYAAAEAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAQAABehEACYITA/RXGBQABQAIGAAABAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAXoTQAmCEMP0VxgUAAdACBgAAAQAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAABAAAF6EYANghKD8FcYFAAFgAwYAAAEAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAQAABehPADYIQQ/BXGBQAB8AMGAAABAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAXoSABGCEgPsVxgUAAYAEBgAAAQAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAABAAAF6EEAVghPD6FcYFAAEQBQYAAAEAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAQAABehKAFYIRg+hXGBQABoAUGAAABAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAXoQwBmCE0PkVxgUAATAGBgAABwAAAAEAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////8HAAAABwBXAFcAOABOAHUAbQAxAAcAVwBXADgATgB1AG0AMwAHAFcAVwA4AE4AdQBtADQABwBXAFcAOABOAHUAbQA1AAcAVwBXADgATgB1AG0ANgAHAFcAVwA4AE4AdQBtADcAAAAAAAAAsQwAAAAAAAACEAAAAAAAAACxDAAAUAAACAAAAAAMAAAARxaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAaQBtAGUAcwAgAE4AZQB3ACAAUgBvAG0AYQBuAAAANRaQAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFMAeQBtAGIAbwBsAAAAMyaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEAcgBpAGEAbAAAAEEmkAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAHIAZQBiAHUAYwBoAGUAdAAgAE0AUwAAAEkmkAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAHIAaQBhAGwAIABVAG4AaQBjAG8AZABlACAATQBTAAAANQaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAYQBoAG8AbQBhAAAANQSQAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFMAeQBtAGIAbwBsAAAAXwSQAQALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE8AcABlAG4AUwB5AG0AYgBvAGwAAABBAHIAaQBhAGwAIABVAG4AaQBjAG8AZABlACAATQBTAAAAXwSQAYALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE8AcABlAG4AUwB5AG0AYgBvAGwAAABBAHIAaQBhAGwAIABVAG4AaQBjAG8AZABlACAATQBTAAAAOwSQAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFcAaQBuAGcAZABpAG4AZwBzAAAAOwaQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE0AUwAgAE0AaQBuAGMAaABvAAAANQSQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAYQBoAG8AbQBhAAAAQgAEAAEIjRgAAMUCAABoAQAAAACWVeoGy1XqBgAAAAABAAAAAAAMAgAAgQwAAAIAPQAAAAQAg5A9AAAADAIAAIEMAAACAD0AAAA9AAAAAAAAACcDACAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAgAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADspQEBTSAJBAAAABK/AAAAAAAAMAAAAAAACAAAYiEAAA4AQ2FvbGFuODAAAAAAAAAAAAAAAAAAAAAAAAAJBBYAMi4AAAAAAAAAAAAAsQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//w8AEQAAAAIAAAD//w8AEwAAAAQAAAD//w8AAAAAAAAAAAAAAAAAAAAAAIgAAAAAAKoKAAAAAAAAqgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqgoAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL4KAAA0AAAA8goAABQAAAAGCwAAJAAAAAAAAAAAAAAAlxsAABwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdhsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACzHgAAYgIAAAAAAAAAAAAAghsAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqCwAAxgAAAH4aAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOGwAAaAAAAAAAAAAAAAAAdhsAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEAcAByAGkAbAAgAFYAaQBzAG4AaQBjAGsADQAxADQAMAAgAEwAbwBuAGcAIABEAHIAaQB2AGUADQBJAHIAdwBpAG4ALAAgAFAAQQAgADEANQA2ADQAMgANACgANwAyADQAKQAgADYAMQAwAC0AMQA0ADgAMAANAA0ADQBDAG8AbQBwAHUAdABlAHIAIABTAGsAaQBsAGwAcwANAA0ACQAJAEkAIABhAG0AIABlAHgAcABlAHIAaQBlAG4AYwBlAGQAIAB3AGkAdABoACAATQBpAGMAcgBvAHMAbwBmAHQAIABXAG8AcgBkACAAYQBuAGQAIABFAHgAYwBlAGwALgANAA0ACQAJAEkAIABjAGEAbgAgAHUAcwBlACAASQBuAHQAZQByAG4AZQB0ACAARQB4AHAAbABvAHIAZQByACAAdABvACAAZABvAHcAbgBsAG8AYQBkACAAdQBwAGQAYQB0AGUAcwAgAGYAbwByACAATQBpAGMAcgBvAHMAbwBmAHQAIABXAG8AcgBkACAAYQBuAGQAIABFAHgAYwBlAGwALAAgAHMAZQBhAHIAYwBoAA0ACQAJAGQAaQByAGUAYwB0AGkAbwBuAHMAIAB0AG8AIABhAG4AZAAgAGYAcgBvAG0AIABkAGkAZgBmAGUAcgBlAG4AdAAgAGwAbwBjAGEAdABpAG8AbgBzACwAIABjAGEAbgAgAHMAZQBhAHIAYwBoACAAZgBvAHIAIABwAGgAeQBzAGkAYwBhAGwAIABhAGQAZAByAGUAcwBzAGUAcwAgAGYAbwByAA0ACQAJAGMAbwBtAHAAYQBuAGkAZQBzACAAbwByACAAaQBuAGQAaQB2AGkAZAB1AGEAbABzACwAIABhAG4AZAAgAGUAbQBhAGkAbAAuAA0ADQBFAGQAdQBjAGEAdABpAG8AbgANAA0ACQAJAEIAcgBhAGQAZgBvAHIAZAAgAEIAdQBzAGkAbgBlAHMAcwAsACAAUABpAHQAdABzAGIAdQByAGcAaAAsACAAUABBAAkACQAJAAkACQAJACgAOQAvADAAMAAtADEAMAAvADAAMQApAA0ACQAJAEEAUwBCACwAIABPAGYAZgBpAGMAZQAgAEEAZABtAGkAbgBpAHMAdAByAGEAdABpAG8AbgANAEMAbwB1AHIAcwBlACAAdwBvAHIAawAgAGkAbgBjAGwAdQBkAGUAZAA6ACAARQBzAHMAZQBuAHQAaQBhAGwAcwAgAG8AZgAgAE0AYQBuAGEAZwBlAG0AZQBuAHQALAAgAEQAYQB0AGEAIABBAG4AYQBsAHkAcwBpAHMALAAgAEMAbwBuAGMAZQBwAHQAcwAgAG8AZgAgAEQAZQBzAGsAdABvAHAAIABQAHUAYgBsAGkAcwBoAGkAbgBnACwAIABBAGQAdgBhAG4AYwBlAGQAIABFAGwAZQBjAHQAcgBvAG4AaQBjACAAUwBwAHIAZQBhAGQAcwBoAGUAZQB0AHMALgANAA0ACQAJAFAAZQBuAG4AIABUAHIAYQBmAGYAbwByAGQAIABIAGkAZwBoACAAUwBjAGgAbwBvAGwALAAgAEgAYQByAHIAaQBzAG8AbgAgAEMAaQB0AHkALAAgAFAAQQAJAAkACQAJAAkAKAAxADkAOQA2AC0AMgAwADAAMAApAA0ACQAJAEQAaQBwAGwAbwBtAGEALQAgAEcAZQBuAGUAcgBhAGwAIABTAHQAdQBkAGkAZQBzAA0ARwBlAG4AZQByAGEAbAAgAEMAbwB1AHIAcwBlAHMAIABvAGYAIABzAHQAdQBkAHkAIAB3AGUAcgBlACAATQBhAHQAaAAsACAARQBuAGcAbABpAHMAaAAgAGEAbgBkACAAUwBjAGkAZQBuAGMAZQAuAA0AVABvAG8AawAgAFMAcABlAGUAZAB3AHIAaQB0AGkAbgBnACwAIABTAHAAZQBlAGQAdwByAGkAdABpAG4AZwAgAEkASQAsACAAUABvAHQAdABlAHIAeQAgAGEAbgBkACAASgBlAHcAZQBsAHIAeQAgAGEAcwAgAGEAZABkAGUAZAAgAGMAbwB1AHIAcwBlAHMALgANAFAAZQByAGYAbwByAG0AZQBkACAAaQBuACAAdABoAGUAIABtAGEAcgBjAGgAaQBuAGcAIABiAGEAbgBkACAAYQBuAGQAIABjAG8AbgBjAGUAcgB0ACAAYgBhAG4AZAAgAGEAbABsACAAZgBvAHUAcgAgAHkAZQBhAHIAcwAuAA0AVwBhAHMAIABhACAAbQBlAG0AYgBlAHIAIABvAGYAIABDAG8AbQBtAHUAbgBpAHQAeQAgAEEAYwB0AGkAbwBuACAAUAByAG8AZwByAGEAbQAgACgAQwBBAFAAKQANAEgAZQBsAHAAZQBkACAAbwB1AHQAIABiAGEAYwBrAHMAdABhAGcAZQAgAHcAaQB0AGgAIAB0AGgAZQAgAHMAcAByAGkAbgBnACAAbQB1AHMAaQBjAGEAbAAgAHQAdwBvACAAeQBlAGEAcgBzACAAaQBuACAAYQAgAHIAbwB3AC4ADQANAA0ARQBtAHAAbABvAHkAbQBlAG4AdAAgAEgAaQBzAHQAbwByAHkADQANAAkASwBlAHkAcwB0AG8AbgBlACAAQwBvAGwAbABlAGMAdABpAG8AbgBzACwAIABJAHIAdwBpAG4ALAAgAFAAQQAJAAkACQAJAAkACQAJACgANgAvADEANAAtAFAAcgBlAHMAZQBuAHQAKQANAAkARABhAHQAYQAgAEUAbgB0AHIAeQANAE8AbgAgAGEAIABkAGEAaQBsAHkAIABiAGEAcwBpAHMAIABJACAAdgBlAHIAaQBmAHkAIABmAGkAbgBhAGwAIABsAG8AYwBhAGwAIAByAGUAdAB1AHIAbgBzACAAYQBuAGQAIAB2AGUAcgBpAGYAeQAgAHQAaABlACAAaQBuAGYAbwByAG0AYQB0AGkAbwBuACAAdABoAGEAdAAgAGkAcwAgAGkAbgANAHQAaABlACAAcwB5AHMAdABlAG0ALgANAAkADQAJAEMAYQB0AGMAaAAtAFUAcAAgAEwAbwBnAGkAcwB0AGkAYwBzACwAIABHAHIAZQBlAG4AcwBiAHUAcgBnACwAIABQAEEACQAJAAkACQAJAAkAKAA0AC8AMQA0AC0ANQAvADEANAApAA0ACQBTAGgAaQBwAHAAaQBuAGcALwBSAGUAYwBlAGkAdgBpAG4AZwAgAEMAbABlAHIAawANAE8AbgAgAGEAIABkAGEAaQBsAHkAIABiAGEAcwBpAHMAIABJACAAcABlAHIAZgBvAHIAbQAgAHQAaABlACAASQBuACAAJgAgAE8AdQB0ACAAYwBvAHUAbgB0ACAAZgBvAHIAIAB0AGgAZQAgAHAAcgBlAHYAaQBvAHUAcwAgAGQAYQB5AC4ADQBPAG4AIABhACAAZABhAGkAbAB5ACAAYgBhAHMAaQBzACAASQAgAHAAcgBvAGMAZQBzAHMAIABCAGkAbABsAHMAIABvAGYAIABMAGEAZABpAG4AZwAgAGYAbwByACAAUwBoAGkAcABtAGUAbgB0AHMAIAB1AHMAaQBuAGcAIAAzAFAATAAuAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABwAHIAbwBjAGUAcwBzACAAcgBlAGMAZQBpAHAAdABzACAAZgBvAHIAIABpAHQAZQBtAHMAIABkAGUAbABpAHYAZQByAGUAZAAgAHUAcwBpAG4AZwAgADMAUABMAC4ADQBPAG4AIABhACAAZABhAGkAbAB5ACAAYgBhAHMAaQBzACAASQAgAGMAYQBsAGwAIABjAGEAcgByAGkAZQByAHMAIAB0AG8AIABhAHIAcgBhAG4AZwBlACAAcABpAGMAawAgAHUAcABzACAAZgBvAHIAIABzAGgAaQBwAG0AZQBuAHQAcwAuAA0ADQANAAkATABvAGQAbwB2AGkAYwBvACAAJgAgAEEAcwBzAG8AYwBpAGEAdABlAHMALAAgAEYAbwByAGUAcwB0ACAASABpAGwAbABzACwAIABQAEEACQAJAAkACQAJAAkAKAAxAC8AMQAzAC0AMgAvADEANAApAA0ACQBQAHIAbwBjAGUAcwBzAG8AcgANAEQAdQByAGkAbgBnACAAdABhAHgAIABzAGUAYQBzAG8AbgAgAEkAIABwAHIAbwBjAGUAcwBzACAAYwBsAGkAZQBuAHQAcwAgAHQAYQB4ACAAcgBlAHQAdQByAG4AcwAgAGIAeQAgAG0AYQBrAGkAbgBnACAAYwBvAHAAaQBlAHMAIABvAGYAIAB0AGgAZQAgAGMAbABpAGUAbgB0AHMAIAB0AGEAeAAgAHIAZQB0AHUAcgBuACAAZgBvAHIAIAB0AGgAZQAgAGMAbABpAGUAbgB0ACAAdABvACAAawBlAGUAcAAgAGYAbwByACAAdABoAGUAaQByACAAcgBlAGMAbwByAGQAcwAuAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABwAGUAcgBmAG8AcgBtACAAZwBlAG4AZQByAGEAbAAgAG8AZgBmAGkAYwBlACAAZAB1AHQAaQBlAHMALgANAA0ADQAJAA0ACQBBAG0AZQByAGkAcwBvAHUAcgBjAGUAYgBlAHIAZwBlAG4ALQAgAFQAaABlAHIAYQBjAG8AbQAsACAATQBvAG4AcgBvAGUAdgBpAGwAbABlACwAIABQAEEACQAJAAkACQAoADEAMgAvADEAMQAtADEAMAAvADEAMgApAA0ACQBTAGUAbgBpAG8AcgAgAEQAYQB0AGEAIABFAG4AdAByAHkALQBYAGEAcgBlAGwAdABvAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABwAGUAcgBmAG8AcgBtACAAZABhAHQAYQAgAGUAbgB0AHIAeQAgAGYAbwByACAAYgBlAG4AZQBmAGkAdAAgAGkAbgB2AGUAcwB0AGkAZwBhAHQAaQBvAG4AcwAgAGYAbwByACAAdABoAGUAIABkAHIAdQBnACAAYwBhAGwAbABlAGQAIABYAGEAcgBlAGwAdABvAC4ADQBFAG4AdABlAHIAIABCAHUAcwBpAG4AZQBzAHMAIABBAHMAcwBvAGMAaQBhAHQAZQBzACAAQQBnAHIAZQBlAG0AZQBuAHQAcwAgAGYAbwByACAAcABoAHkAcwBpAGMAaQBhAG4AcwAgAG8AZgBmAGkAYwBlAHMAIABmAG8AcgAgAHQAaABlACAAZAByAHUAZwAgAGMAYQBsAGwAZQBkACAAWABhAHIAZQBsAHQAbwAuAA0AUwBlAGEAcgBjAGgAIABwAGgAeQBzAGkAYwBpAGEAbgBzACAATgBQAEkAIABuAHUAbQBiAGUAcgBzACAAdQBzAGkAbgBnACAASQBuAHQAZQByAG4AZQB0ACAARQB4AHAAbABvAHIAZQByAC4ADQBMAGkAbgBrACAAaQBtAGEAZwBlAHMAIAB0AG8AIABjAGEAcwBlAHMAIAB1AHMAaQBuAGcAIABLAG8AZgBhAHgALgANAEYAYQB4ACAAaQBuACAAVgBlAHIAYgBhAGwAIABCAGUAbgBlAGYAaQB0ACAASQBuAHYAZQBzAHQAaQBnAGEAdABpAG8AbgAgAGYAbwByAG0AcwAgAHQAbwAgAEsAbwBmAGEAeAAgAHQAbwAgAGwAaQBuAGsAIAB0AG8AIABjAGEAcwBlAHMALgANAA0ADQAJAFQAaABlACAATgBlAHcAIABNAG8AbgByAG8AZQB2AGkAbABsAGUAIABEAG8AZABnAGUAIABDAG8AbABsAGkAcwBpAG8AbgAgAEMAZQBuAHQAZQByACwAIABNAG8AbgByAG8AZQB2AGkAbABsAGUALAAgAFAAQQAJAAkAKAAxAC8AMQAxAC0AMQAyAC8AMQAxACkAIAAJAFIAZQBjAGUAcAB0AGkAbwBuAGkAcwB0AA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABhAG4AcwB3AGUAcgAgAHAAaABvAG4AZQBzAC4ADQBPAG4AIABhACAAZABhAGkAbAB5ACAAYgBhAHMAaQBzACAASQAgAGMAYQBsAGwAIABjAHUAcwB0AG8AbQBlAHIAcwAgACAAdwBpAHQAaAAgAGkAbgBzAHUAcgBhAG4AYwBlACAAYQBzAHMAaQBnAG4AbQBlAG4AdABzACAASQAgAHIAZQBjAGUAaQB2AGUAZAAgAHYAaQBhACAAQwBDAEMAIABPAG4AZQAgAHQAbwAgAHMAYwBoAGUAZAB1AGwAZQAgAGYAbwByACAAZQBzAHQAaQBtAGEAdABlAHMALgANAEkAIABlAG4AdABlAHIAIABiAG8AZAB5ACAAcwBoAG8AcAAgAHQAZQBjAGgAbgBpAGMAaQBhAG4AJwBzACAAdABpAG0AZQAgAGMAYQByAGQAcwAgAHUAcwBpAG4AZwAgAEEARABQAC4ADQBJACAAbwByAGQAZQByACAAJgAgAGMAaABlAGMAawAgAGkAbgAgAHAAYQByAHQAcwAuAA0ASQAgAHcAcgBpAHQAZQAgAHIAZQBwAGEAaQByACAAbwByAGQAZQByAHMAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ASQAgAGMAbABvAHMAZQAgAHIAZQBwAGEAaQByACAAbwByAGQAZQByAHMAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ATwBuACAAbwBjAGMAYQBzAGkAbwBuACAASQAgAGgAYQB2AGUAIABmAGkAbABsAGUAZAAgAGkAbgAgAGYAbwByACAAdABoAGUAIABjAGEAcwBoAGkAZQByACAAYQB0ACAASwBpAGEALwBNAGEAegBkAGEALgANAA0ACQANAAkARABhAHkAIABGAG8AcgBkACwAIABNAG8AbgByAG8AZQB2AGkAbABsAGUALAAgAFAAQQAJAAkACQAJAAkACQAJACgAMQAxAC8AMAA1AC0ANgAvADEAMAApAA0ACQBSAGUAYwBlAHAAdABpAG8AbgBpAHMAdAAvAEMAYQBzAGgAaQBlAHIALwBDAHUAcwB0AG8AbQBlAHIAIABTAGUAcgB2AGkAYwBlAA0ATwBuACAAYQAgAGQAYQBpAGwAeQAgAGIAYQBzAGkAcwAgAEkAIABhAG4AcwB3AGUAcgBlAGQAIABwAGgAbwBuAGUAcwAsACAAdABhAGsAZQAgAGMAYQByAGUAIABvAGYAIABzAGUAcgB2AGkAYwBlACAAYwB1AHMAdABvAG0AZQByAHMALAAgAGIAYQBsAGEAbgBjAGUAIABiAG8AdABoACAAYwBhAHMAaAAgAGQAcgBhAHcAZQByAHMALAAgAGEAbgBkACAAZABvACAAYQAgAGQAZQBwAG8AcwBpAHQALgANAEkAIABzAHQAbwBjAGsAZQBkACAAaQBuACAAbgBlAHcAIABhAG4AZAAgAHUAcwBlAGQAIAB2AGUAaABpAGMAbABlAHMAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ASQAgAHcAYQBzACAAcwBvAGwAZQBsAHkAIAByAGUAcwBwAG8AbgBzAGkAYgBsAGUAIABmAG8AcgAgAGUAbgB0AGUAcgBpAG4AZwAgAGkAbgB2AG8AaQBjAGUAcwAgAGYAbwByACAAYQBjAGMAbwB1AG4AdABzACAAcABhAHkAYQBiAGwAZQAgAGEAbgBkACAAcAByAGkAbgB0AGkAbgBnACAAYwBoAGUAYwBrAHMAIABmAG8AcgAgAGEAYwBjAG8AdQBuAHQAcwAgAHAAYQB5AGEAYgBsAGUAIAB1AHMAaQBuAGcAIABBAEQAUAAuAA0ASQAgAGUAbgB0AGUAcgBlAGQAIABzAHQAbwBjAGsAIABuAHUAbQBiAGUAcgBzACAAZgBvAHIAIABuAGUAdwAgAHYAZQBoAGkAYwBsAGUAcwAgAG8AbgBsAGkAbgBlACAAdQBzAGkAbgBnACAASQBuAHQAZQByAG4AZQB0ACAARQB4AHAAbABvAHIAZQByACAAbwBuACAARABlAGEAbABlAHIAIABBAGMAYwBlAHMAcwAgAFMAeQBzAHQAZQBtACAAZgBvAHIAIABQAE4AQwAuAA0ASQAgAFMAdQBiAG0AaQB0AHQAZQBkACAAdwBhAHIAcgBhAG4AdAB5ACAAYwBsAGEAaQBtAHMAIABmAG8AcgAgAEoATQAmAEEAIABvAG4AbABpAG4AZQAgAHUAcwBpAG4AZwAgAEkAbgB0AGUAcgBuAGUAdAAgAEUAeABwAGwAbwByAGUAcgAuAA0ASQAgAFMAdQBiAG0AaQB0AHQAZQBkACAAdAByAGEAbgBzAGYAZQByACAAcABhAHAAZQByAHcAbwByAGsAIABmAG8AcgAgAGQAZQBhAGwAZQByACAAdAByAGEAZABlAHMAIAB1AHMAaQBuAGcAIABDAG8AbgBjAGUAcABzACAAbwBuACAARgBNAEMAIABEAGUAYQBsAGUAcgAuAA0ADQANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAABwIAAA6CAAAWggAAHgIAAB6CAAAfAgAAJwIAACeCAAAAgkAAAQJAACyCQAAWgoAAKgKAACqCgAAvgoAAMAKAAAsCwAAMAsAAGYLAABoDAAAagwAAOgMAADsDAAAHg0AAJANAAAkDgAApA4AAAIPAACEDwAAhg8AAIgPAACuDwAAsA8AABwQAAAeEAAANBAAANwQAAD0EAAA+BAAAPoQAABiEQAAZBEAAJYRAAAeEgAAphIAACwTAAC0EwAAthMAALgTAAAsFAAAQhQAAEwVAACwFQAAshUAALQVAAC4FQAANhYAADgWAABsFgAAKBcAANoXAABIGAAAjBgAABYZAAD06+vr39/Q39/f39/f39DBwcHQwcHBwdDBwcHBwbKy0N/f39DBp9DQ39/QwcHBwaMA39Df39/f39/f0N/f39/fAAAGNQgAXAgAABQ2CAE1CABdCAFcCABPSgMAUUoDAAAcQ0ocADYIATUIAGFKHABdCAFcCABPSgMAUUoDAAAcQ0oYADYIATUIAGFKGABdCAFcCABPSgMAUUoDAAAcQ0oYADYIATUIAWFKGABdCAFcCAFPSgMAUUoDAAAWQ0oYADYIAWFKGABdCAFPSgMAUUoDAAAQQ0ocAGFKHABPSgMAUUoDAAAWQ0owADUIAWFKMABcCAFPSgMAUUoDAEAWGQAAGBkAABoZAACyGQAAzBkAABAaAADwGgAAWhsAAI4bAADQGwAAEhwAAIgcAACKHAAAjhwAAJAcAADqHAAAOB0AABoeAAB2HgAAZh8AADggAADCIAAAXiEAAGAhAABiIQAA9/fr3M3Nzc3Nzc3Nzc3c3Nzc3Nzc3M3NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxDShgANggBNQgAYUoYAF0IAVwIAE9KAwBRSgMAABxDShgANggBNQgBYUoYAF0IAVwIAU9KAwBRSgMAABZDShgANggBYUoYAF0IAU9KAwBRSgMAABBDShgAYUoYAE9KAwBRSgMAGAAIAAAcCAAAOggAAFoIAAB4CAAAeggAAHwIAACcCAAAnggAAAIJAAAECQAAsgkAAFoKAACoCgAAqgoAAL4KAADACgAALAsAAGYLAAD6AAAAAAAAAAAAAAAA9QAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAADrAAAAAAAAAAAAAAAA5gAAAAAAAAAAAAAAAOEAAAAAAAAAAAAAAADcAAAAAAAAAAAAAAAA1wAAAAAAAAAAAAAAANIAAAAAAAAAAAAAAADNAAAAAAAAAAAAAAAAyAAAAAAAAAAAAAAAAMMAAAAAAAAAAAAAAAC+AAAAAAAAAAAAAAAAuQAAAAAAAAAAAAAAALQAAAAAAAAAAAAAAACvAAAAAAAAAAAAAAAAqgAAAAAAAAAAAAAAAKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQBYSQBAAQAAAMkAWEkAQAEAAADJAFhJAEABAAAAyQBYSQBAAQAAAMkAWEkAQASZgsAAGgMAABqDAAA6AwAAB4NAACQDQAAJA4AAKQOAAACDwAAhA8AAIYPAACIDwAArg8AALAPAAAcEAAANBAAANwQAAD0EAAA+BAAAGIRAAD3AAAAAAAAAAAAAAAA8gAAAAAAAAAAAAAAAO0AAAAAAAAAAAAAAADoAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAAADgAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAAADbAAAAAAAAAAAAAAAA1gAAAAAAAAAAAAAAANEAAAAAAAAAAAAAAADMAAAAAAAAAAAAAAAAxwAAAAAAAAAAAAAAAMIAAAAAAAAAAAAAAAC9AAAAAAAAAAAAAAAAuAAAAAAAAAAAAAAAALMAAAAAAAAAAAAAAACuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAMkAGEkAAAEAAADJABhJAAFAAAKJgALRgAABQAACiYAC0YBAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAgAAAomAAtGAwADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAIAAAKJgALRgIAAyQAYSQAABNiEQAAlhEAAB4SAACmEgAALBMAALQTAAC2EwAAuBMAACwUAABCFAAATBUAALAVAACyFQAAtBUAALgVAAA2FgAAbBYAACgXAADaFwAASBgAAIwYAAAWGQAA+gAAAAAAAAAAAAAAAPUAAAAAAAAAAAAAAAD1AAAAAAAAAAAAAAAA9QAAAAAAAAAAAAAAAPUAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAA6wAAAAAAAAAAAAAAAOYAAAAAAAAAAAAAAADhAAAAAAAAAAAAAAAA2QAAAAAAAAAAAAAAANkAAAAAAAAAAAAAAADUAAAAAAAAAAAAAAAAzwAAAAAAAAAAAAAAAMoAAAAAAAAAAAAAAADFAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAALgAAAAAAAAAAAAAAAC4AAAAAAAAAAAAAAAAuAAAAAAAAAAAAAAAALgAAAAAAAAAAAAAAAC4AAAAAAAAAAAAAAAAAAAAAAAAAAgAAAomAAtGBQADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAgAAAomAAtGBgADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQABQAACiYAC0YBAAAEAAADJABhJAAAFRYZAAAYGQAAGhkAAMwZAAAQGgAA8BoAAFobAACOGwAA0BsAABIcAACIHAAAihwAAI4cAADqHAAAOB0AABoeAAB2HgAAZh8AADggAADCIAAAXiEAAGAhAABiIQAA+gAAAAAAAAAAAAAAAPUAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAA6AAAAAAAAAAAAAAAAOgAAAAAAAAAAAAAAADoAAAAAAAAAAAAAAAA6AAAAAAAAAAAAAAAAOgAAAAAAAAAAAAAAADoAAAAAAAAAAAAAAAA6AAAAAAAAAAAAAAAAOMAAAAAAAAAAAAAAADeAAAAAAAAAAAAAAAA2QAAAAAAAAAAAAAAANQAAAAAAAAAAAAAAADMAAAAAAAAAAAAAAAAzAAAAAAAAAAAAAAAAMwAAAAAAAAAAAAAAADMAAAAAAAAAAAAAAAAzAAAAAAAAAAAAAAAAMwAAAAAAAAAAAAAAADHAAAAAAAAAAAAAAAAwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAyQAYSQAAAQAAAMkAGEkAAgAAAomAAtGAQADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQACAAACiYAC0YEAAMkAGEkAAAEAAADJABhJAAABAAAAyQAYSQAAAQAAAMkAGEkAAAWMAAfsNAvILDgPSGwwgIisMICI5CwASSQAAAyUAAAMZBoATBwAAAAADNQAAAoMgAOMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAAAGAAAAAEAAAABAAAAEAAAAAIAAADp/QAAGAAAAAEAAAABAAAAEAAAAAIAAADp/QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIAbwBvAHQAIABFAG4AdAByAHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAUA//////////8BAAAABgkCAAAAAADAAAAAAAAARgAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAEACAAAAAAAAAQBDAG8AbQBwAE8AYgBqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAgACAAAABAAAAP////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAagAAAAAAAAABAE8AbABlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgACAP////8DAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAUAAAAAAAAADEAVABhAGIAbABlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAIA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABUhAAAAAAAABQBTAHUAbQBtAGEAcgB5AEkAbgBmAG8AcgBtAGEAdABpAG8AbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAgAFAAAABgAAAP////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAA7AAAAAAAAABXAG8AcgBkAEQAbwBjAHUAbQBlAG4AdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgACAP///////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAyLgAAAAAAAAUARABvAGMAdQBtAGUAbgB0AFMAdQBtAG0AYQByAHkASQBuAGYAbwByAG0AYQB0AGkAbwBuAAAAAAAAAAAAAAA4AAIA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+////AAAAAAAAAAA=;type:2"]}}
diff --git a/src/parser/__tests__/languageguesser/bash.shebang b/src/parser/__tests__/languageguesser/bash.shebang
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/bash.shebang
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exit 1;
diff --git a/src/parser/__tests__/languageguesser/console.path b/src/parser/__tests__/languageguesser/console.path
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/console.path
@@ -0,0 +1,8 @@
+path/to/somewhere/ $ ls
+[ dd kill mv sh wait4path
+bash df ksh pax sleep zsh
+cat domainname launchctl ps stty
+chmod echo link pwd sync
+cp ed ln rcp tcsh
+csh expr ls rm test
+date hostname mkdir rmdir unlink
diff --git a/src/parser/__tests__/languageguesser/console.prompt b/src/parser/__tests__/languageguesser/console.prompt
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/console.prompt
@@ -0,0 +1,8 @@
+$ ls
+[ dd kill mv sh wait4path
+bash df ksh pax sleep zsh
+cat domainname launchctl ps stty
+chmod echo link pwd sync
+cp ed ln rcp tcsh
+csh expr ls rm test
+date hostname mkdir rmdir unlink
diff --git a/src/parser/__tests__/languageguesser/diff.git b/src/parser/__tests__/languageguesser/diff.git
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/diff.git
@@ -0,0 +1,7 @@
+diff --git a/some_file b/some_file
+index 4c479de..637a09b 100644
+--- a/some_file
++++ b/some_file
+@@ -1 +1 @@
+-apple
++banana
diff --git a/src/parser/__tests__/languageguesser/diff.udiff b/src/parser/__tests__/languageguesser/diff.udiff
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/diff.udiff
@@ -0,0 +1,5 @@
+--- some_file 2012-05-20 19:35:28.000000000 -0700
++++ other_file 2012-05-20 19:35:23.000000000 -0700
+@@ -1 +1 @@
+-apple
++banana
diff --git a/src/parser/__tests__/languageguesser/nothing-useful b/src/parser/__tests__/languageguesser/nothing-useful
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/nothing-useful
@@ -0,0 +1,2 @@
+derp derp derp derp derp derp derp derp derp derp derp derp derp derp
+herp derp herp derp herp derp herp derp herp derp herp derp herp derp
diff --git a/src/parser/__tests__/languageguesser/php.shell b/src/parser/__tests__/languageguesser/php.shell
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/php.shell
@@ -0,0 +1,3 @@
+#!/usr/bin/php
+
+exit(1);
diff --git a/src/parser/__tests__/languageguesser/php.shell-env b/src/parser/__tests__/languageguesser/php.shell-env
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/php.shell-env
@@ -0,0 +1,3 @@
+#!/usr/bin/env php
+
+exit(1);
diff --git a/src/parser/__tests__/languageguesser/php.test b/src/parser/__tests__/languageguesser/php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/__tests__/languageguesser/php.test
@@ -0,0 +1,3 @@
+id = $id;
+ $this->typeID = $data[0];
+ if (isset($data[1])) {
+ $this->l = $data[1];
+ } else {
+ $this->l = -1;
+ }
+ if (isset($data[2])) {
+ $this->r = $data[2];
+ } else {
+ $this->r = -1;
+ }
+ $this->tree = $tree;
+ }
+
+ final public function getParentNode() {
+ return $this->parentNode;
+ }
+
+ final public function setParentNode(AASTNode $node = null) {
+ $this->parentNode = $node;
+ return $this;
+ }
+
+ final public function getPreviousSibling() {
+ return $this->previousSibling;
+ }
+
+ final public function setPreviousSibling(AASTNode $node = null) {
+ $this->previousSibling = $node;
+ return $this;
+ }
+
+ final public function getNextSibling() {
+ return $this->nextSibling;
+ }
+
+ final public function setNextSibling(AASTNode $node = null) {
+ $this->nextSibling = $node;
+ return $this;
+ }
+
+ final public function getID() {
+ return $this->id;
+ }
+
+ final public function getTypeID() {
+ return $this->typeID;
+ }
+
+ final public function getTree() {
+ return $this->tree;
+ }
+
+ final public function getTypeName() {
+ if (empty($this->typeName)) {
+ $this->typeName =
+ $this->tree->getNodeTypeNameFromTypeID($this->getTypeID());
+ }
+ return $this->typeName;
+ }
+
+ final public function getChildren() {
+ return $this->children;
+ }
+
+ final public function setChildren(array $children) {
+ // We don't call `assert_instances_of($children, 'AASTNode')` because doing
+ // so would incur a significant performance penalty.
+ $this->children = $children;
+ return $this;
+ }
+
+ public function getChildrenOfType($type) {
+ $nodes = array();
+
+ foreach ($this->children as $child) {
+ if ($child->getTypeName() == $type) {
+ $nodes[] = $child;
+ }
+ }
+
+ return $nodes;
+ }
+
+ public function getChildOfType($index, $type) {
+ $child = $this->getChildByIndex($index);
+ if ($child->getTypeName() != $type) {
+ throw new Exception(
+ pht(
+ "Child in position '%d' is not of type '%s': %s",
+ $index,
+ $type,
+ $this->getDescription()));
+ }
+
+ return $child;
+ }
+
+ public function getChildByIndex($index) {
+ // NOTE: Microoptimization to avoid calls like array_values() or idx().
+
+ $idx = 0;
+ foreach ($this->children as $child) {
+ if ($idx == $index) {
+ return $child;
+ }
+ ++$idx;
+ }
+
+ throw new Exception(pht("No child with index '%d'.", $index));
+ }
+
+ /**
+ * Build a cache to improve the performance of
+ * @{method:selectDescendantsOfType}. This cache makes a time/memory tradeoff
+ * by aggressively caching node descendants. It may improve the tree's query
+ * performance substantially if you make a large number of queries, but also
+ * requires a significant amount of memory.
+ *
+ * This builds a cache for the entire tree and improves performance of all
+ * @{method:selectDescendantsOfType} calls.
+ */
+ public function buildSelectCache() {
+ $cache = array();
+ foreach ($this->getChildren() as $id => $child) {
+ $type_id = $child->getTypeID();
+ if (empty($cache[$type_id])) {
+ $cache[$type_id] = array();
+ }
+ $cache[$type_id][$id] = $child;
+ foreach ($child->buildSelectCache() as $type_id => $nodes) {
+ if (empty($cache[$type_id])) {
+ $cache[$type_id] = array();
+ }
+ $cache[$type_id] += $nodes;
+ }
+ }
+ $this->selectCache = $cache;
+ return $this->selectCache;
+ }
+
+ /**
+ * Build a cache to improve the performance of @{method:selectTokensOfType}.
+ * This cache makes a time/memory tradeoff by aggressively caching token
+ * types. It may improve the tree's query performance substantially if you
+ * make a large number of queries, but also requires a significant amount of
+ * memory.
+ *
+ * This builds a cache for this node only.
+ */
+ public function buildTokenCache() {
+ $cache = array();
+ foreach ($this->getTokens() as $id => $token) {
+ $cache[$token->getTypeName()][$id] = $token;
+ }
+ $this->tokenCache = $cache;
+ return $this->tokenCache;
+ }
+
+ public function selectTokensOfType($type_name) {
+ return $this->selectTokensOfTypes(array($type_name));
+ }
+
+ /**
+ * Select all tokens of any given types.
+ */
+ public function selectTokensOfTypes(array $type_names) {
+ $tokens = array();
+
+ foreach ($type_names as $type_name) {
+ if (isset($this->tokenCache)) {
+ $cached_tokens = idx($this->tokenCache, $type_name, array());
+ foreach ($cached_tokens as $id => $cached_token) {
+ $tokens[$id] = $cached_token;
+ }
+ } else {
+ foreach ($this->getTokens() as $id => $token) {
+ if ($token->getTypeName() == $type_name) {
+ $tokens[$id] = $token;
+ }
+ }
+ }
+ }
+
+ return $tokens;
+ }
+
+ final public function isDescendantOf(AASTNode $node) {
+ for ($it = $this; $it !== null; $it = $it->getParentNode()) {
+ if ($it === $node) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public function selectDescendantsOfType($type_name) {
+ return $this->selectDescendantsOfTypes(array($type_name));
+ }
+
+ public function selectDescendantsOfTypes(array $type_names) {
+ $nodes = array();
+ foreach ($type_names as $type_name) {
+ $type = $this->getTypeIDFromTypeName($type_name);
+
+ if (isset($this->selectCache)) {
+ if (isset($this->selectCache[$type])) {
+ $nodes = $nodes + $this->selectCache[$type];
+ }
+ } else {
+ $nodes = $nodes + $this->executeSelectDescendantsOfType($this, $type);
+ }
+ }
+
+ return AASTNodeList::newFromTreeAndNodes($this->tree, $nodes);
+ }
+
+ protected function executeSelectDescendantsOfType($node, $type) {
+ $results = array();
+ foreach ($node->getChildren() as $id => $child) {
+ if ($child->getTypeID() == $type) {
+ $results[$id] = $child;
+ }
+ $results += $this->executeSelectDescendantsOfType($child, $type);
+ }
+ return $results;
+ }
+
+ public function getTokens() {
+ if ($this->l == -1 || $this->r == -1) {
+ return array();
+ }
+ $tokens = $this->tree->getRawTokenStream();
+ $result = array();
+ foreach (range($this->l, $this->r) as $token_id) {
+ $result[$token_id] = $tokens[$token_id];
+ }
+ return $result;
+ }
+
+ public function getConcreteString() {
+ $values = array();
+ foreach ($this->getTokens() as $token) {
+ $values[] = $token->getValue();
+ }
+ return implode('', $values);
+ }
+
+ public function getSemanticString() {
+ $tokens = $this->getTokens();
+ foreach ($tokens as $id => $token) {
+ if ($token->isComment()) {
+ unset($tokens[$id]);
+ }
+ }
+ return implode('', mpull($tokens, 'getValue'));
+ }
+
+ public function getIndentation() {
+ $tokens = $this->getTokens();
+ $left = head($tokens);
+
+ while ($left &&
+ (!$left->isAnyWhitespace() ||
+ strpos($left->getValue(), "\n") === false)) {
+ $left = $left->getPrevToken();
+ }
+
+ if (!$left) {
+ return null;
+ }
+
+ return preg_replace("/^.*\n/s", '', $left->getValue());
+ }
+
+ public function getDescription() {
+ $concrete = $this->getConcreteString();
+ if (strlen($concrete) > 75) {
+ $concrete = substr($concrete, 0, 36).'...'.substr($concrete, -36);
+ }
+
+ $concrete = addcslashes($concrete, "\\\n\"");
+
+ return pht('a node of type %s: "%s"', $this->getTypeName(), $concrete);
+ }
+
+ final protected function getTypeIDFromTypeName($type_name) {
+ return $this->tree->getNodeTypeIDFromTypeName($type_name);
+ }
+
+ final public function getOffset() {
+ $stream = $this->tree->getRawTokenStream();
+ if (empty($stream[$this->l])) {
+ return null;
+ }
+ return $stream[$this->l]->getOffset();
+ }
+
+ final public function getLength() {
+ $stream = $this->tree->getRawTokenStream();
+ if (empty($stream[$this->r])) {
+ return null;
+ }
+ return $stream[$this->r]->getOffset() - $this->getOffset();
+ }
+
+
+ public function getSurroundingNonsemanticTokens() {
+ $before = array();
+ $after = array();
+
+ $tokens = $this->tree->getRawTokenStream();
+
+ if ($this->l != -1) {
+ $before = $tokens[$this->l]->getNonsemanticTokensBefore();
+ }
+
+ if ($this->r != -1) {
+ $after = $tokens[$this->r]->getNonsemanticTokensAfter();
+ }
+
+ return array($before, $after);
+ }
+
+ final public function getLineNumber() {
+ return idx($this->tree->getOffsetToLineNumberMap(), $this->getOffset());
+ }
+
+ final public function getEndLineNumber() {
+ return idx(
+ $this->tree->getOffsetToLineNumberMap(),
+ $this->getOffset() + $this->getLength());
+ }
+
+ /**
+ * Determines whether the current node appears //after// a specified node in
+ * the tree.
+ *
+ * @param AASTNode
+ * @return bool
+ */
+ final public function isAfter(AASTNode $node) {
+ return head($this->getTokens())->getOffset() >
+ last($node->getTokens())->getOffset();
+ }
+
+ /**
+ * Determines whether the current node appears //before// a specified node in
+ * the tree.
+ *
+ * @param AASTNode
+ * @return bool
+ */
+ final public function isBefore(AASTNode $node) {
+ return last($this->getTokens())->getOffset() <
+ head($node->getTokens())->getOffset();
+ }
+
+ /**
+ * Determines whether a specified node is a descendant of the current node.
+ *
+ * @param AASTNode
+ * @return bool
+ */
+ final public function containsDescendant(AASTNode $node) {
+ return !$this->isAfter($node) && !$this->isBefore($node);
+ }
+
+ public function dispose() {
+ foreach ($this->getChildren() as $child) {
+ $child->dispose();
+ }
+
+ unset($this->selectCache);
+ }
+
+}
diff --git a/src/parser/aast/api/AASTNodeList.php b/src/parser/aast/api/AASTNodeList.php
new file mode 100644
--- /dev/null
+++ b/src/parser/aast/api/AASTNodeList.php
@@ -0,0 +1,110 @@
+tree, $nodes);
+ }
+
+ public function selectDescendantsOfType($type_name) {
+ return $this->selectDescendantsOfTypes(array($type_name));
+ }
+
+ public function selectDescendantsOfTypes(array $type_names) {
+ $results = array();
+ foreach ($type_names as $type_name) {
+ foreach ($this->list as $id => $node) {
+ $results += $node->selectDescendantsOfType($type_name)->getRawNodes();
+ }
+ }
+ return $this->newList($results);
+ }
+
+ public function getChildrenByIndex($index) {
+ $results = array();
+ foreach ($this->list as $id => $node) {
+ $child = $node->getChildByIndex($index);
+ $results[$child->getID()] = $child;
+ }
+ return $this->newList($results);
+ }
+
+ public function add(AASTNodeList $list) {
+ foreach ($list->list as $id => $node) {
+ $this->list[$id] = $node;
+ }
+ $this->ids = array_keys($this->list);
+ return $this;
+ }
+
+ public function getTokens() {
+ $tokens = array();
+ foreach ($this->list as $node) {
+ $tokens += $node->getTokens();
+ }
+ return $tokens;
+ }
+
+ public function getRawNodes() {
+ return $this->list;
+ }
+
+ public static function newFromTreeAndNodes(AASTTree $tree, array $nodes) {
+ // We could do `assert_instances_of($nodes, 'AASTNode')` here, but doing
+ // so imposes an observable performance penalty for linting.
+
+ $obj = new AASTNodeList();
+ $obj->tree = $tree;
+ $obj->list = $nodes;
+ $obj->ids = array_keys($nodes);
+ return $obj;
+ }
+
+ public static function newFromTree(AASTTree $tree) {
+ $obj = new AASTNodeList();
+ $obj->tree = $tree;
+ $obj->list = array(0 => $tree->getRootNode());
+ $obj->ids = array(0 => 0);
+ return $obj;
+ }
+
+
+/* -( Countable )---------------------------------------------------------- */
+
+ public function count() {
+ return count($this->ids);
+ }
+
+
+/* -( Iterator )----------------------------------------------------------- */
+
+ public function current() {
+ return $this->list[$this->key()];
+ }
+
+ public function key() {
+ return $this->ids[$this->pos];
+ }
+
+ public function next() {
+ $this->pos++;
+ }
+
+ public function rewind() {
+ $this->pos = 0;
+ }
+
+ public function valid() {
+ return $this->pos < count($this->ids);
+ }
+
+}
diff --git a/src/parser/aast/api/AASTToken.php b/src/parser/aast/api/AASTToken.php
new file mode 100644
--- /dev/null
+++ b/src/parser/aast/api/AASTToken.php
@@ -0,0 +1,91 @@
+id = $id;
+ $this->typeID = $type;
+ $this->value = $value;
+ $this->offset = $offset;
+ $this->tree = $tree;
+ }
+
+ final public function getTokenID() {
+ return $this->id;
+ }
+
+ final public function getTypeID() {
+ return $this->typeID;
+ }
+
+ public function getTypeName() {
+ if (empty($this->typeName)) {
+ $this->typeName = $this->tree->getTokenTypeNameFromTypeID($this->typeID);
+ }
+ return $this->typeName;
+ }
+
+ final public function getValue() {
+ return $this->value;
+ }
+
+ final public function overwriteValue($value) {
+ $this->value = $value;
+ return $this;
+ }
+
+ final public function getOffset() {
+ return $this->offset;
+ }
+
+ abstract public function isComment();
+ abstract public function isAnyWhitespace();
+
+ public function isSemantic() {
+ return !($this->isComment() || $this->isAnyWhitespace());
+ }
+
+ public function getPrevToken() {
+ $tokens = $this->tree->getRawTokenStream();
+ return idx($tokens, $this->id - 1);
+ }
+
+ public function getNextToken() {
+ $tokens = $this->tree->getRawTokenStream();
+ return idx($tokens, $this->id + 1);
+ }
+
+ public function getNonsemanticTokensBefore() {
+ $tokens = $this->tree->getRawTokenStream();
+ $result = array();
+ $ii = $this->id - 1;
+ while ($ii >= 0 && !$tokens[$ii]->isSemantic()) {
+ $result[$ii] = $tokens[$ii];
+ --$ii;
+ }
+ return array_reverse($result);
+ }
+
+ public function getNonsemanticTokensAfter() {
+ $tokens = $this->tree->getRawTokenStream();
+ $result = array();
+ $ii = $this->id + 1;
+ while ($ii < count($tokens) && !$tokens[$ii]->isSemantic()) {
+ $result[$ii] = $tokens[$ii];
+ ++$ii;
+ }
+ return $result;
+ }
+
+ final public function getLineNumber() {
+ return idx($this->tree->getOffsetToLineNumberMap(), $this->getOffset());
+ }
+
+}
diff --git a/src/parser/aast/api/AASTTree.php b/src/parser/aast/api/AASTTree.php
new file mode 100644
--- /dev/null
+++ b/src/parser/aast/api/AASTTree.php
@@ -0,0 +1,194 @@
+stream[$ii] = $this->newToken(
+ $ii,
+ $token[0],
+ substr($source, $offset, $token[1]),
+ $offset,
+ $this);
+ $offset += $token[1];
+ ++$ii;
+ }
+
+ $this->rawSource = $source;
+ $this->buildTree(array($tree));
+ }
+
+ final public function setTreeType($description) {
+ $this->treeType = $description;
+ return $this;
+ }
+
+ final public function getTreeType() {
+ return $this->treeType;
+ }
+
+ final public function setTokenConstants(array $token_map) {
+ $this->tokenConstants = $token_map;
+ $this->tokenReverseMap = array_flip($token_map);
+ return $this;
+ }
+
+ final public function setNodeConstants(array $node_map) {
+ $this->nodeConstants = $node_map;
+ $this->nodeReverseMap = array_flip($node_map);
+ return $this;
+ }
+
+ final public function getNodeTypeNameFromTypeID($type_id) {
+ if (empty($this->nodeConstants[$type_id])) {
+ $tree_type = $this->getTreeType();
+ throw new Exception(
+ pht(
+ "No type name for node type ID '%s' in '%s' AAST.",
+ $type_id,
+ $tree_type));
+ }
+
+ return $this->nodeConstants[$type_id];
+ }
+
+ final public function getNodeTypeIDFromTypeName($type_name) {
+ if (empty($this->nodeReverseMap[$type_name])) {
+ $tree_type = $this->getTreeType();
+ throw new Exception(
+ pht(
+ "No type ID for node type name '%s' in '%s' AAST.",
+ $type_name,
+ $tree_type));
+ }
+ return $this->nodeReverseMap[$type_name];
+ }
+
+ final public function getTokenTypeNameFromTypeID($type_id) {
+ if (empty($this->tokenConstants[$type_id])) {
+ $tree_type = $this->getTreeType();
+ throw new Exception(
+ pht(
+ "No type name for token type ID '%s' in '%s' AAST.",
+ $type_id,
+ $tree_type));
+ }
+ return $this->tokenConstants[$type_id];
+ }
+
+ final public function getTokenTypeIDFromTypeName($type_name) {
+ if (empty($this->tokenReverseMap[$type_name])) {
+ $tree_type = $this->getTreeType();
+ throw new Exception(
+ pht(
+ "No type ID for token type name '%s' in '%s' AAST.",
+ $type_name,
+ $tree_type));
+ }
+ return $this->tokenReverseMap[$type_name];
+ }
+
+ /**
+ * Unlink internal datastructures so that PHP will garbage collect the tree.
+ *
+ * This renders the object useless.
+ *
+ * @return void
+ */
+ public function dispose() {
+ $this->getRootNode()->dispose();
+ unset($this->tree);
+ unset($this->stream);
+ }
+
+ final public function getRootNode() {
+ return $this->tree[0];
+ }
+
+ protected function buildTree(array $tree) {
+ $ii = count($this->tree);
+ $nodes = array();
+ foreach ($tree as $node) {
+ $this->tree[$ii] = $this->newNode($ii, $node, $this);
+ $nodes[$ii] = $node;
+ ++$ii;
+ }
+ foreach ($nodes as $node_id => $node) {
+ if (isset($node[3])) {
+ $children = $this->buildTree($node[3]);
+ $previous_child = null;
+
+ foreach ($children as $ii => $child) {
+ $child->setParentNode($this->tree[$node_id]);
+ $child->setPreviousSibling($previous_child);
+
+ if ($previous_child) {
+ $previous_child->setNextSibling($child);
+ }
+
+ $previous_child = $child;
+ }
+
+ if ($previous_child) {
+ $previous_child->setNextSibling($child);
+ }
+
+ $this->tree[$node_id]->setChildren($children);
+ }
+ }
+
+ $result = array();
+ foreach ($nodes as $key => $node) {
+ $result[$key] = $this->tree[$key];
+ }
+
+ return $result;
+ }
+
+ final public function getRawTokenStream() {
+ return $this->stream;
+ }
+
+ public function getOffsetToLineNumberMap() {
+ if ($this->lineMap === null) {
+ $src = $this->rawSource;
+ $len = strlen($src);
+ $lno = 1;
+ $map = array();
+ for ($ii = 0; $ii < $len; ++$ii) {
+ $map[$ii] = $lno;
+ if ($src[$ii] == "\n") {
+ ++$lno;
+ }
+ }
+ $this->lineMap = $map;
+ }
+ return $this->lineMap;
+ }
+
+}
diff --git a/src/parser/argument/PhutilArgumentParser.php b/src/parser/argument/PhutilArgumentParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/PhutilArgumentParser.php
@@ -0,0 +1,935 @@
+setTagline('make an new dog')
+ * $args->setSynopsis(<<parse(
+ * array(
+ * array(
+ * 'name' => 'name',
+ * 'param' => 'dogname',
+ * 'default' => 'Rover',
+ * 'help' => 'Set the dog\'s name. By default, the dog will be '.
+ * 'named "Rover".',
+ * ),
+ * array(
+ * 'name' => 'big',
+ * 'short' => 'b',
+ * 'help' => 'If set, create a large dog.',
+ * ),
+ * ));
+ *
+ * $dog_name = $args->getArg('name');
+ * $dog_size = $args->getArg('big') ? 'big' : 'small';
+ *
+ * // ... etc ...
+ *
+ * (For detailed documentation on supported keys in argument specifications,
+ * see @{class:PhutilArgumentSpecification}.)
+ *
+ * This will handle argument parsing, and generate appropriate usage help if
+ * the user provides an unsupported flag. @{class:PhutilArgumentParser} also
+ * supports some builtin "standard" arguments:
+ *
+ * $args->parseStandardArguments();
+ *
+ * See @{method:parseStandardArguments} for details. Notably, this includes
+ * a "--help" flag, and an "--xprofile" flag for profiling command-line scripts.
+ *
+ * Normally, when the parser encounters an unknown flag, it will exit with
+ * an error. However, you can use @{method:parsePartial} to consume only a
+ * set of flags:
+ *
+ * $args->parsePartial($spec_list);
+ *
+ * This allows you to parse some flags before making decisions about other
+ * parsing, or share some flags across scripts. The builtin standard arguments
+ * are implemented in this way.
+ *
+ * There is also builtin support for "workflows", which allow you to build a
+ * script that operates in several modes (e.g., by accepting commands like
+ * `install`, `upgrade`, etc), like `arc` does. For detailed documentation on
+ * workflows, see @{class:PhutilArgumentWorkflow}.
+ *
+ * @task parse Parsing Arguments
+ * @task read Reading Arguments
+ * @task help Command Help
+ * @task internal Internals
+ */
+final class PhutilArgumentParser extends Phobject {
+
+ private $bin;
+ private $argv;
+ private $specs = array();
+ private $results = array();
+ private $parsed;
+
+ private $tagline;
+ private $synopsis;
+ private $workflows;
+ private $showHelp;
+
+ const PARSE_ERROR_CODE = 77;
+
+ private static $traceModeEnabled = false;
+
+
+/* -( Parsing Arguments )-------------------------------------------------- */
+
+
+ /**
+ * Build a new parser. Generally, you start a script with:
+ *
+ * $args = new PhutilArgumentParser($argv);
+ *
+ * @param list Argument vector to parse, generally the $argv global.
+ * @task parse
+ */
+ public function __construct(array $argv) {
+ $this->bin = $argv[0];
+ $this->argv = array_slice($argv, 1);
+ }
+
+
+ /**
+ * Parse and consume a list of arguments, removing them from the argument
+ * vector but leaving unparsed arguments for later consumption. You can
+ * retrieve unconsumed arguments directly with
+ * @{method:getUnconsumedArgumentVector}. Doing a partial parse can make it
+ * easier to share common flags across scripts or workflows.
+ *
+ * @param list List of argument specs, see
+ * @{class:PhutilArgumentSpecification}.
+ * @param bool Require flags appear before any non-flag arguments.
+ * @return this
+ * @task parse
+ */
+ public function parsePartial(array $specs, $initial_only = false) {
+ return $this->parseInternal($specs, false, $initial_only);
+ }
+
+ /**
+ * @return this
+ */
+ private function parseInternal(
+ array $specs,
+ $correct_spelling,
+ $initial_only) {
+
+ $specs = PhutilArgumentSpecification::newSpecsFromList($specs);
+ $this->mergeSpecs($specs);
+
+ $specs_by_name = mpull($specs, null, 'getName');
+ $specs_by_short = mpull($specs, null, 'getShortAlias');
+ unset($specs_by_short[null]);
+
+ $argv = $this->argv;
+ $len = count($argv);
+ $is_initial = true;
+ for ($ii = 0; $ii < $len; $ii++) {
+ $arg = $argv[$ii];
+ $map = null;
+ $options = null;
+ if (!is_string($arg)) {
+ // Non-string argument; pass it through as-is.
+ } else if ($arg == '--') {
+ // This indicates "end of flags".
+ break;
+ } else if ($arg == '-') {
+ // This is a normal argument (e.g., stdin).
+ continue;
+ } else if (!strncmp('--', $arg, 2)) {
+ $pre = '--';
+ $arg = substr($arg, 2);
+ $map = $specs_by_name;
+ $options = array_keys($specs_by_name);
+ } else if (!strncmp('-', $arg, 1) && strlen($arg) > 1) {
+ $pre = '-';
+ $arg = substr($arg, 1);
+ $map = $specs_by_short;
+ } else {
+ $is_initial = false;
+ }
+
+ if ($map) {
+ $val = null;
+ $parts = explode('=', $arg, 2);
+ if (count($parts) == 2) {
+ list($arg, $val) = $parts;
+ }
+
+ // Try to correct flag spelling for full flags, to allow users to make
+ // minor mistakes.
+ if ($correct_spelling && $options && !isset($map[$arg])) {
+ $corrections = PhutilArgumentSpellingCorrector::newFlagCorrector()
+ ->correctSpelling($arg, $options);
+
+ if (count($corrections) == 1) {
+ $corrected = head($corrections);
+
+ $this->logMessage(
+ tsprintf(
+ "%s\n",
+ pht(
+ '(Assuming "%s" is the British spelling of "%s".)',
+ $pre.$arg,
+ $pre.$corrected)));
+
+ $arg = $corrected;
+ }
+ }
+
+ if (isset($map[$arg])) {
+ if ($initial_only && !$is_initial) {
+ throw new PhutilArgumentUsageException(
+ pht(
+ 'Argument "%s" appears after the first non-flag argument. '.
+ 'This special argument must appear before other arguments.',
+ "{$pre}{$arg}"));
+ }
+
+ $spec = $map[$arg];
+ unset($argv[$ii]);
+
+ $param_name = $spec->getParamName();
+ if ($val !== null) {
+ if ($param_name === null) {
+ throw new PhutilArgumentUsageException(
+ pht(
+ "Argument '%s' does not take a parameter.",
+ "{$pre}{$arg}"));
+ }
+ } else {
+ if ($param_name !== null) {
+ if ($ii + 1 < $len) {
+ $val = $argv[$ii + 1];
+ unset($argv[$ii + 1]);
+ $ii++;
+ } else {
+ throw new PhutilArgumentUsageException(
+ pht(
+ "Argument '%s' requires a parameter.",
+ "{$pre}{$arg}"));
+ }
+ } else {
+ $val = true;
+ }
+ }
+
+ if (!$spec->getRepeatable()) {
+ if (array_key_exists($spec->getName(), $this->results)) {
+ throw new PhutilArgumentUsageException(
+ pht(
+ "Argument '%s' was provided twice.",
+ "{$pre}{$arg}"));
+ }
+ }
+
+ $conflicts = $spec->getConflicts();
+ foreach ($conflicts as $conflict => $reason) {
+ if (array_key_exists($conflict, $this->results)) {
+
+ if (!is_string($reason) || !strlen($reason)) {
+ $reason = '.';
+ } else {
+ $reason = ': '.$reason.'.';
+ }
+
+ throw new PhutilArgumentUsageException(
+ pht(
+ "Argument '%s' conflicts with argument '%s'%s",
+ "{$pre}{$arg}",
+ "--{$conflict}",
+ $reason));
+ }
+ }
+
+ if ($spec->getRepeatable()) {
+ if ($spec->getParamName() === null) {
+ if (empty($this->results[$spec->getName()])) {
+ $this->results[$spec->getName()] = 0;
+ }
+ $this->results[$spec->getName()]++;
+ } else {
+ $this->results[$spec->getName()][] = $val;
+ }
+ } else {
+ $this->results[$spec->getName()] = $val;
+ }
+ }
+ }
+ }
+
+ foreach ($specs as $spec) {
+ if ($spec->getWildcard()) {
+ $this->results[$spec->getName()] = $this->filterWildcardArgv($argv);
+ $argv = array();
+ break;
+ }
+ }
+
+ $this->argv = array_values($argv);
+ return $this;
+ }
+
+
+ /**
+ * Parse and consume a list of arguments, throwing an exception if there is
+ * anything left unconsumed. This is like @{method:parsePartial}, but raises
+ * a {class:PhutilArgumentUsageException} if there are leftovers.
+ *
+ * Normally, you would call @{method:parse} instead, which emits a
+ * user-friendly error. You can also use @{method:printUsageException} to
+ * render the exception in a user-friendly way.
+ *
+ * @param list List of argument specs, see
+ * @{class:PhutilArgumentSpecification}.
+ * @return this
+ * @task parse
+ */
+ public function parseFull(array $specs) {
+ $this->parseInternal($specs, true, false);
+
+ if (count($this->argv)) {
+ $arg = head($this->argv);
+ throw new PhutilArgumentUsageException(
+ pht("Unrecognized argument '%s'.", $arg));
+ }
+
+ if ($this->showHelp) {
+ $this->printHelpAndExit();
+ }
+
+ return $this;
+ }
+
+
+ /**
+ * Parse and consume a list of arguments, raising a user-friendly error if
+ * anything remains. See also @{method:parseFull} and @{method:parsePartial}.
+ *
+ * @param list List of argument specs, see
+ * @{class:PhutilArgumentSpecification}.
+ * @return this
+ * @task parse
+ */
+ public function parse(array $specs) {
+ try {
+ return $this->parseFull($specs);
+ } catch (PhutilArgumentUsageException $ex) {
+ $this->printUsageException($ex);
+ exit(self::PARSE_ERROR_CODE);
+ }
+ }
+
+
+ /**
+ * Parse and execute workflows, raising a user-friendly error if anything
+ * remains. See also @{method:parseWorkflowsFull}.
+ *
+ * See @{class:PhutilArgumentWorkflow} for details on using workflows.
+ *
+ * @param list List of argument specs, see
+ * @{class:PhutilArgumentSpecification}.
+ * @return this
+ * @task parse
+ */
+ public function parseWorkflows(array $workflows) {
+ try {
+ return $this->parseWorkflowsFull($workflows);
+ } catch (PhutilArgumentUsageException $ex) {
+ $this->printUsageException($ex);
+ exit(self::PARSE_ERROR_CODE);
+ }
+ }
+
+
+ /**
+ * Select a workflow. For commands that may operate in several modes, like
+ * `arc`, the modes can be split into "workflows". Each workflow specifies
+ * the arguments it accepts. This method takes a list of workflows, selects
+ * the chosen workflow, parses its arguments, and either executes it (if it
+ * is executable) or returns it for handling.
+ *
+ * See @{class:PhutilArgumentWorkflow} for details on using workflows.
+ *
+ * @param list List of @{class:PhutilArgumentWorkflow}s.
+ * @return PhutilArgumentWorkflow|no Returns the chosen workflow if it is
+ * not executable, or executes it and
+ * exits with a return code if it is.
+ * @task parse
+ */
+ public function parseWorkflowsFull(array $workflows) {
+ assert_instances_of($workflows, 'PhutilArgumentWorkflow');
+
+ // Clear out existing workflows. We need to do this to permit the
+ // construction of sub-workflows.
+ $this->workflows = array();
+
+ foreach ($workflows as $workflow) {
+ $name = $workflow->getName();
+
+ if ($name === null) {
+ throw new PhutilArgumentSpecificationException(
+ pht('Workflow has no name!'));
+ }
+
+ if (isset($this->workflows[$name])) {
+ throw new PhutilArgumentSpecificationException(
+ pht("Two workflows with name '%s!", $name));
+ }
+
+ $this->workflows[$name] = $workflow;
+ }
+
+ $argv = $this->argv;
+ if (empty($argv)) {
+ // TODO: this is kind of hacky / magical.
+ if (isset($this->workflows['help'])) {
+ $argv = array('help');
+ } else {
+ throw new PhutilArgumentUsageException(pht('No workflow selected.'));
+ }
+ }
+
+ $flow = array_shift($argv);
+
+ if (empty($this->workflows[$flow])) {
+ $corrected = PhutilArgumentSpellingCorrector::newCommandCorrector()
+ ->correctSpelling($flow, array_keys($this->workflows));
+
+ if (count($corrected) == 1) {
+ $corrected = head($corrected);
+
+ $this->logMessage(
+ tsprintf(
+ "%s\n",
+ pht(
+ '(Assuming "%s" is the British spelling of "%s".)',
+ $flow,
+ $corrected)));
+
+ $flow = $corrected;
+ } else {
+ $this->raiseUnknownWorkflow($flow, $corrected);
+ }
+ }
+
+ $workflow = $this->workflows[$flow];
+
+ if ($this->showHelp) {
+ // Make "cmd flow --help" behave like "cmd help flow", not "cmd help".
+ $help_flow = idx($this->workflows, 'help');
+ if ($help_flow) {
+ if ($help_flow !== $workflow) {
+ $workflow = $help_flow;
+ $argv = array($flow);
+
+ // Prevent parse() from dumping us back out to standard help.
+ $this->showHelp = false;
+ }
+ } else {
+ $this->printHelpAndExit();
+ }
+ }
+
+ $this->argv = array_values($argv);
+
+ if ($workflow->shouldParsePartial()) {
+ $this->parsePartial($workflow->getArguments());
+ } else {
+ $this->parse($workflow->getArguments());
+ }
+
+
+ if ($workflow->isExecutable()) {
+ $workflow->setArgv($this);
+ $err = $workflow->execute($this);
+ exit($err);
+ } else {
+ return $workflow;
+ }
+ }
+
+
+ /**
+ * Parse "standard" arguments and apply their effects:
+ *
+ * --trace Enable service call tracing.
+ * --no-ansi Disable ANSI color/style sequences.
+ * --xprofile Write out an XHProf profile.
+ * --help Show help.
+ *
+ * @return this
+ *
+ * @phutil-external-symbol function xhprof_enable
+ */
+ public function parseStandardArguments() {
+ try {
+ $this->parsePartial(
+ array(
+ array(
+ 'name' => 'trace',
+ 'help' => pht('Trace command execution and show service calls.'),
+ 'standard' => true,
+ ),
+ array(
+ 'name' => 'no-ansi',
+ 'help' => pht(
+ 'Disable ANSI terminal codes, printing plain text with '.
+ 'no color or style.'),
+ 'conflicts' => array(
+ 'ansi' => null,
+ ),
+ 'standard' => true,
+ ),
+ array(
+ 'name' => 'ansi',
+ 'help' => pht(
+ "Use formatting even in environments which probably ".
+ "don't support it."),
+ 'standard' => true,
+ ),
+ array(
+ 'name' => 'xprofile',
+ 'param' => 'profile',
+ 'help' => pht(
+ 'Profile script execution and write results to a file.'),
+ 'standard' => true,
+ ),
+ array(
+ 'name' => 'help',
+ 'short' => 'h',
+ 'help' => pht('Show this help.'),
+ 'standard' => true,
+ ),
+ array(
+ 'name' => 'show-standard-options',
+ 'help' => pht(
+ 'Show every option, including standard options like this one.'),
+ 'standard' => true,
+ ),
+ array(
+ 'name' => 'recon',
+ 'help' => pht('Start in remote console mode.'),
+ 'standard' => true,
+ ),
+ ));
+ } catch (PhutilArgumentUsageException $ex) {
+ $this->printUsageException($ex);
+ exit(self::PARSE_ERROR_CODE);
+ }
+
+ if ($this->getArg('trace')) {
+ PhutilServiceProfiler::installEchoListener();
+ self::$traceModeEnabled = true;
+ }
+
+ if ($this->getArg('no-ansi')) {
+ PhutilConsoleFormatter::disableANSI(true);
+ }
+
+ if ($this->getArg('ansi')) {
+ PhutilConsoleFormatter::disableANSI(false);
+ }
+
+ if ($this->getArg('help')) {
+ $this->showHelp = true;
+ }
+
+ $xprofile = $this->getArg('xprofile');
+ if ($xprofile) {
+ if (!function_exists('xhprof_enable')) {
+ throw new Exception(
+ pht("To use '%s', you must install XHProf.", '--xprofile'));
+ }
+
+ xhprof_enable(0);
+ register_shutdown_function(array($this, 'shutdownProfiler'));
+ }
+
+ $recon = $this->getArg('recon');
+ if ($recon) {
+ $remote_console = PhutilConsole::newRemoteConsole();
+ $remote_console->beginRedirectOut();
+ PhutilConsole::setConsole($remote_console);
+ } else if ($this->getArg('trace')) {
+ $server = new PhutilConsoleServer();
+ $server->setEnableLog(true);
+ $console = PhutilConsole::newConsoleForServer($server);
+ PhutilConsole::setConsole($console);
+ }
+
+ return $this;
+ }
+
+
+/* -( Reading Arguments )-------------------------------------------------- */
+
+
+ public function getArg($name) {
+ if (empty($this->specs[$name])) {
+ throw new PhutilArgumentSpecificationException(
+ pht("No specification exists for argument '%s'!", $name));
+ }
+
+ if (idx($this->results, $name) !== null) {
+ return $this->results[$name];
+ }
+
+ return $this->specs[$name]->getDefault();
+ }
+
+ public function getUnconsumedArgumentVector() {
+ return $this->argv;
+ }
+
+ public function setUnconsumedArgumentVector(array $argv) {
+ $this->argv = $argv;
+ return $this;
+ }
+
+
+/* -( Command Help )------------------------------------------------------- */
+
+
+ public function setSynopsis($synopsis) {
+ $this->synopsis = $synopsis;
+ return $this;
+ }
+
+ public function setTagline($tagline) {
+ $this->tagline = $tagline;
+ return $this;
+ }
+
+ public function printHelpAndExit() {
+ echo $this->renderHelp();
+ exit(self::PARSE_ERROR_CODE);
+ }
+
+ public function renderHelp() {
+ $out = array();
+ $more = array();
+
+ if ($this->bin) {
+ $out[] = $this->format('**%s**', pht('NAME'));
+ $name = $this->indent(6, '**%s**', basename($this->bin));
+ if ($this->tagline) {
+ $name .= $this->format(' - '.$this->tagline);
+ }
+ $out[] = $name;
+ $out[] = null;
+ }
+
+ if ($this->synopsis) {
+ $out[] = $this->format('**%s**', pht('SYNOPSIS'));
+ $out[] = $this->indent(6, $this->synopsis);
+ $out[] = null;
+ }
+
+ if ($this->workflows) {
+ $has_help = false;
+ $out[] = $this->format('**%s**', pht('WORKFLOWS'));
+ $out[] = null;
+ $flows = $this->workflows;
+ ksort($flows);
+ foreach ($flows as $workflow) {
+ if ($workflow->getName() == 'help') {
+ $has_help = true;
+ }
+ $out[] = $this->renderWorkflowHelp(
+ $workflow->getName(),
+ $show_details = false);
+ }
+ if ($has_help) {
+ $more[] = pht(
+ 'Use **%s** __command__ for a detailed command reference.', 'help');
+ }
+ }
+
+ $specs = $this->renderArgumentSpecs($this->specs);
+ if ($specs) {
+ $out[] = $this->format('**%s**', pht('OPTION REFERENCE'));
+ $out[] = null;
+ $out[] = $specs;
+ }
+
+ // If we have standard options but no --show-standard-options, print out
+ // a quick hint about it.
+ if (!empty($this->specs['show-standard-options']) &&
+ !$this->getArg('show-standard-options')) {
+ $more[] = pht(
+ 'Use __%s__ to show additional options.', '--show-standard-options');
+ }
+
+ $out[] = null;
+
+ if ($more) {
+ foreach ($more as $hint) {
+ $out[] = $this->indent(0, $hint);
+ }
+ $out[] = null;
+ }
+
+ return implode("\n", $out);
+ }
+
+ public function renderWorkflowHelp(
+ $workflow_name,
+ $show_details = false) {
+
+ $out = array();
+
+ $indent = ($show_details ? 0 : 6);
+
+ $workflow = idx($this->workflows, strtolower($workflow_name));
+ if (!$workflow) {
+ $out[] = $this->indent(
+ $indent,
+ pht('There is no **%s** workflow.', $workflow_name));
+ } else {
+ $out[] = $this->indent($indent, $workflow->getExamples());
+ $out[] = $this->indent($indent, $workflow->getSynopsis());
+ if ($show_details) {
+ $full_help = $workflow->getHelp();
+ if ($full_help) {
+ $out[] = null;
+ $out[] = $this->indent($indent, $full_help);
+ }
+ $specs = $this->renderArgumentSpecs($workflow->getArguments());
+ if ($specs) {
+ $out[] = null;
+ $out[] = $specs;
+ }
+ }
+ }
+
+ $out[] = null;
+
+ return implode("\n", $out);
+ }
+
+ public function printUsageException(PhutilArgumentUsageException $ex) {
+ $message = tsprintf(
+ "**%s** %B\n",
+ pht('Usage Exception:'),
+ $ex->getMessage());
+
+ $this->logMessage($message);
+ }
+
+
+ private function logMessage($message) {
+ fwrite(STDERR, $message);
+ }
+
+
+/* -( Internals )---------------------------------------------------------- */
+
+
+ private function filterWildcardArgv(array $argv) {
+ foreach ($argv as $key => $value) {
+ if ($value == '--') {
+ unset($argv[$key]);
+ break;
+ } else if (
+ is_string($value) &&
+ !strncmp($value, '-', 1) &&
+ strlen($value) > 1) {
+
+ throw new PhutilArgumentUsageException(
+ pht(
+ "Argument '%s' is unrecognized. Use '%s' to indicate ".
+ "the end of flags.",
+ $value,
+ '--'));
+ }
+ }
+ return array_values($argv);
+ }
+
+ private function mergeSpecs(array $specs) {
+
+ $short_map = mpull($this->specs, null, 'getShortAlias');
+ unset($short_map[null]);
+
+ $wildcard = null;
+ foreach ($this->specs as $spec) {
+ if ($spec->getWildcard()) {
+ $wildcard = $spec;
+ break;
+ }
+ }
+
+ foreach ($specs as $spec) {
+ $spec->validate();
+ $name = $spec->getName();
+
+ if (isset($this->specs[$name])) {
+ throw new PhutilArgumentSpecificationException(
+ pht("Two argument specifications have the same name ('%s').", $name));
+ }
+
+ $short = $spec->getShortAlias();
+ if ($short) {
+ if (isset($short_map[$short])) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ "Two argument specifications have the same short alias ('%s').",
+ $short));
+ }
+ $short_map[$short] = $spec;
+ }
+
+ if ($spec->getWildcard()) {
+ if ($wildcard) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ 'Two argument specifications are marked as wildcard arguments. '.
+ 'You can have a maximum of one wildcard argument.'));
+ } else {
+ $wildcard = $spec;
+ }
+ }
+
+ $this->specs[$name] = $spec;
+ }
+
+ foreach ($this->specs as $name => $spec) {
+ foreach ($spec->getConflicts() as $conflict => $reason) {
+ if (empty($this->specs[$conflict])) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ "Argument '%s' conflicts with unspecified argument '%s'.",
+ $name,
+ $conflict));
+ }
+ if ($conflict == $name) {
+ throw new PhutilArgumentSpecificationException(
+ pht("Argument '%s' conflicts with itself!", $name));
+ }
+ }
+ }
+
+ }
+
+ private function renderArgumentSpecs(array $specs) {
+ foreach ($specs as $key => $spec) {
+ if ($spec->getWildcard()) {
+ unset($specs[$key]);
+ }
+ }
+
+ $out = array();
+
+ $no_standard_options =
+ !empty($this->specs['show-standard-options']) &&
+ !$this->getArg('show-standard-options');
+
+ $specs = msort($specs, 'getName');
+ foreach ($specs as $spec) {
+ if ($spec->getStandard() && $no_standard_options) {
+ // If this is a standard argument and the user didn't pass
+ // --show-standard-options, skip it.
+ continue;
+ }
+ $name = $this->indent(6, '__--%s__', $spec->getName());
+ $short = null;
+ if ($spec->getShortAlias()) {
+ $short = $this->format(', __-%s__', $spec->getShortAlias());
+ }
+ if ($spec->getParamName()) {
+ $param = $this->format(' __%s__', $spec->getParamName());
+ $name .= $param;
+ if ($short) {
+ $short .= $param;
+ }
+ }
+ $out[] = $name.$short;
+ $out[] = $this->indent(10, $spec->getHelp());
+ $out[] = null;
+ }
+
+ return implode("\n", $out);
+ }
+
+ private function format($str /* , ... */) {
+ $args = func_get_args();
+ return call_user_func_array(
+ 'phutil_console_format',
+ $args);
+ }
+
+ private function indent($level, $str /* , ... */) {
+ $args = func_get_args();
+ $args = array_slice($args, 1);
+ $text = call_user_func_array(array($this, 'format'), $args);
+ return phutil_console_wrap($text, $level);
+ }
+
+ /**
+ * @phutil-external-symbol function xhprof_disable
+ */
+ public function shutdownProfiler() {
+ $data = xhprof_disable();
+ $data = json_encode($data);
+ Filesystem::writeFile($this->getArg('xprofile'), $data);
+ }
+
+ public static function isTraceModeEnabled() {
+ return self::$traceModeEnabled;
+ }
+
+ private function raiseUnknownWorkflow($flow, array $maybe) {
+ if ($maybe) {
+ sort($maybe);
+
+ $maybe_list = id(new PhutilConsoleList())
+ ->setWrap(false)
+ ->setBullet(null)
+ ->addItems($maybe)
+ ->drawConsoleString();
+
+ $message = tsprintf(
+ "%B\n%B",
+ pht(
+ 'Invalid command "%s". Did you mean:',
+ $flow),
+ $maybe_list);
+ } else {
+ $names = mpull($this->workflows, 'getName');
+ sort($names);
+
+ $message = tsprintf(
+ '%B',
+ pht(
+ 'Invalid command "%s". Valid commands are: %s.',
+ $flow,
+ implode(', ', $names)));
+ }
+
+ if (isset($this->workflows['help'])) {
+ $binary = basename($this->bin);
+ $message = tsprintf(
+ "%B\n%s",
+ $message,
+ pht(
+ 'For details on available commands, run `%s`.',
+ "{$binary} help"));
+ }
+
+ throw new PhutilArgumentUsageException($message);
+ }
+
+}
diff --git a/src/parser/argument/PhutilArgumentSpecification.php b/src/parser/argument/PhutilArgumentSpecification.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/PhutilArgumentSpecification.php
@@ -0,0 +1,268 @@
+ 'verbose',
+ * 'short' => 'v',
+ * ));
+ *
+ * Recognized keys and equivalent verbose methods are:
+ *
+ * name setName()
+ * help setHelp()
+ * short setShortAlias()
+ * param setParamName()
+ * default setDefault()
+ * conflicts setConflicts()
+ * wildcard setWildcard()
+ * repeat setRepeatable()
+ *
+ * @param dict Dictionary of quick parameter definitions.
+ * @return PhutilArgumentSpecification Constructed argument specification.
+ */
+ public static function newQuickSpec(array $spec) {
+ $recognized_keys = array(
+ 'name',
+ 'help',
+ 'short',
+ 'param',
+ 'default',
+ 'conflicts',
+ 'wildcard',
+ 'repeat',
+ 'standard',
+ );
+
+ $unrecognized = array_diff_key(
+ $spec,
+ array_fill_keys($recognized_keys, true));
+
+ foreach ($unrecognized as $key => $ignored) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ "Unrecognized key '%s' in argument specification. Recognized keys ".
+ "are: %s.",
+ $key,
+ implode(', ', $recognized_keys)));
+ }
+
+ $obj = new PhutilArgumentSpecification();
+
+ foreach ($spec as $key => $value) {
+ switch ($key) {
+ case 'name':
+ $obj->setName($value);
+ break;
+ case 'help':
+ $obj->setHelp($value);
+ break;
+ case 'short':
+ $obj->setShortAlias($value);
+ break;
+ case 'param':
+ $obj->setParamName($value);
+ break;
+ case 'default':
+ $obj->setDefault($value);
+ break;
+ case 'conflicts':
+ $obj->setConflicts($value);
+ break;
+ case 'wildcard':
+ $obj->setWildcard($value);
+ break;
+ case 'repeat':
+ $obj->setRepeatable($value);
+ break;
+ case 'standard':
+ $obj->setStandard($value);
+ break;
+ }
+ }
+
+ $obj->validate();
+
+ return $obj;
+ }
+
+ public static function newSpecsFromList(array $specs) {
+ foreach ($specs as $key => $spec) {
+ if (is_array($spec)) {
+ $specs[$key] = self::newQuickSpec(
+ $spec);
+ }
+ }
+ return $specs;
+ }
+
+ public function setName($name) {
+ self::validateName($name);
+ $this->name = $name;
+ return $this;
+ }
+
+ private static function validateName($name) {
+ if (!preg_match('/^[a-z0-9][a-z0-9-]*$/', $name)) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ "Argument names may only contain a-z, 0-9 and -, and must be ".
+ "at least one character long. '%s' is invalid.",
+ $name));
+ }
+ }
+
+ public function getName() {
+ return $this->name;
+ }
+
+ public function setHelp($help) {
+ $this->help = $help;
+ return $this;
+ }
+
+ public function getHelp() {
+ return $this->help;
+ }
+
+ public function setShortAlias($short_alias) {
+ self::validateShortAlias($short_alias);
+ $this->shortAlias = $short_alias;
+ return $this;
+ }
+
+ private static function validateShortAlias($alias) {
+ if (strlen($alias) !== 1) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ "Argument short aliases must be exactly one character long. ".
+ "'%s' is invalid.",
+ $alias));
+ }
+ if (!preg_match('/^[a-zA-Z0-9]$/', $alias)) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ "Argument short aliases may only be in a-z, A-Z and 0-9. ".
+ "'%s' is invalid.",
+ $alias));
+ }
+ }
+
+ public function getShortAlias() {
+ return $this->shortAlias;
+ }
+
+ public function setParamName($param_name) {
+ $this->paramName = $param_name;
+ return $this;
+ }
+
+ public function getParamName() {
+ return $this->paramName;
+ }
+
+ public function setDefault($default) {
+ $this->default = $default;
+ return $this;
+ }
+
+ public function getDefault() {
+ if ($this->getParamName() === null) {
+ if ($this->getRepeatable()) {
+ return 0;
+ } else {
+ return false;
+ }
+ } else {
+ if ($this->getRepeatable()) {
+ return array();
+ } else {
+ return $this->default;
+ }
+ }
+ }
+
+ public function setConflicts(array $conflicts) {
+ $this->conflicts = $conflicts;
+ return $this;
+ }
+
+ public function getConflicts() {
+ return $this->conflicts;
+ }
+
+ public function setWildcard($wildcard) {
+ $this->wildcard = $wildcard;
+ return $this;
+ }
+
+ public function getWildcard() {
+ return $this->wildcard;
+ }
+
+ public function setRepeatable($repeatable) {
+ $this->repeatable = $repeatable;
+ return $this;
+ }
+
+ public function getRepeatable() {
+ return $this->repeatable;
+ }
+
+ public function setStandard($standard) {
+ $this->standard = $standard;
+ return $this;
+ }
+
+ public function getStandard() {
+ return $this->standard;
+ }
+
+ public function validate() {
+ if ($this->name === null) {
+ throw new PhutilArgumentSpecificationException(
+ pht("Argument specification MUST have a 'name'."));
+ }
+
+ if ($this->getWildcard()) {
+ if ($this->getParamName()) {
+ throw new PhutilArgumentSpecificationException(
+ pht('Wildcard arguments may not specify a parameter.'));
+ }
+ if ($this->getRepeatable()) {
+ throw new PhutilArgumentSpecificationException(
+ pht('Wildcard arguments may not be repeatable.'));
+ }
+ }
+
+ if ($this->default !== null) {
+ if ($this->getRepeatable()) {
+ throw new PhutilArgumentSpecificationException(
+ pht(
+ 'Repeatable arguments may not have a default (always array() for '.
+ 'arguments which accept a parameter, or 0 for arguments which do '.
+ 'not).'));
+ } else if ($this->getParamName() === null) {
+ throw new PhutilArgumentSpecificationException(
+ pht('Flag arguments may not have a default (always false).'));
+ }
+ }
+ }
+
+}
diff --git a/src/parser/argument/PhutilArgumentSpellingCorrector.php b/src/parser/argument/PhutilArgumentSpellingCorrector.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/PhutilArgumentSpellingCorrector.php
@@ -0,0 +1,132 @@
+setInsertCost(4)
+ ->setDeleteCost(4)
+ ->setReplaceCost(3)
+ ->setTransposeCost(2);
+
+ return id(new self())
+ ->setEditDistanceMatrix($matrix)
+ ->setMaximumDistance($max_distance);
+ }
+
+
+ /**
+ * Build a new corrector with parameters for correcting flags, like
+ * fixing "--nolint" into "--no-lint".
+ *
+ * @return PhutilArgumentSpellingCorrector Configured corrector.
+ */
+ public static function newFlagCorrector() {
+ // When correcting flag spelling, we're stricter than we are when
+ // correcting command spelling: we allow only one inserted or deleted
+ // character. It is mainly to handle cases like "--no-lint" versus
+ // "--nolint" or "--reviewer" versus "--reviewers".
+ $max_distance = 1;
+
+ $matrix = id(new PhutilEditDistanceMatrix())
+ ->setInsertCost(1)
+ ->setDeleteCost(1)
+ ->setReplaceCost(10);
+
+ return id(new self())
+ ->setEditDistanceMatrix($matrix)
+ ->setMaximumDistance($max_distance);
+ }
+
+ public function setEditDistanceMatrix(PhutilEditDistanceMatrix $matrix) {
+ $this->editDistanceMatrix = $matrix;
+ return $this;
+ }
+
+ public function getEditDistanceMatrix() {
+ return $this->editDistanceMatrix;
+ }
+
+ public function setMaximumDistance($maximum_distance) {
+ $this->maximumDistance = $maximum_distance;
+ return $this;
+ }
+
+ public function getMaximumDistance() {
+ return $this->maximumDistance;
+ }
+
+ public function correctSpelling($input, array $options) {
+ $matrix = $this->getEditDistanceMatrix();
+ if (!$matrix) {
+ throw new PhutilInvalidStateException('setEditDistanceMatrix');
+ }
+
+ $max_distance = $this->getMaximumDistance();
+ if (!$max_distance) {
+ throw new PhutilInvalidStateException('setMaximumDistance');
+ }
+
+ $input = $this->normalizeString($input);
+ foreach ($options as $key => $option) {
+ $options[$key] = $this->normalizeString($option);
+ }
+
+ $distances = array();
+ $inputv = phutil_utf8v($input);
+ foreach ($options as $option) {
+ $optionv = phutil_utf8v($option);
+ $matrix->setSequences($optionv, $inputv);
+ $distances[$option] = $matrix->getEditDistance();
+ }
+
+ asort($distances);
+ $best = min($max_distance, head($distances));
+ foreach ($distances as $option => $distance) {
+ if ($distance > $best) {
+ unset($distances[$option]);
+ }
+ }
+
+ // Before filtering, check if we have multiple equidistant matches and
+ // return them if we do. This prevents us from, e.g., matching "alnd" with
+ // both "land" and "amend", then dropping "land" for being too short, and
+ // incorrectly completing to "amend".
+ if (count($distances) > 1) {
+ return array_keys($distances);
+ }
+
+ foreach ($distances as $option => $distance) {
+ if (phutil_utf8_strlen($option) < $distance) {
+ unset($distances[$option]);
+ }
+ }
+
+ return array_keys($distances);
+ }
+
+ private function normalizeString($string) {
+ return phutil_utf8_strtolower($string);
+ }
+
+}
diff --git a/src/parser/argument/__tests__/PhutilArgumentParserTestCase.php b/src/parser/argument/__tests__/PhutilArgumentParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/__tests__/PhutilArgumentParserTestCase.php
@@ -0,0 +1,426 @@
+ 'flag',
+ ),
+ );
+
+ $args = new PhutilArgumentParser(array('bin'));
+ $args->parseFull($specs);
+ $this->assertEqual(false, $args->getArg('flag'));
+
+ $args = new PhutilArgumentParser(array('bin', '--flag'));
+ $args->parseFull($specs);
+ $this->assertEqual(true, $args->getArg('flag'));
+ }
+
+ public function testWildcards() {
+ $specs = array(
+ array(
+ 'name' => 'flag',
+ ),
+ array(
+ 'name' => 'files',
+ 'wildcard' => true,
+ ),
+ );
+
+ $args = new PhutilArgumentParser(array('bin', '--flag', 'a', 'b'));
+ $args->parseFull($specs);
+ $this->assertEqual(true, $args->getArg('flag'));
+ $this->assertEqual(
+ array('a', 'b'),
+ $args->getArg('files'));
+
+ $caught = null;
+ try {
+ $args = new PhutilArgumentParser(array('bin', '--derp', 'a', 'b'));
+ $args->parseFull($specs);
+ } catch (PhutilArgumentUsageException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+
+ $args = new PhutilArgumentParser(array('bin', '--', '--derp', 'a', 'b'));
+ $args->parseFull($specs);
+ $this->assertEqual(
+ array('--derp', 'a', 'b'),
+ $args->getArg('files'));
+ }
+
+ public function testPartialParse() {
+ $specs = array(
+ array(
+ 'name' => 'flag',
+ ),
+ );
+
+ $args = new PhutilArgumentParser(array('bin', 'a', '--flag', '--', 'b'));
+ $args->parsePartial($specs);
+
+ $this->assertEqual(
+ array('a', '--', 'b'),
+ $args->getUnconsumedArgumentVector());
+ }
+
+ public function testBadArg() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $args->parseFull(array());
+
+ $caught = null;
+ try {
+ $args->getArg('flag');
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testDuplicateNames() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'x',
+ ),
+ array(
+ 'name' => 'x',
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testDuplicateNamesWithParsePartial() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parsePartial(
+ array(
+ array(
+ 'name' => 'x',
+ ),
+ ));
+ $args->parsePartial(
+ array(
+ array(
+ 'name' => 'x',
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testDuplicateShortAliases() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'x',
+ 'short' => 'x',
+ ),
+ array(
+ 'name' => 'y',
+ 'short' => 'x',
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testDuplicateWildcards() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'x',
+ 'wildcard' => true,
+ ),
+ array(
+ 'name' => 'y',
+ 'wildcard' => true,
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testDuplicatePartialWildcards() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parsePartial(
+ array(
+ array(
+ 'name' => 'x',
+ 'wildcard' => true,
+ ),
+ ));
+ $args->parsePartial(
+ array(
+ array(
+ 'name' => 'y',
+ 'wildcard' => true,
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testConflictSpecificationWithUnrecognizedArg() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'x',
+ 'conflicts' => array(
+ 'y' => true,
+ ),
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testConflictSpecificationWithSelf() {
+ $args = new PhutilArgumentParser(array('bin'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'x',
+ 'conflicts' => array(
+ 'x' => true,
+ ),
+ ),
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testUnrecognizedFlag() {
+ $args = new PhutilArgumentParser(array('bin', '--flag'));
+ $caught = null;
+ try {
+ $args->parseFull(array());
+ } catch (PhutilArgumentUsageException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testDuplicateFlag() {
+ $args = new PhutilArgumentParser(array('bin', '--flag', '--flag'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'flag',
+ ),
+ ));
+ } catch (PhutilArgumentUsageException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testMissingParameterValue() {
+ $args = new PhutilArgumentParser(array('bin', '--with'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'with',
+ 'param' => 'stuff',
+ ),
+ ));
+ } catch (PhutilArgumentUsageException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testExtraParameterValue() {
+ $args = new PhutilArgumentParser(array('bin', '--true=apple'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'true',
+ ),
+ ));
+ } catch (PhutilArgumentUsageException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testConflictParameterValue() {
+ $args = new PhutilArgumentParser(array('bin', '--true', '--false'));
+ $caught = null;
+ try {
+ $args->parseFull(
+ array(
+ array(
+ 'name' => 'true',
+ 'conflicts' => array(
+ 'false' => true,
+ ),
+ ),
+ array(
+ 'name' => 'false',
+ 'conflicts' => array(
+ 'true' => true,
+ ),
+ ),
+ ));
+ } catch (PhutilArgumentUsageException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof Exception);
+ }
+
+ public function testParameterValues() {
+ $specs = array(
+ array(
+ 'name' => 'a',
+ 'param' => 'value',
+ ),
+ array(
+ 'name' => 'b',
+ 'param' => 'value',
+ ),
+ array(
+ 'name' => 'cee',
+ 'short' => 'c',
+ 'param' => 'value',
+ ),
+ array(
+ 'name' => 'dee',
+ 'short' => 'd',
+ 'param' => 'value',
+ ),
+ );
+
+ $args = new PhutilArgumentParser(
+ array(
+ 'bin',
+ '--a',
+ 'a',
+ '--b=b',
+ '-c',
+ 'c',
+ '-d=d',
+ ));
+ $args->parseFull($specs);
+
+ $this->assertEqual('a', $args->getArg('a'));
+ $this->assertEqual('b', $args->getArg('b'));
+ $this->assertEqual('c', $args->getArg('cee'));
+ $this->assertEqual('d', $args->getArg('dee'));
+ }
+
+ public function testStdinValidParameter() {
+ $specs = array(
+ array(
+ 'name' => 'file',
+ 'param' => 'file',
+ ),
+ );
+
+ $args = new PhutilArgumentParser(
+ array(
+ 'bin',
+ '-',
+ '--file',
+ '-',
+ ));
+ $args->parsePartial($specs);
+
+ $this->assertEqual('-', $args->getArg('file'));
+ }
+
+ public function testRepeatableFlag() {
+ $specs = array(
+ array(
+ 'name' => 'verbose',
+ 'short' => 'v',
+ 'repeat' => true,
+ ),
+ );
+
+ $args = new PhutilArgumentParser(array('bin', '-v', '-v', '-v'));
+ $args->parseFull($specs);
+
+ $this->assertEqual(3, $args->getArg('verbose'));
+ }
+
+ public function testRepeatableParam() {
+ $specs = array(
+ array(
+ 'name' => 'eat',
+ 'param' => 'fruit',
+ 'repeat' => true,
+ ),
+ );
+
+ $args = new PhutilArgumentParser(array(
+ 'bin',
+ '--eat',
+ 'apple',
+ '--eat',
+ 'pear',
+ '--eat=orange',
+ ));
+ $args->parseFull($specs);
+
+ $this->assertEqual(
+ array('apple', 'pear', 'orange'),
+ $args->getArg('eat'));
+ }
+
+}
diff --git a/src/parser/argument/__tests__/PhutilArgumentSpecificationTestCase.php b/src/parser/argument/__tests__/PhutilArgumentSpecificationTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/__tests__/PhutilArgumentSpecificationTestCase.php
@@ -0,0 +1,142 @@
+ true,
+ 'xx' => true,
+ '!' => false,
+ 'XX' => false,
+ '1=' => false,
+ '--' => false,
+
+ 'no-stuff' => true,
+ '-stuff' => false,
+ );
+
+ foreach ($names as $name => $valid) {
+ $caught = null;
+ try {
+ PhutilArgumentSpecification::newQuickSpec(
+ array(
+ 'name' => $name,
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+ $this->assertEqual(
+ !$valid,
+ $caught instanceof Exception,
+ pht("Argument name '%s'.", $name));
+ }
+ }
+
+ public function testAliases() {
+ $aliases = array(
+ 'a' => true,
+ '1' => true,
+
+ 'no' => false,
+ '-' => false,
+ '_' => false,
+ ' ' => false,
+ '' => false,
+ );
+
+ foreach ($aliases as $alias => $valid) {
+ $caught = null;
+ try {
+ PhutilArgumentSpecification::newQuickSpec(
+ array(
+ 'name' => 'example',
+ 'short' => $alias,
+ ));
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+ $this->assertEqual(
+ !$valid,
+ $caught instanceof Exception,
+ pht("Arg alias '%s'.", $alias));
+ }
+ }
+
+ public function testSpecs() {
+ $good_specs = array(
+ array(
+ 'name' => 'verbose',
+ ),
+ array(
+ 'name' => 'verbose',
+ 'short' => 'v',
+ 'help' => 'Derp.',
+ 'param' => 'level',
+ 'default' => 'y',
+ 'conflicts' => array(
+ 'quiet' => true,
+ ),
+ 'wildcard' => false,
+ ),
+ array(
+ 'name' => 'files',
+ 'wildcard' => true,
+ ),
+ );
+
+ $bad_specs = array(
+ array(
+ ),
+ array(
+ 'alias' => 'v',
+ ),
+ array(
+ 'name' => 'derp',
+ 'fruit' => 'apple',
+ ),
+ array(
+ 'name' => 'x',
+ 'default' => 'y',
+ ),
+ array(
+ 'name' => 'x',
+ 'param' => 'y',
+ 'default' => 'z',
+ 'repeat' => true,
+ ),
+ array(
+ 'name' => 'x',
+ 'wildcard' => true,
+ 'repeat' => true,
+ ),
+ array(
+ 'name' => 'x',
+ 'param' => 'y',
+ 'wildcard' => true,
+ ),
+
+ );
+
+ $cases = array(
+ array(true, $good_specs),
+ array(false, $bad_specs),
+ );
+
+ foreach ($cases as $case) {
+ list($expect, $specs) = $case;
+ foreach ($specs as $spec) {
+ $caught = null;
+ try {
+ PhutilArgumentSpecification::newQuickSpec($spec);
+ } catch (PhutilArgumentSpecificationException $ex) {
+ $caught = $ex;
+ }
+ $this->assertEqual(
+ !$expect,
+ $caught instanceof Exception,
+ pht('Spec validity for: %s', print_r($spec, true)));
+ }
+ }
+ }
+
+}
diff --git a/src/parser/argument/__tests__/PhutilArgumentSpellingCorrectorTestCase.php b/src/parser/argument/__tests__/PhutilArgumentSpellingCorrectorTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/__tests__/PhutilArgumentSpellingCorrectorTestCase.php
@@ -0,0 +1,94 @@
+assertCommandCorrection(
+ array('land'),
+ 'alnd',
+ array('land', 'amend'));
+
+ $this->assertCommandCorrection(
+ array('branch'),
+ 'brnach',
+ array('branch', 'browse'));
+
+ $this->assertCommandCorrection(
+ array(),
+ 'test',
+ array('list', 'unit'));
+
+ $this->assertCommandCorrection(
+ array('list'),
+ 'lists',
+ array('list'));
+
+ $this->assertCommandCorrection(
+ array('diff'),
+ 'dfif',
+ array('diff'));
+
+ $this->assertCommandCorrection(
+ array('unit'),
+ 'uint',
+ array('unit', 'lint', 'list'));
+
+ $this->assertCommandCorrection(
+ array('list', 'lint'),
+ 'nilt',
+ array('unit', 'lint', 'list'));
+ }
+
+ private function assertCommandCorrection($expect, $input, $commands) {
+ $result = PhutilArgumentSpellingCorrector::newCommandCorrector()
+ ->correctSpelling($input, $commands);
+
+ sort($result);
+ sort($expect);
+
+ $commands = implode(', ', $commands);
+
+ $this->assertEqual(
+ $expect,
+ $result,
+ pht('Correction of %s against: %s', $input, $commands));
+ }
+
+ public function testFlagCorrection() {
+ $this->assertFlagCorrection(
+ array('nolint'),
+ 'no-lint',
+ array('nolint', 'nounit'));
+
+ $this->assertFlagCorrection(
+ array('reviewers'),
+ 'reviewer',
+ array('reviewers', 'cc'));
+
+ $this->assertFlagCorrection(
+ array(),
+ 'onlint',
+ array('nolint'));
+
+ $this->assertFlagCorrection(
+ array(),
+ 'nolind',
+ array('nolint'));
+ }
+
+ private function assertFlagCorrection($expect, $input, $flags) {
+ $result = PhutilArgumentSpellingCorrector::newFlagCorrector()
+ ->correctSpelling($input, $flags);
+
+ sort($result);
+ sort($expect);
+
+ $flags = implode(', ', $flags);
+
+ $this->assertEqual(
+ $expect,
+ $result,
+ pht('Correction of %s against: %s', $input, $flags));
+ }
+
+}
diff --git a/src/parser/argument/exception/PhutilArgumentParserException.php b/src/parser/argument/exception/PhutilArgumentParserException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/exception/PhutilArgumentParserException.php
@@ -0,0 +1,3 @@
+setTagline('simple calculator example');
+ * $args->setSynopsis(<<setName('add')
+ * ->setExamples('**add** __n__ ...')
+ * ->setSynopsis('Compute the sum of a list of numbers.')
+ * ->setArguments(
+ * array(
+ * array(
+ * 'name' => 'numbers',
+ * 'wildcard' => true,
+ * ),
+ * ));
+ *
+ * $mul_workflow = id(new PhutilArgumentWorkflow())
+ * ->setName('mul')
+ * ->setExamples('**mul** __n__ ...')
+ * ->setSynopsis('Compute the product of a list of numbers.')
+ * ->setArguments(
+ * array(
+ * array(
+ * 'name' => 'numbers',
+ * 'wildcard' => true,
+ * ),
+ * ));
+ *
+ * $flow = $args->parseWorkflows(
+ * array(
+ * $add_workflow,
+ * $mul_workflow,
+ * new PhutilHelpArgumentWorkflow(),
+ * ));
+ *
+ * $nums = $args->getArg('numbers');
+ * if (empty($nums)) {
+ * echo "You must provide one or more numbers!\n";
+ * exit(1);
+ * }
+ *
+ * foreach ($nums as $num) {
+ * if (!is_numeric($num)) {
+ * echo "Number '{$num}' is not numeric!\n";
+ * exit(1);
+ * }
+ * }
+ *
+ * switch ($flow->getName()) {
+ * case 'add':
+ * echo array_sum($nums)."\n";
+ * break;
+ * case 'mul':
+ * echo array_product($nums)."\n";
+ * break;
+ * }
+ *
+ * You can also subclass this class and return `true` from
+ * @{method:isExecutable}. In this case, the parser will automatically select
+ * your workflow when the user invokes it.
+ *
+ * @concrete-extensible
+ */
+class PhutilArgumentWorkflow extends Phobject {
+
+ private $name;
+ private $synopsis;
+ private $specs = array();
+ private $examples;
+ private $help;
+ private $argv;
+
+ final public function __construct() {
+ $this->didConstruct();
+ }
+
+ public function setName($name) {
+ $this->name = $name;
+ return $this;
+ }
+
+ public function getName() {
+ return $this->name;
+ }
+
+ /**
+ * Provide brief usage examples of common calling conventions, like:
+ *
+ * $workflow->setExamples("**delete** __file__ [__options__]");
+ *
+ * This text is shown in both brief and detailed help, and should give the
+ * user a quick reference for common uses. You can separate several common
+ * uses with newlines, but usually should not provide more than 2-3 examples.
+ */
+ final public function setExamples($examples) {
+ $this->examples = $examples;
+ return $this;
+ }
+
+ final public function getExamples() {
+ if (!$this->examples) {
+ return '**'.$this->name.'**';
+ }
+ return $this->examples;
+ }
+
+ /**
+ * Provide a brief description of the command, like "Delete a file.".
+ *
+ * This text is shown in both brief and detailed help, and should give the
+ * user a general idea of what the workflow does.
+ */
+ final public function setSynopsis($synopsis) {
+ $this->synopsis = $synopsis;
+ return $this;
+ }
+
+ final public function getSynopsis() {
+ return $this->synopsis;
+ }
+
+
+ /**
+ * Provide a full explanation of the command. This text is shown only in
+ * detailed help.
+ */
+ final public function getHelp() {
+ return $this->help;
+ }
+
+ final public function setHelp($help) {
+ $this->help = $help;
+ return $this;
+ }
+
+ final public function setArguments(array $specs) {
+ $specs = PhutilArgumentSpecification::newSpecsFromList($specs);
+ $this->specs = $specs;
+ return $this;
+ }
+
+ final public function getArguments() {
+ return $this->specs;
+ }
+
+ final public function setArgv(PhutilArgumentParser $argv) {
+ $this->argv = $argv;
+ return $this;
+ }
+
+ final public function getArgv() {
+ return $this->argv;
+ }
+
+ protected function didConstruct() {
+ return null;
+ }
+
+ public function isExecutable() {
+ return false;
+ }
+
+ public function execute(PhutilArgumentParser $args) {
+ throw new Exception(pht("This workflow isn't executable!"));
+ }
+
+ /**
+ * Normally, workflow arguments are parsed fully, so unexpected arguments will
+ * raise an error. You can return `true` from this method to parse workflow
+ * arguments only partially. This will allow you to manually parse remaining
+ * arguments or delegate to a second level of workflows.
+ *
+ * @return bool True to partially parse workflow arguments (default false).
+ */
+ public function shouldParsePartial() {
+ return false;
+ }
+
+}
diff --git a/src/parser/argument/workflow/PhutilHelpArgumentWorkflow.php b/src/parser/argument/workflow/PhutilHelpArgumentWorkflow.php
new file mode 100644
--- /dev/null
+++ b/src/parser/argument/workflow/PhutilHelpArgumentWorkflow.php
@@ -0,0 +1,45 @@
+setName('help');
+ $this->setExamples(<<setSynopsis(<<setArguments(
+ array(
+ array(
+ 'name' => 'help-with-what',
+ 'wildcard' => true,
+ ),
+ ));
+ }
+
+ public function isExecutable() {
+ return true;
+ }
+
+ public function execute(PhutilArgumentParser $args) {
+ $with = $args->getArg('help-with-what');
+
+ if (!$with) {
+ $args->printHelpAndExit();
+ } else {
+ foreach ($with as $thing) {
+ echo phutil_console_format(
+ "**%s**\n\n",
+ pht('%s WORKFLOW', strtoupper($thing)));
+ echo $args->renderWorkflowHelp($thing, $show_flags = true);
+ echo "\n";
+ }
+ exit(PhutilArgumentParser::PARSE_ERROR_CODE);
+ }
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarAbsoluteDateTime.php b/src/parser/calendar/data/PhutilCalendarAbsoluteDateTime.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarAbsoluteDateTime.php
@@ -0,0 +1,287 @@
+\d{4})(?P\d{2})(?P\d{2})'.
+ '(?:'.
+ 'T(?P\d{2})(?P\d{2})(?P\d{2})(?Z)?'.
+ ')?'.
+ '\z/';
+
+ $matches = null;
+ $ok = preg_match($pattern, $value, $matches);
+ if (!$ok) {
+ throw new Exception(
+ pht(
+ 'Expected ISO8601 datetime in the format "19990105T112233Z", '.
+ 'found "%s".',
+ $value));
+ }
+
+ if (isset($matches['z'])) {
+ if ($timezone != 'UTC') {
+ throw new Exception(
+ pht(
+ 'ISO8601 date ends in "Z" indicating UTC, but a timezone other '.
+ 'than UTC ("%s") was specified.',
+ $timezone));
+ }
+ }
+
+ $datetime = id(new self())
+ ->setYear((int)$matches['y'])
+ ->setMonth((int)$matches['m'])
+ ->setDay((int)$matches['d'])
+ ->setTimezone($timezone);
+
+ if (isset($matches['h'])) {
+ $datetime
+ ->setHour((int)$matches['h'])
+ ->setMinute((int)$matches['i'])
+ ->setSecond((int)$matches['s']);
+ } else {
+ $datetime
+ ->setIsAllDay(true);
+ }
+
+ return $datetime;
+ }
+
+ public static function newFromEpoch($epoch, $timezone = 'UTC') {
+ $date = new DateTime('@'.$epoch);
+
+ $zone = new DateTimeZone($timezone);
+ $date->setTimezone($zone);
+
+ return id(new self())
+ ->setYear((int)$date->format('Y'))
+ ->setMonth((int)$date->format('m'))
+ ->setDay((int)$date->format('d'))
+ ->setHour((int)$date->format('H'))
+ ->setMinute((int)$date->format('i'))
+ ->setSecond((int)$date->format('s'))
+ ->setTimezone($timezone);
+ }
+
+ public static function newFromDictionary(array $dict) {
+ static $keys;
+ if ($keys === null) {
+ $keys = array_fuse(
+ array(
+ 'kind',
+ 'year',
+ 'month',
+ 'day',
+ 'hour',
+ 'minute',
+ 'second',
+ 'timezone',
+ 'isAllDay',
+ ));
+ }
+
+ foreach ($dict as $key => $value) {
+ if (!isset($keys[$key])) {
+ throw new Exception(
+ pht(
+ 'Unexpected key "%s" in datetime dictionary, expected keys: %s.',
+ $key,
+ implode(', ', array_keys($keys))));
+ }
+ }
+
+ if (idx($dict, 'kind') !== 'absolute') {
+ throw new Exception(
+ pht(
+ 'Expected key "%s" with value "%s" in datetime dictionary.',
+ 'kind',
+ 'absolute'));
+ }
+
+ if (!isset($dict['year'])) {
+ throw new Exception(
+ pht(
+ 'Expected key "%s" in datetime dictionary.',
+ 'year'));
+ }
+
+ $datetime = id(new self())
+ ->setYear(idx($dict, 'year'))
+ ->setMonth(idx($dict, 'month', 1))
+ ->setDay(idx($dict, 'day', 1))
+ ->setHour(idx($dict, 'hour', 0))
+ ->setMinute(idx($dict, 'minute', 0))
+ ->setSecond(idx($dict, 'second', 0))
+ ->setTimezone(idx($dict, 'timezone'))
+ ->setIsAllDay((bool)idx($dict, 'isAllDay', false));
+
+ return $datetime;
+ }
+
+ public function newRelativeDateTime($duration) {
+ if (is_string($duration)) {
+ $duration = PhutilCalendarDuration::newFromISO8601($duration);
+ }
+
+ if (!($duration instanceof PhutilCalendarDuration)) {
+ throw new Exception(
+ pht(
+ 'Expected "PhutilCalendarDuration" object or ISO8601 duration '.
+ 'string.'));
+ }
+
+ return id(new PhutilCalendarRelativeDateTime())
+ ->setOrigin($this)
+ ->setDuration($duration);
+ }
+
+ public function toDictionary() {
+ return array(
+ 'kind' => 'absolute',
+ 'year' => (int)$this->getYear(),
+ 'month' => (int)$this->getMonth(),
+ 'day' => (int)$this->getDay(),
+ 'hour' => (int)$this->getHour(),
+ 'minute' => (int)$this->getMinute(),
+ 'second' => (int)$this->getSecond(),
+ 'timezone' => $this->getTimezone(),
+ 'isAllDay' => (bool)$this->getIsAllDay(),
+ );
+ }
+
+ public function setYear($year) {
+ $this->year = $year;
+ return $this;
+ }
+
+ public function getYear() {
+ return $this->year;
+ }
+
+ public function setMonth($month) {
+ $this->month = $month;
+ return $this;
+ }
+
+ public function getMonth() {
+ return $this->month;
+ }
+
+ public function setDay($day) {
+ $this->day = $day;
+ return $this;
+ }
+
+ public function getDay() {
+ return $this->day;
+ }
+
+ public function setHour($hour) {
+ $this->hour = $hour;
+ return $this;
+ }
+
+ public function getHour() {
+ return $this->hour;
+ }
+
+ public function setMinute($minute) {
+ $this->minute = $minute;
+ return $this;
+ }
+
+ public function getMinute() {
+ return $this->minute;
+ }
+
+ public function setSecond($second) {
+ $this->second = $second;
+ return $this;
+ }
+
+ public function getSecond() {
+ return $this->second;
+ }
+
+ public function setTimezone($timezone) {
+ $this->timezone = $timezone;
+ return $this;
+ }
+
+ public function getTimezone() {
+ return $this->timezone;
+ }
+
+ private function getEffectiveTimezone() {
+ $date_timezone = $this->getTimezone();
+ $viewer_timezone = $this->getViewerTimezone();
+
+ // Because all-day events are always "floating", the effective timezone
+ // is the viewer timezone if it is available. Otherwise, we'll return a
+ // DateTime object with the correct values, but it will be incorrectly
+ // adjusted forward or backward to the viewer's zone later.
+
+ $zones = array();
+ if ($this->getIsAllDay()) {
+ $zones[] = $viewer_timezone;
+ $zones[] = $date_timezone;
+ } else {
+ $zones[] = $date_timezone;
+ $zones[] = $viewer_timezone;
+ }
+ $zones = array_filter($zones);
+
+ if (!$zones) {
+ throw new Exception(
+ pht(
+ 'Datetime has no timezone or viewer timezone.'));
+ }
+
+ return head($zones);
+ }
+
+ public function newPHPDateTimeZone() {
+ $zone = $this->getEffectiveTimezone();
+ return new DateTimeZone($zone);
+ }
+
+ public function newPHPDateTime() {
+ $zone = $this->newPHPDateTimeZone();
+
+ $y = $this->getYear();
+ $m = $this->getMonth();
+ $d = $this->getDay();
+
+ if ($this->getIsAllDay()) {
+ $h = 0;
+ $i = 0;
+ $s = 0;
+ } else {
+ $h = $this->getHour();
+ $i = $this->getMinute();
+ $s = $this->getSecond();
+ }
+
+ $format = sprintf('%04d-%02d-%02d %02d:%02d:%02d', $y, $m, $d, $h, $i, $s);
+
+ return new DateTime($format, $zone);
+ }
+
+
+ public function newAbsoluteDateTime() {
+ return clone $this;
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarContainerNode.php b/src/parser/calendar/data/PhutilCalendarContainerNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarContainerNode.php
@@ -0,0 +1,30 @@
+children;
+ }
+
+ final public function getChildrenOfType($type) {
+ $result = array();
+
+ foreach ($this->getChildren() as $key => $child) {
+ if ($child->getNodeType() != $type) {
+ continue;
+ }
+ $result[$key] = $child;
+ }
+
+ return $result;
+ }
+
+ final public function appendChild(PhutilCalendarNode $node) {
+ $this->children[] = $node;
+ return $this;
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarDateTime.php b/src/parser/calendar/data/PhutilCalendarDateTime.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarDateTime.php
@@ -0,0 +1,54 @@
+viewerTimezone = $viewer_timezone;
+ return $this;
+ }
+
+ public function getViewerTimezone() {
+ return $this->viewerTimezone;
+ }
+
+ public function setIsAllDay($is_all_day) {
+ $this->isAllDay = $is_all_day;
+ return $this;
+ }
+
+ public function getIsAllDay() {
+ return $this->isAllDay;
+ }
+
+ public function getEpoch() {
+ $datetime = $this->newPHPDateTime();
+ return (int)$datetime->format('U');
+ }
+
+ public function getISO8601() {
+ $datetime = $this->newPHPDateTime();
+
+ if ($this->getIsAllDay()) {
+ return $datetime->format('Ymd');
+ } else if ($this->getTimezone()) {
+ // With a timezone, the event occurs at a specific second universally.
+ // We return the UTC representation of that point in time.
+ $datetime->setTimezone(new DateTimeZone('UTC'));
+ return $datetime->format('Ymd\\THis\\Z');
+ } else {
+ // With no timezone, events are "floating" and occur at local time.
+ // We return a representation without the "Z".
+ return $datetime->format('Ymd\\THis');
+ }
+ }
+
+ abstract public function newPHPDateTimeZone();
+ abstract public function newPHPDateTime();
+ abstract public function newAbsoluteDateTime();
+
+ abstract public function getTimezone();
+}
diff --git a/src/parser/calendar/data/PhutilCalendarDocumentNode.php b/src/parser/calendar/data/PhutilCalendarDocumentNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarDocumentNode.php
@@ -0,0 +1,12 @@
+getChildrenOfType(PhutilCalendarEventNode::NODETYPE);
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarDuration.php b/src/parser/calendar/data/PhutilCalendarDuration.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarDuration.php
@@ -0,0 +1,181 @@
+ $value) {
+ if (!isset($keys[$key])) {
+ throw new Exception(
+ pht(
+ 'Unexpected key "%s" in duration dictionary, expected keys: %s.',
+ $key,
+ implode(', ', array_keys($keys))));
+ }
+ }
+
+ $duration = id(new self())
+ ->setIsNegative(idx($dict, 'isNegative', false))
+ ->setWeeks(idx($dict, 'weeks', 0))
+ ->setDays(idx($dict, 'days', 0))
+ ->setHours(idx($dict, 'hours', 0))
+ ->setMinutes(idx($dict, 'minutes', 0))
+ ->setSeconds(idx($dict, 'seconds', 0));
+
+ return $duration;
+ }
+
+ public function toDictionary() {
+ return array(
+ 'isNegative' => $this->getIsNegative(),
+ 'weeks' => $this->getWeeks(),
+ 'days' => $this->getDays(),
+ 'hours' => $this->getHours(),
+ 'minutes' => $this->getMinutes(),
+ 'seconds' => $this->getSeconds(),
+ );
+ }
+
+ public static function newFromISO8601($value) {
+ $pattern =
+ '/^'.
+ '(?P[+-])?'.
+ 'P'.
+ '(?:'.
+ '(?P\d+)W'.
+ '|'.
+ '(?:(?:(?P\d+)D)?'.
+ '(?:T(?:(?P\d+)H)?(?:(?P\d+)M)?(?:(?P\d+)S)?)?'.
+ ')'.
+ ')'.
+ '\z/';
+
+ $matches = null;
+ $ok = preg_match($pattern, $value, $matches);
+ if (!$ok) {
+ throw new Exception(
+ pht(
+ 'Expected ISO8601 duration in the format "P12DT3H4M5S", found '.
+ '"%s".',
+ $value));
+ }
+
+ $is_negative = (idx($matches, 'sign') == '-');
+
+ return id(new self())
+ ->setIsNegative($is_negative)
+ ->setWeeks((int)idx($matches, 'W', 0))
+ ->setDays((int)idx($matches, 'D', 0))
+ ->setHours((int)idx($matches, 'H', 0))
+ ->setMinutes((int)idx($matches, 'M', 0))
+ ->setSeconds((int)idx($matches, 'S', 0));
+ }
+
+ public function toISO8601() {
+ $parts = array();
+ $parts[] = 'P';
+
+ $weeks = $this->getWeeks();
+ if ($weeks) {
+ $parts[] = $weeks.'W';
+ } else {
+ $days = $this->getDays();
+ if ($days) {
+ $parts[] = $days.'D';
+ }
+
+ $parts[] = 'T';
+
+ $hours = $this->getHours();
+ if ($hours) {
+ $parts[] = $hours.'H';
+ }
+
+ $minutes = $this->getMinutes();
+ if ($minutes) {
+ $parts[] = $minutes.'M';
+ }
+
+ $seconds = $this->getSeconds();
+ if ($seconds) {
+ $parts[] = $seconds.'S';
+ }
+ }
+
+ return implode('', $parts);
+ }
+
+ public function setIsNegative($is_negative) {
+ $this->isNegative = $is_negative;
+ return $this;
+ }
+
+ public function getIsNegative() {
+ return $this->isNegative;
+ }
+
+ public function setWeeks($weeks) {
+ $this->weeks = $weeks;
+ return $this;
+ }
+
+ public function getWeeks() {
+ return $this->weeks;
+ }
+
+ public function setDays($days) {
+ $this->days = $days;
+ return $this;
+ }
+
+ public function getDays() {
+ return $this->days;
+ }
+
+ public function setHours($hours) {
+ $this->hours = $hours;
+ return $this;
+ }
+
+ public function getHours() {
+ return $this->hours;
+ }
+
+ public function setMinutes($minutes) {
+ $this->minutes = $minutes;
+ return $this;
+ }
+
+ public function getMinutes() {
+ return $this->minutes;
+ }
+
+ public function setSeconds($seconds) {
+ $this->seconds = $seconds;
+ return $this;
+ }
+
+ public function getSeconds() {
+ return $this->seconds;
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarEventNode.php b/src/parser/calendar/data/PhutilCalendarEventNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarEventNode.php
@@ -0,0 +1,172 @@
+uid = $uid;
+ return $this;
+ }
+
+ public function getUID() {
+ return $this->uid;
+ }
+
+ public function setName($name) {
+ $this->name = $name;
+ return $this;
+ }
+
+ public function getName() {
+ return $this->name;
+ }
+
+ public function setDescription($description) {
+ $this->description = $description;
+ return $this;
+ }
+
+ public function getDescription() {
+ return $this->description;
+ }
+
+ public function setStartDateTime(PhutilCalendarDateTime $start) {
+ $this->startDateTime = $start;
+ return $this;
+ }
+
+ public function getStartDateTime() {
+ return $this->startDateTime;
+ }
+
+ public function setEndDateTime(PhutilCalendarDateTime $end) {
+ $this->endDateTime = $end;
+ return $this;
+ }
+
+ public function getEndDateTime() {
+ $end = $this->endDateTime;
+ if ($end) {
+ return $end;
+ }
+
+ $start = $this->getStartDateTime();
+ $duration = $this->getDuration();
+ if ($start && $duration) {
+ return id(new PhutilCalendarRelativeDateTime())
+ ->setOrigin($start)
+ ->setDuration($duration);
+ }
+
+ // If no end date or duration are specified, the event is instantaneous.
+ return $start;
+ }
+
+ public function setDuration(PhutilCalendarDuration $duration) {
+ $this->duration = $duration;
+ return $this;
+ }
+
+ public function getDuration() {
+ return $this->duration;
+ }
+
+ public function setCreatedDateTime(PhutilCalendarDateTime $created) {
+ $this->createdDateTime = $created;
+ return $this;
+ }
+
+ public function getCreatedDateTime() {
+ return $this->createdDateTime;
+ }
+
+ public function setModifiedDateTime(PhutilCalendarDateTime $modified) {
+ $this->modifiedDateTime = $modified;
+ return $this;
+ }
+
+ public function getModifiedDateTime() {
+ return $this->modifiedDateTime;
+ }
+
+ public function setOrganizer(PhutilCalendarUserNode $organizer) {
+ $this->organizer = $organizer;
+ return $this;
+ }
+
+ public function getOrganizer() {
+ return $this->organizer;
+ }
+
+ public function setAttendees(array $attendees) {
+ assert_instances_of($attendees, 'PhutilCalendarUserNode');
+ $this->attendees = $attendees;
+ return $this;
+ }
+
+ public function getAttendees() {
+ return $this->attendees;
+ }
+
+ public function addAttendee(PhutilCalendarUserNode $attendee) {
+ $this->attendees[] = $attendee;
+ return $this;
+ }
+
+ public function setRecurrenceRule(
+ PhutilCalendarRecurrenceRule $recurrence_rule) {
+ $this->recurrenceRule = $recurrence_rule;
+ return $this;
+ }
+
+ public function getRecurrenceRule() {
+ return $this->recurrenceRule;
+ }
+
+ public function setRecurrenceExceptions(array $recurrence_exceptions) {
+ assert_instances_of($recurrence_exceptions, 'PhutilCalendarDateTime');
+ $this->recurrenceExceptions = $recurrence_exceptions;
+ return $this;
+ }
+
+ public function getRecurrenceExceptions() {
+ return $this->recurrenceExceptions;
+ }
+
+ public function setRecurrenceDates(array $recurrence_dates) {
+ assert_instances_of($recurrence_dates, 'PhutilCalendarDateTime');
+ $this->recurrenceDates = $recurrence_dates;
+ return $this;
+ }
+
+ public function getRecurrenceDates() {
+ return $this->recurrenceDates;
+ }
+
+ public function setRecurrenceID($recurrence_id) {
+ $this->recurrenceID = $recurrence_id;
+ return $this;
+ }
+
+ public function getRecurrenceID() {
+ return $this->recurrenceID;
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarNode.php b/src/parser/calendar/data/PhutilCalendarNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarNode.php
@@ -0,0 +1,20 @@
+getPhobjectClassConstant('NODETYPE');
+ }
+
+ final public function setAttribute($key, $value) {
+ $this->attributes[$key] = $value;
+ return $this;
+ }
+
+ final public function getAttribute($key, $default = null) {
+ return idx($this->attributes, $key, $default);
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarProxyDateTime.php b/src/parser/calendar/data/PhutilCalendarProxyDateTime.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarProxyDateTime.php
@@ -0,0 +1,51 @@
+proxy = $proxy;
+ return $this;
+ }
+
+ final protected function getProxy() {
+ return $this->proxy;
+ }
+
+ public function __clone() {
+ $this->proxy = clone $this->proxy;
+ }
+
+ public function setViewerTimezone($timezone) {
+ $this->getProxy()->setViewerTimezone($timezone);
+ return $this;
+ }
+
+ public function getViewerTimezone() {
+ return $this->getProxy()->getViewerTimezone();
+ }
+
+ public function setIsAllDay($is_all_day) {
+ $this->getProxy()->setIsAllDay($is_all_day);
+ return $this;
+ }
+
+ public function getIsAllDay() {
+ return $this->getProxy()->getIsAllDay();
+ }
+
+ public function newPHPDateTimezone() {
+ return $this->getProxy()->newPHPDateTimezone();
+ }
+
+ public function newPHPDateTime() {
+ return $this->getProxy()->newPHPDateTime();
+ }
+
+ public function getTimezone() {
+ return $this->getProxy()->getTimezone();
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarRawNode.php b/src/parser/calendar/data/PhutilCalendarRawNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarRawNode.php
@@ -0,0 +1,8 @@
+dates = $dates;
+ return $this;
+ }
+
+ public function getDates() {
+ return $this->dates;
+ }
+
+ public function resetSource() {
+ foreach ($this->getDates() as $date) {
+ $date->setViewerTimezone($this->getViewerTimezone());
+ }
+
+ $order = msort($this->getDates(), 'getEpoch');
+ $order = array_reverse($order);
+ $this->order = $order;
+
+ return $this;
+ }
+
+ public function getNextEvent($cursor) {
+ while ($this->order) {
+ $next = array_pop($this->order);
+ if ($next->getEpoch() >= $cursor) {
+ return $next;
+ }
+ }
+
+ return null;
+ }
+
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarRecurrenceRule.php b/src/parser/calendar/data/PhutilCalendarRecurrenceRule.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarRecurrenceRule.php
@@ -0,0 +1,1820 @@
+getFrequency();
+
+ $interval = $this->getInterval();
+ if ($interval != 1) {
+ $parts['INTERVAL'] = $interval;
+ }
+
+ $by_second = $this->getBySecond();
+ if ($by_second) {
+ $parts['BYSECOND'] = $by_second;
+ }
+
+ $by_minute = $this->getByMinute();
+ if ($by_minute) {
+ $parts['BYMINUTE'] = $by_minute;
+ }
+
+ $by_hour = $this->getByHour();
+ if ($by_hour) {
+ $parts['BYHOUR'] = $by_hour;
+ }
+
+ $by_day = $this->getByDay();
+ if ($by_day) {
+ $parts['BYDAY'] = $by_day;
+ }
+
+ $by_month = $this->getByMonth();
+ if ($by_month) {
+ $parts['BYMONTH'] = $by_month;
+ }
+
+ $by_monthday = $this->getByMonthDay();
+ if ($by_monthday) {
+ $parts['BYMONTHDAY'] = $by_monthday;
+ }
+
+ $by_yearday = $this->getByYearDay();
+ if ($by_yearday) {
+ $parts['BYYEARDAY'] = $by_yearday;
+ }
+
+ $by_weekno = $this->getByWeekNumber();
+ if ($by_weekno) {
+ $parts['BYWEEKNO'] = $by_weekno;
+ }
+
+ $by_setpos = $this->getBySetPosition();
+ if ($by_setpos) {
+ $parts['BYSETPOS'] = $by_setpos;
+ }
+
+ $wkst = $this->getWeekStart();
+ if ($wkst != self::WEEKDAY_MONDAY) {
+ $parts['WKST'] = $wkst;
+ }
+
+ $count = $this->getCount();
+ if ($count) {
+ $parts['COUNT'] = $count;
+ }
+
+ $until = $this->getUntil();
+ if ($until) {
+ $parts['UNTIL'] = $until->getISO8601();
+ }
+
+ return $parts;
+ }
+
+ public static function newFromDictionary(array $dict) {
+ static $expect;
+ if ($expect === null) {
+ $expect = array_fuse(
+ array(
+ 'FREQ',
+ 'INTERVAL',
+ 'BYSECOND',
+ 'BYMINUTE',
+ 'BYHOUR',
+ 'BYDAY',
+ 'BYMONTH',
+ 'BYMONTHDAY',
+ 'BYYEARDAY',
+ 'BYWEEKNO',
+ 'BYSETPOS',
+ 'WKST',
+ 'UNTIL',
+ 'COUNT',
+ ));
+ }
+
+ foreach ($dict as $key => $value) {
+ if (empty($expect[$key])) {
+ throw new Exception(
+ pht(
+ 'RRULE dictionary includes unknown key "%s". Expected keys '.
+ 'are: %s.',
+ $key,
+ implode(', ', array_keys($expect))));
+ }
+ }
+
+ $rrule = id(new self())
+ ->setFrequency(idx($dict, 'FREQ'))
+ ->setInterval(idx($dict, 'INTERVAL', 1))
+ ->setBySecond(idx($dict, 'BYSECOND', array()))
+ ->setByMinute(idx($dict, 'BYMINUTE', array()))
+ ->setByHour(idx($dict, 'BYHOUR', array()))
+ ->setByDay(idx($dict, 'BYDAY', array()))
+ ->setByMonth(idx($dict, 'BYMONTH', array()))
+ ->setByMonthDay(idx($dict, 'BYMONTHDAY', array()))
+ ->setByYearDay(idx($dict, 'BYYEARDAY', array()))
+ ->setByWeekNumber(idx($dict, 'BYWEEKNO', array()))
+ ->setBySetPosition(idx($dict, 'BYSETPOS', array()))
+ ->setWeekStart(idx($dict, 'WKST', self::WEEKDAY_MONDAY));
+
+ $count = idx($dict, 'COUNT');
+ if ($count) {
+ $rrule->setCount($count);
+ }
+
+ $until = idx($dict, 'UNTIL');
+ if ($until) {
+ $until = PhutilCalendarAbsoluteDateTime::newFromISO8601($until);
+ $rrule->setUntil($until);
+ }
+
+ return $rrule;
+ }
+
+ public function toRRULE() {
+ $dict = $this->toDictionary();
+
+ $parts = array();
+ foreach ($dict as $key => $value) {
+ if (is_array($value)) {
+ $value = implode(',', $value);
+ }
+ $parts[] = "{$key}={$value}";
+ }
+
+ return implode(';', $parts);
+ }
+
+ public static function newFromRRULE($rrule) {
+ $parts = explode(';', $rrule);
+
+ $dict = array();
+ foreach ($parts as $part) {
+ list($key, $value) = explode('=', $part, 2);
+ switch ($key) {
+ case 'FREQ':
+ case 'INTERVAL':
+ case 'WKST':
+ case 'COUNT':
+ case 'UNTIL';
+ break;
+ default:
+ $value = explode(',', $value);
+ break;
+ }
+ $dict[$key] = $value;
+ }
+
+ $int_lists = array_fuse(
+ array(
+ // NOTE: "BYDAY" is absent, and takes a list like "MO, TU, WE".
+ 'BYSECOND',
+ 'BYMINUTE',
+ 'BYHOUR',
+ 'BYMONTH',
+ 'BYMONTHDAY',
+ 'BYYEARDAY',
+ 'BYWEEKNO',
+ 'BYSETPOS',
+ ));
+
+ $int_values = array_fuse(
+ array(
+ 'COUNT',
+ 'INTERVAL',
+ ));
+
+ foreach ($dict as $key => $value) {
+ if (isset($int_values[$key])) {
+ // None of these values may be negative.
+ if (!preg_match('/^\d+\z/', $value)) {
+ throw new Exception(
+ pht(
+ 'Unexpected value "%s" in "%s" RULE property: expected an '.
+ 'integer.',
+ $value,
+ $key));
+ }
+ $dict[$key] = (int)$value;
+ }
+
+ if (isset($int_lists[$key])) {
+ foreach ($value as $k => $v) {
+ if (!preg_match('/^-?\d+\z/', $v)) {
+ throw new Exception(
+ pht(
+ 'Unexpected value "%s" in "%s" RRULE property: expected '.
+ 'only integers.',
+ $v,
+ $key));
+ }
+ $value[$k] = (int)$v;
+ }
+ $dict[$key] = $value;
+ }
+ }
+
+ return self::newFromDictionary($dict);
+ }
+
+ private static function getAllWeekdayConstants() {
+ return array_keys(self::getWeekdayIndexMap());
+ }
+
+ private static function getWeekdayIndexMap() {
+ static $map = array(
+ self::WEEKDAY_SUNDAY => self::WEEKINDEX_SUNDAY,
+ self::WEEKDAY_MONDAY => self::WEEKINDEX_MONDAY,
+ self::WEEKDAY_TUESDAY => self::WEEKINDEX_TUESDAY,
+ self::WEEKDAY_WEDNESDAY => self::WEEKINDEX_WEDNESDAY,
+ self::WEEKDAY_THURSDAY => self::WEEKINDEX_THURSDAY,
+ self::WEEKDAY_FRIDAY => self::WEEKINDEX_FRIDAY,
+ self::WEEKDAY_SATURDAY => self::WEEKINDEX_SATURDAY,
+ );
+
+ return $map;
+ }
+
+ private static function getWeekdayIndex($weekday) {
+ $map = self::getWeekdayIndexMap();
+ if (!isset($map[$weekday])) {
+ $constants = array_keys($map);
+ throw new Exception(
+ pht(
+ 'Weekday "%s" is not a valid weekday constant. Valid constants '.
+ 'are: %s.',
+ $weekday,
+ implode(', ', $constants)));
+ }
+
+ return $map[$weekday];
+ }
+
+ public function setStartDateTime(PhutilCalendarDateTime $start) {
+ $this->startDateTime = $start;
+ return $this;
+ }
+
+ public function getStartDateTime() {
+ return $this->startDateTime;
+ }
+
+ public function setCount($count) {
+ if ($count < 1) {
+ throw new Exception(
+ pht(
+ 'RRULE COUNT value "%s" is invalid: count must be at least 1.',
+ $count));
+ }
+
+ $this->count = $count;
+ return $this;
+ }
+
+ public function getCount() {
+ return $this->count;
+ }
+
+ public function setUntil(PhutilCalendarDateTime $until) {
+ $this->until = $until;
+ return $this;
+ }
+
+ public function getUntil() {
+ return $this->until;
+ }
+
+ public function setFrequency($frequency) {
+ static $map = array(
+ self::FREQUENCY_SECONDLY => self::SCALE_SECONDLY,
+ self::FREQUENCY_MINUTELY => self::SCALE_MINUTELY,
+ self::FREQUENCY_HOURLY => self::SCALE_HOURLY,
+ self::FREQUENCY_DAILY => self::SCALE_DAILY,
+ self::FREQUENCY_WEEKLY => self::SCALE_WEEKLY,
+ self::FREQUENCY_MONTHLY => self::SCALE_MONTHLY,
+ self::FREQUENCY_YEARLY => self::SCALE_YEARLY,
+ );
+
+ if (empty($map[$frequency])) {
+ throw new Exception(
+ pht(
+ 'RRULE FREQ "%s" is invalid. Valid frequencies are: %s.',
+ $frequency,
+ implode(', ', array_keys($map))));
+ }
+
+ $this->frequency = $frequency;
+ $this->frequencyScale = $map[$frequency];
+
+ return $this;
+ }
+
+ public function getFrequency() {
+ return $this->frequency;
+ }
+
+ public function getFrequencyScale() {
+ return $this->frequencyScale;
+ }
+
+ public function setInterval($interval) {
+ if (!is_int($interval)) {
+ throw new Exception(
+ pht(
+ 'RRULE INTERVAL "%s" is invalid: interval must be an integer.',
+ $interval));
+ }
+
+ if ($interval < 1) {
+ throw new Exception(
+ pht(
+ 'RRULE INTERVAL "%s" is invalid: interval must be 1 or more.',
+ $interval));
+ }
+
+ $this->interval = $interval;
+ return $this;
+ }
+
+ public function getInterval() {
+ return $this->interval;
+ }
+
+ public function setBySecond(array $by_second) {
+ $this->assertByRange('BYSECOND', $by_second, 0, 60);
+ $this->bySecond = array_fuse($by_second);
+ return $this;
+ }
+
+ public function getBySecond() {
+ return $this->bySecond;
+ }
+
+ public function setByMinute(array $by_minute) {
+ $this->assertByRange('BYMINUTE', $by_minute, 0, 59);
+ $this->byMinute = array_fuse($by_minute);
+ return $this;
+ }
+
+ public function getByMinute() {
+ return $this->byMinute;
+ }
+
+ public function setByHour(array $by_hour) {
+ $this->assertByRange('BYHOUR', $by_hour, 0, 23);
+ $this->byHour = array_fuse($by_hour);
+ return $this;
+ }
+
+ public function getByHour() {
+ return $this->byHour;
+ }
+
+ public function setByDay(array $by_day) {
+ $constants = self::getAllWeekdayConstants();
+ $constants = implode('|', $constants);
+
+ $pattern = '/^(?:[+-]?([1-9]\d?))?('.$constants.')\z/';
+ foreach ($by_day as $key => $value) {
+ $matches = null;
+ if (!preg_match($pattern, $value, $matches)) {
+ throw new Exception(
+ pht(
+ 'RRULE BYDAY value "%s" is invalid: rule part must be in the '.
+ 'expected form (like "MO", "-3TH", or "+2SU").',
+ $value));
+ }
+
+ // The maximum allowed value is 53, which corresponds to "the 53rd
+ // Monday every year" or similar when evaluated against a YEARLY rule.
+
+ $maximum = 53;
+ $magnitude = (int)$matches[1];
+ if ($magnitude > $maximum) {
+ throw new Exception(
+ pht(
+ 'RRULE BYDAY value "%s" has an offset with magnitude "%s", but '.
+ 'the maximum permitted value is "%s".',
+ $value,
+ $magnitude,
+ $maximum));
+ }
+
+ // Normalize "+3FR" into "3FR".
+ $by_day[$key] = ltrim($value, '+');
+ }
+
+ $this->byDay = array_fuse($by_day);
+ return $this;
+ }
+
+ public function getByDay() {
+ return $this->byDay;
+ }
+
+ public function setByMonthDay(array $by_month_day) {
+ $this->assertByRange('BYMONTHDAY', $by_month_day, -31, 31, false);
+ $this->byMonthDay = array_fuse($by_month_day);
+ return $this;
+ }
+
+ public function getByMonthDay() {
+ return $this->byMonthDay;
+ }
+
+ public function setByYearDay($by_year_day) {
+ $this->assertByRange('BYYEARDAY', $by_year_day, -366, 366, false);
+ $this->byYearDay = array_fuse($by_year_day);
+ return $this;
+ }
+
+ public function getByYearDay() {
+ return $this->byYearDay;
+ }
+
+ public function setByMonth(array $by_month) {
+ $this->assertByRange('BYMONTH', $by_month, 1, 12);
+ $this->byMonth = array_fuse($by_month);
+ return $this;
+ }
+
+ public function getByMonth() {
+ return $this->byMonth;
+ }
+
+ public function setByWeekNumber(array $by_week_number) {
+ $this->assertByRange('BYWEEKNO', $by_week_number, -53, 53, false);
+ $this->byWeekNumber = array_fuse($by_week_number);
+ return $this;
+ }
+
+ public function getByWeekNumber() {
+ return $this->byWeekNumber;
+ }
+
+ public function setBySetPosition(array $by_set_position) {
+ $this->assertByRange('BYSETPOS', $by_set_position, -366, 366, false);
+ $this->bySetPosition = $by_set_position;
+ return $this;
+ }
+
+ public function getBySetPosition() {
+ return $this->bySetPosition;
+ }
+
+ public function setWeekStart($week_start) {
+ // Make sure this is a valid weekday constant.
+ self::getWeekdayIndex($week_start);
+
+ $this->weekStart = $week_start;
+ return $this;
+ }
+
+ public function getWeekStart() {
+ return $this->weekStart;
+ }
+
+ public function resetSource() {
+ $frequency = $this->getFrequency();
+
+ if ($this->getByMonthDay()) {
+ switch ($frequency) {
+ case self::FREQUENCY_WEEKLY:
+ // RFC5545: "The BYMONTHDAY rule part MUST NOT be specified when the
+ // FREQ rule part is set to WEEKLY."
+ throw new Exception(
+ pht(
+ 'RRULE specifies BYMONTHDAY with FREQ set to WEEKLY, which '.
+ 'violates RFC5545.'));
+ break;
+ default:
+ break;
+ }
+
+ }
+
+ if ($this->getByYearDay()) {
+ switch ($frequency) {
+ case self::FREQUENCY_DAILY:
+ case self::FREQUENCY_WEEKLY:
+ case self::FREQUENCY_MONTHLY:
+ // RFC5545: "The BYYEARDAY rule part MUST NOT be specified when the
+ // FREQ rule part is set to DAILY, WEEKLY, or MONTHLY."
+ throw new Exception(
+ pht(
+ 'RRULE specifies BYYEARDAY with FREQ of DAILY, WEEKLY or '.
+ 'MONTHLY, which violates RFC5545.'));
+ default:
+ break;
+ }
+ }
+
+ // TODO
+ // RFC5545: "The BYDAY rule part MUST NOT be specified with a numeric
+ // value when the FREQ rule part is not set to MONTHLY or YEARLY."
+ // RFC5545: "Furthermore, the BYDAY rule part MUST NOT be specified with a
+ // numeric value with the FREQ rule part set to YEARLY when the BYWEEKNO
+ // rule part is specified."
+
+
+ $date = $this->getStartDateTime();
+
+ $this->cursorSecond = $date->getSecond();
+ $this->cursorMinute = $date->getMinute();
+ $this->cursorHour = $date->getHour();
+
+ $this->cursorDay = $date->getDay();
+ $this->cursorMonth = $date->getMonth();
+ $this->cursorYear = $date->getYear();
+
+ $year_map = $this->getYearMap($this->cursorYear, $this->getWeekStart());
+ $key = $this->cursorMonth.'M'.$this->cursorDay.'D';
+ $this->cursorWeek = $year_map['info'][$key]['week'];
+ $this->cursorWeekday = $year_map['info'][$key]['weekday'];
+
+ $this->setSeconds = array();
+ $this->setMinutes = array();
+ $this->setHours = array();
+ $this->setDays = array();
+ $this->setMonths = array();
+ $this->setYears = array();
+
+ $this->stateSecond = null;
+ $this->stateMinute = null;
+ $this->stateHour = null;
+ $this->stateDay = null;
+ $this->stateWeek = null;
+ $this->stateMonth = null;
+ $this->stateYear = null;
+
+ // If we have a BYSETPOS, we need to generate the entire set before we
+ // can filter it and return results. Normally, we start generating at
+ // the start date, but we need to go back one interval to generate
+ // BYSETPOS events so we can make sure the entire set is generated.
+ if ($this->getBySetPosition()) {
+ $interval = $this->getInterval();
+ switch ($frequency) {
+ case self::FREQUENCY_YEARLY:
+ $this->cursorYear -= $interval;
+ break;
+ case self::FREQUENCY_MONTHLY:
+ $this->cursorMonth -= $interval;
+ $this->rewindMonth();
+ break;
+ case self::FREQUENCY_WEEKLY:
+ $this->cursorWeek -= $interval;
+ $this->rewindWeek();
+ break;
+ case self::FREQUENCY_DAILY:
+ $this->cursorDay -= $interval;
+ $this->rewindDay();
+ break;
+ case self::FREQUENCY_HOURLY:
+ $this->cursorHour -= $interval;
+ $this->rewindHour();
+ break;
+ case self::FREQUENCY_MINUTELY:
+ $this->cursorMinute -= $interval;
+ $this->rewindMinute();
+ break;
+ case self::FREQUENCY_SECONDLY:
+ default:
+ throw new Exception(
+ pht(
+ 'RRULE specifies BYSETPOS with FREQ "%s", but this is invalid.',
+ $frequency));
+ }
+ }
+
+ // We can generate events from before the cursor when evaluating rules
+ // with BYSETPOS or FREQ=WEEKLY.
+ $this->minimumEpoch = $this->getStartDateTime()->getEpoch();
+
+ $cursor_state = array(
+ 'year' => $this->cursorYear,
+ 'month' => $this->cursorMonth,
+ 'week' => $this->cursorWeek,
+ 'day' => $this->cursorDay,
+ 'hour' => $this->cursorHour,
+ );
+
+ $this->cursorDayState = $cursor_state;
+ $this->cursorWeekState = $cursor_state;
+ $this->cursorHourState = $cursor_state;
+
+ $by_hour = $this->getByHour();
+ $by_minute = $this->getByMinute();
+ $by_second = $this->getBySecond();
+
+ $scale = $this->getFrequencyScale();
+
+ // We return all-day events if the start date is an all-day event and we
+ // don't have more granular selectors or a more granular frequency.
+ $this->isAllDay = $date->getIsAllDay()
+ && !$by_hour
+ && !$by_minute
+ && !$by_second
+ && ($scale > self::SCALE_HOURLY);
+ }
+
+ public function getNextEvent($cursor) {
+ while (true) {
+ $event = $this->generateNextEvent();
+ if (!$event) {
+ break;
+ }
+
+ $epoch = $event->getEpoch();
+ if ($this->minimumEpoch) {
+ if ($epoch < $this->minimumEpoch) {
+ continue;
+ }
+ }
+
+ if ($epoch < $cursor) {
+ continue;
+ }
+
+ break;
+ }
+
+ return $event;
+ }
+
+ private function generateNextEvent() {
+ if ($this->activeSet) {
+ return array_pop($this->activeSet);
+ }
+
+ $this->baseYear = $this->cursorYear;
+
+ $by_setpos = $this->getBySetPosition();
+ if ($by_setpos) {
+ $old_state = $this->getSetPositionState();
+ }
+
+ while (!$this->activeSet) {
+ $this->activeSet = $this->nextSet;
+ $this->nextSet = array();
+
+ while (true) {
+ if ($this->isAllDay) {
+ $this->nextDay();
+ } else {
+ $this->nextSecond();
+ }
+
+ $result = id(new PhutilCalendarAbsoluteDateTime())
+ ->setTimezone($this->getStartDateTime()->getTimezone())
+ ->setViewerTimezone($this->getViewerTimezone())
+ ->setYear($this->stateYear)
+ ->setMonth($this->stateMonth)
+ ->setDay($this->stateDay);
+
+ if ($this->isAllDay) {
+ $result->setIsAllDay(true);
+ } else {
+ $result
+ ->setHour($this->stateHour)
+ ->setMinute($this->stateMinute)
+ ->setSecond($this->stateSecond);
+ }
+
+ // If we don't have BYSETPOS, we're all done. We put this into the
+ // set and will immediately return it.
+ if (!$by_setpos) {
+ $this->activeSet[] = $result;
+ break;
+ }
+
+ // Otherwise, check if we've completed a set. The set is complete if
+ // the state has moved past the span we were examining (for example,
+ // with a YEARLY event, if the state is now in the next year).
+ $new_state = $this->getSetPositionState();
+ if ($new_state == $old_state) {
+ $this->activeSet[] = $result;
+ continue;
+ }
+
+ $this->activeSet = $this->applySetPos($this->activeSet, $by_setpos);
+ $this->activeSet = array_reverse($this->activeSet);
+ $this->nextSet[] = $result;
+ $old_state = $new_state;
+ break;
+ }
+ }
+
+ return array_pop($this->activeSet);
+ }
+
+
+ protected function nextSecond() {
+ if ($this->setSeconds) {
+ $this->stateSecond = array_pop($this->setSeconds);
+ return;
+ }
+
+ $frequency = $this->getFrequency();
+ $interval = $this->getInterval();
+ $is_secondly = ($frequency == self::FREQUENCY_SECONDLY);
+ $by_second = $this->getBySecond();
+
+ while (!$this->setSeconds) {
+ $this->nextMinute();
+
+ if ($is_secondly || $by_second) {
+ $seconds = $this->newSecondsSet(
+ ($is_secondly ? $interval : 1),
+ $by_second);
+ } else {
+ $seconds = array(
+ $this->cursorSecond,
+ );
+ }
+
+ $this->setSeconds = array_reverse($seconds);
+ }
+
+ $this->stateSecond = array_pop($this->setSeconds);
+ }
+
+ protected function nextMinute() {
+ if ($this->setMinutes) {
+ $this->stateMinute = array_pop($this->setMinutes);
+ return;
+ }
+
+ $frequency = $this->getFrequency();
+ $interval = $this->getInterval();
+ $scale = $this->getFrequencyScale();
+ $is_minutely = ($frequency === self::FREQUENCY_MINUTELY);
+ $by_minute = $this->getByMinute();
+
+ while (!$this->setMinutes) {
+ $this->nextHour();
+
+ if ($is_minutely || $by_minute) {
+ $minutes = $this->newMinutesSet(
+ ($is_minutely ? $interval : 1),
+ $by_minute);
+ } else if ($scale < self::SCALE_MINUTELY) {
+ $minutes = $this->newMinutesSet(
+ 1,
+ array());
+ } else {
+ $minutes = array(
+ $this->cursorMinute,
+ );
+ }
+
+ $this->setMinutes = array_reverse($minutes);
+ }
+
+ $this->stateMinute = array_pop($this->setMinutes);
+ }
+
+ protected function nextHour() {
+ if ($this->setHours) {
+ $this->stateHour = array_pop($this->setHours);
+ return;
+ }
+
+ $frequency = $this->getFrequency();
+ $interval = $this->getInterval();
+ $scale = $this->getFrequencyScale();
+ $is_hourly = ($frequency === self::FREQUENCY_HOURLY);
+ $by_hour = $this->getByHour();
+
+ while (!$this->setHours) {
+ $this->nextDay();
+
+ $is_dynamic = $is_hourly
+ || $by_hour
+ || ($scale < self::SCALE_HOURLY);
+
+ if ($is_dynamic) {
+ $hours = $this->newHoursSet(
+ ($is_hourly ? $interval : 1),
+ $by_hour);
+ } else {
+ $hours = array(
+ $this->cursorHour,
+ );
+ }
+
+ $this->setHours = array_reverse($hours);
+ }
+
+ $this->stateHour = array_pop($this->setHours);
+ }
+
+ protected function nextDay() {
+ if ($this->setDays) {
+ $info = array_pop($this->setDays);
+ $this->setDayState($info);
+ return;
+ }
+
+ $frequency = $this->getFrequency();
+ $interval = $this->getInterval();
+ $scale = $this->getFrequencyScale();
+ $is_daily = ($frequency === self::FREQUENCY_DAILY);
+ $is_weekly = ($frequency === self::FREQUENCY_WEEKLY);
+
+ $by_day = $this->getByDay();
+ $by_monthday = $this->getByMonthDay();
+ $by_yearday = $this->getByYearDay();
+ $by_weekno = $this->getByWeekNumber();
+ $by_month = $this->getByMonth();
+ $week_start = $this->getWeekStart();
+
+ while (!$this->setDays) {
+ if ($is_weekly) {
+ $this->nextWeek();
+ } else {
+ $this->nextMonth();
+ }
+
+ // NOTE: We normally handle BYMONTH when iterating months, but it acts
+ // like a filter if FREQ=WEEKLY.
+
+ $is_dynamic = $is_daily
+ || $is_weekly
+ || $by_day
+ || $by_monthday
+ || $by_yearday
+ || $by_weekno
+ || ($by_month && $is_weekly)
+ || ($scale < self::SCALE_DAILY);
+
+ if ($is_dynamic) {
+ $weeks = $this->newDaysSet(
+ ($is_daily ? $interval : 1),
+ $by_day,
+ $by_monthday,
+ $by_yearday,
+ $by_weekno,
+ $by_month,
+ $week_start);
+ } else {
+ // The cursor day may not actually exist in the current month, so
+ // make sure the day is valid before we generate a set which contains
+ // it.
+ $year_map = $this->getYearMap($this->stateYear, $week_start);
+ if ($this->cursorDay > $year_map['monthDays'][$this->stateMonth]) {
+ $weeks = array(
+ array(),
+ );
+ } else {
+ $key = $this->stateMonth.'M'.$this->cursorDay.'D';
+ $weeks = array(
+ array($year_map['info'][$key]),
+ );
+ }
+ }
+
+ // Unpack the weeks into days.
+ $days = array_mergev($weeks);
+
+ $this->setDays = array_reverse($days);
+ }
+
+ $info = array_pop($this->setDays);
+ $this->setDayState($info);
+ }
+
+ private function setDayState(array $info) {
+ $this->stateDay = $info['monthday'];
+ $this->stateWeek = $info['week'];
+ $this->stateMonth = $info['month'];
+ }
+
+ protected function nextMonth() {
+ if ($this->setMonths) {
+ $this->stateMonth = array_pop($this->setMonths);
+ return;
+ }
+
+ $frequency = $this->getFrequency();
+ $interval = $this->getInterval();
+ $scale = $this->getFrequencyScale();
+ $is_monthly = ($frequency === self::FREQUENCY_MONTHLY);
+
+ $by_month = $this->getByMonth();
+
+ // If we have a BYMONTHDAY, we consider that set of days in every month.
+ // For example, "FREQ=YEARLY;BYMONTHDAY=3" means "the third day of every
+ // month", so we need to expand the month set if the constraint is present.
+ $by_monthday = $this->getByMonthDay();
+
+ // Likewise, we need to generate all months if we have BYYEARDAY or
+ // BYWEEKNO or BYDAY.
+ $by_yearday = $this->getByYearDay();
+ $by_weekno = $this->getByWeekNumber();
+ $by_day = $this->getByDay();
+
+ while (!$this->setMonths) {
+ $this->nextYear();
+
+ $is_dynamic = $is_monthly
+ || $by_month
+ || $by_monthday
+ || $by_yearday
+ || $by_weekno
+ || $by_day
+ || ($scale < self::SCALE_MONTHLY);
+
+ if ($is_dynamic) {
+ $months = $this->newMonthsSet(
+ ($is_monthly ? $interval : 1),
+ $by_month);
+ } else {
+ $months = array(
+ $this->cursorMonth,
+ );
+ }
+
+ $this->setMonths = array_reverse($months);
+ }
+
+ $this->stateMonth = array_pop($this->setMonths);
+ }
+
+ protected function nextWeek() {
+ if ($this->setWeeks) {
+ $this->stateWeek = array_pop($this->setWeeks);
+ return;
+ }
+
+ $frequency = $this->getFrequency();
+ $interval = $this->getInterval();
+ $scale = $this->getFrequencyScale();
+ $by_weekno = $this->getByWeekNumber();
+
+ while (!$this->setWeeks) {
+ $this->nextYear();
+
+ $weeks = $this->newWeeksSet(
+ $interval,
+ $by_weekno);
+
+ $this->setWeeks = array_reverse($weeks);
+ }
+
+ $this->stateWeek = array_pop($this->setWeeks);
+ }
+
+ protected function nextYear() {
+ $this->stateYear = $this->cursorYear;
+
+ $frequency = $this->getFrequency();
+ $is_yearly = ($frequency === self::FREQUENCY_YEARLY);
+
+ if ($is_yearly) {
+ $interval = $this->getInterval();
+ } else {
+ $interval = 1;
+ }
+
+ $this->cursorYear = $this->cursorYear + $interval;
+
+ if ($this->cursorYear > ($this->baseYear + 100)) {
+ throw new Exception(
+ pht(
+ 'RRULE evaluation failed to generate more events in the next 100 '.
+ 'years. This RRULE is likely invalid or degenerate.'));
+ }
+
+ }
+
+ private function newSecondsSet($interval, $set) {
+ // TODO: This doesn't account for leap seconds. In theory, it probably
+ // should, although this shouldn't impact any real events.
+ $seconds_in_minute = 60;
+
+ if ($this->cursorSecond >= $seconds_in_minute) {
+ $this->cursorSecond -= $seconds_in_minute;
+ return array();
+ }
+
+ list($cursor, $result) = $this->newIteratorSet(
+ $this->cursorSecond,
+ $interval,
+ $set,
+ $seconds_in_minute);
+
+ $this->cursorSecond = ($cursor - $seconds_in_minute);
+
+ return $result;
+ }
+
+ private function newMinutesSet($interval, $set) {
+ // NOTE: This value is legitimately a constant! Amazing!
+ $minutes_in_hour = 60;
+
+ if ($this->cursorMinute >= $minutes_in_hour) {
+ $this->cursorMinute -= $minutes_in_hour;
+ return array();
+ }
+
+ list($cursor, $result) = $this->newIteratorSet(
+ $this->cursorMinute,
+ $interval,
+ $set,
+ $minutes_in_hour);
+
+ $this->cursorMinute = ($cursor - $minutes_in_hour);
+
+ return $result;
+ }
+
+ private function newHoursSet($interval, $set) {
+ // TODO: This doesn't account for hours caused by daylight savings time.
+ // It probably should, although this seems unlikely to impact any real
+ // events.
+ $hours_in_day = 24;
+
+ // If the hour cursor is behind the current time, we need to forward it in
+ // INTERVAL increments so we end up with the right offset.
+ list($skip, $this->cursorHourState) = $this->advanceCursorState(
+ $this->cursorHourState,
+ self::SCALE_HOURLY,
+ $interval,
+ $this->getWeekStart());
+
+ if ($skip) {
+ return array();
+ }
+
+ list($cursor, $result) = $this->newIteratorSet(
+ $this->cursorHour,
+ $interval,
+ $set,
+ $hours_in_day);
+
+ $this->cursorHour = ($cursor - $hours_in_day);
+
+ return $result;
+ }
+
+ private function newWeeksSet($interval, $set) {
+ $week_start = $this->getWeekStart();
+
+ list($skip, $this->cursorWeekState) = $this->advanceCursorState(
+ $this->cursorWeekState,
+ self::SCALE_WEEKLY,
+ $interval,
+ $week_start);
+
+ if ($skip) {
+ return array();
+ }
+
+ $year_map = $this->getYearMap($this->stateYear, $week_start);
+
+ $result = array();
+ while (true) {
+ if (!isset($year_map['weekMap'][$this->cursorWeek])) {
+ break;
+ }
+ $result[] = $this->cursorWeek;
+ $this->cursorWeek += $interval;
+ }
+
+ $this->cursorWeek -= $year_map['weekCount'];
+
+ return $result;
+ }
+
+ private function newDaysSet(
+ $interval_day,
+ $by_day,
+ $by_monthday,
+ $by_yearday,
+ $by_weekno,
+ $by_month,
+ $week_start) {
+
+ $frequency = $this->getFrequency();
+ $is_yearly = ($frequency == self::FREQUENCY_YEARLY);
+ $is_monthly = ($frequency == self::FREQUENCY_MONTHLY);
+ $is_weekly = ($frequency == self::FREQUENCY_WEEKLY);
+
+ $selection = array();
+ if ($is_weekly) {
+ $year_map = $this->getYearMap($this->stateYear, $week_start);
+
+ if (isset($year_map['weekMap'][$this->stateWeek])) {
+ foreach ($year_map['weekMap'][$this->stateWeek] as $key) {
+ $selection[] = $year_map['info'][$key];
+ }
+ }
+ } else {
+ // If the day cursor is behind the current year and month, we need to
+ // forward it in INTERVAL increments so we end up with the right offset
+ // in the current month.
+ list($skip, $this->cursorDayState) = $this->advanceCursorState(
+ $this->cursorDayState,
+ self::SCALE_DAILY,
+ $interval_day,
+ $week_start);
+
+ if (!$skip) {
+ $year_map = $this->getYearMap($this->stateYear, $week_start);
+ while (true) {
+ $month_idx = $this->stateMonth;
+ $month_days = $year_map['monthDays'][$month_idx];
+ if ($this->cursorDay > $month_days) {
+ // NOTE: The year map is now out of date, but we're about to break
+ // out of the loop anyway so it doesn't matter.
+ break;
+ }
+
+ $day_idx = $this->cursorDay;
+
+ $key = "{$month_idx}M{$day_idx}D";
+ $selection[] = $year_map['info'][$key];
+
+ $this->cursorDay += $interval_day;
+ }
+ }
+ }
+
+ // As a special case, BYDAY applies to relative month offsets if BYMONTH
+ // is present in a YEARLY rule.
+ if ($is_yearly) {
+ if ($this->getByMonth()) {
+ $is_yearly = false;
+ $is_monthly = true;
+ }
+ }
+
+ // As a special case, BYDAY makes us examine all week days. This doesn't
+ // check BYMONTHDAY or BYYEARDAY because they are not valid with WEEKLY.
+ $filter_weekday = true;
+ if ($is_weekly) {
+ if ($by_day) {
+ $filter_weekday = false;
+ }
+ }
+
+ $weeks = array();
+ foreach ($selection as $key => $info) {
+ if ($is_weekly) {
+ if ($filter_weekday) {
+ if ($info['weekday'] != $this->cursorWeekday) {
+ continue;
+ }
+ }
+ } else {
+ if ($info['month'] != $this->stateMonth) {
+ continue;
+ }
+ }
+
+ if ($by_day) {
+ if (empty($by_day[$info['weekday']])) {
+ if ($is_yearly) {
+ if (empty($by_day[$info['weekday.yearly']]) &&
+ empty($by_day[$info['-weekday.yearly']])) {
+ continue;
+ }
+ } else if ($is_monthly) {
+ if (empty($by_day[$info['weekday.monthly']]) &&
+ empty($by_day[$info['-weekday.monthly']])) {
+ continue;
+ }
+ } else {
+ continue;
+ }
+ }
+ }
+
+ if ($by_monthday) {
+ if (empty($by_monthday[$info['monthday']]) &&
+ empty($by_monthday[$info['-monthday']])) {
+ continue;
+ }
+ }
+
+ if ($by_yearday) {
+ if (empty($by_yearday[$info['yearday']]) &&
+ empty($by_yearday[$info['-yearday']])) {
+ continue;
+ }
+ }
+
+ if ($by_weekno) {
+ if (empty($by_weekno[$info['week']]) &&
+ empty($by_weekno[$info['-week']])) {
+ continue;
+ }
+ }
+
+ if ($by_month) {
+ if (empty($by_month[$info['month']])) {
+ continue;
+ }
+ }
+
+ $weeks[$info['week']][] = $info;
+ }
+
+ return array_values($weeks);
+ }
+
+ private function newMonthsSet($interval, $set) {
+ // NOTE: This value is also a real constant! Wow!
+ $months_in_year = 12;
+
+ if ($this->cursorMonth > $months_in_year) {
+ $this->cursorMonth -= $months_in_year;
+ return array();
+ }
+
+ list($cursor, $result) = $this->newIteratorSet(
+ $this->cursorMonth,
+ $interval,
+ $set,
+ $months_in_year + 1);
+
+ $this->cursorMonth = ($cursor - $months_in_year);
+
+ return $result;
+ }
+
+ public static function getYearMap($year, $week_start) {
+ static $maps = array();
+
+ $key = "{$year}/{$week_start}";
+ if (isset($maps[$key])) {
+ return $maps[$key];
+ }
+
+ $map = self::newYearMap($year, $week_start);
+ $maps[$key] = $map;
+
+ return $maps[$key];
+ }
+
+ private static function newYearMap($year, $weekday_start) {
+ $weekday_index = self::getWeekdayIndex($weekday_start);
+
+ $is_leap = (($year % 4 === 0) && ($year % 100 !== 0)) ||
+ ($year % 400 === 0);
+
+ // There may be some clever way to figure out which day of the week a given
+ // year starts on and avoid the cost of a DateTime construction, but I
+ // wasn't able to turn it up and we only need to do this once per year.
+ $datetime = new DateTime("{$year}-01-01", new DateTimeZone('UTC'));
+ $weekday = (int)$datetime->format('w');
+
+ if ($is_leap) {
+ $max_day = 366;
+ } else {
+ $max_day = 365;
+ }
+
+ $month_days = array(
+ 1 => 31,
+ 2 => $is_leap ? 29 : 28,
+ 3 => 31,
+ 4 => 30,
+ 5 => 31,
+ 6 => 30,
+ 7 => 31,
+ 8 => 31,
+ 9 => 30,
+ 10 => 31,
+ 11 => 30,
+ 12 => 31,
+ );
+
+ // Per the spec, the first week of the year must contain at least four
+ // days. If the week starts on a Monday but the year starts on a Saturday,
+ // the first couple of days don't count as a week. In this case, the first
+ // week will begin on January 3.
+ $first_week_size = 0;
+ $first_weekday = $weekday;
+ for ($year_day = 1; $year_day <= $max_day; $year_day++) {
+ $first_weekday = ($first_weekday + 1) % 7;
+ $first_week_size++;
+ if ($first_weekday === $weekday_index) {
+ break;
+ }
+ }
+
+ if ($first_week_size >= 4) {
+ $week_number = 1;
+ } else {
+ $week_number = 0;
+ }
+
+ $info_map = array();
+
+ $weekday_map = self::getWeekdayIndexMap();
+ $weekday_map = array_flip($weekday_map);
+
+ $yearly_counts = array();
+ $monthly_counts = array();
+
+ $month_number = 1;
+ $month_day = 1;
+ for ($year_day = 1; $year_day <= $max_day; $year_day++) {
+ $key = "{$month_number}M{$month_day}D";
+
+ $short_day = $weekday_map[$weekday];
+ if (empty($yearly_counts[$short_day])) {
+ $yearly_counts[$short_day] = 0;
+ }
+ $yearly_counts[$short_day]++;
+
+ if (empty($monthly_counts[$month_number][$short_day])) {
+ $monthly_counts[$month_number][$short_day] = 0;
+ }
+ $monthly_counts[$month_number][$short_day]++;
+
+ $info = array(
+ 'year' => $year,
+ 'key' => $key,
+ 'month' => $month_number,
+ 'monthday' => $month_day,
+ '-monthday' => -$month_days[$month_number] + $month_day - 1,
+ 'yearday' => $year_day,
+ '-yearday' => -$max_day + $year_day - 1,
+ 'week' => $week_number,
+ 'weekday' => $short_day,
+ 'weekday.yearly' => $yearly_counts[$short_day],
+ 'weekday.monthly' => $monthly_counts[$month_number][$short_day],
+ );
+
+ $info_map[$key] = $info;
+
+ $weekday = ($weekday + 1) % 7;
+ if ($weekday === $weekday_index) {
+ $week_number++;
+ }
+
+ $month_day = ($month_day + 1);
+ if ($month_day > $month_days[$month_number]) {
+ $month_day = 1;
+ $month_number++;
+ }
+ }
+
+ // Check how long the final week is. If it doesn't have four days, this
+ // is really the first week of the next year.
+ $final_week = array();
+ foreach ($info_map as $key => $info) {
+ if ($info['week'] == $week_number) {
+ $final_week[] = $key;
+ }
+ }
+
+ if (count($final_week) < 4) {
+ $week_number = $week_number - 1;
+ $next_year = self::getYearMap($year + 1, $weekday_start);
+ $next_year_weeks = $next_year['weekCount'];
+ } else {
+ $next_year_weeks = null;
+ }
+
+ if ($first_week_size < 4) {
+ $last_year = self::getYearMap($year - 1, $weekday_start);
+ $last_year_weeks = $last_year['weekCount'];
+ } else {
+ $last_year_weeks = null;
+ }
+
+ // Now that we know how many weeks the year has, we can compute the
+ // negative offsets.
+ foreach ($info_map as $key => $info) {
+ $week = $info['week'];
+
+ if ($week === 0) {
+ // If this day is part of the first partial week of the year, give
+ // it the week number of the last week of the prior year instead.
+ $info['week'] = $last_year_weeks;
+ $info['-week'] = -1;
+ } else if ($week > $week_number) {
+ // If this day is part of the last partial week of the year, give
+ // it week numbers from the next year.
+ $info['week'] = 1;
+ $info['-week'] = -$next_year_weeks;
+ } else {
+ $info['-week'] = -$week_number + $week - 1;
+ }
+
+ // Do all the arithmetic to figure out if this is the -19th Thursday
+ // in the year and such.
+ $month_number = $info['month'];
+ $short_day = $info['weekday'];
+ $monthly_count = $monthly_counts[$month_number][$short_day];
+ $monthly_index = $info['weekday.monthly'];
+ $info['-weekday.monthly'] = -$monthly_count + $monthly_index - 1;
+ $info['-weekday.monthly'] .= $short_day;
+ $info['weekday.monthly'] .= $short_day;
+
+ $yearly_count = $yearly_counts[$short_day];
+ $yearly_index = $info['weekday.yearly'];
+ $info['-weekday.yearly'] = -$yearly_count + $yearly_index - 1;
+ $info['-weekday.yearly'] .= $short_day;
+ $info['weekday.yearly'] .= $short_day;
+
+ $info_map[$key] = $info;
+ }
+
+ $week_map = array();
+ foreach ($info_map as $key => $info) {
+ $week_map[$info['week']][] = $key;
+ }
+
+ return array(
+ 'info' => $info_map,
+ 'weekCount' => $week_number,
+ 'dayCount' => $max_day,
+ 'monthDays' => $month_days,
+ 'weekMap' => $week_map,
+ );
+ }
+
+ private function newIteratorSet($cursor, $interval, $set, $limit) {
+ if ($interval < 1) {
+ throw new Exception(
+ pht(
+ 'Invalid iteration interval ("%d"), must be at least 1.',
+ $interval));
+ }
+
+ $result = array();
+ $seen = array();
+
+ $ii = $cursor;
+ while (true) {
+ if (!$set || isset($set[$ii])) {
+ $result[] = $ii;
+ }
+
+ $ii = ($ii + $interval);
+
+ if ($ii >= $limit) {
+ break;
+ }
+ }
+
+ sort($result);
+ $result = array_values($result);
+
+ return array($ii, $result);
+ }
+
+ private function applySetPos(array $values, array $setpos) {
+ $select = array();
+
+ $count = count($values);
+ foreach ($setpos as $pos) {
+ if ($pos > 0 && $pos <= $count) {
+ $select[] = ($pos - 1);
+ } else if ($pos < 0 && $pos >= -$count) {
+ $select[] = ($count + $pos);
+ }
+ }
+
+ sort($select);
+ $select = array_unique($select);
+
+ return array_select_keys($values, $select);
+ }
+
+ private function assertByRange(
+ $source,
+ array $values,
+ $min,
+ $max,
+ $allow_zero = true) {
+
+ foreach ($values as $value) {
+ if (!is_int($value)) {
+ throw new Exception(
+ pht(
+ 'Value "%s" in RRULE "%s" parameter is invalid: values must be '.
+ 'integers.',
+ $value,
+ $source));
+ }
+
+ if ($value < $min || $value > $max) {
+ throw new Exception(
+ pht(
+ 'Value "%s" in RRULE "%s" parameter is invalid: it must be '.
+ 'between %s and %s.',
+ $value,
+ $source,
+ $min,
+ $max));
+ }
+
+ if (!$value && !$allow_zero) {
+ throw new Exception(
+ pht(
+ 'Value "%s" in RRULE "%s" parameter is invalid: it must not '.
+ 'be zero.',
+ $value,
+ $source));
+ }
+ }
+ }
+
+ private function getSetPositionState() {
+ $scale = $this->getFrequencyScale();
+
+ $parts = array();
+ $parts[] = $this->stateYear;
+
+ if ($scale == self::SCALE_WEEKLY) {
+ $parts[] = $this->stateWeek;
+ } else {
+ if ($scale < self::SCALE_YEARLY) {
+ $parts[] = $this->stateMonth;
+ }
+ if ($scale < self::SCALE_MONTHLY) {
+ $parts[] = $this->stateDay;
+ }
+ if ($scale < self::SCALE_DAILY) {
+ $parts[] = $this->stateHour;
+ }
+ if ($scale < self::SCALE_HOURLY) {
+ $parts[] = $this->stateMinute;
+ }
+ }
+
+ return implode('/', $parts);
+ }
+
+ private function rewindMonth() {
+ while ($this->cursorMonth < 1) {
+ $this->cursorYear--;
+ $this->cursorMonth += 12;
+ }
+ }
+
+ private function rewindWeek() {
+ $week_start = $this->getWeekStart();
+ while ($this->cursorWeek < 1) {
+ $this->cursorYear--;
+ $year_map = $this->getYearMap($this->cursorYear, $week_start);
+ $this->cursorWeek += $year_map['weekCount'];
+ }
+ }
+
+ private function rewindDay() {
+ $week_start = $this->getWeekStart();
+ while ($this->cursorDay < 1) {
+ $year_map = $this->getYearMap($this->cursorYear, $week_start);
+ $this->cursorDay += $year_map['monthDays'][$this->cursorMonth];
+ $this->cursorMonth--;
+ $this->rewindMonth();
+ }
+ }
+
+ private function rewindHour() {
+ while ($this->cursorHour < 0) {
+ $this->cursorHour += 24;
+ $this->cursorDay--;
+ $this->rewindDay();
+ }
+ }
+
+ private function rewindMinute() {
+ while ($this->cursorMinute < 0) {
+ $this->cursorMinute += 60;
+ $this->cursorHour--;
+ $this->rewindHour();
+ }
+ }
+
+ private function advanceCursorState(
+ array $cursor,
+ $scale,
+ $interval,
+ $week_start) {
+
+ $state = array(
+ 'year' => $this->stateYear,
+ 'month' => $this->stateMonth,
+ 'week' => $this->stateWeek,
+ 'day' => $this->stateDay,
+ 'hour' => $this->stateHour,
+ );
+
+ // In the common case when the interval is 1, we'll visit every possible
+ // value so we don't need to do any math and can just jump to the first
+ // hour, day, etc.
+ if ($interval == 1) {
+ if ($this->isCursorBehind($cursor, $state, $scale)) {
+ switch ($scale) {
+ case self::SCALE_DAILY:
+ $this->cursorDay = 1;
+ break;
+ case self::SCALE_HOURLY:
+ $this->cursorHour = 0;
+ break;
+ case self::SCALE_WEEKLY:
+ $this->cursorWeek = 1;
+ break;
+ }
+ }
+
+ return array(false, $state);
+ }
+
+ $year_map = $this->getYearMap($cursor['year'], $week_start);
+ while ($this->isCursorBehind($cursor, $state, $scale)) {
+ switch ($scale) {
+ case self::SCALE_DAILY:
+ $cursor['day'] += $interval;
+ break;
+ case self::SCALE_HOURLY:
+ $cursor['hour'] += $interval;
+ break;
+ case self::SCALE_WEEKLY:
+ $cursor['week'] += $interval;
+ break;
+ }
+
+ if ($scale <= self::SCALE_HOURLY) {
+ while ($cursor['hour'] >= 24) {
+ $cursor['hour'] -= 24;
+ $cursor['day']++;
+ }
+ }
+
+ if ($scale == self::SCALE_WEEKLY) {
+ while ($cursor['week'] > $year_map['weekCount']) {
+ $cursor['week'] -= $year_map['weekCount'];
+ $cursor['year']++;
+ $year_map = $this->getYearMap($cursor['year'], $week_start);
+ }
+ }
+
+ if ($scale <= self::SCALE_DAILY) {
+ while ($cursor['day'] > $year_map['monthDays'][$cursor['month']]) {
+ $cursor['day'] -= $year_map['monthDays'][$cursor['month']];
+ $cursor['month']++;
+ if ($cursor['month'] > 12) {
+ $cursor['month'] -= 12;
+ $cursor['year']++;
+ $year_map = $this->getYearMap($cursor['year'], $week_start);
+ }
+ }
+ }
+ }
+
+ switch ($scale) {
+ case self::SCALE_DAILY:
+ $this->cursorDay = $cursor['day'];
+ break;
+ case self::SCALE_HOURLY:
+ $this->cursorHour = $cursor['hour'];
+ break;
+ case self::SCALE_WEEKLY:
+ $this->cursorWeek = $cursor['week'];
+ break;
+ }
+
+ $skip = $this->isCursorBehind($state, $cursor, $scale);
+
+ return array($skip, $cursor);
+ }
+
+ private function isCursorBehind(array $cursor, array $state, $scale) {
+ if ($cursor['year'] < $state['year']) {
+ return true;
+ } else if ($cursor['year'] > $state['year']) {
+ return false;
+ }
+
+ if ($scale == self::SCALE_WEEKLY) {
+ return false;
+ }
+
+ if ($cursor['month'] < $state['month']) {
+ return true;
+ } else if ($cursor['month'] > $state['month']) {
+ return false;
+ }
+
+ if ($scale >= self::SCALE_DAILY) {
+ return false;
+ }
+
+ if ($cursor['day'] < $state['day']) {
+ return true;
+ } else if ($cursor['day'] > $state['day']) {
+ return false;
+ }
+
+ if ($scale >= self::SCALE_HOURLY) {
+ return false;
+ }
+
+ if ($cursor['hour'] < $state['hour']) {
+ return true;
+ } else if ($cursor['hour'] > $state['hour']) {
+ return false;
+ }
+
+ return false;
+ }
+
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarRecurrenceSet.php b/src/parser/calendar/data/PhutilCalendarRecurrenceSet.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarRecurrenceSet.php
@@ -0,0 +1,162 @@
+sources[] = $source;
+ return $this;
+ }
+
+ public function setViewerTimezone($viewer_timezone) {
+ $this->viewerTimezone = $viewer_timezone;
+ return $this;
+ }
+
+ public function getViewerTimezone() {
+ return $this->viewerTimezone;
+ }
+
+ public function getEventsBetween(
+ PhutilCalendarDateTime $start = null,
+ PhutilCalendarDateTime $end = null,
+ $limit = null) {
+
+ if ($end === null && $limit === null) {
+ throw new Exception(
+ pht(
+ 'Recurring event range queries must have an end date, a limit, or '.
+ 'both.'));
+ }
+
+ $timezone = $this->getViewerTimezone();
+
+ $sources = array();
+ foreach ($this->sources as $source) {
+ $source = clone $source;
+ $source->setViewerTimezone($timezone);
+ $source->resetSource();
+
+ $sources[] = array(
+ 'source' => $source,
+ 'state' => null,
+ 'epoch' => null,
+ );
+ }
+
+ if ($start) {
+ $start = clone $start;
+ $start->setViewerTimezone($timezone);
+ $min_epoch = $start->getEpoch();
+ } else {
+ $min_epoch = 0;
+ }
+
+ if ($end) {
+ $end = clone $end;
+ $end->setViewerTimezone($timezone);
+ $end_epoch = $end->getEpoch();
+ } else {
+ $end_epoch = null;
+ }
+
+ $results = array();
+ $index = 0;
+ $cursor = 0;
+ while (true) {
+ // Get the next event for each source which we don't have a future
+ // event for.
+ foreach ($sources as $key => $source) {
+ $state = $source['state'];
+ $epoch = $source['epoch'];
+
+ if ($state !== null && $epoch >= $cursor) {
+ // We have an event for this source, and it's a future event, so
+ // we don't need to do anything.
+ continue;
+ }
+
+ $next = $source['source']->getNextEvent($cursor);
+ if ($next === null) {
+ // This source doesn't have any more events, so we're all done.
+ unset($sources[$key]);
+ continue;
+ }
+
+ $next_epoch = $next->getEpoch();
+
+ if ($end_epoch !== null && $next_epoch > $end_epoch) {
+ // We have an end time and the next event from this source is
+ // past that end, so we know there are no more relevant events
+ // coming from this source.
+ unset($sources[$key]);
+ continue;
+ }
+
+ $sources[$key]['state'] = $next;
+ $sources[$key]['epoch'] = $next_epoch;
+ }
+
+ if (!$sources) {
+ // We've run out of sources which can produce valid events in the
+ // window, so we're all done.
+ break;
+ }
+
+ // Find the minimum event time across all sources.
+ $next_epoch = null;
+ foreach ($sources as $source) {
+ if ($next_epoch === null) {
+ $next_epoch = $source['epoch'];
+ } else {
+ $next_epoch = min($next_epoch, $source['epoch']);
+ }
+ }
+
+ $is_exception = false;
+ $next_source = null;
+ foreach ($sources as $source) {
+ if ($source['epoch'] == $next_epoch) {
+ if ($source['source']->getIsExceptionSource()) {
+ $is_exception = true;
+ } else {
+ $next_source = $source;
+ }
+ }
+ }
+
+ // If this is an exception, it means the event does NOT occur. We
+ // skip it and move on. If it's not an exception, it does occur, so
+ // we record it.
+ if (!$is_exception) {
+
+ // Only actually include this event in the results if it starts after
+ // any specified start time. We increment the index regardless, so we
+ // return results with proper offsets.
+ if ($next_source['epoch'] >= $min_epoch) {
+ $results[$index] = $next_source['state'];
+ }
+ $index++;
+
+ if ($limit !== null && (count($results) >= $limit)) {
+ break;
+ }
+ }
+
+ $cursor = $next_epoch + 1;
+
+ // If we have an end of the window and we've reached it, we're done.
+ if ($end_epoch) {
+ if ($cursor > $end_epoch) {
+ break;
+ }
+ }
+ }
+
+ return $results;
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarRecurrenceSource.php b/src/parser/calendar/data/PhutilCalendarRecurrenceSource.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarRecurrenceSource.php
@@ -0,0 +1,34 @@
+isExceptionSource = $is_exception_source;
+ return $this;
+ }
+
+ public function getIsExceptionSource() {
+ return $this->isExceptionSource;
+ }
+
+ public function setViewerTimezone($viewer_timezone) {
+ $this->viewerTimezone = $viewer_timezone;
+ return $this;
+ }
+
+ public function getViewerTimezone() {
+ return $this->viewerTimezone;
+ }
+
+ public function resetSource() {
+ return;
+ }
+
+ abstract public function getNextEvent($cursor);
+
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarRelativeDateTime.php b/src/parser/calendar/data/PhutilCalendarRelativeDateTime.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarRelativeDateTime.php
@@ -0,0 +1,74 @@
+setProxy($origin);
+ }
+
+ public function getOrigin() {
+ return $this->getProxy();
+ }
+
+ public function setDuration(PhutilCalendarDuration $duration) {
+ $this->duration = $duration;
+ return $this;
+ }
+
+ public function getDuration() {
+ return $this->duration;
+ }
+
+ public function newPHPDateTime() {
+ $datetime = parent::newPHPDateTime();
+ $duration = $this->getDuration();
+
+ if ($duration->getIsNegative()) {
+ $sign = '-';
+ } else {
+ $sign = '+';
+ }
+
+ $map = array(
+ 'weeks' => $duration->getWeeks(),
+ 'days' => $duration->getDays(),
+ 'hours' => $duration->getHours(),
+ 'minutes' => $duration->getMinutes(),
+ 'seconds' => $duration->getSeconds(),
+ );
+
+ foreach ($map as $unit => $value) {
+ if (!$value) {
+ continue;
+ }
+ $datetime->modify("{$sign}{$value} {$unit}");
+ }
+
+ return $datetime;
+ }
+
+ public function newAbsoluteDateTime() {
+ $clone = clone $this;
+
+ if ($clone->getTimezone()) {
+ $clone->setViewerTimezone(null);
+ }
+
+ $datetime = $clone->newPHPDateTime();
+
+ return id(new PhutilCalendarAbsoluteDateTime())
+ ->setYear((int)$datetime->format('Y'))
+ ->setMonth((int)$datetime->format('m'))
+ ->setDay((int)$datetime->format('d'))
+ ->setHour((int)$datetime->format('H'))
+ ->setMinute((int)$datetime->format('i'))
+ ->setSecond((int)$datetime->format('s'))
+ ->setIsAllDay($clone->getIsAllDay())
+ ->setTimezone($clone->getTimezone())
+ ->setViewerTimezone($this->getViewerTimezone());
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarRootNode.php b/src/parser/calendar/data/PhutilCalendarRootNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarRootNode.php
@@ -0,0 +1,12 @@
+getChildrenOfType(PhutilCalendarDocumentNode::NODETYPE);
+ }
+
+}
diff --git a/src/parser/calendar/data/PhutilCalendarUserNode.php b/src/parser/calendar/data/PhutilCalendarUserNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/PhutilCalendarUserNode.php
@@ -0,0 +1,40 @@
+name = $name;
+ return $this;
+ }
+
+ public function getName() {
+ return $this->name;
+ }
+
+ public function setURI($uri) {
+ $this->uri = $uri;
+ return $this;
+ }
+
+ public function getURI() {
+ return $this->uri;
+ }
+
+ public function setStatus($status) {
+ $this->status = $status;
+ return $this;
+ }
+
+ public function getStatus() {
+ return $this->status;
+ }
+
+}
diff --git a/src/parser/calendar/data/__tests__/PhutilCalendarDateTimeTestCase.php b/src/parser/calendar/data/__tests__/PhutilCalendarDateTimeTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/__tests__/PhutilCalendarDateTimeTestCase.php
@@ -0,0 +1,49 @@
+setTimezone('America/Los_Angeles')
+ ->setViewerTimezone('America/Chicago')
+ ->setIsAllDay(true);
+
+ $this->assertEqual(
+ '20161128',
+ $start->getISO8601());
+
+ $end = $start
+ ->newAbsoluteDateTime()
+ ->setHour(0)
+ ->setMinute(0)
+ ->setSecond(0)
+ ->newRelativeDateTime('P1D')
+ ->newAbsoluteDateTime();
+
+ $this->assertEqual(
+ '20161129',
+ $end->getISO8601());
+
+ // This is a date which explicitly has no specified timezone.
+ $start = PhutilCalendarAbsoluteDateTime::newFromISO8601('20161128', null)
+ ->setViewerTimezone('UTC');
+
+ $this->assertEqual(
+ '20161128',
+ $start->getISO8601());
+
+ $end = $start
+ ->newAbsoluteDateTime()
+ ->setHour(0)
+ ->setMinute(0)
+ ->setSecond(0)
+ ->newRelativeDateTime('P1D')
+ ->newAbsoluteDateTime();
+
+ $this->assertEqual(
+ '20161129',
+ $end->getISO8601());
+ }
+
+
+}
diff --git a/src/parser/calendar/data/__tests__/PhutilCalendarRecurrenceRuleTestCase.php b/src/parser/calendar/data/__tests__/PhutilCalendarRecurrenceRuleTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/__tests__/PhutilCalendarRecurrenceRuleTestCase.php
@@ -0,0 +1,1750 @@
+setStartDateTime($start)
+ ->setFrequency(PhutilCalendarRecurrenceRule::FREQUENCY_DAILY);
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($rrule);
+
+ $result = $set->getEventsBetween(null, null, 3);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ );
+
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Simple daily event.'));
+
+
+
+ $rrule = id(new PhutilCalendarRecurrenceRule())
+ ->setStartDateTime($start)
+ ->setFrequency(PhutilCalendarRecurrenceRule::FREQUENCY_HOURLY)
+ ->setByHour(array(12, 13));
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($rrule);
+
+ $result = $set->getEventsBetween(null, null, 5);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T130000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T130000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ );
+
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Hourly event with BYHOUR.'));
+
+
+ $rrule = id(new PhutilCalendarRecurrenceRule())
+ ->setStartDateTime($start)
+ ->setFrequency(PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY);
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($rrule);
+
+ $result = $set->getEventsBetween(null, null, 2);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20170101T120000Z'),
+ );
+
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Yearly event.'));
+
+
+ // This is an efficiency test for bizarre rules: it defines a secondly
+ // event which only occurs one a year, and generates 3 instances of it.
+ // This implementation should be fast enough that this test doesn't take
+ // a significant amount of time.
+
+ $rrule = id(new PhutilCalendarRecurrenceRule())
+ ->setStartDateTime($start)
+ ->setFrequency(PhutilCalendarRecurrenceRule::FREQUENCY_SECONDLY)
+ ->setByMonth(array(1))
+ ->setByMonthDay(array(1))
+ ->setByHour(array(12))
+ ->setByMinute(array(0))
+ ->setBySecond(array(0));
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($rrule);
+
+ $result = $set->getEventsBetween(null, null, 3);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20170101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20180101T120000Z'),
+ );
+
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Secondly event with many constraints.'));
+ }
+
+ public function testYearlyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array();
+ $expect[] = array(
+ '19970902',
+ '19980902',
+ '19990902',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902',
+ '19990902',
+ '20010902',
+ );
+
+ $tests[] = array(
+ 'DTSTART' => '20000229',
+ );
+ $expect[] = array(
+ '20000229',
+ '20040229',
+ '20080229',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980102',
+ '19980302',
+ '19990102',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ );
+ $expect[] = array(
+ '19970903',
+ '19971001',
+ '19971003',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYMONTHDAY' => array(5, 7),
+ );
+ $expect[] = array(
+ '19980105',
+ '19980107',
+ '19980305',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19970902',
+ '19970904',
+ '19970909',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('SU'),
+ );
+ $expect[] = array(
+ '19970907',
+ '19970914',
+ '19970921',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980106',
+ '19980108',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980203',
+ '19980303',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980303',
+ '20010301',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('1TU', '-1TH'),
+ );
+ $expect[] = array(
+ '19971225',
+ '19980106',
+ '19981231',
+ );
+
+ // Same test as above, just making sure the optional "+" syntax works.
+ $tests[] = array(
+ 'BYDAY' => array('+1TU', '-1TH'),
+ );
+ $expect[] = array(
+ '19971225',
+ '19980106',
+ '19981231',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('3TU', '-3TH'),
+ );
+ $expect[] = array(
+ '19971211',
+ '19980120',
+ '19981217',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('1TU', '-1TH'),
+ );
+ $expect[] = array(
+ '19980106',
+ '19980129',
+ '19980303',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('3TU', '-3TH'),
+ );
+ $expect[] = array(
+ '19980115',
+ '19980120',
+ '19980312',
+ );
+
+ $tests[] = array(
+ 'BYYEARDAY' => array(1, 100, 200, 365),
+ 'COUNT' => 4,
+ );
+ $expect[] = array(
+ '19971231',
+ '19980101',
+ '19980410',
+ '19980719',
+ );
+
+ $tests[] = array(
+ 'BYYEARDAY' => array(-365, -266, -166, -1),
+ 'COUNT' => 4,
+ );
+ $expect[] = array(
+ '19971231',
+ '19980101',
+ '19980410',
+ '19980719',
+ );
+
+ $tests[] = array(
+ 'BYYEARDAY' => array(1, 100, 200, 365),
+ 'BYMONTH' => array(4, 7),
+ 'COUNT' => 4,
+ );
+ $expect[] = array(
+ '19980410',
+ '19980719',
+ '19990410',
+ '19990719',
+ );
+
+ $tests[] = array(
+ 'BYYEARDAY' => array(-365, -266, -166, -1),
+ 'BYMONTH' => array(4, 7),
+ 'COUNT' => 4,
+ );
+ $expect[] = array(
+ '19980410',
+ '19980719',
+ '19990410',
+ '19990719',
+ );
+
+ $tests[] = array(
+ 'BYWEEKNO' => array(20),
+ );
+ $expect[] = array(
+ '19980511',
+ '19980512',
+ '19980513',
+ );
+
+ $tests[] = array(
+ 'BYWEEKNO' => array(1),
+ 'BYDAY' => array('MO'),
+ );
+ $expect[] = array(
+ '19971229',
+ '19990104',
+ '20000103',
+ );
+
+ $tests[] = array(
+ 'BYWEEKNO' => array(52),
+ 'BYDAY' => array('SU'),
+ );
+ $expect[] = array(
+ '19971228',
+ '19981227',
+ '20000102',
+ );
+
+ $tests[] = array(
+ 'BYWEEKNO' => array(-1),
+ 'BYDAY' => array('SU'),
+ );
+ $expect[] = array(
+ '19971228',
+ '19990103',
+ '20000102',
+ );
+
+ $tests[] = array(
+ 'BYWEEKNO' => array(53),
+ 'BYDAY' => array('MO'),
+ );
+ $expect[] = array(
+ '19981228',
+ '20041227',
+ '20091228',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T060000Z',
+ '19970902T180000Z',
+ '19980902T060000Z',
+ );
+
+ $tests[] = array(
+ 'BYMINUTE' => array(15, 30),
+ );
+ $expect[] = array(
+ '19970902T001500Z',
+ '19970902T003000Z',
+ '19980902T001500Z',
+ );
+
+ $tests[] = array(
+ 'BYSECOND' => array(10, 20),
+ );
+ $expect[] = array(
+ '19970902T000010Z',
+ '19970902T000020Z',
+ '19980902T000010Z',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ 'BYMINUTE' => array(15, 30),
+ );
+ $expect[] = array(
+ '19970902T061500Z',
+ '19970902T063000Z',
+ '19970902T181500Z',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ 'BYSECOND' => array(10, 20),
+ );
+ $expect[] = array(
+ '19970902T060010Z',
+ '19970902T060020Z',
+ '19970902T180010Z',
+ );
+
+ $tests[] = array(
+ 'BYMINUTE' => array(15, 30),
+ 'BYSECOND' => array(10, 20),
+ );
+ $expect[] = array(
+ '19970902T001510Z',
+ '19970902T001520Z',
+ '19970902T003010Z',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ 'BYMINUTE' => array(15, 30),
+ 'BYSECOND' => array(10, 20),
+ );
+ $expect[] = array(
+ '19970902T061510Z',
+ '19970902T061520Z',
+ '19970902T063010Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(15),
+ 'BYHOUR' => array(6, 18),
+ 'BYSETPOS' => array(3, -3),
+ );
+ $expect[] = array(
+ '19971115T180000Z',
+ '19980215T060000Z',
+ '19981115T180000Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'YEARLY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testMonthlyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array();
+ $expect[] = array(
+ '19970902',
+ '19971002',
+ '19971102',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902',
+ '19971102',
+ '19980102',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 18,
+ );
+ $expect[] = array(
+ '19970902',
+ '19990302',
+ '20000902',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980102',
+ '19980302',
+ '19990102',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ );
+ $expect[] = array(
+ '19970903',
+ '19971001',
+ '19971003',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(5, 7),
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980105',
+ '19980107',
+ '19980305',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19970902',
+ '19970904',
+ '19970909',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('3MO'),
+ );
+ $expect[] = array(
+ '19970915',
+ '19971020',
+ '19971117',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('1TU', '-1TH'),
+ );
+ $expect[] = array(
+ '19970902',
+ '19970925',
+ '19971007',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('3TU', '-3TH'),
+ );
+ $expect[] = array(
+ '19970911',
+ '19970916',
+ '19971016',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980106',
+ '19980108',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('1TU', '-1TH'),
+ );
+ $expect[] = array(
+ '19980106',
+ '19980129',
+ '19980303',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('3TU', '-3TH'),
+ );
+ $expect[] = array(
+ '19980115',
+ '19980120',
+ '19980312',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980203',
+ '19980303',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980303',
+ '20010301',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('MO', 'TU', 'WE', 'TH', 'FR'),
+ 'BYSETPOS' => array(-1),
+ );
+ $expect[] = array(
+ '19970930',
+ '19971031',
+ '19971128',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('1MO', '1TU', '1WE', '1TH', '1FR', '-1FR'),
+ 'BYMONTHDAY' => array(1, -1, -2),
+ );
+ $expect[] = array(
+ '19971001',
+ '19971031',
+ '19971201',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('1MO', '1TU', '1WE', '1TH', 'FR'),
+ 'BYMONTHDAY' => array(1, -1, -2),
+ );
+ $expect[] = array(
+ '19971001',
+ '19971031',
+ '19971201',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T060000Z',
+ '19970902T180000Z',
+ '19971002T060000Z',
+ );
+
+ $tests[] = array(
+ 'BYMINUTE' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T000600Z',
+ '19970902T001800Z',
+ '19971002T000600Z',
+ );
+
+ $tests[] = array(
+ 'BYSECOND' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T000006Z',
+ '19970902T000018Z',
+ '19971002T000006Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(13, 17),
+ 'BYHOUR' => array(6, 18),
+ 'BYSETPOS' => array(3, -3),
+ );
+ $expect[] = array(
+ '19970913T180000Z',
+ '19970917T060000Z',
+ '19971013T180000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(13, 17),
+ 'BYHOUR' => array(6, 18),
+ 'BYSETPOS' => array(3, 3, -3),
+ );
+ $expect[] = array(
+ '19970913T180000Z',
+ '19970917T060000Z',
+ '19971013T180000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(13, 17),
+ 'BYHOUR' => array(6, 18),
+ 'BYSETPOS' => array(4, -1),
+ );
+ $expect[] = array(
+ '19970917T180000Z',
+ '19971017T180000Z',
+ '19971117T180000Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testWeeklyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array();
+ $expect[] = array(
+ '19970902',
+ '19970909',
+ '19970916',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902',
+ '19970916',
+ '19970930',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 20,
+ );
+ $expect[] = array(
+ '19970902',
+ '19980120',
+ '19980609',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980106',
+ '19980113',
+ '19980120',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19970902',
+ '19970904',
+ '19970909',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980106',
+ '19980108',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T060000Z',
+ '19970902T180000Z',
+ '19970909T060000Z',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ 'BYHOUR' => array(6, 18),
+ 'BYSETPOS' => array(3, -3),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T180000Z',
+ '19970904T060000Z',
+ '19970909T180000Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'WEEKLY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testDailyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array();
+ $expect[] = array(
+ '19970902',
+ '19970903',
+ '19970904',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902',
+ '19970904',
+ '19970906',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 92,
+ );
+ $expect[] = array(
+ '19970902',
+ '19971203',
+ '19980305',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980102',
+ '19980103',
+ );
+
+ // This is testing that INTERVAL is respected in the presence of a BYMONTH
+ // filter which skips some months.
+ $tests[] = array(
+ 'BYMONTH' => array(12),
+ 'INTERVAL' => 17,
+ );
+ $expect[] = array(
+ '19971213',
+ '19971230',
+ '19981205',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ );
+ $expect[] = array(
+ '19970903',
+ '19971001',
+ '19971003',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYMONTHDAY' => array(5, 7),
+ );
+ $expect[] = array(
+ '19980105',
+ '19980107',
+ '19980305',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19970902',
+ '19970904',
+ '19970909',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980106',
+ '19980108',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980203',
+ '19980303',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101',
+ '19980303',
+ '20010301',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ 'BYMINUTE' => array(15, 45),
+ 'BYSETPOS' => array(3, -3),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T181500Z',
+ '19970903T064500Z',
+ '19970903T181500Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'DAILY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testHourlyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array();
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T100000Z',
+ '19970902T110000Z',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T110000Z',
+ '19970902T130000Z',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 769,
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19971004T100000Z',
+ '19971105T110000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ );
+ $expect[] = array(
+ '19980101T000000Z',
+ '19980101T010000Z',
+ '19980101T020000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ );
+ $expect[] = array(
+ '19970903T000000Z',
+ '19970903T010000Z',
+ '19970903T020000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYMONTHDAY' => array(5, 7),
+ );
+ $expect[] = array(
+ '19980105T000000Z',
+ '19980105T010000Z',
+ '19980105T020000Z',
+ );
+
+ $tests[] = array(
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T100000Z',
+ '19970902T110000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101T000000Z',
+ '19980101T010000Z',
+ '19980101T020000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101T000000Z',
+ '19980101T010000Z',
+ '19980101T020000Z',
+ );
+
+ $tests[] = array(
+ 'BYMONTHDAY' => array(1, 3),
+ 'BYMONTH' => array(1, 3),
+ 'BYDAY' => array('TU', 'TH'),
+ );
+ $expect[] = array(
+ '19980101T000000Z',
+ '19980101T010000Z',
+ '19980101T020000Z',
+ );
+
+ $tests[] = array(
+ 'COUNT' => 4,
+ 'BYYEARDAY' => array(1, 100, 200, 365),
+ );
+ $expect[] = array(
+ '19971231T000000Z',
+ '19971231T010000Z',
+ '19971231T020000Z',
+ '19971231T030000Z',
+ );
+
+ $tests[] = array(
+ 'COUNT' => 4,
+ 'BYYEARDAY' => array(-365, -266, -166, -1),
+ );
+ $expect[] = array(
+ '19971231T000000Z',
+ '19971231T010000Z',
+ '19971231T020000Z',
+ '19971231T030000Z',
+ );
+
+ $tests[] = array(
+ 'COUNT' => 4,
+ 'BYMONTH' => array(4, 7),
+ 'BYYEARDAY' => array(1, 100, 200, 365),
+ );
+ $expect[] = array(
+ '19980410T000000Z',
+ '19980410T010000Z',
+ '19980410T020000Z',
+ '19980410T030000Z',
+ );
+
+ $tests[] = array(
+ 'COUNT' => 4,
+ 'BYMONTH' => array(4, 7),
+ 'BYYEARDAY' => array(-365, -266, -166, -1),
+ );
+ $expect[] = array(
+ '19980410T000000Z',
+ '19980410T010000Z',
+ '19980410T020000Z',
+ '19980410T030000Z',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T180000Z',
+ '19970903T060000Z',
+ '19970903T180000Z',
+ );
+
+ $tests[] = array(
+ 'BYMINUTE' => array(15, 45),
+ 'BYSECOND' => array(15, 45),
+ 'BYSETPOS' => array(3, -3),
+ );
+ $expect[] = array(
+ '19970902T091545Z',
+ '19970902T094515Z',
+ '19970902T101545Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'HOURLY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902T090000Z',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testMinutelyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array(
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T090100Z',
+ '19970902T090200Z',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T090200Z',
+ '19970902T090400Z',
+ );
+
+ $tests[] = array(
+ 'BYHOUR' => array(6, 18),
+ 'BYMINUTE' => array(6, 18),
+ 'BYSECOND' => array(6, 18),
+ );
+ $expect[] = array(
+ '19970902T180606Z',
+ '19970902T180618Z',
+ '19970902T181806Z',
+ );
+
+ $tests[] = array(
+ 'BYSECOND' => array(15, 30, 45),
+ 'BYSETPOS' => array(3, -3),
+ );
+ $expect[] = array(
+ '19970902T090015Z',
+ '19970902T090045Z',
+ '19970902T090115Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'MINUTELY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902T090000Z',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testSecondlyRecurrenceRules() {
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array();
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T090001Z',
+ '19970902T090002Z',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 2,
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T090002Z',
+ '19970902T090004Z',
+ );
+
+ $tests[] = array(
+ 'INTERVAL' => 90061,
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970903T100101Z',
+ '19970904T110202Z',
+ );
+
+ $tests[] = array(
+ 'BYSECOND' => array(0),
+ 'BYMINUTE' => array(1),
+ 'DTSTART' => '20100322T120100Z',
+ );
+ $expect[] = array(
+ '20100322T120100Z',
+ '20100322T130100Z',
+ '20100322T140100Z',
+ );
+
+ $this->assertRules(
+ array(
+ 'FREQ' => 'SECONDLY',
+ 'COUNT' => 3,
+ 'DTSTART' => '19970902T090000Z',
+ ),
+ $tests,
+ $expect);
+ }
+
+ public function testRFC5545RecurrenceRules() {
+ // These tests are derived from the examples in RFC5545.
+ $tests = array();
+ $expect = array();
+
+ $tests[] = array(
+ 'FREQ' => 'DAILY',
+ 'COUNT' => 10,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970903T090000Z',
+ '19970904T090000Z',
+ '19970905T090000Z',
+ '19970906T090000Z',
+ '19970907T090000Z',
+ '19970908T090000Z',
+ '19970909T090000Z',
+ '19970910T090000Z',
+ '19970911T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'DAILY',
+ 'INTERVAL' => 2,
+ 'DTSTART' => '19970902T090000Z',
+ 'COUNT' => 5,
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970904T090000Z',
+ '19970906T090000Z',
+ '19970908T090000Z',
+ '19970910T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'BYMONTH' => array(1),
+ 'BYDAY' => array('MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'),
+ 'DTSTART' => '19970902T090000Z',
+ 'COUNT' => 3,
+ );
+ $expect[] = array(
+ '19980101T090000Z',
+ '19980102T090000Z',
+ '19980103T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 3,
+ 'BYDAY' => array('1FR'),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970905T090000Z',
+ '19971003T090000Z',
+ '19971107T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'INTERVAL' => 2,
+ 'COUNT' => 5,
+ 'BYDAY' => array('1SU', '-1SU'),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970907T090000Z',
+ '19970928T090000Z',
+ '19971102T090000Z',
+ '19971130T090000Z',
+ '19980104T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 6,
+ 'BYDAY' => array('-2MO'),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970922T090000Z',
+ '19971020T090000Z',
+ '19971117T090000Z',
+ '19971222T090000Z',
+ '19980119T090000Z',
+ '19980216T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 6,
+ 'BYMONTHDAY' => array(-3),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970928T090000Z',
+ '19971029T090000Z',
+ '19971128T090000Z',
+ '19971229T090000Z',
+ '19980129T090000Z',
+ '19980226T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 5,
+ 'BYMONTHDAY' => array(2, 15),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970915T090000Z',
+ '19971002T090000Z',
+ '19971015T090000Z',
+ '19971102T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 5,
+ 'BYMONTHDAY' => array(-1, 1),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970930T090000Z',
+ '19971001T090000Z',
+ '19971031T090000Z',
+ '19971101T090000Z',
+ '19971130T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 7,
+ 'INTERVAL' => 18,
+ 'BYMONTHDAY' => array(10, 11, 12, 13, 14, 15),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970910T090000Z',
+ '19970911T090000Z',
+ '19970912T090000Z',
+ '19970913T090000Z',
+ '19970914T090000Z',
+ '19970915T090000Z',
+ '19990310T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'COUNT' => 6,
+ 'INTERVAL' => 2,
+ 'BYDAY' => array('TU'),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970909T090000Z',
+ '19970916T090000Z',
+ '19970923T090000Z',
+ '19970930T090000Z',
+ '19971104T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'COUNT' => 10,
+ 'BYMONTH' => array(6, 7),
+ 'DTSTART' => '19970610T090000Z',
+ );
+ $expect[] = array(
+ '19970610T090000Z',
+ '19970710T090000Z',
+ '19980610T090000Z',
+ '19980710T090000Z',
+ '19990610T090000Z',
+ '19990710T090000Z',
+ '20000610T090000Z',
+ '20000710T090000Z',
+ '20010610T090000Z',
+ '20010710T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'COUNT' => 4,
+ 'INTERVAL' => 3,
+ 'BYYEARDAY' => array(1, 100, 200),
+ 'DTSTART' => '19970101T090000Z',
+ );
+ $expect[] = array(
+ '19970101T090000Z',
+ '19970410T090000Z',
+ '19970719T090000Z',
+ '20000101T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'COUNT' => 3,
+ 'BYDAY' => array('20MO'),
+ 'DTSTART' => '19970519T090000Z',
+ );
+ $expect[] = array(
+ '19970519T090000Z',
+ '19980518T090000Z',
+ '19990517T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'COUNT' => 3,
+ 'BYWEEKNO' => array(20),
+ 'BYDAY' => array('MO'),
+ 'DTSTART' => '19970512T090000Z',
+ );
+ $expect[] = array(
+ '19970512T090000Z',
+ '19980511T090000Z',
+ '19990517T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'BYDAY' => array('TH'),
+ 'BYMONTH' => array(3),
+ 'DTSTART' => '19970313T090000Z',
+ 'COUNT' => 5,
+ );
+ $expect[] = array(
+ '19970313T090000Z',
+ '19970320T090000Z',
+ '19970327T090000Z',
+ '19980305T090000Z',
+ '19980312T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'BYDAY' => array('TH'),
+ 'BYMONTH' => array(6, 7, 8),
+ 'DTSTART' => '19970101T090000Z',
+ 'COUNT' => 15,
+ );
+ $expect[] = array(
+ '19970605T090000Z',
+ '19970612T090000Z',
+ '19970619T090000Z',
+ '19970626T090000Z',
+ '19970703T090000Z',
+ '19970710T090000Z',
+ '19970717T090000Z',
+ '19970724T090000Z',
+ '19970731T090000Z',
+ '19970807T090000Z',
+ '19970814T090000Z',
+ '19970821T090000Z',
+ '19970828T090000Z',
+ '19980604T090000Z',
+ '19980611T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'BYDAY' => array('FR'),
+ 'BYMONTHDAY' => array(13),
+ 'COUNT' => 4,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19980213T090000Z',
+ '19980313T090000Z',
+ '19981113T090000Z',
+ '19990813T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'BYDAY' => array('SA'),
+ 'BYMONTHDAY' => array(7, 8, 9, 10, 11, 12, 13),
+ 'COUNT' => 10,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970913T090000Z',
+ '19971011T090000Z',
+ '19971108T090000Z',
+ '19971213T090000Z',
+ '19980110T090000Z',
+ '19980207T090000Z',
+ '19980307T090000Z',
+ '19980411T090000Z',
+ '19980509T090000Z',
+ '19980613T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'YEARLY',
+ 'INTERVAL' => 4,
+ 'BYMONTH' => array(11),
+ 'BYDAY' => array('TU'),
+ 'BYMONTHDAY' => array(2, 3, 4, 5, 6, 7, 8),
+ 'COUNT' => 6,
+ 'DTSTART' => '19961105T090000Z',
+ );
+ $expect[] = array(
+ '19961105T090000Z',
+ '20001107T090000Z',
+ '20041102T090000Z',
+ '20081104T090000Z',
+ '20121106T090000Z',
+ '20161108T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'BYDAY' => array('TU', 'WE', 'TH'),
+ 'BYSETPOS' => array(3),
+ 'COUNT' => 3,
+ 'DTSTART' => '19970904T090000Z',
+ );
+ $expect[] = array(
+ '19970904T090000Z',
+ '19971007T090000Z',
+ '19971106T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MONTHLY',
+ 'BYDAY' => array('MO', 'TU', 'WE', 'TH', 'FR'),
+ 'BYSETPOS' => array(-2),
+ 'COUNT' => 3,
+ 'DTSTART' => '19970929T090000Z',
+ );
+ $expect[] = array(
+ '19970929T090000Z',
+ '19971030T090000Z',
+ '19971127T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'HOURLY',
+ 'INTERVAL' => 3,
+ 'DTSTART' => '19970929T090000Z',
+ 'COUNT' => 3,
+ );
+ $expect[] = array(
+ '19970929T090000Z',
+ '19970929T120000Z',
+ '19970929T150000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MINUTELY',
+ 'INTERVAL' => 15,
+ 'COUNT' => 6,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T091500Z',
+ '19970902T093000Z',
+ '19970902T094500Z',
+ '19970902T100000Z',
+ '19970902T101500Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'MINUTELY',
+ 'INTERVAL' => 90,
+ 'COUNT' => 4,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970902T103000Z',
+ '19970902T120000Z',
+ '19970902T133000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'WEEKLY',
+ 'COUNT' => 10,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970909T090000Z',
+ '19970916T090000Z',
+ '19970923T090000Z',
+ '19970930T090000Z',
+ '19971007T090000Z',
+ '19971014T090000Z',
+ '19971021T090000Z',
+ '19971028T090000Z',
+ '19971104T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'WEEKLY',
+ 'INTERVAL' => 2,
+ 'COUNT' => 6,
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970916T090000Z',
+ '19970930T090000Z',
+ '19971014T090000Z',
+ '19971028T090000Z',
+ '19971111T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'WEEKLY',
+ 'COUNT' => 10,
+ 'WKST' => 'SU',
+ 'BYDAY' => array('TU', 'TH'),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970904T090000Z',
+ '19970909T090000Z',
+ '19970911T090000Z',
+ '19970916T090000Z',
+ '19970918T090000Z',
+ '19970923T090000Z',
+ '19970925T090000Z',
+ '19970930T090000Z',
+ '19971002T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'WEEKLY',
+ 'INTERVAL' => 2,
+ 'COUNT' => 8,
+ 'WKST' => 'SU',
+ 'BYDAY' => array('TU', 'TH'),
+ 'DTSTART' => '19970902T090000Z',
+ );
+ $expect[] = array(
+ '19970902T090000Z',
+ '19970904T090000Z',
+ '19970916T090000Z',
+ '19970918T090000Z',
+ '19970930T090000Z',
+ '19971002T090000Z',
+ '19971014T090000Z',
+ '19971016T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'WEEKLY',
+ 'INTERVAL' => 2,
+ 'COUNT' => 4,
+ 'BYDAY' => array('TU', 'SU'),
+ 'WKST' => 'MO',
+ 'DTSTART' => '19970805T090000Z',
+ );
+ $expect[] = array(
+ '19970805T090000Z',
+ '19970810T090000Z',
+ '19970819T090000Z',
+ '19970824T090000Z',
+ );
+
+ $tests[] = array(
+ 'FREQ' => 'WEEKLY',
+ 'INTERVAL' => 2,
+ 'COUNT' => 4,
+ 'BYDAY' => array('TU', 'SU'),
+ 'WKST' => 'SU',
+ 'DTSTART' => '19970805T090000Z',
+ );
+ $expect[] = array(
+ '19970805T090000Z',
+ '19970817T090000Z',
+ '19970819T090000Z',
+ '19970831T090000Z',
+ );
+
+
+ $this->assertRules(array(), $tests, $expect);
+ }
+
+
+ private function assertRules(array $defaults, array $tests, array $expect) {
+ foreach ($tests as $key => $test) {
+ $options = $test + $defaults;
+
+ $start = PhutilCalendarAbsoluteDateTime::newFromISO8601(
+ $options['DTSTART']);
+
+ $rrule = id(new PhutilCalendarRecurrenceRule())
+ ->setStartDateTime($start)
+ ->setFrequency($options['FREQ']);
+
+ $interval = idx($options, 'INTERVAL');
+ if ($interval) {
+ $rrule->setInterval($interval);
+ }
+
+ $by_day = idx($options, 'BYDAY');
+ if ($by_day) {
+ $rrule->setByDay($by_day);
+ }
+
+ $by_month = idx($options, 'BYMONTH');
+ if ($by_month) {
+ $rrule->setByMonth($by_month);
+ }
+
+ $by_monthday = idx($options, 'BYMONTHDAY');
+ if ($by_monthday) {
+ $rrule->setByMonthDay($by_monthday);
+ }
+
+ $by_yearday = idx($options, 'BYYEARDAY');
+ if ($by_yearday) {
+ $rrule->setByYearDay($by_yearday);
+ }
+
+ $by_weekno = idx($options, 'BYWEEKNO');
+ if ($by_weekno) {
+ $rrule->setByWeekNumber($by_weekno);
+ }
+
+ $by_hour = idx($options, 'BYHOUR');
+ if ($by_hour) {
+ $rrule->setByHour($by_hour);
+ }
+
+ $by_minute = idx($options, 'BYMINUTE');
+ if ($by_minute) {
+ $rrule->setByMinute($by_minute);
+ }
+
+ $by_second = idx($options, 'BYSECOND');
+ if ($by_second) {
+ $rrule->setBySecond($by_second);
+ }
+
+ $by_setpos = idx($options, 'BYSETPOS');
+ if ($by_setpos) {
+ $rrule->setBySetPosition($by_setpos);
+ }
+
+ $week_start = idx($options, 'WKST');
+ if ($week_start) {
+ $rrule->setWeekStart($week_start);
+ }
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($rrule);
+
+ $result = $set->getEventsBetween(null, null, $options['COUNT']);
+
+ $this->assertEqual(
+ $expect[$key],
+ mpull($result, 'getISO8601'));
+ }
+ }
+
+
+}
diff --git a/src/parser/calendar/data/__tests__/PhutilCalendarRecurrenceTestCase.php b/src/parser/calendar/data/__tests__/PhutilCalendarRecurrenceTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/data/__tests__/PhutilCalendarRecurrenceTestCase.php
@@ -0,0 +1,196 @@
+getEventsBetween(null, null, 0xFFFF);
+ $this->assertEqual(
+ array(),
+ $result,
+ pht('Set with no sources.'));
+
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource(new PhutilCalendarRecurrenceList());
+ $result = $set->getEventsBetween(null, null, 0xFFFF);
+ $this->assertEqual(
+ array(),
+ $result,
+ pht('Set with empty list source.'));
+
+
+ $list = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ );
+
+ $source = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list);
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($source);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ );
+
+ $result = $set->getEventsBetween(null, null, 0xFFFF);
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Simple date list.'));
+
+ $list_a = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ );
+
+ $list_b = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ );
+
+ $source_a = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list_a);
+
+ $source_b = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list_b);
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($source_a)
+ ->addSource($source_b);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ );
+
+ $result = $set->getEventsBetween(null, null, 0xFFFF);
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Multiple date lists.'));
+
+ $list_a = array(
+ // This is Jan 1, 3, 5, 7, 8 and 10, but listed out-of-order.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160105T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160108T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160110T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160107T120000Z'),
+ );
+
+ $list_b = array(
+ // This is Jan 2, 4, 5, 8, but listed out of order.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160104T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160105T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160108T120000Z'),
+ );
+
+ $list_c = array(
+ // We're going to use this as an exception list.
+
+ // This is Jan 7 (listed in one other source), 8 (listed in two)
+ // and 9 (listed in none).
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160107T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160108T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160109T120000Z'),
+ );
+
+ $expect = array(
+ // From source A.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ // From source B.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ // From source A.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ // From source B.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160104T120000Z'),
+ // From source A and B. Should appear only once.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160105T120000Z'),
+ // The 6th appears in no source.
+ // The 7th, 8th and 9th are excluded.
+ // The 10th is from source A.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160110T120000Z'),
+ );
+
+ $list_a = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list_a);
+
+ $list_b = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list_b);
+
+ $list_c = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list_c)
+ ->setIsExceptionSource(true);
+
+ $date_set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($list_b)
+ ->addSource($list_c)
+ ->addSource($list_a);
+
+ $date_set->setViewerTimezone('UTC');
+
+ $result = $date_set->getEventsBetween(null, null, 0xFFFF);
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Set of all results in multiple lists with exclusions.'));
+
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ );
+ $result = $date_set->getEventsBetween(null, null, 1);
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Multiple lists, one result.'));
+
+ $expect = array(
+ 2 => PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ 3 => PhutilCalendarAbsoluteDateTime::newFromISO8601('20160104T120000Z'),
+ );
+ $result = $date_set->getEventsBetween(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160104T120000Z'));
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Multiple lists, time window.'));
+ }
+
+ public function testCalendarRecurrenceOffsets() {
+ $list = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160101T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120000Z'),
+ );
+
+ $source = id(new PhutilCalendarRecurrenceList())
+ ->setDates($list);
+
+ $set = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($source);
+
+ $t1 = PhutilCalendarAbsoluteDateTime::newFromISO8601('20160102T120001Z');
+ $t2 = PhutilCalendarAbsoluteDateTime::newFromISO8601('20160103T120000Z');
+
+ $expect = array(
+ 2 => $t2,
+ );
+
+ $result = $set->getEventsBetween($t1, null, 0xFFFF);
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Correct event indexes with start date.'));
+ }
+
+}
diff --git a/src/parser/calendar/ics/PhutilICSParser.php b/src/parser/calendar/ics/PhutilICSParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/PhutilICSParser.php
@@ -0,0 +1,919 @@
+stack = array();
+ $this->node = null;
+ $this->cursor = null;
+ $this->warnings = array();
+
+ $lines = $this->unfoldICSLines($data);
+ $this->lines = $lines;
+
+ $root = $this->newICSNode('');
+ $this->stack[] = $root;
+ $this->node = $root;
+
+ foreach ($lines as $key => $line) {
+ $this->cursor = $key;
+ $matches = null;
+ if (preg_match('(^BEGIN:(.*)\z)', $line, $matches)) {
+ $this->beginParsingNode($matches[1]);
+ } else if (preg_match('(^END:(.*)\z)', $line, $matches)) {
+ $this->endParsingNode($matches[1]);
+ } else {
+ if (count($this->stack) < 2) {
+ $this->raiseParseFailure(
+ self::PARSE_ROOT_PROPERTY,
+ pht(
+ 'Found unexpected property at ICS document root.'));
+ }
+ $this->parseICSProperty($line);
+ }
+ }
+
+ if (count($this->stack) > 1) {
+ $this->raiseParseFailure(
+ self::PARSE_MISSING_END,
+ pht(
+ 'Expected all "BEGIN:" sections in ICS document to have '.
+ 'corresponding "END:" sections.'));
+ }
+
+ $this->node = null;
+ $this->lines = null;
+ $this->cursor = null;
+
+ return $root;
+ }
+
+ private function getNode() {
+ return $this->node;
+ }
+
+ private function unfoldICSLines($data) {
+ $lines = phutil_split_lines($data, $retain_endings = false);
+ $this->lines = $lines;
+
+ // ICS files are wrapped at 75 characters, with overlong lines continued
+ // on the following line with an initial space or tab. Unwrap all of the
+ // lines in the file.
+
+ // This unwrapping is specifically byte-oriented, not character oriented,
+ // and RFC5545 anticipates that simple implementations may even split UTF8
+ // characters in the middle.
+
+ $last = null;
+ foreach ($lines as $idx => $line) {
+ $this->cursor = $idx;
+ if (!preg_match('/^[ \t]/', $line)) {
+ $last = $idx;
+ continue;
+ }
+
+ if ($last === null) {
+ $this->raiseParseFailure(
+ self::PARSE_INITIAL_UNFOLD,
+ pht(
+ 'First line of ICS file begins with a space or tab, but this '.
+ 'marks a line which should be unfolded.'));
+ }
+
+ $lines[$last] = $lines[$last].substr($line, 1);
+ unset($lines[$idx]);
+ }
+
+ return $lines;
+ }
+
+ private function beginParsingNode($type) {
+ $node = $this->getNode();
+ $new_node = $this->newICSNode($type);
+
+ if ($node instanceof PhutilCalendarContainerNode) {
+ $node->appendChild($new_node);
+ } else {
+ $this->raiseParseFailure(
+ self::PARSE_UNEXPECTED_CHILD,
+ pht(
+ 'Found unexpected node "%s" inside node "%s".',
+ $new_node->getAttribute('ics.type'),
+ $node->getAttribute('ics.type')));
+ }
+
+ $this->stack[] = $new_node;
+ $this->node = $new_node;
+
+ return $this;
+ }
+
+ private function newICSNode($type) {
+ switch ($type) {
+ case '':
+ $node = new PhutilCalendarRootNode();
+ break;
+ case 'VCALENDAR':
+ $node = new PhutilCalendarDocumentNode();
+ break;
+ case 'VEVENT':
+ $node = new PhutilCalendarEventNode();
+ break;
+ default:
+ $node = new PhutilCalendarRawNode();
+ break;
+ }
+
+ $node->setAttribute('ics.type', $type);
+
+ return $node;
+ }
+
+ private function endParsingNode($type) {
+ $node = $this->getNode();
+ if ($node instanceof PhutilCalendarRootNode) {
+ $this->raiseParseFailure(
+ self::PARSE_EXTRA_END,
+ pht(
+ 'Found unexpected "END" without a "BEGIN".'));
+ }
+
+ $old_type = $node->getAttribute('ics.type');
+ if ($old_type != $type) {
+ $this->raiseParseFailure(
+ self::PARSE_MISMATCHED_SECTIONS,
+ pht(
+ 'Found mismatched "BEGIN" ("%s") and "END" ("%s") sections.',
+ $old_type,
+ $type));
+ }
+
+ array_pop($this->stack);
+ $this->node = last($this->stack);
+
+ return $this;
+ }
+
+ private function parseICSProperty($line) {
+ $matches = null;
+
+ // Properties begin with an alphanumeric name with no escaping, followed
+ // by either a ";" (to begin a list of parameters) or a ":" (to begin
+ // the actual field body).
+
+ $ok = preg_match('(^([A-Za-z0-9-]+)([;:])(.*)\z)', $line, $matches);
+ if (!$ok) {
+ $this->raiseParseFailure(
+ self::PARSE_MALFORMED_PROPERTY,
+ pht(
+ 'Found malformed property in ICS document.'));
+ }
+
+ $name = $matches[1];
+ $body = $matches[3];
+ $has_parameters = ($matches[2] == ';');
+
+ $parameters = array();
+ if ($has_parameters) {
+ // Parameters are a sensible name, a literal "=", a pile of magic,
+ // and then maybe a comma and another parameter.
+
+ while (true) {
+ // We're going to get the first couple of parts first.
+ $ok = preg_match('(^([^=]+)=)', $body, $matches);
+ if (!$ok) {
+ $this->raiseParseFailure(
+ self::PARSE_MALFORMED_PARAMETER_NAME,
+ pht(
+ 'Found malformed property in ICS document: %s',
+ $body));
+ }
+
+ $param_name = $matches[1];
+ $body = substr($body, strlen($matches[0]));
+
+ // Now we're going to match zero or more values.
+ $param_values = array();
+ while (true) {
+ // The value can either be a double-quoted string or an unquoted
+ // string, with some characters forbidden.
+ if (strlen($body) && $body[0] == '"') {
+ $is_quoted = true;
+ $ok = preg_match(
+ '(^"([^\x00-\x08\x10-\x19"]*)")',
+ $body,
+ $matches);
+ if (!$ok) {
+ $this->raiseParseFailure(
+ self::PARSE_MALFORMED_DOUBLE_QUOTE,
+ pht(
+ 'Found malformed double-quoted string in ICS document '.
+ 'parameter value.'));
+ }
+ } else {
+ $is_quoted = false;
+
+ // It's impossible for this not to match since it can match
+ // nothing, and it's valid for it to match nothing.
+ preg_match('(^([^\x00-\x08\x10-\x19";:,]*))', $body, $matches);
+ }
+
+ // NOTE: RFC5545 says "Property parameter values that are not in
+ // quoted-strings are case-insensitive." -- that is, the quoted and
+ // unquoted representations are not equivalent. Thus, preserve the
+ // original formatting in case we ever need to respect this.
+
+ $param_values[] = array(
+ 'value' => $this->unescapeParameterValue($matches[1]),
+ 'quoted' => $is_quoted,
+ );
+
+ $body = substr($body, strlen($matches[0]));
+ if (!strlen($body)) {
+ $this->raiseParseFailure(
+ self::PARSE_MISSING_VALUE,
+ pht(
+ 'Expected ":" after parameters in ICS document property.'));
+ }
+
+ // If we have a comma now, we're going to read another value. Strip
+ // it off and keep going.
+ if ($body[0] == ',') {
+ $body = substr($body, 1);
+ continue;
+ }
+
+ // If we have a semicolon, we're going to read another parameter.
+ if ($body[0] == ';') {
+ break;
+ }
+
+ // If we have a colon, this is the last value and also the last
+ // property. Break, then handle the colon below.
+ if ($body[0] == ':') {
+ break;
+ }
+
+ $short_body = id(new PhutilUTF8StringTruncator())
+ ->setMaximumGlyphs(32)
+ ->truncateString($body);
+
+ // We aren't expecting anything else.
+ $this->raiseParseFailure(
+ self::PARSE_UNEXPECTED_TEXT,
+ pht(
+ 'Found unexpected text ("%s") after reading parameter value.',
+ $short_body));
+ }
+
+ $parameters[] = array(
+ 'name' => $param_name,
+ 'values' => $param_values,
+ );
+
+ if ($body[0] == ';') {
+ $body = substr($body, 1);
+ continue;
+ }
+
+ if ($body[0] == ':') {
+ $body = substr($body, 1);
+ break;
+ }
+ }
+ }
+
+ $value = $this->unescapeFieldValue($name, $parameters, $body);
+
+ $node = $this->getNode();
+
+
+ $raw = $node->getAttribute('ics.properties', array());
+ $raw[] = array(
+ 'name' => $name,
+ 'parameters' => $parameters,
+ 'value' => $value,
+ );
+ $node->setAttribute('ics.properties', $raw);
+
+ switch ($node->getAttribute('ics.type')) {
+ case 'VEVENT':
+ $this->didParseEventProperty($node, $name, $parameters, $value);
+ break;
+ }
+ }
+
+ private function unescapeParameterValue($data) {
+ // The parameter grammar is adjusted by RFC6868 to permit escaping with
+ // carets. Remove that escaping.
+
+ // This escaping is a bit weird because it's trying to be backwards
+ // compatible and the original spec didn't think about this and didn't
+ // provide much room to fix things.
+
+ $out = '';
+ $esc = false;
+ foreach (phutil_utf8v($data) as $c) {
+ if (!$esc) {
+ if ($c != '^') {
+ $out .= $c;
+ } else {
+ $esc = true;
+ }
+ } else {
+ switch ($c) {
+ case 'n':
+ $out .= "\n";
+ break;
+ case '^':
+ $out .= '^';
+ break;
+ case "'":
+ // NOTE: This is " " being decoded into a
+ // double quote!
+ $out .= '"';
+ break;
+ default:
+ // NOTE: The caret is NOT an escape for any other characters.
+ // This is a "MUST" requirement of RFC6868.
+ $out .= '^'.$c;
+ break;
+ }
+ }
+ }
+
+ // NOTE: Because caret on its own just means "caret" for backward
+ // compatibility, we don't warn if we're still in escaped mode once we
+ // reach the end of the string.
+
+ return $out;
+ }
+
+ private function unescapeFieldValue($name, array $parameters, $data) {
+ // NOTE: The encoding of the field value data is dependent on the field
+ // name (which defines a default encoding) and the parameters (which may
+ // include "VALUE", specifying a type of the data.
+
+ $default_types = array(
+ 'CALSCALE' => 'TEXT',
+ 'METHOD' => 'TEXT',
+ 'PRODID' => 'TEXT',
+ 'VERSION' => 'TEXT',
+
+ 'ATTACH' => 'URI',
+ 'CATEGORIES' => 'TEXT',
+ 'CLASS' => 'TEXT',
+ 'COMMENT' => 'TEXT',
+ 'DESCRIPTION' => 'TEXT',
+
+ // TODO: The spec appears to contradict itself: it says that the value
+ // type is FLOAT, but it also says that this property value is actually
+ // two semicolon-separated values, which is not what FLOAT is defined as.
+ 'GEO' => 'TEXT',
+
+ 'LOCATION' => 'TEXT',
+ 'PERCENT-COMPLETE' => 'INTEGER',
+ 'PRIORITY' => 'INTEGER',
+ 'RESOURCES' => 'TEXT',
+ 'STATUS' => 'TEXT',
+ 'SUMMARY' => 'TEXT',
+
+ 'COMPLETED' => 'DATE-TIME',
+ 'DTEND' => 'DATE-TIME',
+ 'DUE' => 'DATE-TIME',
+ 'DTSTART' => 'DATE-TIME',
+ 'DURATION' => 'DURATION',
+ 'FREEBUSY' => 'PERIOD',
+ 'TRANSP' => 'TEXT',
+
+ 'TZID' => 'TEXT',
+ 'TZNAME' => 'TEXT',
+ 'TZOFFSETFROM' => 'UTC-OFFSET',
+ 'TZOFFSETTO' => 'UTC-OFFSET',
+ 'TZURL' => 'URI',
+
+ 'ATTENDEE' => 'CAL-ADDRESS',
+ 'CONTACT' => 'TEXT',
+ 'ORGANIZER' => 'CAL-ADDRESS',
+ 'RECURRENCE-ID' => 'DATE-TIME',
+ 'RELATED-TO' => 'TEXT',
+ 'URL' => 'URI',
+ 'UID' => 'TEXT',
+ 'EXDATE' => 'DATE-TIME',
+ 'RDATE' => 'DATE-TIME',
+ 'RRULE' => 'RECUR',
+
+ 'ACTION' => 'TEXT',
+ 'REPEAT' => 'INTEGER',
+ 'TRIGGER' => 'DURATION',
+
+ 'CREATED' => 'DATE-TIME',
+ 'DTSTAMP' => 'DATE-TIME',
+ 'LAST-MODIFIED' => 'DATE-TIME',
+ 'SEQUENCE' => 'INTEGER',
+
+ 'REQUEST-STATUS' => 'TEXT',
+ );
+
+ $value_type = idx($default_types, $name, 'TEXT');
+
+ foreach ($parameters as $parameter) {
+ if ($parameter['name'] == 'VALUE') {
+ $value_type = idx(head($parameter['values']), 'value');
+ }
+ }
+
+ switch ($value_type) {
+ case 'BINARY':
+ $result = base64_decode($data, true);
+ if ($result === false) {
+ $this->raiseParseFailure(
+ self::PARSE_BAD_BASE64,
+ pht(
+ 'Unable to decode base64 data: %s',
+ $data));
+ }
+ break;
+ case 'BOOLEAN':
+ $map = array(
+ 'true' => true,
+ 'false' => false,
+ );
+ $result = phutil_utf8_strtolower($data);
+ if (!isset($map[$result])) {
+ $this->raiseParseFailure(
+ self::PARSE_BAD_BOOLEAN,
+ pht(
+ 'Unexpected BOOLEAN value "%s".',
+ $data));
+ }
+ $result = $map[$result];
+ break;
+ case 'CAL-ADDRESS':
+ $result = $data;
+ break;
+ case 'DATE':
+ // This is a comma-separated list of "YYYYMMDD" values.
+ $result = explode(',', $data);
+ break;
+ case 'DATE-TIME':
+ if (!strlen($data)) {
+ $result = array();
+ } else {
+ $result = explode(',', $data);
+ }
+ break;
+ case 'DURATION':
+ if (!strlen($data)) {
+ $result = array();
+ } else {
+ $result = explode(',', $data);
+ }
+ break;
+ case 'FLOAT':
+ $result = explode(',', $data);
+ foreach ($result as $k => $v) {
+ $result[$k] = (float)$v;
+ }
+ break;
+ case 'INTEGER':
+ $result = explode(',', $data);
+ foreach ($result as $k => $v) {
+ $result[$k] = (int)$v;
+ }
+ break;
+ case 'PERIOD':
+ $result = explode(',', $data);
+ break;
+ case 'RECUR':
+ $result = $data;
+ break;
+ case 'TEXT':
+ $result = $this->unescapeTextValue($data);
+ break;
+ case 'TIME':
+ $result = explode(',', $data);
+ break;
+ case 'URI':
+ $result = $data;
+ break;
+ case 'UTC-OFFSET':
+ $result = $data;
+ break;
+ default:
+ // RFC5545 says we MUST preserve the data for any types we don't
+ // recognize.
+ $result = $data;
+ break;
+ }
+
+ return array(
+ 'type' => $value_type,
+ 'value' => $result,
+ 'raw' => $data,
+ );
+ }
+
+ private function unescapeTextValue($data) {
+ $result = array();
+
+ $buf = '';
+ $esc = false;
+ foreach (phutil_utf8v($data) as $c) {
+ if (!$esc) {
+ if ($c == '\\') {
+ $esc = true;
+ } else if ($c == ',') {
+ $result[] = $buf;
+ $buf = '';
+ } else {
+ $buf .= $c;
+ }
+ } else {
+ switch ($c) {
+ case 'n':
+ case 'N':
+ $buf .= "\n";
+ break;
+ default:
+ $buf .= $c;
+ break;
+ }
+ $esc = false;
+ }
+ }
+
+ if ($esc) {
+ $this->raiseParseFailure(
+ self::PARSE_UNESCAPED_BACKSLASH,
+ pht(
+ 'ICS document contains TEXT value ending with unescaped '.
+ 'backslash.'));
+ }
+
+ $result[] = $buf;
+
+ return $result;
+ }
+
+ private function raiseParseFailure($code, $message) {
+ if ($this->lines && isset($this->lines[$this->cursor])) {
+ $message = pht(
+ "ICS Parse Error near line %s:\n\n>>> %s\n\n%s",
+ $this->cursor + 1,
+ $this->lines[$this->cursor],
+ $message);
+ } else {
+ $message = pht(
+ 'ICS Parse Error: %s',
+ $message);
+ }
+
+ throw id(new PhutilICSParserException($message))
+ ->setParserFailureCode($code);
+ }
+
+ private function raiseWarning($code, $message) {
+ $this->warnings[] = array(
+ 'code' => $code,
+ 'line' => $this->cursor,
+ 'text' => $this->lines[$this->cursor],
+ 'message' => $message,
+ );
+
+ return $this;
+ }
+
+ public function getWarnings() {
+ return $this->warnings;
+ }
+
+ private function didParseEventProperty(
+ PhutilCalendarEventNode $node,
+ $name,
+ array $parameters,
+ array $value) {
+
+ switch ($name) {
+ case 'UID':
+ $text = $this->newTextFromProperty($parameters, $value);
+ $node->setUID($text);
+ break;
+ case 'CREATED':
+ $datetime = $this->newDateTimeFromProperty($parameters, $value);
+ $node->setCreatedDateTime($datetime);
+ break;
+ case 'DTSTAMP':
+ $datetime = $this->newDateTimeFromProperty($parameters, $value);
+ $node->setModifiedDateTime($datetime);
+ break;
+ case 'SUMMARY':
+ $text = $this->newTextFromProperty($parameters, $value);
+ $node->setName($text);
+ break;
+ case 'DESCRIPTION':
+ $text = $this->newTextFromProperty($parameters, $value);
+ $node->setDescription($text);
+ break;
+ case 'DTSTART':
+ $datetime = $this->newDateTimeFromProperty($parameters, $value);
+ $node->setStartDateTime($datetime);
+ break;
+ case 'DTEND':
+ $datetime = $this->newDateTimeFromProperty($parameters, $value);
+ $node->setEndDateTime($datetime);
+ break;
+ case 'DURATION':
+ $duration = $this->newDurationFromProperty($parameters, $value);
+ $node->setDuration($duration);
+ break;
+ case 'RRULE':
+ $rrule = $this->newRecurrenceRuleFromProperty($parameters, $value);
+ $node->setRecurrenceRule($rrule);
+ break;
+ case 'RECURRENCE-ID':
+ $text = $this->newTextFromProperty($parameters, $value);
+ $node->setRecurrenceID($text);
+ break;
+ case 'ATTENDEE':
+ $attendee = $this->newAttendeeFromProperty($parameters, $value);
+ $node->addAttendee($attendee);
+ break;
+ }
+
+ }
+
+ private function newTextFromProperty(array $parameters, array $value) {
+ $value = $value['value'];
+ return implode("\n\n", $value);
+ }
+
+ private function newAttendeeFromProperty(array $parameters, array $value) {
+ $uri = $value['value'];
+
+ switch (idx($parameters, 'PARTSTAT')) {
+ case 'ACCEPTED':
+ $status = PhutilCalendarUserNode::STATUS_ACCEPTED;
+ break;
+ case 'DECLINED':
+ $status = PhutilCalendarUserNode::STATUS_DECLINED;
+ break;
+ case 'NEEDS-ACTION':
+ default:
+ $status = PhutilCalendarUserNode::STATUS_INVITED;
+ break;
+ }
+
+ $name = $this->getScalarParameterValue($parameters, 'CN');
+
+ return id(new PhutilCalendarUserNode())
+ ->setURI($uri)
+ ->setName($name)
+ ->setStatus($status);
+ }
+
+ private function newDateTimeFromProperty(array $parameters, array $value) {
+ $value = $value['value'];
+
+ if (!$value) {
+ $this->raiseParseFailure(
+ self::PARSE_EMPTY_DATETIME,
+ pht(
+ 'Expected DATE-TIME to have exactly one value, found none.'));
+
+ }
+
+ if (count($value) > 1) {
+ $this->raiseParseFailure(
+ self::PARSE_MANY_DATETIME,
+ pht(
+ 'Expected DATE-TIME to have exactly one value, found more than '.
+ 'one.'));
+ }
+
+ $value = head($value);
+ $tzid = $this->getScalarParameterValue($parameters, 'TZID');
+
+ if (preg_match('/Z\z/', $value)) {
+ if ($tzid) {
+ $this->raiseWarning(
+ self::WARN_TZID_UTC,
+ pht(
+ 'DATE-TIME "%s" uses "Z" to specify UTC, but also has a TZID '.
+ 'parameter with value "%s". This violates RFC5545. The TZID '.
+ 'will be ignored, and the value will be interpreted as UTC.',
+ $value,
+ $tzid));
+ }
+ $tzid = 'UTC';
+ } else if ($tzid !== null) {
+ $tzid = $this->guessTimezone($tzid);
+ }
+
+ try {
+ $datetime = PhutilCalendarAbsoluteDateTime::newFromISO8601(
+ $value,
+ $tzid);
+ } catch (Exception $ex) {
+ $this->raiseParseFailure(
+ self::PARSE_BAD_DATETIME,
+ pht(
+ 'Error parsing DATE-TIME: %s',
+ $ex->getMessage()));
+ }
+
+ return $datetime;
+ }
+
+ private function newDurationFromProperty(array $parameters, array $value) {
+ $value = $value['value'];
+
+ if (!$value) {
+ $this->raiseParseFailure(
+ self::PARSE_EMPTY_DURATION,
+ pht(
+ 'Expected DURATION to have exactly one value, found none.'));
+
+ }
+
+ if (count($value) > 1) {
+ $this->raiseParseFailure(
+ self::PARSE_MANY_DURATION,
+ pht(
+ 'Expected DURATION to have exactly one value, found more than '.
+ 'one.'));
+ }
+
+ $value = head($value);
+
+ try {
+ $duration = PhutilCalendarDuration::newFromISO8601($value);
+ } catch (Exception $ex) {
+ $this->raiseParseFailure(
+ self::PARSE_BAD_DURATION,
+ pht(
+ 'Invalid DURATION: %s',
+ $ex->getMessage()));
+ }
+
+ return $duration;
+ }
+
+ private function newRecurrenceRuleFromProperty(array $parameters, $value) {
+ return PhutilCalendarRecurrenceRule::newFromRRULE($value['value']);
+ }
+
+ private function getScalarParameterValue(
+ array $parameters,
+ $name,
+ $default = null) {
+
+ $match = null;
+ foreach ($parameters as $parameter) {
+ if ($parameter['name'] == $name) {
+ $match = $parameter;
+ }
+ }
+
+ if ($match === null) {
+ return $default;
+ }
+
+ $value = $match['values'];
+ if (!$value) {
+ // Parameter is specified, but with no value, like "KEY=". Just return
+ // the default, as though the parameter was not specified.
+ return $default;
+ }
+
+ if (count($value) > 1) {
+ $this->raiseParseFailure(
+ self::PARSE_MULTIPLE_PARAMETERS,
+ pht(
+ 'Expected parameter "%s" to have at most one value, but found '.
+ 'more than one.',
+ $name));
+ }
+
+ return idx(head($value), 'value');
+ }
+
+ private function guessTimezone($tzid) {
+ $map = DateTimeZone::listIdentifiers();
+ $map = array_fuse($map);
+ if (isset($map[$tzid])) {
+ // This is a real timezone we recognize, so just use it as provided.
+ return $tzid;
+ }
+
+ // These are alternate names for timezones.
+ static $aliases;
+
+ if ($aliases === null) {
+ $aliases = array(
+ 'Etc/GMT' => 'UTC',
+ );
+
+ // Load the map of Windows timezones.
+ $root_path = dirname(phutil_get_library_root('phutil'));
+ $windows_path = $root_path.'/resources/timezones/windows_timezones.json';
+ $windows_data = Filesystem::readFile($windows_path);
+ $windows_zones = phutil_json_decode($windows_data);
+
+ $aliases = $aliases + $windows_zones;
+ }
+
+ if (isset($aliases[$tzid])) {
+ return $aliases[$tzid];
+ }
+
+ // Look for something that looks like "UTC+3" or "GMT -05.00". If we find
+ // anything, pick a timezone with that offset.
+ $offset_pattern =
+ '/'.
+ '(?:UTC|GMT)'.
+ '\s*'.
+ '(?P[+-])'.
+ '\s*'.
+ '(?P\d+)'.
+ '(?:'.
+ '[:.](?P\d+)'.
+ ')?'.
+ '/i';
+
+ $matches = null;
+ if (preg_match($offset_pattern, $tzid, $matches)) {
+ $hours = (int)$matches['h'];
+ $minutes = (int)idx($matches, 'm');
+ $offset = ($hours * 60 * 60) + ($minutes * 60);
+
+ if (idx($matches, 'sign') == '-') {
+ $offset = -$offset;
+ }
+
+ // NOTE: We could possibly do better than this, by using the event start
+ // time to guess a timezone. However, that won't work for recurring
+ // events and would require us to do this work after finishing initial
+ // parsing. Since these unusual offset-based timezones appear to be rare,
+ // the benefit may not be worth the complexity.
+ $now = new DateTime('@'.time());
+
+ foreach ($map as $identifier) {
+ $zone = new DateTimeZone($identifier);
+ if ($zone->getOffset($now) == $offset) {
+ $this->raiseWarning(
+ self::WARN_TZID_GUESS,
+ pht(
+ 'TZID "%s" is unknown, guessing "%s" based on pattern "%s".',
+ $tzid,
+ $identifier,
+ $matches[0]));
+ return $identifier;
+ }
+ }
+ }
+
+ $this->raiseWarning(
+ self::WARN_TZID_IGNORED,
+ pht(
+ 'TZID "%s" is unknown, using UTC instead.',
+ $tzid));
+
+ return 'UTC';
+ }
+
+}
diff --git a/src/parser/calendar/ics/PhutilICSParserException.php b/src/parser/calendar/ics/PhutilICSParserException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/PhutilICSParserException.php
@@ -0,0 +1,16 @@
+parserFailureCode = $code;
+ return $this;
+ }
+
+ public function getParserFailureCode() {
+ return $this->parserFailureCode;
+ }
+
+}
diff --git a/src/parser/calendar/ics/PhutilICSWriter.php b/src/parser/calendar/ics/PhutilICSWriter.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/PhutilICSWriter.php
@@ -0,0 +1,387 @@
+getChildren() as $child) {
+ $out[] = $this->writeNode($child);
+ }
+
+ return implode('', $out);
+ }
+
+ private function writeNode(PhutilCalendarNode $node) {
+ if (!$this->getICSNodeType($node)) {
+ return null;
+ }
+
+ $out = array();
+
+ $out[] = $this->writeBeginNode($node);
+ $out[] = $this->writeNodeProperties($node);
+
+ if ($node instanceof PhutilCalendarContainerNode) {
+ foreach ($node->getChildren() as $child) {
+ $out[] = $this->writeNode($child);
+ }
+ }
+
+ $out[] = $this->writeEndNode($node);
+
+ return implode('', $out);
+ }
+
+ private function writeBeginNode(PhutilCalendarNode $node) {
+ $type = $this->getICSNodeType($node);
+ return $this->wrapICSLine("BEGIN:{$type}");
+ }
+
+ private function writeEndNode(PhutilCalendarNode $node) {
+ $type = $this->getICSNodeType($node);
+ return $this->wrapICSLine("END:{$type}");
+ }
+
+ private function writeNodeProperties(PhutilCalendarNode $node) {
+ $properties = $this->getNodeProperties($node);
+
+ $out = array();
+ foreach ($properties as $property) {
+ $propname = $property['name'];
+ $propvalue = $property['value'];
+
+ $propline = array();
+ $propline[] = $propname;
+
+ foreach ($property['parameters'] as $parameter) {
+ $paramname = $parameter['name'];
+ $paramvalue = $parameter['value'];
+ $propline[] = ";{$paramname}={$paramvalue}";
+ }
+
+ $propline[] = ":{$propvalue}";
+ $propline = implode('', $propline);
+
+ $out[] = $this->wrapICSLine($propline);
+ }
+
+ return implode('', $out);
+ }
+
+ private function getICSNodeType(PhutilCalendarNode $node) {
+ switch ($node->getNodeType()) {
+ case PhutilCalendarDocumentNode::NODETYPE:
+ return 'VCALENDAR';
+ case PhutilCalendarEventNode::NODETYPE:
+ return 'VEVENT';
+ default:
+ return null;
+ }
+ }
+
+ private function wrapICSLine($line) {
+ $out = array();
+ $buf = '';
+
+ // NOTE: The line may contain sequences of combining characters which are
+ // more than 80 bytes in length. If it does, we'll split them in the
+ // middle of the sequence. This is okay and generally anticipated by
+ // RFC5545, which even allows implementations to split multibyte
+ // characters. The sequence will be stitched back together properly by
+ // whatever is parsing things.
+
+ foreach (phutil_utf8v($line) as $character) {
+ // If adding this character would bring the line over 75 bytes, start
+ // a new line.
+ if (strlen($buf) + strlen($character) > 75) {
+ $out[] = $buf."\r\n";
+ $buf = ' ';
+ }
+
+ $buf .= $character;
+ }
+
+ $out[] = $buf."\r\n";
+
+ return implode('', $out);
+ }
+
+ private function getNodeProperties(PhutilCalendarNode $node) {
+ switch ($node->getNodeType()) {
+ case PhutilCalendarDocumentNode::NODETYPE:
+ return $this->getDocumentNodeProperties($node);
+ case PhutilCalendarEventNode::NODETYPE:
+ return $this->getEventNodeProperties($node);
+ default:
+ return array();
+ }
+ }
+
+ private function getDocumentNodeProperties(
+ PhutilCalendarDocumentNode $event) {
+ $properties = array();
+
+ $properties[] = $this->newTextProperty(
+ 'VERSION',
+ '2.0');
+
+ $properties[] = $this->newTextProperty(
+ 'PRODID',
+ '-//Phacility//Phabricator//EN');
+
+ return $properties;
+ }
+
+ private function getEventNodeProperties(PhutilCalendarEventNode $event) {
+ $properties = array();
+
+ $uid = $event->getUID();
+ if (!strlen($uid)) {
+ throw new Exception(
+ pht(
+ 'Unable to write ICS document: event has no UID, but each event '.
+ 'MUST have a UID.'));
+ }
+ $properties[] = $this->newTextProperty(
+ 'UID',
+ $uid);
+
+ $created = $event->getCreatedDateTime();
+ if ($created) {
+ $properties[] = $this->newDateTimeProperty(
+ 'CREATED',
+ $event->getCreatedDateTime());
+ }
+
+ $dtstamp = $event->getModifiedDateTime();
+ if (!$dtstamp) {
+ throw new Exception(
+ pht(
+ 'Unable to write ICS document: event has no modified time, but '.
+ 'each event MUST have a modified time.'));
+ }
+ $properties[] = $this->newDateTimeProperty(
+ 'DTSTAMP',
+ $dtstamp);
+
+ $dtstart = $event->getStartDateTime();
+ if ($dtstart) {
+ $properties[] = $this->newDateTimeProperty(
+ 'DTSTART',
+ $dtstart);
+ }
+
+ $dtend = $event->getEndDateTime();
+ if ($dtend) {
+ $properties[] = $this->newDateTimeProperty(
+ 'DTEND',
+ $event->getEndDateTime());
+ }
+
+ $name = $event->getName();
+ if (strlen($name)) {
+ $properties[] = $this->newTextProperty(
+ 'SUMMARY',
+ $name);
+ }
+
+ $description = $event->getDescription();
+ if (strlen($description)) {
+ $properties[] = $this->newTextProperty(
+ 'DESCRIPTION',
+ $description);
+ }
+
+ $organizer = $event->getOrganizer();
+ if ($organizer) {
+ $properties[] = $this->newUserProperty(
+ 'ORGANIZER',
+ $organizer);
+ }
+
+ $attendees = $event->getAttendees();
+ if ($attendees) {
+ foreach ($attendees as $attendee) {
+ $properties[] = $this->newUserProperty(
+ 'ATTENDEE',
+ $attendee);
+ }
+ }
+
+ $rrule = $event->getRecurrenceRule();
+ if ($rrule) {
+ $properties[] = $this->newRRULEProperty(
+ 'RRULE',
+ $rrule);
+ }
+
+ $recurrence_id = $event->getRecurrenceID();
+ if ($recurrence_id) {
+ $properties[] = $this->newTextProperty(
+ 'RECURRENCE-ID',
+ $recurrence_id);
+ }
+
+ $exdates = $event->getRecurrenceExceptions();
+ if ($exdates) {
+ $properties[] = $this->newDateTimesProperty(
+ 'EXDATE',
+ $exdates);
+ }
+
+ $rdates = $event->getRecurrenceDates();
+ if ($rdates) {
+ $properties[] = $this->newDateTimesProperty(
+ 'RDATE',
+ $rdates);
+ }
+
+ return $properties;
+ }
+
+ private function newTextProperty(
+ $name,
+ $value,
+ array $parameters = array()) {
+
+ $map = array(
+ '\\' => '\\\\',
+ ',' => '\\,',
+ "\n" => '\\n',
+ );
+
+ $value = (array)$value;
+ foreach ($value as $k => $v) {
+ $v = str_replace(array_keys($map), array_values($map), $v);
+ $value[$k] = $v;
+ }
+
+ $value = implode(',', $value);
+
+ return $this->newProperty($name, $value, $parameters);
+ }
+
+ private function newDateTimeProperty(
+ $name,
+ PhutilCalendarDateTime $value,
+ array $parameters = array()) {
+
+ return $this->newDateTimesProperty($name, array($value), $parameters);
+ }
+
+ private function newDateTimesProperty(
+ $name,
+ array $values,
+ array $parameters = array()) {
+ assert_instances_of($values, 'PhutilCalendarDateTime');
+
+ if (head($values)->getIsAllDay()) {
+ $parameters[] = array(
+ 'name' => 'VALUE',
+ 'values' => array(
+ 'DATE',
+ ),
+ );
+ }
+
+ $datetimes = array();
+ foreach ($values as $value) {
+ $datetimes[] = $value->getISO8601();
+ }
+ $datetimes = implode(';', $datetimes);
+
+ return $this->newProperty($name, $datetimes, $parameters);
+ }
+
+ private function newUserProperty(
+ $name,
+ PhutilCalendarUserNode $value,
+ array $parameters = array()) {
+
+ $parameters[] = array(
+ 'name' => 'CN',
+ 'values' => array(
+ $value->getName(),
+ ),
+ );
+
+ $partstat = null;
+ switch ($value->getStatus()) {
+ case PhutilCalendarUserNode::STATUS_INVITED:
+ $partstat = 'NEEDS-ACTION';
+ break;
+ case PhutilCalendarUserNode::STATUS_ACCEPTED:
+ $partstat = 'ACCEPTED';
+ break;
+ case PhutilCalendarUserNode::STATUS_DECLINED:
+ $partstat = 'DECLINED';
+ break;
+ }
+
+ if ($partstat !== null) {
+ $parameters[] = array(
+ 'name' => 'PARTSTAT',
+ 'values' => array(
+ $partstat,
+ ),
+ );
+ }
+
+ // TODO: We could reasonably fill in "ROLE" and "RSVP" here too, but it
+ // isn't clear if these are important to external programs or not.
+
+ return $this->newProperty($name, $value->getURI(), $parameters);
+ }
+
+ private function newRRULEProperty(
+ $name,
+ PhutilCalendarRecurrenceRule $rule,
+ array $parameters = array()) {
+
+ $value = $rule->toRRULE();
+ return $this->newProperty($name, $value, $parameters);
+ }
+
+ private function newProperty(
+ $name,
+ $value,
+ array $parameters = array()) {
+
+ $map = array(
+ '^' => '^^',
+ "\n" => '^n',
+ '"' => "^'",
+ );
+
+ $writable_params = array();
+ foreach ($parameters as $k => $parameter) {
+ $value_list = array();
+ foreach ($parameter['values'] as $v) {
+ $v = str_replace(array_keys($map), array_values($map), $v);
+
+ // If the parameter value isn't a very simple one, quote it.
+
+ // RFC5545 says that we MUST quote it if it has a colon, a semicolon,
+ // or a comma, and that we MUST quote it if it's a URI.
+ if (!preg_match('/^[A-Za-z0-9-]*\z/', $v)) {
+ $v = '"'.$v.'"';
+ }
+
+ $value_list[] = $v;
+ }
+
+ $writable_params[] = array(
+ 'name' => $parameter['name'],
+ 'value' => implode(',', $value_list),
+ );
+ }
+
+ return array(
+ 'name' => $name,
+ 'value' => $value,
+ 'parameters' => $writable_params,
+ );
+ }
+
+}
diff --git a/src/parser/calendar/ics/__tests__/PhutilICSParserTestCase.php b/src/parser/calendar/ics/__tests__/PhutilICSParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/PhutilICSParserTestCase.php
@@ -0,0 +1,341 @@
+parseICSSingleEvent('simple.ics');
+
+ $this->assertEqual(
+ array(
+ array(
+ 'name' => 'CREATED',
+ 'parameters' => array(),
+ 'value' => array(
+ 'type' => 'DATE-TIME',
+ 'value' => array(
+ '20160908T172702Z',
+ ),
+ 'raw' => '20160908T172702Z',
+ ),
+ ),
+ array(
+ 'name' => 'UID',
+ 'parameters' => array(),
+ 'value' => array(
+ 'type' => 'TEXT',
+ 'value' => array(
+ '1CEB57AF-0C9C-402D-B3BD-D75BD4843F68',
+ ),
+ 'raw' => '1CEB57AF-0C9C-402D-B3BD-D75BD4843F68',
+ ),
+ ),
+ array(
+ 'name' => 'DTSTART',
+ 'parameters' => array(
+ array(
+ 'name' => 'TZID',
+ 'values' => array(
+ array(
+ 'value' => 'America/Los_Angeles',
+ 'quoted' => false,
+ ),
+ ),
+ ),
+ ),
+ 'value' => array(
+ 'type' => 'DATE-TIME',
+ 'value' => array(
+ '20160915T090000',
+ ),
+ 'raw' => '20160915T090000',
+ ),
+ ),
+ array(
+ 'name' => 'DTEND',
+ 'parameters' => array(
+ array(
+ 'name' => 'TZID',
+ 'values' => array(
+ array(
+ 'value' => 'America/Los_Angeles',
+ 'quoted' => false,
+ ),
+ ),
+ ),
+ ),
+ 'value' => array(
+ 'type' => 'DATE-TIME',
+ 'value' => array(
+ '20160915T100000',
+ ),
+ 'raw' => '20160915T100000',
+ ),
+ ),
+ array(
+ 'name' => 'SUMMARY',
+ 'parameters' => array(),
+ 'value' => array(
+ 'type' => 'TEXT',
+ 'value' => array(
+ 'Simple Event',
+ ),
+ 'raw' => 'Simple Event',
+ ),
+ ),
+ array(
+ 'name' => 'DESCRIPTION',
+ 'parameters' => array(),
+ 'value' => array(
+ 'type' => 'TEXT',
+ 'value' => array(
+ 'This is a simple event.',
+ ),
+ 'raw' => 'This is a simple event.',
+ ),
+ ),
+ ),
+ $event->getAttribute('ics.properties'));
+
+ $this->assertEqual(
+ 'Simple Event',
+ $event->getName());
+
+ $this->assertEqual(
+ 'This is a simple event.',
+ $event->getDescription());
+
+ $this->assertEqual(
+ 1473955200,
+ $event->getStartDateTime()->getEpoch());
+
+ $this->assertEqual(
+ 1473955200 + phutil_units('1 hour in seconds'),
+ $event->getEndDateTime()->getEpoch());
+ }
+
+ public function testICSOddTimezone() {
+ $event = $this->parseICSSingleEvent('zimbra-timezone.ics');
+
+ $start = $event->getStartDateTime();
+
+ $this->assertEqual(
+ '20170303T140000Z',
+ $start->getISO8601());
+ }
+
+ public function testICSFloatingTime() {
+ // This tests "floating" event times, which have no absolute time and are
+ // supposed to be interpreted using the viewer's timezone. It also uses
+ // a duration, and the duration needs to float along with the viewer
+ // timezone.
+
+ $event = $this->parseICSSingleEvent('floating.ics');
+
+ $start = $event->getStartDateTime();
+
+ $caught = null;
+ try {
+ $start->getEpoch();
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue(
+ ($caught instanceof Exception),
+ pht('Expected exception for floating time with no viewer timezone.'));
+
+ $newyears_utc = strtotime('2015-01-01 00:00:00 UTC');
+ $this->assertEqual(1420070400, $newyears_utc);
+
+ $start->setViewerTimezone('UTC');
+ $this->assertEqual(
+ $newyears_utc,
+ $start->getEpoch());
+
+ $start->setViewerTimezone('America/Los_Angeles');
+ $this->assertEqual(
+ $newyears_utc + phutil_units('8 hours in seconds'),
+ $start->getEpoch());
+
+ $start->setViewerTimezone('America/New_York');
+ $this->assertEqual(
+ $newyears_utc + phutil_units('5 hours in seconds'),
+ $start->getEpoch());
+
+ $end = $event->getEndDateTime();
+ $end->setViewerTimezone('UTC');
+ $this->assertEqual(
+ $newyears_utc + phutil_units('24 hours in seconds'),
+ $end->getEpoch());
+
+ $end->setViewerTimezone('America/Los_Angeles');
+ $this->assertEqual(
+ $newyears_utc + phutil_units('32 hours in seconds'),
+ $end->getEpoch());
+
+ $end->setViewerTimezone('America/New_York');
+ $this->assertEqual(
+ $newyears_utc + phutil_units('29 hours in seconds'),
+ $end->getEpoch());
+ }
+
+ public function testICSVALARM() {
+ $event = $this->parseICSSingleEvent('valarm.ics');
+
+ // For now, we parse but ignore VALARM sections. This test just makes
+ // sure they survive parsing.
+
+ $start_epoch = strtotime('2016-10-19 22:00:00 UTC');
+ $this->assertEqual(1476914400, $start_epoch);
+
+ $this->assertEqual(
+ $start_epoch,
+ $event->getStartDateTime()->getEpoch());
+ }
+
+ public function testICSDuration() {
+ $event = $this->parseICSSingleEvent('duration.ics');
+
+ // Raw value is "20160719T095722Z".
+ $start_epoch = strtotime('2016-07-19 09:57:22 UTC');
+ $this->assertEqual(1468922242, $start_epoch);
+
+ // Raw value is "P1DT17H4M23S".
+ $duration =
+ phutil_units('1 day in seconds') +
+ phutil_units('17 hours in seconds') +
+ phutil_units('4 minutes in seconds') +
+ phutil_units('23 seconds in seconds');
+
+ $this->assertEqual(
+ $start_epoch,
+ $event->getStartDateTime()->getEpoch());
+
+ $this->assertEqual(
+ $start_epoch + $duration,
+ $event->getEndDateTime()->getEpoch());
+ }
+
+ public function testICSWeeklyEvent() {
+ $event = $this->parseICSSingleEvent('weekly.ics');
+
+ $start = $event->getStartDateTime();
+ $start->setViewerTimezone('UTC');
+
+ $rrule = $event->getRecurrenceRule()
+ ->setStartDateTime($start);
+
+ $rset = id(new PhutilCalendarRecurrenceSet())
+ ->addSource($rrule);
+
+ $result = $rset->getEventsBetween(null, null, 3);
+
+ $expect = array(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20150811'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20150818'),
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20150825'),
+ );
+
+ $this->assertEqual(
+ mpull($expect, 'getISO8601'),
+ mpull($result, 'getISO8601'),
+ pht('Weekly recurring event.'));
+ }
+
+ public function testICSParserErrors() {
+ $map = array(
+ 'err-missing-end.ics' => PhutilICSParser::PARSE_MISSING_END,
+ 'err-bad-base64.ics' => PhutilICSParser::PARSE_BAD_BASE64,
+ 'err-bad-boolean.ics' => PhutilICSParser::PARSE_BAD_BOOLEAN,
+ 'err-extra-end.ics' => PhutilICSParser::PARSE_EXTRA_END,
+ 'err-initial-unfold.ics' => PhutilICSParser::PARSE_INITIAL_UNFOLD,
+ 'err-malformed-double-quote.ics' =>
+ PhutilICSParser::PARSE_MALFORMED_DOUBLE_QUOTE,
+ 'err-malformed-parameter.ics' =>
+ PhutilICSParser::PARSE_MALFORMED_PARAMETER_NAME,
+ 'err-malformed-property.ics' =>
+ PhutilICSParser::PARSE_MALFORMED_PROPERTY,
+ 'err-missing-value.ics' => PhutilICSParser::PARSE_MISSING_VALUE,
+ 'err-mixmatched-sections.ics' =>
+ PhutilICSParser::PARSE_MISMATCHED_SECTIONS,
+ 'err-root-property.ics' => PhutilICSParser::PARSE_ROOT_PROPERTY,
+ 'err-unescaped-backslash.ics' =>
+ PhutilICSParser::PARSE_UNESCAPED_BACKSLASH,
+ 'err-unexpected-text.ics' => PhutilICSParser::PARSE_UNEXPECTED_TEXT,
+ 'err-multiple-parameters.ics' =>
+ PhutilICSParser::PARSE_MULTIPLE_PARAMETERS,
+ 'err-empty-datetime.ics' =>
+ PhutilICSParser::PARSE_EMPTY_DATETIME,
+ 'err-many-datetime.ics' =>
+ PhutilICSParser::PARSE_MANY_DATETIME,
+ 'err-bad-datetime.ics' =>
+ PhutilICSParser::PARSE_BAD_DATETIME,
+ 'err-empty-duration.ics' =>
+ PhutilICSParser::PARSE_EMPTY_DURATION,
+ 'err-many-duration.ics' =>
+ PhutilICSParser::PARSE_MANY_DURATION,
+ 'err-bad-duration.ics' =>
+ PhutilICSParser::PARSE_BAD_DURATION,
+
+ 'simple.ics' => null,
+ 'good-boolean.ics' => null,
+ 'multiple-vcalendars.ics' => null,
+ );
+
+ foreach ($map as $test_file => $expect) {
+ $caught = null;
+ try {
+ $this->parseICSDocument($test_file);
+ } catch (PhutilICSParserException $ex) {
+ $caught = $ex;
+ }
+
+ if ($expect === null) {
+ $this->assertTrue(
+ ($caught === null),
+ pht(
+ 'Expected no exception parsing "%s", got: %s',
+ $test_file,
+ (string)$ex));
+ } else {
+ if ($caught) {
+ $code = $ex->getParserFailureCode();
+ $explain = pht(
+ 'Expected one exception parsing "%s", got a different '.
+ 'one: %s',
+ $test_file,
+ (string)$ex);
+ } else {
+ $code = null;
+ $explain = pht(
+ 'Expected exception parsing "%s", got none.',
+ $test_file);
+ }
+
+ $this->assertEqual($expect, $code, $explain);
+ }
+ }
+ }
+
+ private function parseICSSingleEvent($name) {
+ $root = $this->parseICSDocument($name);
+
+ $documents = $root->getDocuments();
+ $this->assertEqual(1, count($documents));
+ $document = head($documents);
+
+ $events = $document->getEvents();
+ $this->assertEqual(1, count($events));
+
+ return head($events);
+ }
+
+ private function parseICSDocument($name) {
+ $path = dirname(__FILE__).'/data/'.$name;
+ $data = Filesystem::readFile($path);
+ return id(new PhutilICSParser())
+ ->parseICSData($data);
+ }
+
+
+}
diff --git a/src/parser/calendar/ics/__tests__/PhutilICSWriterTestCase.php b/src/parser/calendar/ics/__tests__/PhutilICSWriterTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/PhutilICSWriterTestCase.php
@@ -0,0 +1,144 @@
+setUID('tea-time')
+ ->setName('Tea Time')
+ ->setDescription(
+ "Tea and, perhaps, crumpets.\n".
+ "Your presence is requested!\n".
+ "This is a long list of types of tea to test line wrapping: {$teas}.")
+ ->setCreatedDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160915T070000Z'))
+ ->setModifiedDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160915T070000Z'))
+ ->setStartDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160916T150000Z'))
+ ->setEndDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160916T160000Z'));
+
+ $ics_data = $this->writeICSSingleEvent($event);
+
+ $this->assertICS('writer-tea-time.ics', $ics_data);
+ }
+
+ public function testICSWriterChristmas() {
+ $start = PhutilCalendarAbsoluteDateTime::newFromISO8601('20001225T000000Z');
+ $end = PhutilCalendarAbsoluteDateTime::newFromISO8601('20001226T000000Z');
+
+ $rrule = id(new PhutilCalendarRecurrenceRule())
+ ->setFrequency(PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY)
+ ->setByMonth(array(12))
+ ->setByMonthDay(array(25));
+
+ $event = id(new PhutilCalendarEventNode())
+ ->setUID('recurring-christmas')
+ ->setName('Christmas')
+ ->setDescription('Festival holiday first occurring in the year 2000.')
+ ->setStartDateTime($start)
+ ->setEndDateTime($end)
+ ->setCreatedDateTime($start)
+ ->setModifiedDateTime($start)
+ ->setRecurrenceRule($rrule)
+ ->setRecurrenceExceptions(
+ array(
+ // In 2007, Christmas was cancelled.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20071225T000000Z'),
+ ))
+ ->setRecurrenceDates(
+ array(
+ // We had an extra early Christmas in 2009.
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20091125T000000Z'),
+ ));
+
+ $ics_data = $this->writeICSSingleEvent($event);
+ $this->assertICS('writer-recurring-christmas.ics', $ics_data);
+ }
+
+ public function testICSWriterAllDay() {
+ $event = id(new PhutilCalendarEventNode())
+ ->setUID('christmas-day')
+ ->setName('Christmas 2016')
+ ->setDescription('A minor religious holiday.')
+ ->setCreatedDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160901T232425Z'))
+ ->setModifiedDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20160901T232425Z'))
+ ->setStartDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20161225'))
+ ->setEndDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20161226'));
+
+ $ics_data = $this->writeICSSingleEvent($event);
+
+ $this->assertICS('writer-christmas.ics', $ics_data);
+ }
+
+ public function testICSWriterUsers() {
+ $event = id(new PhutilCalendarEventNode())
+ ->setUID('office-party')
+ ->setName('Office Party')
+ ->setCreatedDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20161001T120000Z'))
+ ->setModifiedDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20161001T120000Z'))
+ ->setStartDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20161215T200000Z'))
+ ->setEndDateTime(
+ PhutilCalendarAbsoluteDateTime::newFromISO8601('20161215T230000Z'))
+ ->setOrganizer(
+ id(new PhutilCalendarUserNode())
+ ->setName('Big Boss')
+ ->setURI('mailto:big.boss@example.com'))
+ ->addAttendee(
+ id(new PhutilCalendarUserNode())
+ ->setName('Milton')
+ ->setStatus(PhutilCalendarUserNode::STATUS_INVITED)
+ ->setURI('mailto:milton@example.com'))
+ ->addAttendee(
+ id(new PhutilCalendarUserNode())
+ ->setName('Nancy')
+ ->setStatus(PhutilCalendarUserNode::STATUS_ACCEPTED)
+ ->setURI('mailto:nancy@example.com'));
+
+ $ics_data = $this->writeICSSingleEvent($event);
+ $this->assertICS('writer-office-party.ics', $ics_data);
+ }
+
+ private function writeICSSingleEvent(PhutilCalendarEventNode $event) {
+ $calendar = id(new PhutilCalendarDocumentNode())
+ ->appendChild($event);
+
+ $root = id(new PhutilCalendarRootNode())
+ ->appendChild($calendar);
+
+ return $this->writeICS($root);
+ }
+
+ private function writeICS(PhutilCalendarRootNode $root) {
+ return id(new PhutilICSWriter())
+ ->writeICSDocument($root);
+ }
+
+ private function assertICS($name, $actual) {
+ $path = dirname(__FILE__).'/data/'.$name;
+ $data = Filesystem::readFile($path);
+ $this->assertEqual($data, $actual, pht('ICS: %s', $name));
+ }
+
+}
diff --git a/src/parser/calendar/ics/__tests__/data/duration.ics b/src/parser/calendar/ics/__tests__/data/duration.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/duration.ics
@@ -0,0 +1,8 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:20160719T095722Z
+DURATION:P1DT17H4M23S
+SUMMARY:Duration Event
+DESCRIPTION:This is an event with a complex duration.
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-bad-base64.ics b/src/parser/calendar/ics/__tests__/data/err-bad-base64.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-bad-base64.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DATA;VALUE=BINARY;ENCODING=BASE64:
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-bad-boolean.ics b/src/parser/calendar/ics/__tests__/data/err-bad-boolean.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-bad-boolean.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DUCK;VALUE=BOOLEAN:QUACK
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-bad-datetime.ics b/src/parser/calendar/ics/__tests__/data/err-bad-datetime.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-bad-datetime.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:quack
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-bad-duration.ics b/src/parser/calendar/ics/__tests__/data/err-bad-duration.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-bad-duration.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DURATION:quack
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-empty-datetime.ics b/src/parser/calendar/ics/__tests__/data/err-empty-datetime.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-empty-datetime.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-empty-duration.ics b/src/parser/calendar/ics/__tests__/data/err-empty-duration.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-empty-duration.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DURATION:
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-extra-end.ics b/src/parser/calendar/ics/__tests__/data/err-extra-end.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-extra-end.ics
@@ -0,0 +1 @@
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-initial-unfold.ics b/src/parser/calendar/ics/__tests__/data/err-initial-unfold.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-initial-unfold.ics
@@ -0,0 +1,2 @@
+ BEGIN:VCALENDAR
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-malformed-double-quote.ics b/src/parser/calendar/ics/__tests__/data/err-malformed-double-quote.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-malformed-double-quote.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+A;B="C:D
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-malformed-parameter.ics b/src/parser/calendar/ics/__tests__/data/err-malformed-parameter.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-malformed-parameter.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+A;B:C
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-malformed-property.ics b/src/parser/calendar/ics/__tests__/data/err-malformed-property.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-malformed-property.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+PEANUTBUTTER&JELLY:sandwich
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-many-datetime.ics b/src/parser/calendar/ics/__tests__/data/err-many-datetime.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-many-datetime.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:20130101,20130101
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-many-duration.ics b/src/parser/calendar/ics/__tests__/data/err-many-duration.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-many-duration.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DURATION:P1W,P2W
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-missing-end.ics b/src/parser/calendar/ics/__tests__/data/err-missing-end.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-missing-end.ics
@@ -0,0 +1,2 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
diff --git a/src/parser/calendar/ics/__tests__/data/err-missing-value.ics b/src/parser/calendar/ics/__tests__/data/err-missing-value.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-missing-value.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+TRIANGLE;color=red
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-mixmatched-sections.ics b/src/parser/calendar/ics/__tests__/data/err-mixmatched-sections.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-mixmatched-sections.ics
@@ -0,0 +1,4 @@
+BEGIN:A
+BEGIN:B
+END:A
+END:B
diff --git a/src/parser/calendar/ics/__tests__/data/err-multiple-parameters.ics b/src/parser/calendar/ics/__tests__/data/err-multiple-parameters.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-multiple-parameters.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART;TZID=A,B:20160915T090000
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-root-property.ics b/src/parser/calendar/ics/__tests__/data/err-root-property.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-root-property.ics
@@ -0,0 +1 @@
+NAME:value
diff --git a/src/parser/calendar/ics/__tests__/data/err-unescaped-backslash.ics b/src/parser/calendar/ics/__tests__/data/err-unescaped-backslash.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-unescaped-backslash.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+STORY:The duck coughed up an unescaped backslash: \
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/err-unexpected-text.ics b/src/parser/calendar/ics/__tests__/data/err-unexpected-text.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/err-unexpected-text.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+SQUARE;color=red"
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/floating.ics b/src/parser/calendar/ics/__tests__/data/floating.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/floating.ics
@@ -0,0 +1,8 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:20150101T000000
+DURATION:P1D
+SUMMARY:New Year's 2015
+DESCRIPTION:This is an event with a floating start time.
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/good-boolean.ics b/src/parser/calendar/ics/__tests__/data/good-boolean.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/good-boolean.ics
@@ -0,0 +1,5 @@
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DUCK;VALUE=BOOLEAN:TRUE
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/multiple-vcalendars.ics b/src/parser/calendar/ics/__tests__/data/multiple-vcalendars.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/multiple-vcalendars.ics
@@ -0,0 +1,4 @@
+BEGIN:VCALENDAR
+END:VCALENDAR
+BEGIN:VCALENDAR
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/simple.ics b/src/parser/calendar/ics/__tests__/data/simple.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/simple.ics
@@ -0,0 +1,12 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+CALSCALE:GREGORIAN
+BEGIN:VEVENT
+CREATED:20160908T172702Z
+UID:1CEB57AF-0C9C-402D-B3BD-D75BD4843F68
+DTSTART;TZID=America/Los_Angeles:20160915T090000
+DTEND;TZID=America/Los_Angeles:20160915T100000
+SUMMARY:Simple Event
+DESCRIPTION:This is a simple event.
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/valarm.ics b/src/parser/calendar/ics/__tests__/data/valarm.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/valarm.ics
@@ -0,0 +1,16 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VEVENT
+CREATED:20161027T173727
+DTSTAMP:20161027T173727
+LAST-MODIFIED:20161027T173727
+UID:aic4zm86mg
+SUMMARY:alarm event
+DTSTART;TZID=Europe/Berlin:20161020T000000
+DTEND;TZID=Europe/Berlin:20161020T010000
+BEGIN:VALARM
+ACTION:AUDIO
+TRIGGER:-PT15M
+END:VALARM
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/weekly.ics b/src/parser/calendar/ics/__tests__/data/weekly.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/weekly.ics
@@ -0,0 +1,14 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VEVENT
+TRANSP:OPAQUE
+DTEND;VALUE=DATE:20150812
+LAST-MODIFIED:20160822T130015Z
+UID:4AE69E91-4A51-4B77-8849-85981E037A83
+DTSTAMP:20161129T152151Z
+SUMMARY:Weekly Event
+DTSTART;VALUE=DATE:20150811
+CREATED:20141109T163445Z
+RRULE:FREQ=WEEKLY
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/writer-christmas.ics b/src/parser/calendar/ics/__tests__/data/writer-christmas.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/writer-christmas.ics
@@ -0,0 +1,13 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Phacility//Phabricator//EN
+BEGIN:VEVENT
+UID:christmas-day
+CREATED:20160901T232425Z
+DTSTAMP:20160901T232425Z
+DTSTART;VALUE=DATE:20161225
+DTEND;VALUE=DATE:20161226
+SUMMARY:Christmas 2016
+DESCRIPTION:A minor religious holiday.
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/writer-office-party.ics b/src/parser/calendar/ics/__tests__/data/writer-office-party.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/writer-office-party.ics
@@ -0,0 +1,15 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Phacility//Phabricator//EN
+BEGIN:VEVENT
+UID:office-party
+CREATED:20161001T120000Z
+DTSTAMP:20161001T120000Z
+DTSTART:20161215T200000Z
+DTEND:20161215T230000Z
+SUMMARY:Office Party
+ORGANIZER;CN="Big Boss":mailto:big.boss@example.com
+ATTENDEE;CN=Milton;PARTSTAT=NEEDS-ACTION:mailto:milton@example.com
+ATTENDEE;CN=Nancy;PARTSTAT=ACCEPTED:mailto:nancy@example.com
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/writer-recurring-christmas.ics b/src/parser/calendar/ics/__tests__/data/writer-recurring-christmas.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/writer-recurring-christmas.ics
@@ -0,0 +1,16 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Phacility//Phabricator//EN
+BEGIN:VEVENT
+UID:recurring-christmas
+CREATED:20001225T000000Z
+DTSTAMP:20001225T000000Z
+DTSTART:20001225T000000Z
+DTEND:20001226T000000Z
+SUMMARY:Christmas
+DESCRIPTION:Festival holiday first occurring in the year 2000.
+RRULE:FREQ=YEARLY;BYMONTH=12;BYMONTHDAY=25
+EXDATE:20071225T000000Z
+RDATE:20091125T000000Z
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/writer-tea-time.ics b/src/parser/calendar/ics/__tests__/data/writer-tea-time.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/writer-tea-time.ics
@@ -0,0 +1,16 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Phacility//Phabricator//EN
+BEGIN:VEVENT
+UID:tea-time
+CREATED:20160915T070000Z
+DTSTAMP:20160915T070000Z
+DTSTART:20160916T150000Z
+DTEND:20160916T160000Z
+SUMMARY:Tea Time
+DESCRIPTION:Tea and\, perhaps\, crumpets.\nYour presence is requested!\nThi
+ s is a long list of types of tea to test line wrapping: earl grey tea\, En
+ glish breakfast tea\, black tea\, green tea\, t-rex\, oolong tea\, mint te
+ a\, tea with milk.
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/calendar/ics/__tests__/data/zimbra-timezone.ics b/src/parser/calendar/ics/__tests__/data/zimbra-timezone.ics
new file mode 100644
--- /dev/null
+++ b/src/parser/calendar/ics/__tests__/data/zimbra-timezone.ics
@@ -0,0 +1,12 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+CALSCALE:GREGORIAN
+BEGIN:VEVENT
+CREATED:20161104T220244Z
+UID:zimbra-timezone
+SUMMARY:Zimbra Timezone
+DTSTART;TZID="(GMT-05.00) Auto-Detected":20170303T090000
+DTSTAMP:20161104T220244Z
+SEQUENCE:0
+END:VEVENT
+END:VCALENDAR
diff --git a/src/parser/exception/PhutilINIParserException.php b/src/parser/exception/PhutilINIParserException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/exception/PhutilINIParserException.php
@@ -0,0 +1,3 @@
+sourceLine = $line;
+ $this->sourceChar = $char;
+ $this->sourceToken = $token;
+ $this->expected = $expected;
+
+ parent::__construct(
+ pht('Parse error on line %d at column %d: %s', $line, $char, $message));
+ }
+
+ public function getSourceLine() {
+ return $this->sourceLine;
+ }
+
+ public function getSourceChar() {
+ return $this->sourceChar;
+ }
+
+ public function getSourceToken() {
+ return $this->sourceToken;
+ }
+
+ public function getExpectedTokens() {
+ return $this->expected;
+ }
+
+}
diff --git a/src/parser/exception/PhutilTypeCheckException.php b/src/parser/exception/PhutilTypeCheckException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/exception/PhutilTypeCheckException.php
@@ -0,0 +1,40 @@
+getType() == 'regex') {
+ if (is_string($value)) {
+ $message = pht(
+ "Expected a regular expression, but '%s' is not valid: %s",
+ $value,
+ $err);
+ } else {
+ $message = pht(
+ 'Expected a regular expression, but value is not valid: %s',
+ $err);
+ }
+ } else {
+ $message = pht(
+ "Expected type '%s', got type '%s'.",
+ $type->toString(),
+ PhutilTypeSpec::getTypeOf($value));
+ }
+
+ parent::__construct($invalid.' '.$message);
+ }
+
+}
diff --git a/src/parser/exception/PhutilTypeExtraParametersException.php b/src/parser/exception/PhutilTypeExtraParametersException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/exception/PhutilTypeExtraParametersException.php
@@ -0,0 +1,21 @@
+parameters;
+ }
+
+ public function __construct(array $extra) {
+ $message = pht(
+ 'Got unexpected parameters: %s',
+ implode(', ', array_keys($extra)));
+
+ parent::__construct($message);
+
+ $this->parameters = $extra;
+ }
+
+}
diff --git a/src/parser/exception/PhutilTypeMissingParametersException.php b/src/parser/exception/PhutilTypeMissingParametersException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/exception/PhutilTypeMissingParametersException.php
@@ -0,0 +1,21 @@
+parameters;
+ }
+
+ public function __construct(array $missing) {
+ $message = pht(
+ 'Missing required parameters: %s',
+ implode(', ', $missing));
+
+ parent::__construct($message);
+
+ $this->parameters = $missing;
+ }
+
+}
diff --git a/src/parser/generator/exception/PhutilInvalidRuleParserGeneratorException.php b/src/parser/generator/exception/PhutilInvalidRuleParserGeneratorException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/generator/exception/PhutilInvalidRuleParserGeneratorException.php
@@ -0,0 +1,4 @@
+body = new PhutilRope();
+ }
+
+ public function setHeaders(array $headers) {
+ $this->headers = $headers;
+ return $this;
+ }
+
+ public function getHeaders() {
+ return $this->headers;
+ }
+
+ public function setStatus(HTTPFutureResponseStatus $status) {
+ $this->status = $status;
+ return $this;
+ }
+
+ public function getStatus() {
+ return $this->status;
+ }
+
+ public function appendBody($bytes) {
+ $this->body->append($bytes);
+ }
+
+ public function getBody() {
+ return $this->body->getAsString();
+ }
+
+}
diff --git a/src/parser/http/PhutilHTTPResponseParser.php b/src/parser/http/PhutilHTTPResponseParser.php
new file mode 100644
--- /dev/null
+++ b/src/parser/http/PhutilHTTPResponseParser.php
@@ -0,0 +1,174 @@
+followLocationHeaders = $follow_location_headers;
+ return $this;
+ }
+
+ public function getFollowLocationHeaders() {
+ return $this->followLocationHeaders;
+ }
+
+ public function readBytes($bytes) {
+ if ($this->state == 'discard') {
+ return $this;
+ }
+
+ $this->buffer .= $bytes;
+
+ while (true) {
+ if ($this->state == 'headers') {
+ $matches = null;
+
+ $ok = preg_match(
+ "/(\r?\n\r?\n)/",
+ $this->buffer,
+ $matches,
+ PREG_OFFSET_CAPTURE);
+ if (!$ok) {
+ break;
+ }
+
+ $headers_len = $matches[1][1];
+ $boundary_len = strlen($matches[1][0]);
+ $raw_headers = substr($this->buffer, 0, $headers_len);
+ $this->buffer = substr($this->buffer, $headers_len + $boundary_len);
+
+ $header_lines = phutil_split_lines($raw_headers);
+ $first_line = array_shift($header_lines);
+ $response_valid = true;
+
+ $matches = null;
+ $ok = preg_match(
+ '(^HTTP/\S+\s+(\d+)(?:\s+(.*))?$)i',
+ $first_line,
+ $matches);
+
+ if ($ok) {
+ $http_code = (int)$matches[1];
+ $http_status = phutil_utf8_strtolower($matches[2]);
+ } else {
+ $response_valid = false;
+ }
+
+ $header_list = array();
+ $saw_location = false;
+ foreach ($header_lines as $header_line) {
+ $pos = strpos($header_line, ':');
+ if ($pos === false) {
+ $response_valid = false;
+ break;
+ }
+
+ $name = substr($header_line, 0, $pos);
+ $value = ltrim(substr($header_line, $pos + 1), ' ');
+
+ if (phutil_utf8_strtolower($name) == 'location') {
+ $saw_location = true;
+ }
+
+ $header_list[] = array(
+ $name,
+ $value,
+ );
+ }
+
+ // If the response didn't start with a properly formatted "HTTP/..."
+ // line, or any of the header lines were not formatted correctly, add
+ // a malformed response to the response list and discard anything else
+ // we're given.
+ if (!$response_valid) {
+ $malformed = new HTTPFutureParseResponseStatus(
+ HTTPFutureParseResponseStatus::ERROR_MALFORMED_RESPONSE,
+ $raw_headers);
+
+ $this->newHTTPRepsonse()
+ ->setStatus($malformed);
+
+ $this->buffer = '';
+ $this->state = 'discard';
+ break;
+ }
+
+ // Otherwise, we have a valid set of response headers.
+ $response_status = new HTTPFutureHTTPResponseStatus(
+ $http_code,
+ null,
+ $header_list);
+
+ $this->newHTTPResponse()
+ ->setStatus($response_status)
+ ->setHeaders($header_list);
+
+ $is_https_proxy =
+ ($http_code === 200) &&
+ ($http_status === 'connection established');
+
+ if ($http_code === 100) {
+ // If this is "HTTP/1.1 100 Continue", this is just the server
+ // telling us that everything is okay. This response won't have
+ // a body associated with it.
+ $more_headers = true;
+ } else if ($is_https_proxy) {
+ // If this is "HTTP/1.1 200 Connection Established", this is a
+ // response to a CONNECT request made automatically by cURL to
+ // an HTTPS proxy. This response won't have a body associated
+ // with it, and the real body will follow later.
+ $more_headers = true;
+ } else if ($saw_location && $this->followLocationHeaders) {
+ // If we're following location headers and this response had
+ // a location header, cURL will automatically follow it. This
+ // response shouldn't have a body.
+ $more_headers = true;
+ } else {
+ $more_headers = false;
+ }
+
+ // If we're expecting more headers, we're going to stay in the
+ // "headers" state and parse another set of headers. Otherwise,
+ // we transition to the "body" state and look for a body.
+ if (!$more_headers) {
+ $this->state = 'body';
+ }
+
+ continue;
+ }
+
+ if ($this->state == 'body') {
+ if (strlen($this->buffer)) {
+ $this->response->appendBody($this->buffer);
+ $this->buffer = '';
+ }
+ break;
+ }
+ }
+
+ return $this;
+ }
+
+ public function getResponses() {
+ if ($this->state !== 'body') {
+ throw new HTTPFutureParseResponseStatus(
+ HTTPFutureParseResponseStatus::ERROR_MALFORMED_RESPONSE,
+ $this->buffer);
+ }
+
+ return $this->responses;
+ }
+
+ private function newHTTPResponse() {
+ $response = new PhutilHTTPResponse();
+ $this->responses[] = $response;
+ $this->response = $response;
+ return $response;
+ }
+
+}
diff --git a/src/parser/http/__tests__/PhutilHTTPResponseParserTestCase.php b/src/parser/http/__tests__/PhutilHTTPResponseParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/http/__tests__/PhutilHTTPResponseParserTestCase.php
@@ -0,0 +1,145 @@
+assertParse(
+ array(
+ array(
+ 'headers' => array(
+ array('Duck', 'Quack'),
+ ),
+ 'body' => 'I am the very model of a modern major general.',
+ ),
+ ),
+ $input);
+
+ $input = <<assertParse(
+ array(
+ array(
+ 'code' => 200,
+ 'headers' => array(
+ array('X-I-Am-A-Proxy-Server', 'Hello'),
+ ),
+ 'body' => '',
+ ),
+ array(
+ 'code' => 100,
+ 'headers' => array(
+ array('X-Everything-Is-Fine', 'true'),
+ ),
+ 'body' => '',
+ ),
+ array(
+ 'code' => 302,
+ 'headers' => array(
+ array('Location', 'Over-There'),
+ ),
+ 'body' => '',
+ ),
+ array(
+ 'code' => 404,
+ 'headers' => array(),
+ 'body' => 'Not all who wander are lost.',
+ ),
+ ),
+ $input,
+ id(new PhutilHTTPResponseParser())
+ ->setFollowLocationHeaders(true));
+
+ $input = <<assertParse(
+ array(
+ array(
+ 'code' => 200,
+ 'headers' => array(
+ array('Reason', 'none'),
+ ),
+ 'body' =>
+ 'This response has no "reason-phrase", which is unusual but valid.',
+ ),
+ ),
+ $input,
+ id(new PhutilHTTPResponseParser()));
+ }
+
+ private function assertParse(array $expect, $input, $parser = null) {
+ if ($parser === null) {
+ $parser = new PhutilHTTPResponseParser();
+ }
+
+ // Submit the input in little bits to try to catch any weird parser bugs.
+ $length = strlen($input);
+ $pos = 0;
+ while ($pos < $length) {
+ $next_len = mt_rand(1, 32);
+ $piece = substr($input, $pos, $next_len);
+ $pos = $pos + $next_len;
+
+ $parser->readBytes($piece);
+ }
+
+ $responses = $parser->getResponses();
+
+ $this->assertEqual(count($expect), count($responses));
+
+ $expect = array_values($expect);
+ $responses = array_values($responses);
+
+ for ($ii = 0; $ii < count($expect); $ii++) {
+ $expect_map = $expect[$ii];
+ $actual = $responses[$ii];
+
+ foreach ($expect_map as $key => $spec) {
+ switch ($key) {
+ case 'headers':
+ $this->assertEqual($spec, $actual->getHeaders());
+ break;
+ case 'body':
+ $this->assertEqual($spec, $actual->getBody());
+ break;
+ case 'code':
+ $status = $actual->getStatus();
+ $this->assertTrue($status instanceof HTTPFutureHTTPResponseStatus);
+ $this->assertEqual($spec, $status->getStatusCode());
+ break;
+ default:
+ throw new Exception(
+ pht(
+ 'Unknown HTTPResponseParser test ("%s").',
+ $key));
+ }
+ }
+ }
+ }
+
+}
diff --git a/src/parser/xhpast/__tests__/PHPASTParserTestCase.php b/src/parser/xhpast/__tests__/PHPASTParserTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/PHPASTParserTestCase.php
@@ -0,0 +1,136 @@
+assertSkipped(
+ pht('%s is not built or not up to date.', 'xhpast'));
+ }
+ }
+
+ $dir = dirname(__FILE__).'/data/';
+ foreach (Filesystem::listDirectory($dir) as $file) {
+ if (preg_match('/\.test$/', $file)) {
+ $this->executeParserTest($file, $dir.$file);
+ }
+ }
+ }
+
+ private function executeParserTest($name, $file) {
+ $contents = Filesystem::readFile($file);
+ $contents = preg_split('/^~{4,}\n/m', $contents);
+
+ if (count($contents) < 2) {
+ throw new Exception(
+ pht(
+ "Expected '%s' separating test case and results.",
+ '~~~~~~~~~~'));
+ }
+
+ list($data, $options, $expect) = array_merge($contents, array(null));
+
+ $options = id(new PhutilSimpleOptions())->parse($options);
+
+ $type = null;
+ foreach ($options as $key => $value) {
+ switch ($key) {
+ case 'pass':
+ case 'fail-syntax':
+ case 'fail-parse':
+ if ($type !== null) {
+ throw new Exception(
+ pht(
+ 'Test file "%s" unexpectedly specifies multiple expected '.
+ 'test outcomes.',
+ $name));
+ }
+ $type = $key;
+ break;
+ case 'comment':
+ // Human readable comment providing test case information.
+ break;
+ case 'rtrim':
+ // Allows construction of tests which rely on EOF without newlines.
+ $data = rtrim($data);
+ break;
+ default:
+ throw new Exception(
+ pht(
+ 'Test file "%s" has unknown option "%s" in its options '.
+ 'string.',
+ $name,
+ $key));
+ }
+ }
+
+ if ($type === null) {
+ throw new Exception(
+ pht(
+ 'Test file "%s" does not specify a test result (like "pass") in '.
+ 'its options string.',
+ $name));
+ }
+
+ $future = PhutilXHPASTBinary::getParserFuture($data);
+ list($err, $stdout, $stderr) = $future->resolve();
+
+ switch ($type) {
+ case 'pass':
+ case 'fail-parse':
+ $this->assertEqual(0, $err, pht('Exit code for "%s".', $name));
+
+ if (!strlen($expect)) {
+ // If there's no "expect" data in the test case, that's OK.
+ break;
+ }
+
+ try {
+ $expect = phutil_json_decode($expect);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht(
+ 'Expect data for test "%s" is not valid JSON.',
+ $name),
+ $ex);
+ }
+
+ try {
+ $stdout = phutil_json_decode($stdout);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht(
+ 'Output for test file "%s" is not valid JSON.',
+ $name),
+ $ex);
+ }
+
+ $json = new PhutilJSON();
+
+ $expect_nice = $json->encodeFormatted($expect);
+ $stdout_nice = $json->encodeFormatted($stdout);
+
+ if ($type == 'pass') {
+ $this->assertEqual(
+ $expect_nice,
+ $stdout_nice,
+ pht('Parser output for "%s".', $name));
+ } else {
+ $this->assertFalse(
+ ($expect_nice == $stdout_nice),
+ pht('Expected parser to parse "%s" incorrectly.', $name));
+ }
+ break;
+ case 'fail-syntax':
+ $this->assertEqual(1, $err, pht('Exit code for "%s".', $name));
+ $this->assertTrue(
+ (bool)preg_match('/syntax error/', $stderr),
+ pht('Expect "syntax error" in stderr or "%s".', $name));
+ break;
+ }
+ }
+
+}
diff --git a/src/parser/xhpast/__tests__/data/base-fail-parse.php.test b/src/parser/xhpast/__tests__/data/base-fail-parse.php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/base-fail-parse.php.test
@@ -0,0 +1,8 @@
+ 2 <=> 3;
+~~~~~~~~~~
+fail-syntax, comment=Spaceship operator is non-associative
diff --git a/src/parser/xhpast/__tests__/data/operator-spaceship.php.test b/src/parser/xhpast/__tests__/data/operator-spaceship.php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/operator-spaceship.php.test
@@ -0,0 +1,93 @@
+ 2;
+~~~~~~~~~~
+pass
+~~~~~~~~~~
+{
+ "tree": [
+ 9000,
+ 0,
+ 8,
+ [
+ [
+ 9006,
+ 0,
+ 7,
+ [
+ [
+ 9007,
+ 0,
+ 0
+ ],
+ [
+ 9004,
+ 2,
+ 7,
+ [
+ [
+ 9077,
+ 2,
+ 6,
+ [
+ [
+ 9086,
+ 2,
+ 2
+ ],
+ [
+ 9081,
+ 4,
+ 4
+ ],
+ [
+ 9086,
+ 6,
+ 6
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ "stream": [
+ [
+ 373,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 285,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ]
+ ]
+}
diff --git a/src/parser/xhpast/__tests__/data/optional-parameter.php.test b/src/parser/xhpast/__tests__/data/optional-parameter.php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/optional-parameter.php.test
@@ -0,0 +1,282 @@
+b;
+
+new a->c();
+~~~~~~~~~~
+fail-syntax
diff --git a/src/parser/xhpast/__tests__/data/php-access-on-instanciation.test b/src/parser/xhpast/__tests__/data/php-access-on-instanciation.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/php-access-on-instanciation.test
@@ -0,0 +1,663 @@
+b;
+
+$e = (new a)->c();
+
+(new a)->b;
+
+(new a)->c();
+~~~~~~~~~~
+pass
+~~~~~~~~~~
+{
+ "tree": [
+ 9000,
+ 0,
+ 74,
+ [
+ [
+ 9006,
+ 0,
+ 73,
+ [
+ [
+ 9007,
+ 0,
+ 0
+ ],
+ [
+ 9004,
+ 2,
+ 25,
+ [
+ [
+ 9051,
+ 2,
+ 25,
+ [
+ [
+ 9052,
+ 2,
+ 2
+ ],
+ [
+ 9090,
+ 4,
+ 4
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 6,
+ 25,
+ [
+ [
+ 9004,
+ 8,
+ 11,
+ [
+ [
+ 9063,
+ 8,
+ 10,
+ [
+ [
+ 9070,
+ 8,
+ 8,
+ [
+ [
+ 9013,
+ 8,
+ 8
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 10,
+ 10,
+ [
+ [
+ 9047,
+ 10,
+ 10
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 13,
+ 23,
+ [
+ [
+ 9067,
+ 13,
+ 23,
+ [
+ [
+ 9068,
+ 13,
+ 13,
+ [
+ [
+ 9013,
+ 13,
+ 13
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 17,
+ 17
+ ],
+ [
+ 9059,
+ 18,
+ 19
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 21,
+ 23
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 27,
+ 38,
+ [
+ [
+ 9077,
+ 27,
+ 37,
+ [
+ [
+ 9047,
+ 27,
+ 27
+ ],
+ [
+ 9081,
+ 29,
+ 29
+ ],
+ [
+ 9092,
+ 31,
+ 37,
+ [
+ [
+ 9074,
+ 31,
+ 35,
+ [
+ [
+ 9090,
+ 34,
+ 34
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9013,
+ 37,
+ 37
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 40,
+ 53,
+ [
+ [
+ 9077,
+ 40,
+ 52,
+ [
+ [
+ 9047,
+ 40,
+ 40
+ ],
+ [
+ 9081,
+ 42,
+ 42
+ ],
+ [
+ 9102,
+ 44,
+ 52,
+ [
+ [
+ 9092,
+ 44,
+ 50,
+ [
+ [
+ 9074,
+ 44,
+ 48,
+ [
+ [
+ 9090,
+ 47,
+ 47
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9013,
+ 50,
+ 50
+ ]
+ ]
+ ],
+ [
+ 9095,
+ 51,
+ 52
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 55,
+ 62,
+ [
+ [
+ 9092,
+ 55,
+ 61,
+ [
+ [
+ 9074,
+ 55,
+ 59,
+ [
+ [
+ 9090,
+ 58,
+ 58
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9013,
+ 61,
+ 61
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 64,
+ 73,
+ [
+ [
+ 9102,
+ 64,
+ 72,
+ [
+ [
+ 9092,
+ 64,
+ 70,
+ [
+ [
+ 9074,
+ 64,
+ 68,
+ [
+ [
+ 9090,
+ 67,
+ 67
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9013,
+ 70,
+ 70
+ ]
+ ]
+ ],
+ [
+ 9095,
+ 71,
+ 72
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ "stream": [
+ [
+ 373,
+ 5
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 352,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 352,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 302,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 362,
+ 2
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 302,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 362,
+ 2
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 302,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 362,
+ 2
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 302,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 362,
+ 2
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ]
+ ]
+}
diff --git a/src/parser/xhpast/__tests__/data/php-array-dereference-2.test b/src/parser/xhpast/__tests__/data/php-array-dereference-2.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/php-array-dereference-2.test
@@ -0,0 +1,185 @@
+getStatus()['running']) {
+ // do something
+}
+~~~~~~~~~~
+pass
+~~~~~~~~~~
+{
+ "tree": [
+ 9000,
+ 0,
+ 19,
+ [
+ [
+ 9006,
+ 0,
+ 18,
+ [
+ [
+ 9007,
+ 0,
+ 0
+ ],
+ [
+ 9004,
+ 2,
+ 18,
+ [
+ [
+ 9015,
+ 2,
+ 18,
+ [
+ [
+ 9017,
+ 2,
+ 18,
+ [
+ [
+ 9016,
+ 4,
+ 13,
+ [
+ [
+ 9102,
+ 5,
+ 12,
+ [
+ [
+ 9092,
+ 5,
+ 7,
+ [
+ [
+ 9047,
+ 5,
+ 5
+ ],
+ [
+ 9013,
+ 7,
+ 7
+ ]
+ ]
+ ],
+ [
+ 9100,
+ 8,
+ 12,
+ [
+ [
+ 9095,
+ 8,
+ 9
+ ],
+ [
+ 9087,
+ 11,
+ 11
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 15,
+ 18
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ "stream": [
+ [
+ 373,
+ 5
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 362,
+ 2
+ ],
+ [
+ 311,
+ 9
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 91,
+ 1
+ ],
+ [
+ 319,
+ 9
+ ],
+ [
+ 93,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 371,
+ 16
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ]
+ ]
+}
diff --git a/src/parser/xhpast/__tests__/data/php-array-dereference-3.test b/src/parser/xhpast/__tests__/data/php-array-dereference-3.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/php-array-dereference-3.test
@@ -0,0 +1,209 @@
+ $y) {}
+foreach ($x as $k => &$y) {}
+
+foreach (array() as $x) {}
+foreach (array() as $k => $y) {}
+
+foreach ($x as $y):
+endforeach;
+
+declare(x=1);
+
+declare(y=1) {
+}
+
+declare(z=1):
+enddeclare;
+
+try {} catch (C $x) {}
+try {} catch (C $x) {} catch (D $x) {}
+
+throw 1;
+
+clone $q;
+$x + $x;
+$x - $x;
+$x * $x;
+$x / $x;
+$x . $x;
+$x % $x;
+$x & $x;
+$x | $x;
+$x ^ $x;
+$x << $x;
+$x >> $x;
+$x++;
+++$x;
+$x--;
+--$x;
++$x;
+-$x;
+!$x;
+~$x;
+$x == $x;
+$x === $x;
+$x != $x;
+$x !== $x;
+$x = $x;
+$x < $x;
+$x <= $x;
+$x > $x;
+$x >= $x;
+$x instanceof $x;
+($x);
+($x ? $x : $x);
+($x ?: $x);
+$x || $x;
+$x && $x;
+$x and $x;
+$x or $x;
+$x xor $x;
+$x += $x;
+$x -= $x;
+$x *= $x;
+$x /= $x;
+$x .= $x;
+$x %= $x;
+$x &= $x;
+$x |= $x;
+$x ^= $x;
+$x <<= $x;
+$x >>= $x;
+(int)$x;
+(double)$x;
+(string)$x;
+(binary)$x;
+(array)$x;
+(object)$x;
+(bool)$x;
+(unset)$x;
+$x[] = $x;
+
+@$x;
+
+__LINE__;
+__FILE__;
+__DIR__;
+__CLASS__;
+__METHOD__;
+__FUNCTION__;
+__NAMESPACE__;
+
+goto lbl;
+~~~~~~~~~~
+pass
+~~~~~~~~~~
+{
+ "tree": [
+ 9000,
+ 0,
+ 1376,
+ [
+ [
+ 9006,
+ 0,
+ 1375,
+ [
+ [
+ 9007,
+ 0,
+ 0
+ ],
+ [
+ 9004,
+ 2,
+ 3,
+ [
+ [
+ 9086,
+ 2,
+ 2
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 5,
+ 9,
+ [
+ [
+ 9082,
+ 5,
+ 8,
+ [
+ [
+ 9093,
+ 6,
+ 8,
+ [
+ [
+ 9094,
+ 7,
+ 7,
+ [
+ [
+ 9005
+ ],
+ [
+ 9086,
+ 7,
+ 7
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 11,
+ 18,
+ [
+ [
+ 9050,
+ 11,
+ 18,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 13,
+ 13
+ ],
+ [
+ 9059,
+ 14,
+ 15
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 17,
+ 18
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 20,
+ 28,
+ [
+ [
+ 9050,
+ 20,
+ 28,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 22,
+ 22
+ ],
+ [
+ 9059,
+ 23,
+ 25,
+ [
+ [
+ 9060,
+ 24,
+ 24,
+ [
+ [
+ 9005
+ ],
+ [
+ 9047,
+ 24,
+ 24
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 27,
+ 28
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 30,
+ 39,
+ [
+ [
+ 9050,
+ 30,
+ 39,
+ [
+ [
+ 9005
+ ],
+ [
+ 9048,
+ 32,
+ 32
+ ],
+ [
+ 9013,
+ 33,
+ 33
+ ],
+ [
+ 9059,
+ 34,
+ 36,
+ [
+ [
+ 9060,
+ 35,
+ 35,
+ [
+ [
+ 9005
+ ],
+ [
+ 9047,
+ 35,
+ 35
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 38,
+ 39
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 41,
+ 50,
+ [
+ [
+ 9050,
+ 41,
+ 50,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 43,
+ 43
+ ],
+ [
+ 9059,
+ 44,
+ 47,
+ [
+ [
+ 9060,
+ 45,
+ 45,
+ [
+ [
+ 9005
+ ],
+ [
+ 9049,
+ 45,
+ 46,
+ [
+ [
+ 9047,
+ 46,
+ 46
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 49,
+ 50
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 52,
+ 62,
+ [
+ [
+ 9050,
+ 52,
+ 62,
+ [
+ [
+ 9005
+ ],
+ [
+ 9048,
+ 54,
+ 54
+ ],
+ [
+ 9013,
+ 55,
+ 55
+ ],
+ [
+ 9059,
+ 56,
+ 59,
+ [
+ [
+ 9060,
+ 57,
+ 57,
+ [
+ [
+ 9005
+ ],
+ [
+ 9049,
+ 57,
+ 58,
+ [
+ [
+ 9047,
+ 58,
+ 58
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 61,
+ 62
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 64,
+ 74,
+ [
+ [
+ 9050,
+ 64,
+ 74,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 66,
+ 66
+ ],
+ [
+ 9059,
+ 67,
+ 71,
+ [
+ [
+ 9060,
+ 68,
+ 70,
+ [
+ [
+ 9090,
+ 68,
+ 68
+ ],
+ [
+ 9047,
+ 70,
+ 70
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 73,
+ 74
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 76,
+ 86,
+ [
+ [
+ 9050,
+ 76,
+ 86,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 78,
+ 78
+ ],
+ [
+ 9059,
+ 79,
+ 83,
+ [
+ [
+ 9060,
+ 80,
+ 82,
+ [
+ [
+ 9061,
+ 80,
+ 80
+ ],
+ [
+ 9047,
+ 82,
+ 82
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 85,
+ 86
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 88,
+ 104,
+ [
+ [
+ 9050,
+ 88,
+ 104,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 90,
+ 90
+ ],
+ [
+ 9059,
+ 91,
+ 101,
+ [
+ [
+ 9060,
+ 92,
+ 100,
+ [
+ [
+ 9061,
+ 92,
+ 92
+ ],
+ [
+ 9047,
+ 94,
+ 94
+ ],
+ [
+ 9082,
+ 98,
+ 100,
+ [
+ [
+ 9093,
+ 99,
+ 100
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 103,
+ 104
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 106,
+ 118,
+ [
+ [
+ 9050,
+ 106,
+ 118,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 108,
+ 108
+ ],
+ [
+ 9059,
+ 109,
+ 115,
+ [
+ [
+ 9060,
+ 110,
+ 114,
+ [
+ [
+ 9005
+ ],
+ [
+ 9047,
+ 110,
+ 110
+ ],
+ [
+ 9001,
+ 114,
+ 114
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 117,
+ 118
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 120,
+ 134,
+ [
+ [
+ 9050,
+ 120,
+ 134,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 122,
+ 122
+ ],
+ [
+ 9059,
+ 123,
+ 131,
+ [
+ [
+ 9060,
+ 124,
+ 130,
+ [
+ [
+ 9090,
+ 124,
+ 124
+ ],
+ [
+ 9047,
+ 126,
+ 126
+ ],
+ [
+ 9001,
+ 130,
+ 130
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 133,
+ 134
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 136,
+ 141,
+ [
+ [
+ 9051,
+ 136,
+ 141,
+ [
+ [
+ 9052,
+ 136,
+ 136
+ ],
+ [
+ 9090,
+ 138,
+ 138
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 140,
+ 141
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 143,
+ 152,
+ [
+ [
+ 9051,
+ 143,
+ 152,
+ [
+ [
+ 9052,
+ 143,
+ 143
+ ],
+ [
+ 9090,
+ 145,
+ 145
+ ],
+ [
+ 9054,
+ 147,
+ 149,
+ [
+ [
+ 9090,
+ 149,
+ 149
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 151,
+ 152
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 154,
+ 167,
+ [
+ [
+ 9051,
+ 154,
+ 167,
+ [
+ [
+ 9052,
+ 154,
+ 154
+ ],
+ [
+ 9090,
+ 156,
+ 156
+ ],
+ [
+ 9054,
+ 158,
+ 160,
+ [
+ [
+ 9090,
+ 160,
+ 160
+ ]
+ ]
+ ],
+ [
+ 9055,
+ 162,
+ 164,
+ [
+ [
+ 9090,
+ 164,
+ 164
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 166,
+ 167
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 169,
+ 185,
+ [
+ [
+ 9051,
+ 169,
+ 185,
+ [
+ [
+ 9052,
+ 169,
+ 169
+ ],
+ [
+ 9090,
+ 171,
+ 171
+ ],
+ [
+ 9054,
+ 173,
+ 175,
+ [
+ [
+ 9090,
+ 175,
+ 175
+ ]
+ ]
+ ],
+ [
+ 9055,
+ 177,
+ 182,
+ [
+ [
+ 9090,
+ 179,
+ 179
+ ],
+ [
+ 9090,
+ 182,
+ 182
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 184,
+ 185
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 187,
+ 194,
+ [
+ [
+ 9051,
+ 187,
+ 194,
+ [
+ [
+ 9052,
+ 187,
+ 189,
+ [
+ [
+ 9013,
+ 187,
+ 187
+ ]
+ ]
+ ],
+ [
+ 9090,
+ 191,
+ 191
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 193,
+ 194
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 196,
+ 203,
+ [
+ [
+ 9051,
+ 196,
+ 203,
+ [
+ [
+ 9052,
+ 196,
+ 198,
+ [
+ [
+ 9013,
+ 196,
+ 196
+ ]
+ ]
+ ],
+ [
+ 9090,
+ 200,
+ 200
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 202,
+ 203
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 205,
+ 354,
+ [
+ [
+ 9051,
+ 205,
+ 354,
+ [
+ [
+ 9052,
+ 205,
+ 207,
+ [
+ [
+ 9013,
+ 205,
+ 205
+ ]
+ ]
+ ],
+ [
+ 9090,
+ 209,
+ 209
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 211,
+ 354,
+ [
+ [
+ 9004,
+ 213,
+ 220,
+ [
+ [
+ 9065,
+ 213,
+ 219,
+ [
+ [
+ 9066,
+ 215,
+ 219,
+ [
+ [
+ 9013,
+ 215,
+ 215
+ ],
+ [
+ 9086,
+ 219,
+ 219
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 222,
+ 236,
+ [
+ [
+ 9065,
+ 222,
+ 235,
+ [
+ [
+ 9066,
+ 224,
+ 228,
+ [
+ [
+ 9013,
+ 224,
+ 224
+ ],
+ [
+ 9086,
+ 228,
+ 228
+ ]
+ ]
+ ],
+ [
+ 9066,
+ 231,
+ 235,
+ [
+ [
+ 9013,
+ 231,
+ 231
+ ],
+ [
+ 9086,
+ 235,
+ 235
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 238,
+ 241,
+ [
+ [
+ 9063,
+ 238,
+ 240,
+ [
+ [
+ 9070,
+ 238,
+ 238,
+ [
+ [
+ 9013,
+ 238,
+ 238
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 240,
+ 240,
+ [
+ [
+ 9047,
+ 240,
+ 240
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 243,
+ 249,
+ [
+ [
+ 9063,
+ 243,
+ 248,
+ [
+ [
+ 9070,
+ 243,
+ 243,
+ [
+ [
+ 9013,
+ 243,
+ 243
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 245,
+ 245,
+ [
+ [
+ 9047,
+ 245,
+ 245
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 248,
+ 248,
+ [
+ [
+ 9047,
+ 248,
+ 248
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 251,
+ 254,
+ [
+ [
+ 9063,
+ 251,
+ 253,
+ [
+ [
+ 9070,
+ 251,
+ 251,
+ [
+ [
+ 9013,
+ 251,
+ 251
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 253,
+ 253,
+ [
+ [
+ 9047,
+ 253,
+ 253
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 256,
+ 262,
+ [
+ [
+ 9063,
+ 256,
+ 261,
+ [
+ [
+ 9070,
+ 256,
+ 256,
+ [
+ [
+ 9013,
+ 256,
+ 256
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 258,
+ 258,
+ [
+ [
+ 9047,
+ 258,
+ 258
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 261,
+ 261,
+ [
+ [
+ 9047,
+ 261,
+ 261
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 264,
+ 271,
+ [
+ [
+ 9063,
+ 264,
+ 270,
+ [
+ [
+ 9070,
+ 264,
+ 264,
+ [
+ [
+ 9013,
+ 264,
+ 264
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 266,
+ 270,
+ [
+ [
+ 9047,
+ 266,
+ 266
+ ],
+ [
+ 9086,
+ 270,
+ 270
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 273,
+ 289,
+ [
+ [
+ 9063,
+ 273,
+ 288,
+ [
+ [
+ 9070,
+ 273,
+ 275,
+ [
+ [
+ 9013,
+ 273,
+ 273
+ ],
+ [
+ 9013,
+ 275,
+ 275
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 277,
+ 281,
+ [
+ [
+ 9047,
+ 277,
+ 277
+ ],
+ [
+ 9086,
+ 281,
+ 281
+ ]
+ ]
+ ],
+ [
+ 9064,
+ 284,
+ 288,
+ [
+ [
+ 9047,
+ 284,
+ 284
+ ],
+ [
+ 9086,
+ 288,
+ 288
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 291,
+ 298,
+ [
+ [
+ 9067,
+ 291,
+ 298,
+ [
+ [
+ 9068
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 293,
+ 293
+ ],
+ [
+ 9059,
+ 294,
+ 295
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 297,
+ 298
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 300,
+ 309,
+ [
+ [
+ 9067,
+ 300,
+ 309,
+ [
+ [
+ 9068,
+ 300,
+ 300,
+ [
+ [
+ 9013,
+ 300,
+ 300
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 304,
+ 304
+ ],
+ [
+ 9059,
+ 305,
+ 306
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 308,
+ 309
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 311,
+ 320,
+ [
+ [
+ 9067,
+ 311,
+ 320,
+ [
+ [
+ 9068,
+ 311,
+ 311,
+ [
+ [
+ 9013,
+ 311,
+ 311
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 315,
+ 315
+ ],
+ [
+ 9059,
+ 316,
+ 317
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 319,
+ 320
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 322,
+ 331,
+ [
+ [
+ 9067,
+ 322,
+ 331,
+ [
+ [
+ 9068,
+ 322,
+ 322,
+ [
+ [
+ 9013,
+ 322,
+ 322
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 326,
+ 326
+ ],
+ [
+ 9059,
+ 327,
+ 328
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 330,
+ 331
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 333,
+ 341,
+ [
+ [
+ 9067,
+ 333,
+ 341,
+ [
+ [
+ 9068
+ ],
+ [
+ 9048,
+ 335,
+ 335
+ ],
+ [
+ 9013,
+ 336,
+ 336
+ ],
+ [
+ 9059,
+ 337,
+ 338
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 340,
+ 341
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 343,
+ 352,
+ [
+ [
+ 9067,
+ 343,
+ 352,
+ [
+ [
+ 9068,
+ 343,
+ 343,
+ [
+ [
+ 9013,
+ 343,
+ 343
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 347,
+ 347
+ ],
+ [
+ 9059,
+ 348,
+ 349
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 351,
+ 352
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 356,
+ 373,
+ [
+ [
+ 9051,
+ 356,
+ 373,
+ [
+ [
+ 9052,
+ 356,
+ 358,
+ [
+ [
+ 9013,
+ 356,
+ 356
+ ]
+ ]
+ ],
+ [
+ 9090,
+ 360,
+ 360
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 362,
+ 373,
+ [
+ [
+ 9004,
+ 364,
+ 370,
+ [
+ [
+ 9067,
+ 364,
+ 370,
+ [
+ [
+ 9068,
+ 364,
+ 364,
+ [
+ [
+ 9013,
+ 364,
+ 364
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 368,
+ 368
+ ],
+ [
+ 9059,
+ 369,
+ 370
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 375,
+ 380,
+ [
+ [
+ 9056,
+ 375,
+ 380,
+ [
+ [
+ 9052
+ ],
+ [
+ 9090,
+ 377,
+ 377
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 379,
+ 380
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 382,
+ 391,
+ [
+ [
+ 9056,
+ 382,
+ 391,
+ [
+ [
+ 9052
+ ],
+ [
+ 9090,
+ 384,
+ 384
+ ],
+ [
+ 9054,
+ 386,
+ 388,
+ [
+ [
+ 9090,
+ 388,
+ 388
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 390,
+ 391
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 393,
+ 405,
+ [
+ [
+ 9056,
+ 393,
+ 405,
+ [
+ [
+ 9052
+ ],
+ [
+ 9090,
+ 395,
+ 395
+ ],
+ [
+ 9054,
+ 397,
+ 402,
+ [
+ [
+ 9090,
+ 399,
+ 399
+ ],
+ [
+ 9090,
+ 402,
+ 402
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 404,
+ 405
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 407,
+ 410,
+ [
+ [
+ 9009,
+ 407,
+ 409,
+ [
+ [
+ 9010,
+ 409,
+ 409,
+ [
+ [
+ 9001,
+ 409,
+ 409
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 412,
+ 418,
+ [
+ [
+ 9009,
+ 412,
+ 417,
+ [
+ [
+ 9010,
+ 414,
+ 414,
+ [
+ [
+ 9001,
+ 414,
+ 414
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9010,
+ 417,
+ 417,
+ [
+ [
+ 9001,
+ 417,
+ 417
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 420,
+ 446,
+ [
+ [
+ 9009,
+ 420,
+ 445,
+ [
+ [
+ 9010,
+ 422,
+ 426,
+ [
+ [
+ 9001,
+ 422,
+ 422
+ ],
+ [
+ 9013,
+ 426,
+ 426
+ ]
+ ]
+ ],
+ [
+ 9010,
+ 429,
+ 433,
+ [
+ [
+ 9001,
+ 429,
+ 429
+ ],
+ [
+ 9013,
+ 433,
+ 433
+ ]
+ ]
+ ],
+ [
+ 9010,
+ 436,
+ 437,
+ [
+ [
+ 9001,
+ 436,
+ 437
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9010,
+ 440,
+ 445,
+ [
+ [
+ 9001,
+ 440,
+ 441
+ ],
+ [
+ 9013,
+ 445,
+ 445
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 448,
+ 455,
+ [
+ [
+ 9011,
+ 448,
+ 454,
+ [
+ [
+ 9012,
+ 450,
+ 454,
+ [
+ [
+ 9013,
+ 450,
+ 450
+ ],
+ [
+ 9086,
+ 454,
+ 454
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 457,
+ 471,
+ [
+ [
+ 9011,
+ 457,
+ 470,
+ [
+ [
+ 9012,
+ 459,
+ 463,
+ [
+ [
+ 9013,
+ 459,
+ 459
+ ],
+ [
+ 9086,
+ 463,
+ 463
+ ]
+ ]
+ ],
+ [
+ 9012,
+ 466,
+ 470,
+ [
+ [
+ 9013,
+ 466,
+ 466
+ ],
+ [
+ 9086,
+ 470,
+ 470
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9014,
+ 473,
+ 474,
+ [
+ [
+ 9013,
+ 473,
+ 473
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 476,
+ 483,
+ [
+ [
+ 9015,
+ 476,
+ 483,
+ [
+ [
+ 9017,
+ 476,
+ 483,
+ [
+ [
+ 9016,
+ 478,
+ 480,
+ [
+ [
+ 9086,
+ 479,
+ 479
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 482,
+ 483
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 485,
+ 497,
+ [
+ [
+ 9015,
+ 485,
+ 497,
+ [
+ [
+ 9017,
+ 485,
+ 492,
+ [
+ [
+ 9016,
+ 487,
+ 489,
+ [
+ [
+ 9086,
+ 488,
+ 488
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 491,
+ 492
+ ]
+ ]
+ ],
+ [
+ 9019,
+ 494,
+ 497,
+ [
+ [
+ 9006,
+ 496,
+ 497
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 499,
+ 520,
+ [
+ [
+ 9015,
+ 499,
+ 520,
+ [
+ [
+ 9017,
+ 499,
+ 506,
+ [
+ [
+ 9016,
+ 501,
+ 503,
+ [
+ [
+ 9086,
+ 502,
+ 502
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 505,
+ 506
+ ]
+ ]
+ ],
+ [
+ 9018,
+ 508,
+ 515,
+ [
+ [
+ 9016,
+ 510,
+ 512,
+ [
+ [
+ 9086,
+ 511,
+ 511
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 514,
+ 515
+ ]
+ ]
+ ],
+ [
+ 9019,
+ 517,
+ 520,
+ [
+ [
+ 9006,
+ 519,
+ 520
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 522,
+ 547,
+ [
+ [
+ 9015,
+ 522,
+ 547,
+ [
+ [
+ 9017,
+ 522,
+ 529,
+ [
+ [
+ 9016,
+ 524,
+ 526,
+ [
+ [
+ 9086,
+ 525,
+ 525
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 528,
+ 529
+ ]
+ ]
+ ],
+ [
+ 9018,
+ 531,
+ 538,
+ [
+ [
+ 9016,
+ 533,
+ 535,
+ [
+ [
+ 9086,
+ 534,
+ 534
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 537,
+ 538
+ ]
+ ]
+ ],
+ [
+ 9018,
+ 540,
+ 547,
+ [
+ [
+ 9016,
+ 542,
+ 544,
+ [
+ [
+ 9086,
+ 543,
+ 543
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 546,
+ 547
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 549,
+ 557,
+ [
+ [
+ 9015,
+ 549,
+ 556,
+ [
+ [
+ 9017,
+ 549,
+ 553,
+ [
+ [
+ 9016,
+ 551,
+ 553,
+ [
+ [
+ 9086,
+ 552,
+ 552
+ ]
+ ]
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 559,
+ 570,
+ [
+ [
+ 9015,
+ 559,
+ 569,
+ [
+ [
+ 9017,
+ 559,
+ 563,
+ [
+ [
+ 9016,
+ 561,
+ 563,
+ [
+ [
+ 9086,
+ 562,
+ 562
+ ]
+ ]
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9019,
+ 566,
+ 566,
+ [
+ [
+ 9006
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 572,
+ 587,
+ [
+ [
+ 9015,
+ 572,
+ 586,
+ [
+ [
+ 9017,
+ 572,
+ 576,
+ [
+ [
+ 9016,
+ 574,
+ 576,
+ [
+ [
+ 9086,
+ 575,
+ 575
+ ]
+ ]
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9018,
+ 579,
+ 582,
+ [
+ [
+ 9086,
+ 582,
+ 582
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 589,
+ 611,
+ [
+ [
+ 9015,
+ 589,
+ 610,
+ [
+ [
+ 9017,
+ 589,
+ 593,
+ [
+ [
+ 9016,
+ 591,
+ 593,
+ [
+ [
+ 9086,
+ 592,
+ 592
+ ]
+ ]
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9018,
+ 596,
+ 599,
+ [
+ [
+ 9086,
+ 599,
+ 599
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9018,
+ 603,
+ 606,
+ [
+ [
+ 9086,
+ 606,
+ 606
+ ],
+ [
+ 9006
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 613,
+ 620,
+ [
+ [
+ 9020,
+ 613,
+ 620,
+ [
+ [
+ 9016,
+ 615,
+ 617,
+ [
+ [
+ 9086,
+ 616,
+ 616
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 619,
+ 620
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 622,
+ 630,
+ [
+ [
+ 9020,
+ 622,
+ 630,
+ [
+ [
+ 9016,
+ 624,
+ 626,
+ [
+ [
+ 9086,
+ 625,
+ 625
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 627,
+ 630
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 632,
+ 642,
+ [
+ [
+ 9021,
+ 632,
+ 641,
+ [
+ [
+ 9006,
+ 634,
+ 635
+ ],
+ [
+ 9016,
+ 639,
+ 641,
+ [
+ [
+ 9086,
+ 640,
+ 640
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 644,
+ 652,
+ [
+ [
+ 9022,
+ 644,
+ 652,
+ [
+ [
+ 9023,
+ 646,
+ 649,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 651,
+ 652
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 654,
+ 663,
+ [
+ [
+ 9022,
+ 654,
+ 663,
+ [
+ [
+ 9023,
+ 656,
+ 659,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 660,
+ 663
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 665,
+ 695,
+ [
+ [
+ 9024,
+ 665,
+ 695,
+ [
+ [
+ 9016,
+ 667,
+ 669,
+ [
+ [
+ 9086,
+ 668,
+ 668
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 671,
+ 695,
+ [
+ [
+ 9057,
+ 673,
+ 679,
+ [
+ [
+ 9086,
+ 675,
+ 675
+ ],
+ [
+ 9006,
+ 678,
+ 679,
+ [
+ [
+ 9004,
+ 678,
+ 679,
+ [
+ [
+ 9025,
+ 678,
+ 678,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9057,
+ 681,
+ 687,
+ [
+ [
+ 9086,
+ 683,
+ 683
+ ],
+ [
+ 9006,
+ 686,
+ 687,
+ [
+ [
+ 9004,
+ 686,
+ 687,
+ [
+ [
+ 9025,
+ 686,
+ 686,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9058,
+ 689,
+ 693,
+ [
+ [
+ 9006,
+ 692,
+ 693,
+ [
+ [
+ 9004,
+ 692,
+ 693,
+ [
+ [
+ 9026,
+ 692,
+ 692,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 697,
+ 704,
+ [
+ [
+ 9024,
+ 697,
+ 704,
+ [
+ [
+ 9016,
+ 698,
+ 700,
+ [
+ [
+ 9086,
+ 699,
+ 699
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 702,
+ 704,
+ [
+ [
+ 9004,
+ 703,
+ 703
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 706,
+ 713,
+ [
+ [
+ 9024,
+ 706,
+ 713,
+ [
+ [
+ 9016,
+ 707,
+ 709,
+ [
+ [
+ 9086,
+ 708,
+ 708
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 710,
+ 713
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 715,
+ 716,
+ [
+ [
+ 9025,
+ 715,
+ 715,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 718,
+ 721,
+ [
+ [
+ 9025,
+ 718,
+ 720,
+ [
+ [
+ 9086,
+ 720,
+ 720
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 723,
+ 724,
+ [
+ [
+ 9026,
+ 723,
+ 723,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 726,
+ 729,
+ [
+ [
+ 9026,
+ 726,
+ 728,
+ [
+ [
+ 9086,
+ 728,
+ 728
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 731,
+ 732,
+ [
+ [
+ 9027,
+ 731,
+ 731,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 734,
+ 737,
+ [
+ [
+ 9027,
+ 734,
+ 736,
+ [
+ [
+ 9086,
+ 736,
+ 736
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 739,
+ 742,
+ [
+ [
+ 9027,
+ 739,
+ 741,
+ [
+ [
+ 9047,
+ 741,
+ 741
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 744,
+ 747,
+ [
+ [
+ 9028,
+ 744,
+ 746,
+ [
+ [
+ 9047,
+ 746,
+ 746
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 749,
+ 755,
+ [
+ [
+ 9028,
+ 749,
+ 754,
+ [
+ [
+ 9047,
+ 751,
+ 751
+ ],
+ [
+ 9047,
+ 754,
+ 754
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 757,
+ 761,
+ [
+ [
+ 9028,
+ 757,
+ 760,
+ [
+ [
+ 9062,
+ 759,
+ 760,
+ [
+ [
+ 9047,
+ 760,
+ 760
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 763,
+ 771,
+ [
+ [
+ 9028,
+ 763,
+ 769,
+ [
+ [
+ 9062,
+ 765,
+ 769,
+ [
+ [
+ 9103,
+ 767,
+ 769,
+ [
+ [
+ 9047,
+ 767,
+ 767
+ ],
+ [
+ 9081,
+ 768,
+ 768
+ ],
+ [
+ 9047,
+ 769,
+ 769
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 773,
+ 776,
+ [
+ [
+ 9030,
+ 773,
+ 775,
+ [
+ [
+ 9031,
+ 775,
+ 775,
+ [
+ [
+ 9047,
+ 775,
+ 775
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 778,
+ 784,
+ [
+ [
+ 9030,
+ 778,
+ 783,
+ [
+ [
+ 9031,
+ 780,
+ 780,
+ [
+ [
+ 9047,
+ 780,
+ 780
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9031,
+ 783,
+ 783,
+ [
+ [
+ 9047,
+ 783,
+ 783
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 786,
+ 789,
+ [
+ [
+ 9032,
+ 786,
+ 788,
+ [
+ [
+ 9086,
+ 788,
+ 788
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 791,
+ 797,
+ [
+ [
+ 9032,
+ 791,
+ 796,
+ [
+ [
+ 9086,
+ 793,
+ 793
+ ],
+ [
+ 9086,
+ 796,
+ 796
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 799,
+ 806,
+ [
+ [
+ 9035,
+ 799,
+ 805,
+ [
+ [
+ 9047,
+ 801,
+ 801
+ ],
+ [
+ 9047,
+ 804,
+ 804
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 808,
+ 819,
+ [
+ [
+ 9037,
+ 808,
+ 819,
+ [
+ [
+ 9038,
+ 810,
+ 816,
+ [
+ [
+ 9047,
+ 811,
+ 811
+ ],
+ [
+ 9005
+ ],
+ [
+ 9047,
+ 815,
+ 815
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 818,
+ 819
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 821,
+ 836,
+ [
+ [
+ 9037,
+ 821,
+ 836,
+ [
+ [
+ 9038,
+ 823,
+ 833,
+ [
+ [
+ 9047,
+ 824,
+ 824
+ ],
+ [
+ 9047,
+ 828,
+ 828
+ ],
+ [
+ 9047,
+ 832,
+ 832
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 835,
+ 836
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 838,
+ 854,
+ [
+ [
+ 9037,
+ 838,
+ 854,
+ [
+ [
+ 9038,
+ 840,
+ 851,
+ [
+ [
+ 9047,
+ 841,
+ 841
+ ],
+ [
+ 9047,
+ 845,
+ 845
+ ],
+ [
+ 9049,
+ 849,
+ 850,
+ [
+ [
+ 9047,
+ 850,
+ 850
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 853,
+ 854
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 856,
+ 869,
+ [
+ [
+ 9037,
+ 856,
+ 869,
+ [
+ [
+ 9038,
+ 858,
+ 866,
+ [
+ [
+ 9082,
+ 859,
+ 861,
+ [
+ [
+ 9093,
+ 860,
+ 861
+ ]
+ ]
+ ],
+ [
+ 9005
+ ],
+ [
+ 9047,
+ 865,
+ 865
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 868,
+ 869
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 871,
+ 888,
+ [
+ [
+ 9037,
+ 871,
+ 888,
+ [
+ [
+ 9038,
+ 873,
+ 885,
+ [
+ [
+ 9082,
+ 874,
+ 876,
+ [
+ [
+ 9093,
+ 875,
+ 876
+ ]
+ ]
+ ],
+ [
+ 9047,
+ 880,
+ 880
+ ],
+ [
+ 9047,
+ 884,
+ 884
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 887,
+ 888
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 890,
+ 902,
+ [
+ [
+ 9037,
+ 890,
+ 902,
+ [
+ [
+ 9038,
+ 892,
+ 898,
+ [
+ [
+ 9047,
+ 893,
+ 893
+ ],
+ [
+ 9005
+ ],
+ [
+ 9047,
+ 897,
+ 897
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 899,
+ 902
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 904,
+ 910,
+ [
+ [
+ 9044,
+ 904,
+ 910,
+ [
+ [
+ 9045,
+ 906,
+ 908,
+ [
+ [
+ 9046,
+ 906,
+ 908,
+ [
+ [
+ 9013,
+ 906,
+ 906
+ ],
+ [
+ 9086,
+ 908,
+ 908
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 910,
+ 910,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 912,
+ 921,
+ [
+ [
+ 9044,
+ 912,
+ 921,
+ [
+ [
+ 9045,
+ 914,
+ 916,
+ [
+ [
+ 9046,
+ 914,
+ 916,
+ [
+ [
+ 9013,
+ 914,
+ 914
+ ],
+ [
+ 9086,
+ 916,
+ 916
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 919,
+ 921
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 923,
+ 932,
+ [
+ [
+ 9044,
+ 923,
+ 932,
+ [
+ [
+ 9045,
+ 925,
+ 927,
+ [
+ [
+ 9046,
+ 925,
+ 927,
+ [
+ [
+ 9013,
+ 925,
+ 925
+ ],
+ [
+ 9086,
+ 927,
+ 927
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9006,
+ 929,
+ 932
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 934,
+ 948,
+ [
+ [
+ 9041,
+ 934,
+ 948,
+ [
+ [
+ 9006,
+ 936,
+ 937
+ ],
+ [
+ 9042,
+ 939,
+ 948,
+ [
+ [
+ 9043,
+ 939,
+ 948,
+ [
+ [
+ 9090,
+ 942,
+ 942
+ ],
+ [
+ 9047,
+ 944,
+ 944
+ ],
+ [
+ 9006,
+ 947,
+ 948
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 950,
+ 975,
+ [
+ [
+ 9041,
+ 950,
+ 975,
+ [
+ [
+ 9006,
+ 952,
+ 953
+ ],
+ [
+ 9042,
+ 955,
+ 975,
+ [
+ [
+ 9043,
+ 955,
+ 964,
+ [
+ [
+ 9090,
+ 958,
+ 958
+ ],
+ [
+ 9047,
+ 960,
+ 960
+ ],
+ [
+ 9006,
+ 963,
+ 964
+ ]
+ ]
+ ],
+ [
+ 9043,
+ 966,
+ 975,
+ [
+ [
+ 9090,
+ 969,
+ 969
+ ],
+ [
+ 9047,
+ 971,
+ 971
+ ],
+ [
+ 9006,
+ 974,
+ 975
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 977,
+ 980,
+ [
+ [
+ 9039,
+ 977,
+ 979,
+ [
+ [
+ 9086,
+ 979,
+ 979
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 982,
+ 985,
+ [
+ [
+ 9075,
+ 982,
+ 984,
+ [
+ [
+ 9081,
+ 982,
+ 982
+ ],
+ [
+ 9047,
+ 984,
+ 984
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 987,
+ 992,
+ [
+ [
+ 9077,
+ 987,
+ 991,
+ [
+ [
+ 9047,
+ 987,
+ 987
+ ],
+ [
+ 9081,
+ 989,
+ 989
+ ],
+ [
+ 9047,
+ 991,
+ 991
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 994,
+ 999,
+ [
+ [
+ 9077,
+ 994,
+ 998,
+ [
+ [
+ 9047,
+ 994,
+ 994
+ ],
+ [
+ 9081,
+ 996,
+ 996
+ ],
+ [
+ 9047,
+ 998,
+ 998
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1001,
+ 1006,
+ [
+ [
+ 9077,
+ 1001,
+ 1005,
+ [
+ [
+ 9047,
+ 1001,
+ 1001
+ ],
+ [
+ 9081,
+ 1003,
+ 1003
+ ],
+ [
+ 9047,
+ 1005,
+ 1005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1008,
+ 1013,
+ [
+ [
+ 9077,
+ 1008,
+ 1012,
+ [
+ [
+ 9047,
+ 1008,
+ 1008
+ ],
+ [
+ 9081,
+ 1010,
+ 1010
+ ],
+ [
+ 9047,
+ 1012,
+ 1012
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1015,
+ 1020,
+ [
+ [
+ 9103,
+ 1015,
+ 1019,
+ [
+ [
+ 9047,
+ 1015,
+ 1015
+ ],
+ [
+ 9081,
+ 1017,
+ 1017
+ ],
+ [
+ 9047,
+ 1019,
+ 1019
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1022,
+ 1027,
+ [
+ [
+ 9077,
+ 1022,
+ 1026,
+ [
+ [
+ 9047,
+ 1022,
+ 1022
+ ],
+ [
+ 9081,
+ 1024,
+ 1024
+ ],
+ [
+ 9047,
+ 1026,
+ 1026
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1029,
+ 1034,
+ [
+ [
+ 9077,
+ 1029,
+ 1033,
+ [
+ [
+ 9047,
+ 1029,
+ 1029
+ ],
+ [
+ 9081,
+ 1031,
+ 1031
+ ],
+ [
+ 9047,
+ 1033,
+ 1033
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1036,
+ 1041,
+ [
+ [
+ 9077,
+ 1036,
+ 1040,
+ [
+ [
+ 9047,
+ 1036,
+ 1036
+ ],
+ [
+ 9081,
+ 1038,
+ 1038
+ ],
+ [
+ 9047,
+ 1040,
+ 1040
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1043,
+ 1048,
+ [
+ [
+ 9077,
+ 1043,
+ 1047,
+ [
+ [
+ 9047,
+ 1043,
+ 1043
+ ],
+ [
+ 9081,
+ 1045,
+ 1045
+ ],
+ [
+ 9047,
+ 1047,
+ 1047
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1050,
+ 1055,
+ [
+ [
+ 9077,
+ 1050,
+ 1054,
+ [
+ [
+ 9047,
+ 1050,
+ 1050
+ ],
+ [
+ 9081,
+ 1052,
+ 1052
+ ],
+ [
+ 9047,
+ 1054,
+ 1054
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1057,
+ 1062,
+ [
+ [
+ 9077,
+ 1057,
+ 1061,
+ [
+ [
+ 9047,
+ 1057,
+ 1057
+ ],
+ [
+ 9081,
+ 1059,
+ 1059
+ ],
+ [
+ 9047,
+ 1061,
+ 1061
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1064,
+ 1066,
+ [
+ [
+ 9076,
+ 1064,
+ 1065,
+ [
+ [
+ 9047,
+ 1064,
+ 1064
+ ],
+ [
+ 9081,
+ 1065,
+ 1065
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1068,
+ 1070,
+ [
+ [
+ 9075,
+ 1068,
+ 1069,
+ [
+ [
+ 9081,
+ 1068,
+ 1068
+ ],
+ [
+ 9047,
+ 1069,
+ 1069
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1072,
+ 1074,
+ [
+ [
+ 9076,
+ 1072,
+ 1073,
+ [
+ [
+ 9047,
+ 1072,
+ 1072
+ ],
+ [
+ 9081,
+ 1073,
+ 1073
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1076,
+ 1078,
+ [
+ [
+ 9075,
+ 1076,
+ 1077,
+ [
+ [
+ 9081,
+ 1076,
+ 1076
+ ],
+ [
+ 9047,
+ 1077,
+ 1077
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1080,
+ 1082,
+ [
+ [
+ 9075,
+ 1080,
+ 1081,
+ [
+ [
+ 9081,
+ 1080,
+ 1080
+ ],
+ [
+ 9047,
+ 1081,
+ 1081
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1084,
+ 1086,
+ [
+ [
+ 9075,
+ 1084,
+ 1085,
+ [
+ [
+ 9081,
+ 1084,
+ 1084
+ ],
+ [
+ 9047,
+ 1085,
+ 1085
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1088,
+ 1090,
+ [
+ [
+ 9075,
+ 1088,
+ 1089,
+ [
+ [
+ 9081,
+ 1088,
+ 1088
+ ],
+ [
+ 9047,
+ 1089,
+ 1089
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1092,
+ 1094,
+ [
+ [
+ 9075,
+ 1092,
+ 1093,
+ [
+ [
+ 9081,
+ 1092,
+ 1092
+ ],
+ [
+ 9047,
+ 1093,
+ 1093
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1096,
+ 1101,
+ [
+ [
+ 9077,
+ 1096,
+ 1100,
+ [
+ [
+ 9047,
+ 1096,
+ 1096
+ ],
+ [
+ 9081,
+ 1098,
+ 1098
+ ],
+ [
+ 9047,
+ 1100,
+ 1100
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1103,
+ 1108,
+ [
+ [
+ 9077,
+ 1103,
+ 1107,
+ [
+ [
+ 9047,
+ 1103,
+ 1103
+ ],
+ [
+ 9081,
+ 1105,
+ 1105
+ ],
+ [
+ 9047,
+ 1107,
+ 1107
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1110,
+ 1115,
+ [
+ [
+ 9077,
+ 1110,
+ 1114,
+ [
+ [
+ 9047,
+ 1110,
+ 1110
+ ],
+ [
+ 9081,
+ 1112,
+ 1112
+ ],
+ [
+ 9047,
+ 1114,
+ 1114
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1117,
+ 1122,
+ [
+ [
+ 9077,
+ 1117,
+ 1121,
+ [
+ [
+ 9047,
+ 1117,
+ 1117
+ ],
+ [
+ 9081,
+ 1119,
+ 1119
+ ],
+ [
+ 9047,
+ 1121,
+ 1121
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1124,
+ 1129,
+ [
+ [
+ 9077,
+ 1124,
+ 1128,
+ [
+ [
+ 9047,
+ 1124,
+ 1124
+ ],
+ [
+ 9081,
+ 1126,
+ 1126
+ ],
+ [
+ 9047,
+ 1128,
+ 1128
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1131,
+ 1136,
+ [
+ [
+ 9077,
+ 1131,
+ 1135,
+ [
+ [
+ 9047,
+ 1131,
+ 1131
+ ],
+ [
+ 9081,
+ 1133,
+ 1133
+ ],
+ [
+ 9047,
+ 1135,
+ 1135
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1138,
+ 1143,
+ [
+ [
+ 9077,
+ 1138,
+ 1142,
+ [
+ [
+ 9047,
+ 1138,
+ 1138
+ ],
+ [
+ 9081,
+ 1140,
+ 1140
+ ],
+ [
+ 9047,
+ 1142,
+ 1142
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1145,
+ 1150,
+ [
+ [
+ 9077,
+ 1145,
+ 1149,
+ [
+ [
+ 9047,
+ 1145,
+ 1145
+ ],
+ [
+ 9081,
+ 1147,
+ 1147
+ ],
+ [
+ 9047,
+ 1149,
+ 1149
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1152,
+ 1157,
+ [
+ [
+ 9077,
+ 1152,
+ 1156,
+ [
+ [
+ 9047,
+ 1152,
+ 1152
+ ],
+ [
+ 9081,
+ 1154,
+ 1154
+ ],
+ [
+ 9047,
+ 1156,
+ 1156
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1159,
+ 1164,
+ [
+ [
+ 9077,
+ 1159,
+ 1163,
+ [
+ [
+ 9047,
+ 1159,
+ 1159
+ ],
+ [
+ 9081,
+ 1161,
+ 1161
+ ],
+ [
+ 9047,
+ 1163,
+ 1163
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1166,
+ 1169,
+ [
+ [
+ 9104,
+ 1166,
+ 1168,
+ [
+ [
+ 9047,
+ 1167,
+ 1167
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1171,
+ 1182,
+ [
+ [
+ 9104,
+ 1171,
+ 1181,
+ [
+ [
+ 9078,
+ 1172,
+ 1180,
+ [
+ [
+ 9047,
+ 1172,
+ 1172
+ ],
+ [
+ 9081,
+ 1174,
+ 1174
+ ],
+ [
+ 9047,
+ 1176,
+ 1176
+ ],
+ [
+ 9081,
+ 1178,
+ 1178
+ ],
+ [
+ 9047,
+ 1180,
+ 1180
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1184,
+ 1192,
+ [
+ [
+ 9104,
+ 1184,
+ 1191,
+ [
+ [
+ 9078,
+ 1185,
+ 1190,
+ [
+ [
+ 9047,
+ 1185,
+ 1185
+ ],
+ [
+ 9081,
+ 1187,
+ 1187
+ ],
+ [
+ 9005
+ ],
+ [
+ 9081,
+ 1188,
+ 1188
+ ],
+ [
+ 9047,
+ 1190,
+ 1190
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1194,
+ 1199,
+ [
+ [
+ 9077,
+ 1194,
+ 1198,
+ [
+ [
+ 9047,
+ 1194,
+ 1194
+ ],
+ [
+ 9081,
+ 1196,
+ 1196
+ ],
+ [
+ 9047,
+ 1198,
+ 1198
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1201,
+ 1206,
+ [
+ [
+ 9077,
+ 1201,
+ 1205,
+ [
+ [
+ 9047,
+ 1201,
+ 1201
+ ],
+ [
+ 9081,
+ 1203,
+ 1203
+ ],
+ [
+ 9047,
+ 1205,
+ 1205
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1208,
+ 1213,
+ [
+ [
+ 9077,
+ 1208,
+ 1212,
+ [
+ [
+ 9047,
+ 1208,
+ 1208
+ ],
+ [
+ 9081,
+ 1210,
+ 1210
+ ],
+ [
+ 9047,
+ 1212,
+ 1212
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1215,
+ 1220,
+ [
+ [
+ 9077,
+ 1215,
+ 1219,
+ [
+ [
+ 9047,
+ 1215,
+ 1215
+ ],
+ [
+ 9081,
+ 1217,
+ 1217
+ ],
+ [
+ 9047,
+ 1219,
+ 1219
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1222,
+ 1227,
+ [
+ [
+ 9077,
+ 1222,
+ 1226,
+ [
+ [
+ 9047,
+ 1222,
+ 1222
+ ],
+ [
+ 9081,
+ 1224,
+ 1224
+ ],
+ [
+ 9047,
+ 1226,
+ 1226
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1229,
+ 1234,
+ [
+ [
+ 9077,
+ 1229,
+ 1233,
+ [
+ [
+ 9047,
+ 1229,
+ 1229
+ ],
+ [
+ 9081,
+ 1231,
+ 1231
+ ],
+ [
+ 9047,
+ 1233,
+ 1233
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1236,
+ 1241,
+ [
+ [
+ 9077,
+ 1236,
+ 1240,
+ [
+ [
+ 9047,
+ 1236,
+ 1236
+ ],
+ [
+ 9081,
+ 1238,
+ 1238
+ ],
+ [
+ 9047,
+ 1240,
+ 1240
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1243,
+ 1248,
+ [
+ [
+ 9077,
+ 1243,
+ 1247,
+ [
+ [
+ 9047,
+ 1243,
+ 1243
+ ],
+ [
+ 9081,
+ 1245,
+ 1245
+ ],
+ [
+ 9047,
+ 1247,
+ 1247
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1250,
+ 1255,
+ [
+ [
+ 9077,
+ 1250,
+ 1254,
+ [
+ [
+ 9047,
+ 1250,
+ 1250
+ ],
+ [
+ 9081,
+ 1252,
+ 1252
+ ],
+ [
+ 9047,
+ 1254,
+ 1254
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1257,
+ 1262,
+ [
+ [
+ 9077,
+ 1257,
+ 1261,
+ [
+ [
+ 9047,
+ 1257,
+ 1257
+ ],
+ [
+ 9081,
+ 1259,
+ 1259
+ ],
+ [
+ 9047,
+ 1261,
+ 1261
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1264,
+ 1269,
+ [
+ [
+ 9077,
+ 1264,
+ 1268,
+ [
+ [
+ 9047,
+ 1264,
+ 1264
+ ],
+ [
+ 9081,
+ 1266,
+ 1266
+ ],
+ [
+ 9047,
+ 1268,
+ 1268
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1271,
+ 1276,
+ [
+ [
+ 9077,
+ 1271,
+ 1275,
+ [
+ [
+ 9047,
+ 1271,
+ 1271
+ ],
+ [
+ 9081,
+ 1273,
+ 1273
+ ],
+ [
+ 9047,
+ 1275,
+ 1275
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1278,
+ 1283,
+ [
+ [
+ 9077,
+ 1278,
+ 1282,
+ [
+ [
+ 9047,
+ 1278,
+ 1278
+ ],
+ [
+ 9081,
+ 1280,
+ 1280
+ ],
+ [
+ 9047,
+ 1282,
+ 1282
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1285,
+ 1290,
+ [
+ [
+ 9077,
+ 1285,
+ 1289,
+ [
+ [
+ 9047,
+ 1285,
+ 1285
+ ],
+ [
+ 9081,
+ 1287,
+ 1287
+ ],
+ [
+ 9047,
+ 1289,
+ 1289
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1292,
+ 1297,
+ [
+ [
+ 9077,
+ 1292,
+ 1296,
+ [
+ [
+ 9047,
+ 1292,
+ 1292
+ ],
+ [
+ 9081,
+ 1294,
+ 1294
+ ],
+ [
+ 9047,
+ 1296,
+ 1296
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1299,
+ 1304,
+ [
+ [
+ 9077,
+ 1299,
+ 1303,
+ [
+ [
+ 9047,
+ 1299,
+ 1299
+ ],
+ [
+ 9081,
+ 1301,
+ 1301
+ ],
+ [
+ 9047,
+ 1303,
+ 1303
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1306,
+ 1308,
+ [
+ [
+ 9079,
+ 1306,
+ 1307,
+ [
+ [
+ 9080,
+ 1306,
+ 1306
+ ],
+ [
+ 9047,
+ 1307,
+ 1307
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1310,
+ 1312,
+ [
+ [
+ 9079,
+ 1310,
+ 1311,
+ [
+ [
+ 9080,
+ 1310,
+ 1310
+ ],
+ [
+ 9047,
+ 1311,
+ 1311
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1314,
+ 1316,
+ [
+ [
+ 9079,
+ 1314,
+ 1315,
+ [
+ [
+ 9080,
+ 1314,
+ 1314
+ ],
+ [
+ 9047,
+ 1315,
+ 1315
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1318,
+ 1320,
+ [
+ [
+ 9079,
+ 1318,
+ 1319,
+ [
+ [
+ 9080,
+ 1318,
+ 1318
+ ],
+ [
+ 9047,
+ 1319,
+ 1319
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1322,
+ 1324,
+ [
+ [
+ 9079,
+ 1322,
+ 1323,
+ [
+ [
+ 9080,
+ 1322,
+ 1322
+ ],
+ [
+ 9047,
+ 1323,
+ 1323
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1326,
+ 1328,
+ [
+ [
+ 9079,
+ 1326,
+ 1327,
+ [
+ [
+ 9080,
+ 1326,
+ 1326
+ ],
+ [
+ 9047,
+ 1327,
+ 1327
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1330,
+ 1332,
+ [
+ [
+ 9079,
+ 1330,
+ 1331,
+ [
+ [
+ 9080,
+ 1330,
+ 1330
+ ],
+ [
+ 9047,
+ 1331,
+ 1331
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1334,
+ 1336,
+ [
+ [
+ 9079,
+ 1334,
+ 1335,
+ [
+ [
+ 9080,
+ 1334,
+ 1334
+ ],
+ [
+ 9047,
+ 1335,
+ 1335
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1338,
+ 1345,
+ [
+ [
+ 9077,
+ 1338,
+ 1344,
+ [
+ [
+ 9100,
+ 1338,
+ 1340,
+ [
+ [
+ 9047,
+ 1338,
+ 1338
+ ],
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9081,
+ 1342,
+ 1342
+ ],
+ [
+ 9047,
+ 1344,
+ 1344
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1347,
+ 1349,
+ [
+ [
+ 9075,
+ 1347,
+ 1348,
+ [
+ [
+ 9081,
+ 1347,
+ 1347
+ ],
+ [
+ 9047,
+ 1348,
+ 1348
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1351,
+ 1352,
+ [
+ [
+ 9088,
+ 1351,
+ 1351
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1354,
+ 1355,
+ [
+ [
+ 9088,
+ 1354,
+ 1354
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1357,
+ 1358,
+ [
+ [
+ 9088,
+ 1357,
+ 1357
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1360,
+ 1361,
+ [
+ [
+ 9088,
+ 1360,
+ 1360
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1363,
+ 1364,
+ [
+ [
+ 9088,
+ 1363,
+ 1363
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1366,
+ 1367,
+ [
+ [
+ 9088,
+ 1366,
+ 1366
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1369,
+ 1370,
+ [
+ [
+ 9088,
+ 1369,
+ 1369
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 1372,
+ 1375,
+ [
+ [
+ 9040,
+ 1372,
+ 1374,
+ [
+ [
+ 9013,
+ 1374,
+ 1374
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ "stream": [
+ [
+ 373,
+ 5
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 365,
+ 5
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 365,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 365,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 365,
+ 5
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 4
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 4
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 360,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 360,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 361,
+ 10
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 360,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 361,
+ 10
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 349,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 348,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 349,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 340,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 340,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 4
+ ],
+ [
+ 353,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 353,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 352,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 351,
+ 9
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 350,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 352,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 347,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 5
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 352,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 351,
+ 9
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 350,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 347,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 348,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 358,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 348,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 359,
+ 9
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 359,
+ 9
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 360,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 359,
+ 9
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 360,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 345,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 345,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 345,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 389,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 389,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 340,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 340,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 3
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 307,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 306,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 307,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 306,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 306,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 308,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 307,
+ 4
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 308,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 306,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 308,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 305,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 306,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 306,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 308,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 323,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 323,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 324,
+ 8
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 322,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 323,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 325,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 325,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 326,
+ 6
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 332,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 334,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 5
+ ],
+ [
+ 336,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 334,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 5
+ ],
+ [
+ 336,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 335,
+ 7
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 5
+ ],
+ [
+ 337,
+ 8
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 332,
+ 6
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 332,
+ 6
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 333,
+ 9
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 336,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 336,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 337,
+ 8
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 337,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 341,
+ 6
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 341,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 341,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 346,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 346,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 346,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 36,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 346,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 36,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 46,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 347,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 347,
+ 6
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 321,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 321,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 354,
+ 5
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 44,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 327,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 327,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 363,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 327,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 363,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 327,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 365,
+ 5
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 327,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 365,
+ 5
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 363,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 327,
+ 7
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 331,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 328,
+ 10
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 329,
+ 7
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 329,
+ 7
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 329,
+ 7
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 330,
+ 10
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 342,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 343,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 342,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 343,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 343,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 344,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 303,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 43,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 45,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 42,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 47,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 46,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 37,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 38,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 124,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 94,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 288,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 289,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 291,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 291,
+ 2
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 292,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 292,
+ 2
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 43,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 45,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 33,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 126,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 281,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 283,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 282,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 284,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 60,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 286,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 62,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 287,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 290,
+ 10
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 63,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 63,
+ 1
+ ],
+ [
+ 58,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 279,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 280,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 265,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 263,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 264,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 267,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 268,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 269,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 270,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 271,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 272,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 273,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 274,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 275,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 276,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 277,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 293,
+ 5
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 294,
+ 8
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 295,
+ 8
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 295,
+ 8
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 298,
+ 7
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 299,
+ 8
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 300,
+ 6
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 301,
+ 7
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 91,
+ 1
+ ],
+ [
+ 93,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 64,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 369,
+ 8
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 370,
+ 8
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 388,
+ 7
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 366,
+ 9
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 367,
+ 10
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 368,
+ 12
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 387,
+ 13
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 338,
+ 4
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 3
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ]
+ ]
+}
diff --git a/src/parser/xhpast/__tests__/data/php-tags.php.test b/src/parser/xhpast/__tests__/data/php-tags.php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/php-tags.php.test
@@ -0,0 +1,215 @@
+
+
+
+
+
+~~~~~~~~~~
+pass, comment="Omits ASP tags since parser support is off as built."
+~~~~~~~~~~
+{
+ "tree": [
+ 9000,
+ 0,
+ 21,
+ [
+ [
+ 9006,
+ 0,
+ 21,
+ [
+ [
+ 9007,
+ 0,
+ 0
+ ],
+ [
+ 9004,
+ 2,
+ 3,
+ [
+ [
+ 9086,
+ 2,
+ 2
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 5,
+ 5,
+ [
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9007,
+ 6,
+ 6
+ ],
+ [
+ 9004,
+ 8,
+ 9,
+ [
+ [
+ 9086,
+ 8,
+ 8
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 11,
+ 11,
+ [
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9007,
+ 12,
+ 12
+ ],
+ [
+ 9004,
+ 14,
+ 15,
+ [
+ [
+ 9086,
+ 14,
+ 14
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 17,
+ 17,
+ [
+ [
+ 9005
+ ]
+ ]
+ ],
+ [
+ 9034,
+ 18,
+ 18
+ ],
+ [
+ 9034,
+ 19,
+ 19
+ ],
+ [
+ 9034,
+ 20,
+ 20
+ ],
+ [
+ 9034,
+ 21,
+ 21
+ ]
+ ]
+ ]
+ ]
+ ],
+ "stream": [
+ [
+ 373,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 376,
+ 3
+ ],
+ [
+ 373,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 376,
+ 3
+ ],
+ [
+ 374,
+ 3
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 309,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 376,
+ 3
+ ],
+ [
+ 315,
+ 1
+ ],
+ [
+ 315,
+ 5
+ ],
+ [
+ 315,
+ 1
+ ],
+ [
+ 315,
+ 5
+ ]
+ ]
+}
diff --git a/src/parser/xhpast/__tests__/data/php-traits.php.test b/src/parser/xhpast/__tests__/data/php-traits.php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/php-traits.php.test
@@ -0,0 +1,938 @@
+ $z;
+
+ $data = (yield $a);
+ $data = (yield $b => $c);
+}
+~~~~~~~~~~
+pass
+~~~~~~~~~~
+{
+ "tree": [
+ 9000,
+ 0,
+ 54,
+ [
+ [
+ 9006,
+ 0,
+ 53,
+ [
+ [
+ 9007,
+ 0,
+ 0
+ ],
+ [
+ 9004,
+ 2,
+ 53,
+ [
+ [
+ 9050,
+ 2,
+ 53,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9013,
+ 4,
+ 4
+ ],
+ [
+ 9059,
+ 5,
+ 6
+ ],
+ [
+ 9005
+ ],
+ [
+ 9005
+ ],
+ [
+ 9006,
+ 8,
+ 53,
+ [
+ [
+ 9004,
+ 10,
+ 11,
+ [
+ [
+ 9112,
+ 10,
+ 10,
+ [
+ [
+ 9005
+ ],
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 13,
+ 16,
+ [
+ [
+ 9112,
+ 13,
+ 15,
+ [
+ [
+ 9047,
+ 15,
+ 15,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 18,
+ 25,
+ [
+ [
+ 9112,
+ 18,
+ 24,
+ [
+ [
+ 9047,
+ 20,
+ 20
+ ],
+ [
+ 9047,
+ 24,
+ 24
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 27,
+ 36,
+ [
+ [
+ 9077,
+ 27,
+ 35,
+ [
+ [
+ 9047,
+ 27,
+ 27
+ ],
+ [
+ 9081,
+ 29,
+ 29
+ ],
+ [
+ 9112,
+ 31,
+ 35,
+ [
+ [
+ 9047,
+ 34,
+ 34,
+ [
+ [
+ 9005
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ [
+ 9004,
+ 38,
+ 51,
+ [
+ [
+ 9077,
+ 38,
+ 50,
+ [
+ [
+ 9047,
+ 38,
+ 38
+ ],
+ [
+ 9081,
+ 40,
+ 40
+ ],
+ [
+ 9112,
+ 42,
+ 50,
+ [
+ [
+ 9047,
+ 45,
+ 45
+ ],
+ [
+ 9047,
+ 49,
+ 49
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ]
+ ],
+ "stream": [
+ [
+ 373,
+ 5
+ ],
+ [
+ 377,
+ 2
+ ],
+ [
+ 339,
+ 8
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 311,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 123,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 394,
+ 5
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 394,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 394,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 363,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 4
+ ],
+ [
+ 313,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 394,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 3
+ ],
+ [
+ 313,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 61,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 40,
+ 1
+ ],
+ [
+ 394,
+ 5
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 363,
+ 2
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 313,
+ 2
+ ],
+ [
+ 41,
+ 1
+ ],
+ [
+ 59,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ],
+ [
+ 125,
+ 1
+ ],
+ [
+ 377,
+ 1
+ ]
+ ]
+}
diff --git a/src/parser/xhpast/__tests__/data/return-type.php.test b/src/parser/xhpast/__tests__/data/return-type.php.test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/__tests__/data/return-type.php.test
@@ -0,0 +1,2197 @@
+ $right;
+} else if ($node instanceof Node\Expr\BinaryOp\GreaterOrEqual) {
+ return $left >= $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Identical) {
+ return $left === $right;
+} else if ($node instanceof Node\Expr\BinaryOp\LogicalAnd) {
+ return $left && $right;
+} else if ($node instanceof Node\Expr\BinaryOp\LogicalOr) {
+ return $left || $right;
+} else if ($node instanceof Node\Expr\BinaryOp\LogicalXor) {
+ return $left xor $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Minus) {
+ return $left - $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Mod) {
+ return $left % $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Mul) {
+ return $left * $right;
+} else if ($node instanceof Node\Expr\BinaryOp\NotEqual) {
+ return $left != $right;
+} else if ($node instanceof Node\Expr\BinaryOp\NotIdentical) {
+ return $left !== $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Plus) {
+ return $left + $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Pow) {
+ return pow($left, $right);
+} else if ($node instanceof Node\Expr\BinaryOp\ShiftLeft) {
+ return $left << $right;
+} else if ($node instanceof Node\Expr\BinaryOp\ShiftRight) {
+ return $left >> $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Smaller) {
+ return $left < $right;
+} else if ($node instanceof Node\Expr\BinaryOp\SmallerOrEqual) {
+ return $left <= $right;
+} else if ($node instanceof Node\Expr\BinaryOp\Spaceship) {
+ if ($left < $right) {
+ return -1;
+ } else if ($left == $right) {
+ return 0;
+ } else {
+ return 1;
+ }
+}
+~~~~~~~~~~
+pass
diff --git a/src/parser/xhpast/api/XHPASTNode.php b/src/parser/xhpast/api/XHPASTNode.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/XHPASTNode.php
@@ -0,0 +1,301 @@
+getTypeName(), array(
+ 'n_STRING_SCALAR',
+ 'n_NUMERIC_SCALAR',
+ ));
+ }
+
+ public function getDocblockToken() {
+ if ($this->l == -1) {
+ return null;
+ }
+ $tokens = $this->tree->getRawTokenStream();
+
+ for ($ii = $this->l - 1; $ii >= 0; $ii--) {
+ if ($tokens[$ii]->getTypeName() == 'T_DOC_COMMENT') {
+ return $tokens[$ii];
+ }
+ if (!$tokens[$ii]->isAnyWhitespace()) {
+ return null;
+ }
+ }
+
+ return null;
+ }
+
+ public function evalStatic() {
+ switch ($this->getTypeName()) {
+ case 'n_STATEMENT':
+ return $this->getChildByIndex(0)->evalStatic();
+ break;
+ case 'n_STRING_SCALAR':
+ return (string)$this->getStringLiteralValue();
+ case 'n_NUMERIC_SCALAR':
+ $value = $this->getSemanticString();
+ if (preg_match('/^0x/i', $value)) {
+ // Hex
+ $value = base_convert(substr($value, 2), 16, 10);
+ } else if (preg_match('/^0\d+$/i', $value)) {
+ // Octal
+ $value = base_convert(substr($value, 1), 8, 10);
+ }
+ return +$value;
+ case 'n_SYMBOL_NAME':
+ $value = $this->getSemanticString();
+ if ($value == 'INF') {
+ return INF;
+ }
+ switch (strtolower($value)) {
+ case 'true':
+ return true;
+ case 'false':
+ return false;
+ case 'null':
+ return null;
+ default:
+ throw new Exception(pht('Unrecognized symbol name.'));
+ }
+ break;
+ case 'n_UNARY_PREFIX_EXPRESSION':
+ $operator = $this->getChildOfType(0, 'n_OPERATOR');
+ $operand = $this->getChildByIndex(1);
+ switch ($operator->getSemanticString()) {
+ case '-':
+ return -$operand->evalStatic();
+ break;
+ case '+':
+ return $operand->evalStatic();
+ break;
+ default:
+ throw new Exception(
+ pht('Unexpected operator in static expression.'));
+ }
+ break;
+ case 'n_ARRAY_LITERAL':
+ $result = array();
+ $values = $this->getChildOfType(0, 'n_ARRAY_VALUE_LIST');
+ foreach ($values->getChildren() as $child) {
+ $key = $child->getChildByIndex(0);
+ $val = $child->getChildByIndex(1);
+ if ($key->getTypeName() == 'n_EMPTY') {
+ $result[] = $val->evalStatic();
+ } else {
+ $result[$key->evalStatic()] = $val->evalStatic();
+ }
+ }
+ return $result;
+ case 'n_CONCATENATION_LIST':
+ $result = '';
+ foreach ($this->getChildren() as $child) {
+ if ($child->getTypeName() == 'n_OPERATOR') {
+ continue;
+ }
+ $result .= $child->evalStatic();
+ }
+ return $result;
+ default:
+ throw new Exception(
+ pht(
+ 'Unexpected node during static evaluation, of type: %s',
+ $this->getTypeName()));
+ }
+ }
+
+ public function isConstantString() {
+ return $this->checkIsConstantString();
+ }
+
+ public function isConstantStringWithMagicConstants() {
+ return $this->checkIsConstantString(array('n_MAGIC_SCALAR'));
+ }
+
+ private function checkIsConstantString(array $additional_types = array()) {
+ switch ($this->getTypeName()) {
+ case 'n_HEREDOC':
+ case 'n_STRING_SCALAR':
+ return !$this->getStringVariables();
+
+ case 'n_CONCATENATION_LIST':
+ foreach ($this->getChildren() as $child) {
+ if ($child->getTypeName() == 'n_OPERATOR') {
+ continue;
+ }
+ if (!$child->checkIsConstantString($additional_types)) {
+ return false;
+ }
+ }
+ return true;
+
+ default:
+ if (in_array($this->getTypeName(), $additional_types)) {
+ return true;
+ }
+
+ return false;
+ }
+ }
+
+ public function getStringVariables() {
+ $value = $this->getConcreteString();
+
+ switch ($this->getTypeName()) {
+ case 'n_HEREDOC':
+ if (preg_match("/^<<<\s*'/", $value)) { // Nowdoc: <<<'EOT'
+ return array();
+ }
+ break;
+
+ case 'n_STRING_SCALAR':
+ if ($value[0] == "'") {
+ return array();
+ }
+ break;
+
+ default:
+ throw new Exception(pht('Unexpected type %s.', $this->getTypeName()));
+ }
+
+ // We extract just the variable names and ignore properties and array keys.
+ $re = '/\\\\.|(\$|\{\$|\${)([a-z_\x7F-\xFF][a-z0-9_\x7F-\xFF]*)/i';
+ $matches = null;
+ preg_match_all($re, $value, $matches, PREG_OFFSET_CAPTURE);
+ return ipull(array_filter($matches[2]), 0, 1);
+ }
+
+ public function getStringLiteralValue() {
+ if ($this->getTypeName() != 'n_STRING_SCALAR') {
+ return null;
+ }
+
+ $value = $this->getSemanticString();
+ $type = $value[0];
+ $value = preg_replace('/^b?[\'"]|[\'"]$/i', '', $value);
+ $esc = false;
+ $len = strlen($value);
+ $out = '';
+
+ if ($type == "'") {
+ // Single quoted strings treat everything as a literal except "\\" and
+ // "\'".
+ return str_replace(
+ array('\\\\', '\\\''),
+ array('\\', "'"),
+ $value);
+ }
+
+ // Double quoted strings treat "\X" as a literal if X isn't specifically
+ // a character which needs to be escaped -- e.g., "\q" and "\'" are
+ // literally "\q" and "\'". stripcslashes() is too aggressive, so find
+ // all these under-escaped backslashes and escape them.
+
+ for ($ii = 0; $ii < $len; $ii++) {
+ $c = $value[$ii];
+ if ($esc) {
+ $esc = false;
+ switch ($c) {
+ case 'x':
+ $u = isset($value[$ii + 1]) ? $value[$ii + 1] : null;
+ if (!preg_match('/^[a-f0-9]/i', $u)) {
+ // PHP treats \x followed by anything which is not a hex digit
+ // as a literal \x.
+ $out .= '\\\\'.$c;
+ break;
+ }
+ /* fallthrough */
+ case 'n':
+ case 'r':
+ case 'f':
+ case 'v':
+ case '"':
+ case '$':
+ case 't':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ $out .= '\\'.$c;
+ break;
+ case 'e':
+ // Since PHP 5.4.0, this means "esc". However, stripcslashes() does
+ // not perform this conversion.
+ $out .= chr(27);
+ break;
+ default:
+ $out .= '\\\\'.$c;
+ break;
+ }
+ } else if ($c == '\\') {
+ $esc = true;
+ } else {
+ $out .= $c;
+ }
+ }
+
+ return stripcslashes($out);
+ }
+
+ /**
+ * Determines the parent namespace for a node.
+ *
+ * Traverses the AST upwards from a given node in order to determine the
+ * namespace in which the node is declared.
+ *
+ * To prevent any possible ambiguity, the returned namespace will always be
+ * prefixed with the namespace separator.
+ *
+ * @param XHPASTNode The input node.
+ * @return string|null The namespace which contains the input node, or
+ * `null` if no such node exists.
+ */
+ public function getNamespace() {
+ $namespaces = $this
+ ->getTree()
+ ->getRootNode()
+ ->selectDescendantsOfType('n_NAMESPACE')
+ ->getRawNodes();
+
+ foreach (array_reverse($namespaces) as $namespace) {
+ if ($namespace->isAfter($this)) {
+ continue;
+ }
+
+ $body = $namespace->getChildByIndex(1);
+ if ($body->getTypeName() != 'n_EMPTY') {
+ if (!$body->containsDescendant($this)) {
+ continue;
+ }
+ }
+
+ return $namespace->getNamespaceName();
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the namespace name from a node of type `n_NAMESPACE`.
+ *
+ * @return string|null
+ */
+ private function getNamespaceName() {
+ if ($this->getTypeName() != 'n_NAMESPACE') {
+ return null;
+ }
+
+ $namespace_name = $this->getChildByIndex(0);
+ if ($namespace_name->getTypeName() == 'n_EMPTY') {
+ return null;
+ }
+
+ return '\\'.$namespace_name->getConcreteString();
+ }
+
+}
diff --git a/src/parser/xhpast/api/XHPASTSyntaxErrorException.php b/src/parser/xhpast/api/XHPASTSyntaxErrorException.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/XHPASTSyntaxErrorException.php
@@ -0,0 +1,16 @@
+errorLine = $line;
+ parent::__construct($message);
+ }
+
+ public function getErrorLine() {
+ return $this->errorLine;
+ }
+
+}
diff --git a/src/parser/xhpast/api/XHPASTToken.php b/src/parser/xhpast/api/XHPASTToken.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/XHPASTToken.php
@@ -0,0 +1,39 @@
+typeName)) {
+ $type_id = $this->typeID;
+ if ($type_id <= 255) {
+ $this->typeName = chr($type_id);
+ }
+ $this->typeName = parent::getTypeName();
+ }
+ return $this->typeName;
+ }
+
+ public function isComment() {
+ static $type_ids = null;
+ if ($type_ids === null) {
+ $type_ids = array(
+ $this->tree->getTokenTypeIDFromTypeName('T_COMMENT') => true,
+ $this->tree->getTokenTypeIDFromTypeName('T_DOC_COMMENT') => true,
+ );
+ }
+
+ return isset($type_ids[$this->typeID]);
+ }
+
+ public function isAnyWhitespace() {
+ static $type_ids = null;
+ if ($type_ids === null) {
+ $type_ids = array(
+ $this->tree->getTokenTypeIDFromTypeName('T_WHITESPACE') => true,
+ );
+ }
+
+ return isset($type_ids[$this->typeID]);
+ }
+
+}
diff --git a/src/parser/xhpast/api/XHPASTTree.php b/src/parser/xhpast/api/XHPASTTree.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/XHPASTTree.php
@@ -0,0 +1,78 @@
+setTreeType('XHP');
+ $this->setNodeConstants(xhp_parser_node_constants());
+ $this->setTokenConstants(xhpast_parser_token_constants());
+
+ parent::__construct($tree, $stream, $source);
+ }
+
+ public function newNode($id, array $data, AASTTree $tree) {
+ return new XHPASTNode($id, $data, $tree);
+ }
+
+ public function newToken($id, $type, $value, $offset, AASTTree $tree) {
+ return new XHPASTToken($id, $type, $value, $offset, $tree);
+ }
+
+ public static function newFromData($php_source) {
+ $future = PhutilXHPASTBinary::getParserFuture($php_source);
+ return self::newFromDataAndResolvedExecFuture(
+ $php_source,
+ $future->resolve());
+ }
+
+ public static function newStatementFromString($string) {
+ $string = 'getRootNode()->selectDescendantsOfType('n_STATEMENT');
+ if (count($statements) != 1) {
+ throw new Exception(
+ pht('String does not parse into exactly one statement!'));
+ }
+ // Return the first one, trying to use reset() with iterators ends in tears.
+ foreach ($statements as $statement) {
+ return $statement;
+ }
+ }
+
+ public static function newFromDataAndResolvedExecFuture(
+ $php_source,
+ array $resolved) {
+
+ list($err, $stdout, $stderr) = $resolved;
+ if ($err) {
+ if ($err == 1) {
+ $matches = null;
+ $is_syntax = preg_match(
+ '/^XHPAST Parse Error: (.*) on line (\d+)/s',
+ $stderr,
+ $matches);
+ if ($is_syntax) {
+ throw new XHPASTSyntaxErrorException($matches[2], trim($stderr));
+ }
+ }
+ throw new Exception(
+ pht(
+ '%s failed to parse file data %d: %s',
+ 'XHPAST',
+ $err,
+ $stderr));
+ }
+
+ $data = null;
+ try {
+ $data = phutil_json_decode($stdout);
+ } catch (PhutilJSONParserException $ex) {
+ throw new PhutilProxyException(
+ pht('%s: failed to decode tree.', 'XHPAST'),
+ $ex);
+ }
+
+ return new XHPASTTree($data['tree'], $data['stream'], $php_source);
+ }
+
+}
diff --git a/src/parser/xhpast/api/__tests__/XHPASTNodeTestCase.php b/src/parser/xhpast/api/__tests__/XHPASTNodeTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/__tests__/XHPASTNodeTestCase.php
@@ -0,0 +1,101 @@
+assertStringVariables(array(), '""');
+ $this->assertStringVariables(array(2 => 'abc'), '"$abc"');
+ $this->assertStringVariables(array(), '"\$abc"');
+ $this->assertStringVariables(array(2 => 'a'), '"$a[1]"');
+ $this->assertStringVariables(array(3 => 'a'), '"{$a[1]}"');
+ $this->assertStringVariables(array(2 => 'a', 5 => 'a'), '"$a $a"');
+
+ $this->assertStringVariables(array(), "''");
+ $this->assertStringVariables(array(), "'\$a'");
+
+ $this->assertStringVariables(array(), "<<assertStringVariables(array(8 => 'a'), "<<assertStringVariables(array(), "<<<'EOT'\n\$a\nEOT");
+ }
+
+ private function assertStringVariables($expected, $string) {
+ $statement = XHPASTTree::newStatementFromString($string);
+ $this->assertEqual(
+ $expected,
+ $statement->getChildByIndex(0)->getStringVariables(),
+ $string);
+ }
+
+ public function testGetNamespace() {
+ $dir = dirname(__FILE__).'/namespace/';
+ $files = id(new FileFinder($dir))
+ ->withType('f')
+ ->withSuffix('php.test')
+ ->find();
+
+ foreach ($files as $file) {
+ list($tree, $expect) = $this->readTestData($dir.'/'.$file);
+
+ $root = $tree->getRootNode();
+ $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
+
+ foreach ($classes as $class) {
+ $id = (string)$class->getID();
+
+ if (idx($expect, $id, false) === false) {
+ throw new Exception(
+ pht(
+ 'No expected value for node %d in file "%s".',
+ $class->getID(),
+ $file));
+ }
+
+ $this->assertEqual(
+ $expect[$id],
+ $class->getNamespace());
+ }
+ }
+ }
+
+ /**
+ * Reads and parses test data from a specified file.
+ *
+ * This method reads and parses test data from a file. The file is expected
+ * to have the following structure
+ *
+ * ```
+ * The first element of the pair is the
+ * `XHPASTTree` contained within the test file.
+ * The second element of the pair is the
+ * "expect" data.
+ */
+ private function readTestData($file) {
+ $contents = Filesystem::readFile($file);
+ $contents = preg_split('/^~{10}$/m', $contents);
+
+ if (count($contents) < 2) {
+ throw new Exception(
+ pht(
+ "Expected '%s' separating test case and results.",
+ '~~~~~~~~~~'));
+ }
+
+ list($data, $expect) = $contents;
+
+ $tree = XHPASTTree::newFromData($data);
+ $expect = phutil_json_decode($expect);
+
+ return array($tree, $expect);
+ }
+
+}
diff --git a/src/parser/xhpast/api/__tests__/XHPASTTreeTestCase.php b/src/parser/xhpast/api/__tests__/XHPASTTreeTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/__tests__/XHPASTTreeTestCase.php
@@ -0,0 +1,140 @@
+assertEval(1, '1');
+ $this->assertEval('a', '"a"');
+ $this->assertEval(-1.1, '-1.1');
+ $this->assertEval(
+ array('foo', 'bar', -1, +2, -3.4, +4.3, 1e10, 1e-5, -2.3e7),
+ "array('foo', 'bar', -1, +2, -3.4, +4.3, 1e10, 1e-5, -2.3e7)");
+ $this->assertEval(
+ array(),
+ 'array()');
+ $this->assertEval(
+ array(42 => 7, 'a' => 5, 1, 2, 3, 4, 1 => 'goo'),
+ "array(42 => 7, 'a' => 5, 1, 2, 3, 4, 1 => 'goo')");
+ $this->assertEval(
+ array('a' => 'a', 'b' => array(1, 2, array(3))),
+ "array('a' => 'a', 'b' => array(1, 2, array(3)))");
+ $this->assertEval(
+ array(true, false, null),
+ 'array(true, false, null)');
+
+ // Duplicate keys
+ $this->assertEval(
+ array(0 => '1', 0 => '2'),
+ "array(0 => '1', 0 => '2')");
+
+ $this->assertEval('simple string', "'simple string'");
+ $this->assertEval('42', "'42'");
+ $this->assertEval('binary string', "b'binary string'");
+ $this->assertEval(3.1415926, '3.1415926');
+ $this->assertEval(42, '42');
+ $this->assertEval(
+ array(2147483648, 2147483647, -2147483648, -2147483647),
+ 'array(2147483648, 2147483647, -2147483648, -2147483647)');
+
+ $this->assertEval(INF, 'INF');
+ $this->assertEval(-INF, '-INF');
+
+ $this->assertEval(0x1b, '0x1b');
+ $this->assertEval(0X0A, '0X0A');
+
+ // Octal
+ $this->assertEval(010, '010');
+ // TODO: this passes on < PHP 7 for some reason but fails on PHP 7 correctly
+ //$this->assertEval(080, '080'); // Invalid!
+
+ // Leading 0, but float, not octal.
+ $this->assertEval(0.11e1, '0.11e1');
+ $this->assertEval(0e1, '0e1');
+
+ $this->assertEval(0, '0');
+
+ // Static evaluation treats '$' as a literal dollar glyph.
+ $this->assertEval('$asdf', '"$asdf"');
+
+ $this->assertEval(
+ '\a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z'.
+ '\1\2\3\4\5\6\7\8\9\0'.
+ '\!\@\#\$\%\^\&\*\(\)'.
+ '\`\~\\\|\[\]\{\}\<\>\,\.\/\?\:\;\-\_\=\+',
+
+ "'\\a\\b\\c\\d\\e\\f\\g\\h\\i\\j\\k\\l\\m\\n\\o\\p\\q".
+ "\\r\\s\\t\\u\\v\\w\\x\\y\\z".
+ "\\1\\2\\3\\4\\5\\6\\7\\8\\9\\0".
+ "\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)".
+ "\\`\\~\\\\\\|\\[\\]\\{\\}\\<\\>\\,\\.\\/\\?\\:\\;\\-\\_\\=\\+".
+ "'");
+
+ // After PHP 5.4.0, "\e" means "escape", not "backslash e". We implement the
+ // newer rules, but if we're running in an older version of PHP we can not
+ // express them with "\e".
+ $this->assertEval(chr(27), '"\\e"');
+
+ $this->assertEval(
+ "\a\b\c\d\x1B\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z".
+ "\1\2\3\4\5\6\7\8\9\0".
+ "\!\@\#\$\%\^\&\*\(\)".
+ "\`\~\\\|\[\]\{\}\<\>\,\.\/\?\:\;\-\_\=\+",
+
+ '"\\a\\b\\c\\d\\e\\f\\g\\h\\i\\j\\k\\l\\m\\n\\o\\p\\q'.
+ '\\r\\s\\t\\u\\v\\w\\x\\y\\z'.
+ '\\1\\2\\3\\4\\5\\6\\7\\8\\9\\0'.
+ '\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)'.
+ '\\`\\~\\\\\\|\\[\\]\\{\\}\\<\\>\\,\\.\\/\\?\\:\\;\\-\\_\\=\\+"');
+
+ $this->assertEval(
+ '\' "',
+ "'\\' \"'");
+
+ $this->assertEval(
+ '\\ \\\\ ',
+ '\'\\\\ \\\\\\\\ \'');
+
+ $this->assertEval(
+ '\ \\ ',
+ "'\\ \\\\ '");
+
+ $this->assertEval(
+ '\x92',
+ '\'\x92\'');
+
+ $this->assertEval(
+ "\x92",
+ '"\x92"');
+
+ $this->assertEval(
+ "\x",
+ '"\x"');
+
+ $this->assertEval(
+ "\x1",
+ '"\x1"');
+
+ $this->assertEval(
+ "\x000 !",
+ '"\x000 !"');
+
+ $this->assertEval(
+ "\x0",
+ '"\x0"');
+
+ $this->assertEval(
+ "\xg",
+ '"\xg"');
+ }
+
+ private function assertEval($value, $string) {
+ $this->assertEqual(
+ $value,
+ XHPASTTree::newStatementFromString($string)->evalStatic(),
+ $string);
+ }
+
+}
diff --git a/src/parser/xhpast/api/__tests__/namespace/braces.lint-test b/src/parser/xhpast/api/__tests__/namespace/braces.lint-test
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/api/__tests__/namespace/braces.lint-test
@@ -0,0 +1,18 @@
+write($data);
+
+ return $future;
+ }
+
+ /**
+ * Returns the path to the XHPAST binary.
+ *
+ * @return string
+ */
+ public static function getPath() {
+ if (phutil_is_windows()) {
+ return dirname(__FILE__).'\\xhpast.exe';
+ }
+ return dirname(__FILE__).'/xhpast';
+ }
+
+ /**
+ * Returns the XHPAST version.
+ *
+ * @return string
+ */
+ public static function getVersion() {
+ if (self::$version === null) {
+ $bin = self::getPath();
+
+ if (Filesystem::pathExists($bin)) {
+ list($err, $stdout) = exec_manual('%s --version', $bin);
+ if (!$err) {
+ self::$version = trim($stdout);
+ }
+ }
+ }
+
+ return self::$version;
+ }
+
+ /**
+ * Checks if XHPAST is built and up-to-date.
+ *
+ * @return bool
+ */
+ public static function isAvailable() {
+ return self::getVersion() == self::EXPECTED_VERSION;
+ }
+
+}
diff --git a/src/parser/xhpast/parser_nodes.php b/src/parser/xhpast/parser_nodes.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/parser_nodes.php
@@ -0,0 +1,127 @@
+ 'n_PROGRAM',
+ 9001 => 'n_SYMBOL_NAME',
+ 9002 => 'n_HALT_COMPILER',
+ 9003 => 'n_NAMESPACE',
+ 9004 => 'n_STATEMENT',
+ 9005 => 'n_EMPTY',
+ 9006 => 'n_STATEMENT_LIST',
+ 9007 => 'n_OPEN_TAG',
+ 9008 => 'n_CLOSE_TAG',
+ 9009 => 'n_USE_LIST',
+ 9010 => 'n_USE',
+ 9011 => 'n_CONSTANT_DECLARATION_LIST',
+ 9012 => 'n_CONSTANT_DECLARATION',
+ 9013 => 'n_STRING',
+ 9014 => 'n_LABEL',
+ 9015 => 'n_CONDITION_LIST',
+ 9016 => 'n_CONTROL_CONDITION',
+ 9017 => 'n_IF',
+ 9018 => 'n_ELSEIF',
+ 9019 => 'n_ELSE',
+ 9020 => 'n_WHILE',
+ 9021 => 'n_DO_WHILE',
+ 9022 => 'n_FOR',
+ 9023 => 'n_FOR_EXPRESSION',
+ 9024 => 'n_SWITCH',
+ 9025 => 'n_BREAK',
+ 9026 => 'n_CONTINUE',
+ 9027 => 'n_RETURN',
+ 9028 => 'n_GLOBAL_DECLARATION_LIST',
+ 9029 => 'n_GLOBAL_DECLARATION',
+ 9030 => 'n_STATIC_DECLARATION_LIST',
+ 9031 => 'n_STATIC_DECLARATION',
+ 9032 => 'n_ECHO_LIST',
+ 9033 => 'n_ECHO',
+ 9034 => 'n_INLINE_HTML',
+ 9035 => 'n_UNSET_LIST',
+ 9036 => 'n_UNSET',
+ 9037 => 'n_FOREACH',
+ 9038 => 'n_FOREACH_EXPRESSION',
+ 9039 => 'n_THROW',
+ 9040 => 'n_GOTO',
+ 9041 => 'n_TRY',
+ 9042 => 'n_CATCH_LIST',
+ 9043 => 'n_CATCH',
+ 9044 => 'n_DECLARE',
+ 9045 => 'n_DECLARE_DECLARATION_LIST',
+ 9046 => 'n_DECLARE_DECLARATION',
+ 9047 => 'n_VARIABLE',
+ 9048 => 'n_REFERENCE',
+ 9049 => 'n_VARIABLE_REFERENCE',
+ 9050 => 'n_FUNCTION_DECLARATION',
+ 9051 => 'n_CLASS_DECLARATION',
+ 9052 => 'n_CLASS_ATTRIBUTES',
+ 9053 => 'n_EXTENDS',
+ 9054 => 'n_EXTENDS_LIST',
+ 9055 => 'n_IMPLEMENTS_LIST',
+ 9056 => 'n_INTERFACE_DECLARATION',
+ 9057 => 'n_CASE',
+ 9058 => 'n_DEFAULT',
+ 9059 => 'n_DECLARATION_PARAMETER_LIST',
+ 9060 => 'n_DECLARATION_PARAMETER',
+ 9061 => 'n_TYPE_NAME',
+ 9062 => 'n_VARIABLE_VARIABLE',
+ 9063 => 'n_CLASS_MEMBER_DECLARATION_LIST',
+ 9064 => 'n_CLASS_MEMBER_DECLARATION',
+ 9065 => 'n_CLASS_CONSTANT_DECLARATION_LIST',
+ 9066 => 'n_CLASS_CONSTANT_DECLARATION',
+ 9067 => 'n_METHOD_DECLARATION',
+ 9068 => 'n_METHOD_MODIFIER_LIST',
+ 9069 => 'n_FUNCTION_MODIFIER_LIST',
+ 9070 => 'n_CLASS_MEMBER_MODIFIER_LIST',
+ 9071 => 'n_EXPRESSION_LIST',
+ 9072 => 'n_LIST',
+ 9073 => 'n_ASSIGNMENT',
+ 9074 => 'n_NEW',
+ 9075 => 'n_UNARY_PREFIX_EXPRESSION',
+ 9076 => 'n_UNARY_POSTFIX_EXPRESSION',
+ 9077 => 'n_BINARY_EXPRESSION',
+ 9078 => 'n_TERNARY_EXPRESSION',
+ 9079 => 'n_CAST_EXPRESSION',
+ 9080 => 'n_CAST',
+ 9081 => 'n_OPERATOR',
+ 9082 => 'n_ARRAY_LITERAL',
+ 9083 => 'n_EXIT_EXPRESSION',
+ 9084 => 'n_BACKTICKS_EXPRESSION',
+ 9085 => 'n_LEXICAL_VARIABLE_LIST',
+ 9086 => 'n_NUMERIC_SCALAR',
+ 9087 => 'n_STRING_SCALAR',
+ 9088 => 'n_MAGIC_SCALAR',
+ 9089 => 'n_CLASS_STATIC_ACCESS',
+ 9090 => 'n_CLASS_NAME',
+ 9091 => 'n_MAGIC_CLASS_KEYWORD',
+ 9092 => 'n_OBJECT_PROPERTY_ACCESS',
+ 9093 => 'n_ARRAY_VALUE_LIST',
+ 9094 => 'n_ARRAY_VALUE',
+ 9095 => 'n_CALL_PARAMETER_LIST',
+ 9096 => 'n_VARIABLE_EXPRESSION',
+ 9097 => 'n_INCLUDE_FILE',
+ 9098 => 'n_HEREDOC',
+ 9099 => 'n_FUNCTION_CALL',
+ 9100 => 'n_INDEX_ACCESS',
+ 9101 => 'n_ASSIGNMENT_LIST',
+ 9102 => 'n_METHOD_CALL',
+ 9103 => 'n_CONCATENATION_LIST',
+ 9104 => 'n_PARENTHETICAL_EXPRESSION',
+ 9105 => 'n_TRAIT_USE',
+ 9106 => 'n_TRAIT_USE_LIST',
+ 9107 => 'n_TRAIT_ADAPTATION_LIST',
+ 9108 => 'n_TRAIT_INSTEADOF',
+ 9109 => 'n_TRAIT_REFERENCE_LIST',
+ 9110 => 'n_TRAIT_METHOD_REFERENCE',
+ 9111 => 'n_TRAIT_AS',
+ 9112 => 'n_YIELD',
+ 9113 => 'n_FINALLY',
+ 9114 => 'n_UNPACK',
+ 9115 => 'n_DECLARATION_RETURN',
+ 9116 => 'n_NULLABLE_TYPE',
+ );
+}
diff --git a/src/parser/xhpast/parser_tokens.php b/src/parser/xhpast/parser_tokens.php
new file mode 100644
--- /dev/null
+++ b/src/parser/xhpast/parser_tokens.php
@@ -0,0 +1,147 @@
+ 'T_INCLUDE',
+ 259 => 'T_INCLUDE_ONCE',
+ 260 => 'T_EVAL',
+ 261 => 'T_REQUIRE',
+ 262 => 'T_REQUIRE_ONCE',
+ 263 => 'T_LOGICAL_OR',
+ 264 => 'T_LOGICAL_XOR',
+ 265 => 'T_LOGICAL_AND',
+ 266 => 'T_PRINT',
+ 267 => 'T_PLUS_EQUAL',
+ 268 => 'T_MINUS_EQUAL',
+ 269 => 'T_MUL_EQUAL',
+ 270 => 'T_DIV_EQUAL',
+ 271 => 'T_CONCAT_EQUAL',
+ 272 => 'T_MOD_EQUAL',
+ 273 => 'T_AND_EQUAL',
+ 274 => 'T_OR_EQUAL',
+ 275 => 'T_XOR_EQUAL',
+ 276 => 'T_SL_EQUAL',
+ 277 => 'T_SR_EQUAL',
+ 278 => 'T_COALESCE',
+ 279 => 'T_BOOLEAN_OR',
+ 280 => 'T_BOOLEAN_AND',
+ 281 => 'T_IS_EQUAL',
+ 282 => 'T_IS_NOT_EQUAL',
+ 283 => 'T_IS_IDENTICAL',
+ 284 => 'T_IS_NOT_IDENTICAL',
+ 285 => 'T_SPACESHIP',
+ 286 => 'T_IS_SMALLER_OR_EQUAL',
+ 287 => 'T_IS_GREATER_OR_EQUAL',
+ 288 => 'T_SL',
+ 289 => 'T_SR',
+ 290 => 'T_INSTANCEOF',
+ 291 => 'T_INC',
+ 292 => 'T_DEC',
+ 293 => 'T_INT_CAST',
+ 294 => 'T_DOUBLE_CAST',
+ 295 => 'T_STRING_CAST',
+ 296 => 'T_UNICODE_CAST',
+ 297 => 'T_BINARY_CAST',
+ 298 => 'T_ARRAY_CAST',
+ 299 => 'T_OBJECT_CAST',
+ 300 => 'T_BOOL_CAST',
+ 301 => 'T_UNSET_CAST',
+ 302 => 'T_NEW',
+ 303 => 'T_CLONE',
+ 304 => 'T_EXIT',
+ 305 => 'T_IF',
+ 306 => 'T_ELSEIF',
+ 307 => 'T_ELSE',
+ 308 => 'T_ENDIF',
+ 309 => 'T_LNUMBER',
+ 310 => 'T_DNUMBER',
+ 311 => 'T_STRING',
+ 312 => 'T_STRING_VARNAME',
+ 313 => 'T_VARIABLE',
+ 314 => 'T_NUM_STRING',
+ 315 => 'T_INLINE_HTML',
+ 316 => 'T_CHARACTER',
+ 317 => 'T_BAD_CHARACTER',
+ 318 => 'T_ENCAPSED_AND_WHITESPACE',
+ 319 => 'T_CONSTANT_ENCAPSED_STRING',
+ 320 => 'T_BACKTICKS_EXPR',
+ 321 => 'T_ECHO',
+ 322 => 'T_DO',
+ 323 => 'T_WHILE',
+ 324 => 'T_ENDWHILE',
+ 325 => 'T_FOR',
+ 326 => 'T_ENDFOR',
+ 327 => 'T_FOREACH',
+ 328 => 'T_ENDFOREACH',
+ 329 => 'T_DECLARE',
+ 330 => 'T_ENDDECLARE',
+ 331 => 'T_AS',
+ 332 => 'T_SWITCH',
+ 333 => 'T_ENDSWITCH',
+ 334 => 'T_CASE',
+ 335 => 'T_DEFAULT',
+ 336 => 'T_BREAK',
+ 337 => 'T_CONTINUE',
+ 338 => 'T_GOTO',
+ 339 => 'T_FUNCTION',
+ 340 => 'T_CONST',
+ 341 => 'T_RETURN',
+ 342 => 'T_TRY',
+ 343 => 'T_CATCH',
+ 344 => 'T_THROW',
+ 345 => 'T_USE',
+ 346 => 'T_GLOBAL',
+ 347 => 'T_STATIC',
+ 348 => 'T_ABSTRACT',
+ 349 => 'T_FINAL',
+ 350 => 'T_PRIVATE',
+ 351 => 'T_PROTECTED',
+ 352 => 'T_PUBLIC',
+ 353 => 'T_VAR',
+ 354 => 'T_UNSET',
+ 355 => 'T_ISSET',
+ 356 => 'T_EMPTY',
+ 357 => 'T_HALT_COMPILER',
+ 358 => 'T_CLASS',
+ 359 => 'T_INTERFACE',
+ 360 => 'T_EXTENDS',
+ 361 => 'T_IMPLEMENTS',
+ 362 => 'T_OBJECT_OPERATOR',
+ 363 => 'T_DOUBLE_ARROW',
+ 364 => 'T_LIST',
+ 365 => 'T_ARRAY',
+ 366 => 'T_CLASS_C',
+ 367 => 'T_METHOD_C',
+ 368 => 'T_FUNC_C',
+ 369 => 'T_LINE',
+ 370 => 'T_FILE',
+ 371 => 'T_COMMENT',
+ 372 => 'T_DOC_COMMENT',
+ 373 => 'T_OPEN_TAG',
+ 374 => 'T_OPEN_TAG_WITH_ECHO',
+ 375 => 'T_OPEN_TAG_FAKE',
+ 376 => 'T_CLOSE_TAG',
+ 377 => 'T_WHITESPACE',
+ 378 => 'T_START_HEREDOC',
+ 379 => 'T_END_HEREDOC',
+ 380 => 'T_HEREDOC',
+ 381 => 'T_DOLLAR_OPEN_CURLY_BRACES',
+ 382 => 'T_CURLY_OPEN',
+ 383 => 'T_PAAMAYIM_NEKUDOTAYIM',
+ 384 => 'T_BINARY_DOUBLE',
+ 385 => 'T_BINARY_HEREDOC',
+ 386 => 'T_NAMESPACE',
+ 387 => 'T_NS_C',
+ 388 => 'T_DIR',
+ 389 => 'T_NS_SEPARATOR',
+ 390 => 'T_INSTEADOF',
+ 391 => 'T_CALLABLE',
+ 392 => 'T_TRAIT',
+ 393 => 'T_TRAIT_C',
+ 394 => 'T_YIELD',
+ 395 => 'T_FINALLY',
+ 396 => 'T_ELLIPSIS',
+ );
+}
diff --git a/src/phage/__tests__/PhageAgentTestCase.php b/src/phage/__tests__/PhageAgentTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/phage/__tests__/PhageAgentTestCase.php
@@ -0,0 +1,49 @@
+runBootloaderTests(new PhagePHPAgentBootloader());
+ }
+
+ private function runBootloaderTests(PhageAgentBootloader $boot) {
+ $name = get_class($boot);
+
+ $exec = new ExecFuture('%C', $boot->getBootCommand());
+ $exec->write($boot->getBootSequence(), $keep_open = true);
+
+ $exec_channel = new PhutilExecChannel($exec);
+ $agent = new PhutilJSONProtocolChannel($exec_channel);
+
+ $agent->write(
+ array(
+ 'type' => 'EXEC',
+ 'key' => 1,
+ 'command' => 'echo phage',
+ 'timeout' => null,
+ ));
+
+ $this->agentExpect(
+ $agent,
+ array(
+ 'type' => 'RSLV',
+ 'key' => 1,
+ 'err' => 0,
+ 'stdout' => "phage\n",
+ 'stderr' => '',
+ 'timeout' => false,
+ ),
+ pht("'%s' for %s", 'echo phage', $name));
+
+ $agent->write(
+ array(
+ 'type' => 'EXIT',
+ ));
+ }
+
+ private function agentExpect(PhutilChannel $agent, $expect, $what) {
+ $message = $agent->waitForMessage();
+ $this->assertEqual($expect, $message, $what);
+ }
+
+}
diff --git a/src/phage/action/PhageAction.php b/src/phage/action/PhageAction.php
new file mode 100644
--- /dev/null
+++ b/src/phage/action/PhageAction.php
@@ -0,0 +1,49 @@
+requireContainerAction();
+
+ return $this->actions;
+ }
+
+ final public function addAction(PhageAction $action) {
+ $this->requireContainerAction();
+
+ $this->willAddAction($action);
+
+ $this->actions[] = $action;
+ }
+
+ protected function getAllWaitingChannels() {
+ if (!$this->isContainerAction()) {
+ throw new PhutilMethodNotImplementedException();
+ }
+
+ $channels = array();
+ foreach ($this->getActions() as $action) {
+ foreach ($action->getAllWaitingChannels() as $channel) {
+ $channels[] = $channel;
+ }
+ }
+
+ return $channels;
+ }
+
+ private function requireContainerAction() {
+ if (!$this->isContainerAction()) {
+ throw new Exception(pht('This is not a container action.'));
+ }
+ }
+
+}
diff --git a/src/phage/action/PhageAgentAction.php b/src/phage/action/PhageAgentAction.php
new file mode 100644
--- /dev/null
+++ b/src/phage/action/PhageAgentAction.php
@@ -0,0 +1,274 @@
+isExiting) {
+ throw new Exception(
+ pht(
+ 'You can not add new actions to an exiting agent.'));
+ }
+
+ $key = 'command/'.$this->commandKey++;
+
+ $this->commands[$key] = array(
+ 'key' => $key,
+ 'command' => $action,
+ );
+
+ $this->queued[$key] = $key;
+ }
+
+ public function isActiveAgent() {
+ return $this->isActive;
+ }
+
+ final public function setLimit($limit) {
+ $this->limit = $limit;
+ return $this;
+ }
+
+ final public function getLimit() {
+ return $this->limit;
+ }
+
+ final public function setThrottle($throttle) {
+ $this->throttle = $throttle;
+ return $this;
+ }
+
+ final public function getThrottle() {
+ return $this->throttle;
+ }
+
+ abstract protected function newAgentFuture(PhutilCommandString $command);
+
+ protected function getAllWaitingChannels() {
+ $channels = array();
+
+ if ($this->isActiveAgent()) {
+ $channels[] = $this->channel;
+ }
+
+ return $channels;
+ }
+
+ public function startAgent() {
+ $bootloader = new PhagePHPAgentBootloader();
+
+ $future = $this->newAgentFuture($bootloader->getBootCommand());
+
+ $future->write($bootloader->getBootSequence(), $keep_open = true);
+
+ $channel = new PhutilExecChannel($future);
+ $channel->setStderrHandler(array($this, 'didReadAgentStderr'));
+
+ $channel = new PhutilJSONProtocolChannel($channel);
+
+ $this->future = $future;
+ $this->channel = $channel;
+ $this->isActive = true;
+ }
+
+ private function updateQueue() {
+ // If we don't have anything waiting in queue, we have nothing to do.
+ if (!$this->queued) {
+ return false;
+ }
+
+ $now = microtime(true);
+
+ // If we're throttling commands and recently started one, don't start
+ // another one yet.
+ $throttle = $this->getThrottle();
+ if ($throttle) {
+ if ($this->waitUntil && ($now < $this->waitUntil)) {
+ return false;
+ }
+ }
+
+ // If we're limiting parallelism and the active list is full, don't
+ // start anything else yet.
+ $limit = $this->getLimit();
+ if ($limit) {
+ if (count($this->active) >= $limit) {
+ return false;
+ }
+ }
+
+ // Move a command out of the queue and tell the agent to execute it.
+ $key = head($this->queued);
+ unset($this->queued[$key]);
+
+ $this->active[$key] = $key;
+ $command = $this->commands[$key]['command'];
+
+ $channel = $this->getChannel();
+
+ $channel->write(
+ array(
+ 'type' => 'EXEC',
+ 'key' => $key,
+ 'command' => $command->getCommand()->getUnmaskedString(),
+ 'timeout' => $command->getTimeout(),
+ ));
+
+ if ($throttle) {
+ $this->waitUntil = ($now + $throttle);
+ }
+
+ return true;
+ }
+
+ private function getChannel() {
+ return $this->channel;
+ }
+
+ public function updateAgent() {
+ if (!$this->isActiveAgent()) {
+ return;
+ }
+
+ $channel = $this->channel;
+
+ while (true) {
+ do {
+ $did_update = $this->updateQueue();
+ } while ($did_update);
+
+ $is_open = $channel->update();
+
+ $message = $channel->read();
+ if ($message !== null) {
+ switch ($message['type']) {
+ case 'TEXT':
+ $key = $message['key'];
+ $this->writeOutput($key, $message['kind'], $message['text']);
+ break;
+ case 'RSLV':
+ $key = $message['key'];
+ $command = $this->commands[$key]['command'];
+
+ $this->writeOutput($key, 'stdout', $message['stdout']);
+ $this->writeOutput($key, 'stderr', $message['stderr']);
+
+ $exit_code = $message['err'];
+
+ $command->setExitCode($exit_code);
+ $command->setDidTimeout((bool)idx($message, 'timeout'));
+
+ if ($exit_code != 0) {
+ $exit_code = $this->formatOutput(
+ pht(
+ 'Command ("%s") exited nonzero ("%s")!',
+ $command->getCommand(),
+ $exit_code),
+ $command->getLabel());
+
+ fprintf(STDOUT, '%s', $exit_code);
+ }
+
+ unset($this->active[$key]);
+
+ if (!$this->active && !$this->queued) {
+ $channel->write(
+ array(
+ 'type' => 'EXIT',
+ 'key' => 'exit',
+ ));
+
+ $this->isExiting = true;
+ break;
+ }
+ }
+ }
+
+ if (!$is_open) {
+ if ($this->isExiting) {
+ $this->isActive = false;
+ break;
+ } else {
+ throw new Exception(pht('Channel closed unexpectedly!'));
+ }
+ }
+
+ if ($message === null) {
+ break;
+ }
+ }
+ }
+
+ private function writeOutput($key, $kind, $text) {
+ if (!strlen($text)) {
+ return;
+ }
+
+ switch ($kind) {
+ case 'stdout':
+ $target = STDOUT;
+ break;
+ case 'stderr':
+ $target = STDERR;
+ break;
+ default:
+ throw new Exception(pht('Unknown output kind "%s".', $kind));
+ }
+
+ $command = $this->commands[$key]['command'];
+
+ $label = $command->getLabel();
+ if (!strlen($label)) {
+ $label = pht('Unknown Command');
+ }
+
+ $text = $this->formatOutput($text, $label);
+ fprintf($target, '%s', $text);
+ }
+
+ private function formatOutput($output, $context) {
+ $output = phutil_split_lines($output, false);
+ foreach ($output as $key => $line) {
+ $output[$key] = tsprintf("[%s] %R\n", $context, $line);
+ }
+ $output = implode('', $output);
+
+ return $output;
+ }
+
+ public function didReadAgentStderr($channel, $stderr) {
+ throw new Exception(
+ pht(
+ 'Unexpected output on agent stderr: %s.',
+ $stderr));
+ }
+
+}
diff --git a/src/phage/action/PhageExecuteAction.php b/src/phage/action/PhageExecuteAction.php
new file mode 100644
--- /dev/null
+++ b/src/phage/action/PhageExecuteAction.php
@@ -0,0 +1,62 @@
+command = $command;
+ return $this;
+ }
+
+ public function getCommand() {
+ return $this->command;
+ }
+
+ public function setLabel($label) {
+ $this->label = $label;
+ return $this;
+ }
+
+ public function getLabel() {
+ return $this->label;
+ }
+
+ public function setTimeout($timeout) {
+ $this->timeout = $timeout;
+ return $this;
+ }
+
+ public function getTimeout() {
+ return $this->timeout;
+ }
+
+ public function setExitCode($exit_code) {
+ $this->exitCode = $exit_code;
+ return $this;
+ }
+
+ public function getExitCode() {
+ return $this->exitCode;
+ }
+
+ public function setDidTimeout($did_timeout) {
+ $this->didTimeout = $did_timeout;
+ return $this;
+ }
+
+ public function getDidTimeout() {
+ return $this->didTimeout;
+ }
+
+}
diff --git a/src/phage/action/PhageLocalAction.php b/src/phage/action/PhageLocalAction.php
new file mode 100644
--- /dev/null
+++ b/src/phage/action/PhageLocalAction.php
@@ -0,0 +1,10 @@
+getAgents();
+ foreach ($agents as $agent) {
+ $agent->startAgent();
+ }
+
+ while (true) {
+ $channels = $this->getAllWaitingChannels();
+ PhutilChannel::waitForAny($channels);
+
+ $agents = $this->getActiveAgents();
+ if (!$agents) {
+ break;
+ }
+
+ foreach ($agents as $agent) {
+ $agent->updateAgent();
+ }
+ }
+ }
+
+ protected function getAgents() {
+ return $this->getActions();
+ }
+
+ protected function getActiveAgents() {
+ $agents = $this->getAgents();
+
+ foreach ($agents as $key => $agent) {
+ if (!$agent->isActiveAgent()) {
+ unset($agents[$key]);
+ }
+ }
+
+ return $agents;
+ }
+
+
+}
diff --git a/src/phage/agent/PhagePHPAgent.php b/src/phage/agent/PhagePHPAgent.php
new file mode 100644
--- /dev/null
+++ b/src/phage/agent/PhagePHPAgent.php
@@ -0,0 +1,145 @@
+stdin = $stdin;
+ }
+
+ public function execute() {
+ while (true) {
+ if ($this->exec) {
+ $iterator = new FutureIterator($this->exec);
+ $iterator->setUpdateInterval(0.050);
+ foreach ($iterator as $key => $future) {
+ if ($future === null) {
+ foreach ($this->exec as $read_key => $read_future) {
+ $this->readFuture($read_key, $read_future);
+ }
+
+ break;
+ } else {
+ $this->resolveFuture($key, $future);
+ }
+ }
+ } else {
+ PhutilChannel::waitForAny(array($this->getMaster()));
+ }
+
+ $this->processInput();
+ }
+ }
+
+ private function getMaster() {
+ if (!$this->master) {
+ $raw_channel = new PhutilSocketChannel(
+ $this->stdin,
+ fopen('php://stdout', 'w'));
+
+ $json_channel = new PhutilJSONProtocolChannel($raw_channel);
+ $this->master = $json_channel;
+ }
+
+ return $this->master;
+ }
+
+ private function processInput() {
+ $channel = $this->getMaster();
+
+ $open = $channel->update();
+ if (!$open) {
+ throw new Exception(pht('Channel closed!'));
+ }
+
+ while (true) {
+ $command = $channel->read();
+ if ($command === null) {
+ break;
+ }
+ $this->processCommand($command);
+ }
+ }
+
+ private function processCommand(array $spec) {
+ switch ($spec['type']) {
+ case 'EXEC':
+ $key = $spec['key'];
+ $cmd = $spec['command'];
+
+ $future = new ExecFuture('%C', $cmd);
+
+ $timeout = $spec['timeout'];
+ if ($timeout) {
+ $future->setTimeout(ceil($timeout));
+ }
+
+ $future->isReady();
+
+ $this->exec[$key] = $future;
+ break;
+ case 'EXIT':
+ $this->terminateAgent();
+ break;
+ }
+ }
+
+ private function readFuture($key, ExecFuture $future) {
+ $master = $this->getMaster();
+
+ list($stdout, $stderr) = $future->read();
+ $future->discardBuffers();
+
+ if (strlen($stdout)) {
+ $master->write(
+ array(
+ 'type' => 'TEXT',
+ 'key' => $key,
+ 'kind' => 'stdout',
+ 'text' => $stdout,
+ ));
+ }
+
+ if (strlen($stderr)) {
+ $master->write(
+ array(
+ 'type' => 'TEXT',
+ 'key' => $key,
+ 'kind' => 'stderr',
+ 'text' => $stderr,
+ ));
+ }
+ }
+
+ private function resolveFuture($key, ExecFuture $future) {
+ $result = $future->resolve();
+ $master = $this->getMaster();
+
+ $master->write(
+ array(
+ 'type' => 'RSLV',
+ 'key' => $key,
+ 'err' => $result[0],
+ 'stdout' => $result[1],
+ 'stderr' => $result[2],
+ 'timeout' => (bool)$future->getWasKilledByTimeout(),
+ ));
+
+ unset($this->exec[$key]);
+ }
+
+ public function __destruct() {
+ $this->terminateAgent();
+ }
+
+ private function terminateAgent() {
+ foreach ($this->exec as $key => $future) {
+ $future->resolveKill();
+ }
+ exit(0);
+ }
+
+}
diff --git a/src/phage/bootloader/PhageAgentBootloader.php b/src/phage/bootloader/PhageAgentBootloader.php
new file mode 100644
--- /dev/null
+++ b/src/phage/bootloader/PhageAgentBootloader.php
@@ -0,0 +1,9 @@
+buildBootSequence();
+ $len = $this->bootLength;
+
+ // We need to run a command which will bootload a full agent by reading
+ // and evaluating source code from stdin. This is the smallest bootstrap
+ // I was able to construct:
+ //
+ // - Using `fread(STDIN, ...)` is only good up to 8192 bytes.
+ // - Using `fread(STDIN, ...)` or various other constructs prevents us
+ // from opening STDIN later.
+ //
+ // Instead, we `fread()` a second-stage bootstrap which has enough code
+ // to do arbitrary-length reads from stdin. The second-stage bootstrap
+ // reads and evaluates the main agent program.
+
+ return csprintf(
+ 'php -r %s',
+ "eval(fread(\$I=fopen('php://stdin', 'r'), {$len})); /* phage! */");
+ }
+
+ public function getBootSequence() {
+ $boot = $this->buildBootSequence();
+ return $boot->toString();
+ }
+
+ private function buildBootSequence() {
+ if (!$this->bootSequence) {
+ $files = array(
+ 'utils/utils.php',
+ 'object/Phobject.php',
+ 'utils/PhutilRope.php',
+ 'xsprintf/xsprintf.php',
+ 'xsprintf/csprintf.php',
+ 'xsprintf/PhutilCommandString.php',
+ 'future/Future.php',
+ 'future/FutureIterator.php',
+ 'future/exec/PhutilExecutableFuture.php',
+ 'future/exec/ExecFuture.php',
+ 'future/exec/CommandException.php',
+ 'channel/PhutilChannel.php',
+ 'channel/PhutilSocketChannel.php',
+ 'channel/PhutilChannelChannel.php',
+ 'channel/PhutilProtocolChannel.php',
+ 'channel/PhutilJSONProtocolChannel.php',
+ 'phage/agent/PhagePHPAgent.php',
+ );
+
+ $main_sequence = new PhutilBallOfPHP();
+ $root = phutil_get_library_root('phutil');
+ foreach ($files as $file) {
+ $main_sequence->addFile($root.'/'.$file);
+ }
+
+ // NOTE: If we use id() here, we don't get a stack trace out of it when
+ // we call a nonexistent method from inside "execute()"? Not exactly sure
+ // what's going on here, but just sweep it under the rug for now.
+
+ $main_sequence->addText('$A = new PhagePHPAgent($I); $A->execute();');
+ $main_length = strlen($main_sequence->toString());
+
+ $boot_sequence = new PhutilBallOfPHP();
+ $boot = '
+ $length = '.$main_length.';
+ $buffer = "";
+ while (strlen($buffer) < $length) {
+ $data = fread($I, $length - strlen($buffer));
+ if (!strlen($data)) {
+ exit(1);
+ }
+ $buffer .= $data;
+ }
+
+ eval($buffer);';
+ $boot_sequence->addText($boot);
+ $boot_length = strlen($boot_sequence->toString());
+ $boot_sequence->addText($main_sequence->toString());
+
+ if (strlen($boot_length) > 8192) {
+ throw new Exception(pht('Stage 1 bootloader is too large!'));
+ }
+
+ $this->bootSequence = $boot_sequence;
+ $this->bootLength = $boot_length;
+ $this->mainLength = $main_length;
+ }
+
+ return $this->bootSequence;
+ }
+
+}
diff --git a/src/phage/util/PhutilBallOfPHP.php b/src/phage/util/PhutilBallOfPHP.php
new file mode 100644
--- /dev/null
+++ b/src/phage/util/PhutilBallOfPHP.php
@@ -0,0 +1,32 @@
+parts[] = substr($data, 6);
+ return $this;
+ }
+
+ public function addText($text) {
+ $this->parts[] = $text;
+ }
+
+ public function toString() {
+ return implode('', $this->parts);
+ }
+
+}
diff --git a/src/readableserializer/PhutilReadableSerializer.php b/src/readableserializer/PhutilReadableSerializer.php
new file mode 100644
--- /dev/null
+++ b/src/readableserializer/PhutilReadableSerializer.php
@@ -0,0 +1,189 @@
+ 1) {
+ $str .= 'of size '.count($value).' starting with: ';
+ }
+ reset($value); // Prevent key() from giving warning message in HPHP.
+ $str .= '{ '.self::printShort(key($value)).' => '.
+ self::printShort(head($value)).' }';
+ }
+ return $str;
+ } else {
+ // NOTE: Avoid PhutilUTF8StringTruncator here since the data may not be
+ // UTF8 anyway, it's slow for large inputs, and it might not be loaded
+ // yet.
+ $limit = 1024;
+ $str = self::printableValue($value);
+ if (strlen($str) > $limit) {
+ if (is_string($value)) {
+ $str = "'".substr($str, 1, $limit)."...'";
+ } else {
+ $str = substr($str, 0, $limit).'...';
+ }
+ }
+
+ return $str;
+ }
+ }
+
+
+ /**
+ * Dump some debug output about an object's members without the
+ * potential recursive explosion of verbosity that comes with `print_r()`.
+ *
+ * To print any number of member variables, pass null for `$max_members`.
+ *
+ * @param wild Any value.
+ * @param int Maximum depth to print for nested arrays and objects.
+ * @param int Maximum number of values to print at each level.
+ * @return string Human-readable shallow representation of the value.
+ * @task print
+ */
+ public static function printShallow(
+ $value,
+ $max_depth = 2,
+ $max_members = 25) {
+
+ return self::printShallowRecursive($value, $max_depth, $max_members, 0, '');
+ }
+
+
+/* -( Internals )---------------------------------------------------------- */
+
+
+ /**
+ * Implementation for @{method:printShallow}.
+ *
+ * @param wild Any value.
+ * @param int Maximum depth to print for nested arrays and objects.
+ * @param int Maximum number of values to print at each level.
+ * @param int Current depth.
+ * @param string Indentation string.
+ * @return string Human-readable shallow representation of the value.
+ * @task internal
+ */
+ private static function printShallowRecursive(
+ $value,
+ $max_depth,
+ $max_members,
+ $depth,
+ $indent) {
+
+ if (!is_object($value) && !is_array($value)) {
+ return self::addIndentation(self::printableValue($value), $indent, 1);
+ }
+
+ $ret = '';
+ if (is_object($value)) {
+ $ret = get_class($value)."\nwith members ";
+ $value = array_filter(@(array)$value);
+
+ // Remove null characters that magically appear around keys for
+ // member variables of parent classes.
+ $transformed = array();
+ foreach ($value as $key => $x) {
+ $transformed[str_replace("\0", ' ', $key)] = $x;
+ }
+ $value = $transformed;
+ }
+
+ if ($max_members !== null) {
+ $value = array_slice($value, 0, $max_members, $preserve_keys = true);
+ }
+
+ $shallow = array();
+ if ($depth < $max_depth) {
+ foreach ($value as $k => $v) {
+ $shallow[$k] = self::printShallowRecursive(
+ $v,
+ $max_depth,
+ $max_members,
+ $depth + 1,
+ ' ');
+ }
+ } else {
+ foreach ($value as $k => $v) {
+ // Extra indentation is for empty arrays, because they wrap on multiple
+ // lines and lookup stupid without the extra indentation
+ $shallow[$k] = self::addIndentation(self::printShort($v), $indent, 1);
+ }
+ }
+
+ return self::addIndentation($ret.print_r($shallow, true), $indent, 1);
+ }
+
+
+ /**
+ * Adds indentation to the beginning of every line starting from
+ * `$first_line`.
+ *
+ * @param string Printed value.
+ * @param string String to indent with.
+ * @param int Index of first line to indent.
+ * @return string
+ * @task internal
+ */
+ private static function addIndentation($value, $indent, $first_line) {
+ $lines = explode("\n", $value);
+ $out = array();
+ foreach ($lines as $index => $line) {
+ $out[] = $index >= $first_line ? $indent.$line : $line;
+ }
+
+ return implode("\n", $out);
+ }
+
+}
diff --git a/src/readableserializer/__tests__/PhutilReadableSerializerTestCase.php b/src/readableserializer/__tests__/PhutilReadableSerializerTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/readableserializer/__tests__/PhutilReadableSerializerTestCase.php
@@ -0,0 +1,23 @@
+assertEqual(
+ $expect,
+ PhutilReadableSerializer::printableValue($value));
+ }
+ }
+
+}
diff --git a/src/search/PhutilSearchQueryCompiler.php b/src/search/PhutilSearchQueryCompiler.php
new file mode 100644
--- /dev/null
+++ b/src/search/PhutilSearchQueryCompiler.php
@@ -0,0 +1,374 @@
+<()~*:""&|';
+ private $query;
+ private $stemmer;
+ private $enableFunctions = false;
+
+ const OPERATOR_NOT = 'not';
+ const OPERATOR_AND = 'and';
+ const OPERATOR_SUBSTRING = 'sub';
+ const OPERATOR_EXACT = 'exact';
+
+ public function setOperators($operators) {
+ $this->operators = $operators;
+ return $this;
+ }
+
+ public function getOperators() {
+ return $this->operators;
+ }
+
+ public function setStemmer(PhutilSearchStemmer $stemmer) {
+ $this->stemmer = $stemmer;
+ return $this;
+ }
+
+ public function getStemmer() {
+ return $this->stemmer;
+ }
+
+ public function setEnableFunctions($enable_functions) {
+ $this->enableFunctions = $enable_functions;
+ return $this;
+ }
+
+ public function getEnableFunctions() {
+ return $this->enableFunctions;
+ }
+
+ public function compileQuery(array $tokens) {
+ assert_instances_of($tokens, 'PhutilSearchQueryToken');
+
+ $result = array();
+ foreach ($tokens as $token) {
+ $result[] = $this->renderToken($token);
+ }
+
+ return $this->compileRenderedTokens($result);
+ }
+
+ public function compileLiteralQuery(array $tokens) {
+ assert_instances_of($tokens, 'PhutilSearchQueryToken');
+
+ $result = array();
+ foreach ($tokens as $token) {
+ if (!$token->isQuoted()) {
+ continue;
+ }
+ $result[] = $this->renderToken($token);
+ }
+
+ return $this->compileRenderedTokens($result);
+ }
+
+ public function compileStemmedQuery(array $tokens) {
+ assert_instances_of($tokens, 'PhutilSearchQueryToken');
+
+ $result = array();
+ foreach ($tokens as $token) {
+ if ($token->isQuoted()) {
+ continue;
+ }
+ $result[] = $this->renderToken($token, $this->getStemmer());
+ }
+
+ return $this->compileRenderedTokens($result);
+ }
+
+ private function compileRenderedTokens(array $list) {
+ if (!$list) {
+ return null;
+ }
+
+ $list = array_unique($list);
+ return implode(' ', $list);
+ }
+
+ public function newTokens($query) {
+ $results = $this->tokenizeQuery($query);
+
+ $tokens = array();
+ foreach ($results as $result) {
+ $tokens[] = PhutilSearchQueryToken::newFromDictionary($result);
+ }
+
+ return $tokens;
+ }
+
+ private function tokenizeQuery($query) {
+ $maximum_bytes = 1024;
+
+ $query_bytes = strlen($query);
+ if ($query_bytes > $maximum_bytes) {
+ throw new PhutilSearchQueryCompilerSyntaxException(
+ pht(
+ 'Query is too long (%s bytes, maximum is %s bytes).',
+ new PhutilNumber($query_bytes),
+ new PhutilNumber($maximum_bytes)));
+ }
+
+ $query = phutil_utf8v($query);
+ $length = count($query);
+
+ $enable_functions = $this->getEnableFunctions();
+
+ $mode = 'scan';
+ $current_operator = array();
+ $current_token = array();
+ $current_function = null;
+ $is_quoted = false;
+ $tokens = array();
+
+ if ($enable_functions) {
+ $operator_characters = '[~=+-]';
+ } else {
+ $operator_characters = '[+-]';
+ }
+
+ for ($ii = 0; $ii < $length; $ii++) {
+ $character = $query[$ii];
+
+ if ($mode == 'scan') {
+ if (preg_match('/^\s\z/u', $character)) {
+ continue;
+ }
+
+ $mode = 'function';
+ }
+
+ if ($mode == 'function') {
+ $mode = 'operator';
+
+ if ($enable_functions) {
+ $found = false;
+ for ($jj = $ii; $jj < $length; $jj++) {
+ if (preg_match('/^[a-zA-Z]\z/u', $query[$jj])) {
+ continue;
+ }
+ if ($query[$jj] == ':') {
+ $found = $jj;
+ }
+ break;
+ }
+
+ if ($found !== false) {
+ $function = array_slice($query, $ii, ($jj - $ii));
+ $current_function = implode('', $function);
+
+ if (!strlen($current_function)) {
+ $current_function = null;
+ }
+
+ $ii = $jj;
+ continue;
+ }
+ }
+ }
+
+ if ($mode == 'operator') {
+ if (preg_match('/^\s\z/u', $character)) {
+ continue;
+ }
+
+ if (preg_match('/^'.$operator_characters.'\z/', $character)) {
+ $current_operator[] = $character;
+ continue;
+ }
+
+ $mode = 'quote';
+ }
+
+ if ($mode == 'quote') {
+ if (preg_match('/^"\z/', $character)) {
+ $is_quoted = true;
+ $mode = 'token';
+ continue;
+ }
+
+ $mode = 'token';
+ }
+
+ if ($mode == 'token') {
+ $capture = false;
+ $was_quoted = $is_quoted;
+ if ($is_quoted) {
+ if (preg_match('/^"\z/', $character)) {
+ $capture = true;
+ $mode = 'scan';
+ $is_quoted = false;
+ }
+ } else {
+ if (preg_match('/^\s\z/u', $character)) {
+ $capture = true;
+ $mode = 'scan';
+ }
+
+ if (preg_match('/^"\z/', $character)) {
+ $capture = true;
+ $mode = 'token';
+ $is_quoted = true;
+ }
+ }
+
+ if ($capture) {
+ $token = array(
+ 'operator' => $current_operator,
+ 'quoted' => $was_quoted,
+ 'value' => $current_token,
+ );
+
+ if ($enable_functions) {
+ $token['function'] = $current_function;
+ }
+
+ $tokens[] = $token;
+
+ $current_operator = array();
+ $current_token = array();
+ $current_function = null;
+ continue;
+ } else {
+ $current_token[] = $character;
+ }
+ }
+ }
+
+ if ($is_quoted) {
+ throw new PhutilSearchQueryCompilerSyntaxException(
+ pht(
+ 'Query contains unmatched double quotes.'));
+ }
+
+ if ($mode == 'operator') {
+ throw new PhutilSearchQueryCompilerSyntaxException(
+ pht(
+ 'Query contains operator ("%s") with no search term.',
+ implode('', $current_operator)));
+ }
+
+ $token = array(
+ 'operator' => $current_operator,
+ 'quoted' => false,
+ 'value' => $current_token,
+ );
+
+ if ($enable_functions) {
+ $token['function'] = $current_function;
+ }
+
+ $tokens[] = $token;
+
+ $results = array();
+ foreach ($tokens as $token) {
+ $value = implode('', $token['value']);
+ $operator_string = implode('', $token['operator']);
+
+ if (!strlen($value)) {
+ continue;
+ }
+
+ $is_quoted = $token['quoted'];
+
+ switch ($operator_string) {
+ case '-':
+ $operator = self::OPERATOR_NOT;
+ break;
+ case '~':
+ $operator = self::OPERATOR_SUBSTRING;
+ break;
+ case '=':
+ $operator = self::OPERATOR_EXACT;
+ break;
+ case '+':
+ $operator = self::OPERATOR_AND;
+ break;
+ case '':
+ // See T12995. If this query term contains Chinese, Japanese or
+ // Korean characters, treat the term as a substring term by default.
+ // These languages do not separate words with spaces, so the term
+ // search mode is normally useless.
+ if ($enable_functions && !$is_quoted && phutil_utf8_is_cjk($value)) {
+ $operator = self::OPERATOR_SUBSTRING;
+ } else {
+ $operator = self::OPERATOR_AND;
+ }
+ break;
+ default:
+ throw new PhutilSearchQueryCompilerSyntaxException(
+ pht(
+ 'Query has an invalid sequence of operators ("%s").',
+ $operator_string));
+ }
+
+ $result = array(
+ 'operator' => $operator,
+ 'quoted' => $is_quoted,
+ 'value' => $value,
+ );
+
+ if ($enable_functions) {
+ $result['function'] = $token['function'];
+ }
+
+ $results[] = $result;
+ }
+
+ return $results;
+ }
+
+ private function renderToken(
+ PhutilSearchQueryToken $token,
+ PhutilSearchStemmer $stemmer = null) {
+ $value = $token->getValue();
+
+ if ($stemmer) {
+ $value = $stemmer->stemToken($value);
+ }
+
+ $value = $this->quoteToken($value);
+ $operator = $token->getOperator();
+ $prefix = $this->getOperatorPrefix($operator);
+
+ $value = $prefix.$value;
+
+ return $value;
+ }
+
+ private function getOperatorPrefix($operator) {
+ $operators = $this->operators;
+
+ switch ($operator) {
+ case self::OPERATOR_AND:
+ $prefix = $operators[0];
+ break;
+ case self::OPERATOR_NOT:
+ $prefix = $operators[2];
+ break;
+ default:
+ throw new PhutilSearchQueryCompilerSyntaxException(
+ pht(
+ 'Unsupported operator prefix "%s".',
+ $operator));
+ }
+
+ if ($prefix == ' ') {
+ $prefix = null;
+ }
+
+ return $prefix;
+ }
+
+ private function quoteToken($value) {
+ $operators = $this->operators;
+
+ $open_quote = $this->operators[10];
+ $close_quote = $this->operators[11];
+
+ return $open_quote.$value.$close_quote;
+ }
+
+}
diff --git a/src/search/PhutilSearchQueryCompilerSyntaxException.php b/src/search/PhutilSearchQueryCompilerSyntaxException.php
new file mode 100644
--- /dev/null
+++ b/src/search/PhutilSearchQueryCompilerSyntaxException.php
@@ -0,0 +1,4 @@
+isQuoted = $dictionary['quoted'];
+ $token->operator = $dictionary['operator'];
+ $token->value = $dictionary['value'];
+ $token->function = idx($dictionary, 'function');
+
+ return $token;
+ }
+
+ public function isQuoted() {
+ return $this->isQuoted;
+ }
+
+ public function getValue() {
+ return $this->value;
+ }
+
+ public function getOperator() {
+ return $this->operator;
+ }
+
+ public function getFunction() {
+ return $this->function;
+ }
+
+}
diff --git a/src/search/PhutilSearchStemmer.php b/src/search/PhutilSearchStemmer.php
new file mode 100644
--- /dev/null
+++ b/src/search/PhutilSearchStemmer.php
@@ -0,0 +1,74 @@
+normalizeToken($token);
+ return $this->applyStemmer($token);
+ }
+
+ public function stemCorpus($corpus) {
+ $corpus = $this->normalizeCorpus($corpus);
+ $tokens = preg_split('/[^a-zA-Z0-9\x7F-\xFF._]+/', $corpus);
+
+ $words = array();
+ foreach ($tokens as $key => $token) {
+ $token = trim($token, '._');
+
+ if (strlen($token) < 3) {
+ continue;
+ }
+
+ $words[$token] = $token;
+ }
+
+ $stems = array();
+ foreach ($words as $word) {
+ $stems[] = $this->applyStemmer($word);
+ }
+
+ return implode(' ', $stems);
+ }
+
+ private function normalizeToken($token) {
+ return phutil_utf8_strtolower($token);
+ }
+
+ private function normalizeCorpus($corpus) {
+ return phutil_utf8_strtolower($corpus);
+ }
+
+ /**
+ * @phutil-external-symbol class Porter
+ */
+ private function applyStemmer($normalized_token) {
+ // If the token has internal punctuation, handle it literally. This
+ // deals with things like domain names, Conduit API methods, and other
+ // sorts of informal tokens.
+ if (preg_match('/[._]/', $normalized_token)) {
+ return $normalized_token;
+ }
+
+ static $loaded;
+
+ if ($loaded === null) {
+ $root = dirname(phutil_get_library_root('phutil'));
+ require_once $root.'/externals/porter-stemmer/src/Porter.php';
+ $loaded = true;
+ }
+
+
+ $stem = Porter::stem($normalized_token);
+
+ // If the stem is too short, it won't be a candidate for indexing. These
+ // tokens are also likely to be acronyms (like "DNS") rather than real
+ // English words.
+ if (strlen($stem) < 3) {
+ return $normalized_token;
+ }
+
+ return $stem;
+ }
+
+}
diff --git a/src/search/__tests__/PhutilSearchQueryCompilerTestCase.php b/src/search/__tests__/PhutilSearchQueryCompilerTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/search/__tests__/PhutilSearchQueryCompilerTestCase.php
@@ -0,0 +1,220 @@
+ null,
+ 'cat dog' => '+"cat" +"dog"',
+ 'cat -dog' => '+"cat" -"dog"',
+ 'cat-dog' => '+"cat-dog"',
+
+ // If there are spaces after an operator, the operator applies to the
+ // next search term.
+ 'cat - dog' => '+"cat" -"dog"',
+
+ // Double quotes serve as delimiters even if there is no whitespace
+ // between terms.
+ '"cat"dog' => '+"cat" +"dog"',
+
+ // This query is too long.
+ str_repeat('x', 2048) => false,
+
+ // Multiple operators are not permitted.
+ '++cat' => false,
+ '+-cat' => false,
+ '--cat' => false,
+
+ // Stray operators are not permitted.
+ '+' => false,
+ 'cat +' => false,
+
+ // Double quotes must be paired.
+ '"' => false,
+ 'cat "' => false,
+ '"cat' => false,
+ 'A"' => false,
+ 'A"B"' => '+"A" +"B"',
+ );
+
+ $this->assertCompileQueries($tests);
+
+ // Test that we compile queries correctly if the operators have been
+ // swapped to use "AND" by default.
+ $operator_tests = array(
+ 'cat dog' => '"cat" "dog"',
+ 'cat -dog' => '"cat" -"dog"',
+ );
+ $this->assertCompileQueries($operator_tests, ' |-><()~*:""&\'');
+
+
+ // Test that we compile queries correctly if the quote operators have
+ // been swapped to differ.
+ $quote_tests = array(
+ 'cat dog' => '+[cat] +[dog]',
+ 'cat -dog' => '+[cat] -[dog]',
+ );
+ $this->assertCompileQueries($quote_tests, '+ -><()~*:[]&|');
+
+ }
+
+ public function testCompileQueriesWithStemming() {
+ $stemming_tests = array(
+ 'cat dog' => array(
+ null,
+ '+"cat" +"dog"',
+ ),
+ 'cats dogs' => array(
+ null,
+ '+"cat" +"dog"',
+ ),
+ 'cats "dogs"' => array(
+ '+"dogs"',
+ '+"cat"',
+ ),
+ '"blessed blade" of the windseeker' => array(
+ '+"blessed blade"',
+ '+"of" +"the" +"windseek"',
+ ),
+ 'mailing users for mentions on tasks' => array(
+ null,
+ '+"mail" +"user" +"for" +"mention" +"on" +"task"',
+ ),
+ );
+
+ $stemmer = new PhutilSearchStemmer();
+ $this->assertCompileQueries($stemming_tests, null, $stemmer);
+ }
+
+ public function testCompileQueriesWithFunctions() {
+ $op_and = PhutilSearchQueryCompiler::OPERATOR_AND;
+ $op_sub = PhutilSearchQueryCompiler::OPERATOR_SUBSTRING;
+ $op_exact = PhutilSearchQueryCompiler::OPERATOR_EXACT;
+
+ $mao = "\xE7\x8C\xAB";
+
+ $function_tests = array(
+ 'cat' => array(
+ array(null, $op_and, 'cat'),
+ ),
+ ':cat' => array(
+ array(null, $op_and, 'cat'),
+ ),
+ 'title:cat' => array(
+ array('title', $op_and, 'cat'),
+ ),
+ 'title:cat:dog' => array(
+ array('title', $op_and, 'cat:dog'),
+ ),
+ 'title:~cat' => array(
+ array('title', $op_sub, 'cat'),
+ ),
+ 'cat title:="Meow Meow"' => array(
+ array(null, $op_and, 'cat'),
+ array('title', $op_exact, 'Meow Meow'),
+ ),
+ 'title:cat title:dog' => array(
+ array('title', $op_and, 'cat'),
+ array('title', $op_and, 'dog'),
+ ),
+ '~"core and seven years ag"' => array(
+ array(null, $op_sub, 'core and seven years ag'),
+ ),
+ $mao => array(
+ array(null, $op_sub, $mao),
+ ),
+ '+'.$mao => array(
+ array(null, $op_and, $mao),
+ ),
+ '~'.$mao => array(
+ array(null, $op_sub, $mao),
+ ),
+ '"'.$mao.'"' => array(
+ array(null, $op_and, $mao),
+ ),
+ );
+
+ $this->assertCompileFunctionQueries($function_tests);
+ }
+
+ private function assertCompileQueries(
+ array $tests,
+ $operators = null,
+ PhutilSearchStemmer $stemmer = null) {
+ foreach ($tests as $input => $expect) {
+ $caught = null;
+
+ $query = null;
+ $literal_query = null;
+ $stemmed_query = null;
+
+ try {
+ $compiler = new PhutilSearchQueryCompiler();
+
+ if ($operators !== null) {
+ $compiler->setOperators($operators);
+ }
+
+ if ($stemmer !== null) {
+ $compiler->setStemmer($stemmer);
+ }
+
+ $tokens = $compiler->newTokens($input);
+
+ if ($stemmer) {
+ $literal_query = $compiler->compileLiteralQuery($tokens);
+ $stemmed_query = $compiler->compileStemmedQuery($tokens);
+ } else {
+ $query = $compiler->compileQuery($tokens);
+ }
+ } catch (PhutilSearchQueryCompilerSyntaxException $ex) {
+ $caught = $ex;
+ }
+
+ if ($caught !== null) {
+ $query = false;
+ $literal_query = false;
+ $stemmed_query = false;
+ }
+
+ if (!$stemmer) {
+ $this->assertEqual(
+ $expect,
+ $query,
+ pht('Compilation of query: %s', $input));
+ } else {
+ $this->assertEqual(
+ $expect,
+ ($literal_query === false)
+ ? false
+ : array($literal_query, $stemmed_query),
+ pht('Stemmed compilation of query: %s', $input));
+ }
+ }
+ }
+
+ private function assertCompileFunctionQueries(array $tests) {
+ foreach ($tests as $input => $expect) {
+ $compiler = id(new PhutilSearchQueryCompiler())
+ ->setEnableFunctions(true);
+
+ $tokens = $compiler->newTokens($input);
+
+ $result = array();
+ foreach ($tokens as $token) {
+ $result[] = array(
+ $token->getFunction(),
+ $token->getOperator(),
+ $token->getValue(),
+ );
+ }
+
+ $this->assertEqual(
+ $expect,
+ $result,
+ pht('Function compilation of query: %s', $input));
+ }
+ }
+
+}
diff --git a/src/search/__tests__/PhutilSearchStemmerTestCase.php b/src/search/__tests__/PhutilSearchStemmerTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/search/__tests__/PhutilSearchStemmerTestCase.php
@@ -0,0 +1,85 @@
+ 'token',
+ 'panels' => 'panel',
+
+ 'renames' => 'renam',
+ 'rename' => 'renam',
+
+ 'components' => 'compon',
+ 'component' => 'compon',
+
+ 'implementation' => 'implement',
+ 'implements' => 'implement',
+ 'implementing' => 'implement',
+ 'implementer' => 'implement',
+
+ 'deleting' => 'delet',
+ 'deletion' => 'delet',
+ 'delete' => 'delet',
+
+ 'erratically' => 'errat',
+ 'erratic' => 'errat',
+
+ // Stems should be normalized.
+ 'DOG' => 'dog',
+
+ // If stemming would bring a token under 3 characters, it should not
+ // be stemmed.
+ 'dns' => 'dns',
+ 'nis' => 'nis',
+
+ // Complex tokens with internal punctuation should be left untouched;
+ // these are usually things like domain names, API calls, informal tags,
+ // etc.
+ 'apples' => 'appl',
+ 'bananas' => 'banana',
+ 'apples_bananas' => 'apples_bananas',
+ 'apples_bananas.apples_bananas' => 'apples_bananas.apples_bananas',
+ );
+
+ $stemmer = new PhutilSearchStemmer();
+ foreach ($tests as $input => $expect) {
+ $stem = $stemmer->stemToken($input);
+ $this->assertEqual(
+ $expect,
+ $stem,
+ pht('Token stem of "%s".', $input));
+ }
+ }
+
+ public function testStemDocuments() {
+ $tests = array(
+ 'The wild boar meandered erratically.' =>
+ 'the wild boar meander errat',
+ 'Fool me onc, shame on you. Fool me twice, shame on me.' =>
+ 'fool onc shame you twice',
+ 'Fireball is a seventh-level spell which deals 2d16 points of damage '.
+ 'in a 1-meter radius around a target.' =>
+ 'firebal seventh level spell which deal 2d16 point damag meter '.
+ 'radiu around target',
+ 'apples-bananas' => 'appl banana',
+ 'apples_bananas' => 'apples_bananas',
+ 'apples.bananas' => 'apples.bananas',
+ 'oddly-proportioned' => 'oddli proport',
+ );
+
+ $stemmer = new PhutilSearchStemmer();
+ foreach ($tests as $input => $expect) {
+ $stem = $stemmer->stemCorpus($input);
+ $this->assertEqual(
+ $expect,
+ $stem,
+ pht('Corpus stem of: %s', $input));
+ }
+ }
+
+
+}
diff --git a/src/serviceprofiler/PhutilServiceProfiler.php b/src/serviceprofiler/PhutilServiceProfiler.php
new file mode 100644
--- /dev/null
+++ b/src/serviceprofiler/PhutilServiceProfiler.php
@@ -0,0 +1,222 @@
+discardMode = true;
+ }
+
+ public function setCollectStackTraces($collect_stack_traces) {
+ $this->collectStackTraces = $collect_stack_traces;
+ return $this;
+ }
+
+ public function getCollectStackTraces() {
+ return $this->collectStackTraces;
+ }
+
+ public static function getInstance() {
+ if (empty(self::$instance)) {
+ self::$instance = new PhutilServiceProfiler();
+ }
+ return self::$instance;
+ }
+
+ public function beginServiceCall(array $data) {
+ $data['begin'] = microtime(true);
+
+ if ($this->collectStackTraces) {
+ $trace = debug_backtrace();
+ $trace = PhutilErrorHandler::formatStacktrace($trace);
+ $data['trace'] = $trace;
+ }
+
+ $id = $this->logSize++;
+ $this->events[$id] = $data;
+ foreach ($this->listeners as $listener) {
+ call_user_func($listener, 'begin', $id, $data);
+ }
+ return $id;
+ }
+
+ public function endServiceCall($call_id, array $data) {
+ $data = ($this->events[$call_id] + $data);
+ $data['end'] = microtime(true);
+ $data['duration'] = ($data['end'] - $data['begin']);
+ $this->events[$call_id] = $data;
+ foreach ($this->listeners as $listener) {
+ call_user_func($listener, 'end', $call_id, $data);
+ }
+ if ($this->discardMode) {
+ unset($this->events[$call_id]);
+ }
+ }
+
+ public function getServiceCallLog() {
+ return $this->events;
+ }
+
+ public function addListener($callback) {
+ $this->listeners[] = $callback;
+ }
+
+ public static function installEchoListener() {
+ $instance = self::getInstance();
+ $instance->addListener(array(__CLASS__, 'echoListener'));
+ }
+
+ public static function echoListener($type, $id, $data) {
+ $is_begin = false;
+ $is_end = false;
+
+ switch ($type) {
+ case 'begin':
+ $is_begin = true;
+ $mark = '>>>';
+ break;
+ case 'end':
+ $is_end = true;
+ $mark = '<<<';
+ break;
+ default:
+ $mark = null;
+ break;
+ }
+
+ $type = idx($data, 'type', 'mystery');
+
+ $desc = null;
+ if ($is_begin) {
+ switch ($type) {
+ case 'connect':
+ $desc = $data['database'];
+ break;
+ case 'query':
+ $desc = substr($data['query'], 0, 512);
+ break;
+ case 'multi-query':
+ $desc = array();
+ foreach ($data['queries'] as $query) {
+ $desc[] = substr($query, 0, 256);
+ }
+ $desc = implode('; ', $desc);
+ break;
+ case 'exec':
+ $desc = '$ '.$data['command'];
+ break;
+ case 'conduit':
+ if (isset($data['size'])) {
+ $desc = $data['method'].'() ';
+ $desc .= pht('', new PhutilNumber($data['size']));
+ } else {
+ $desc = $data['method'].'()';
+ }
+ break;
+ case 'http':
+ if (isset($data['proxy'])) {
+ $proxy = phutil_censor_credentials($data['proxy']);
+ } else {
+ $proxy = null;
+ }
+
+ $uri = phutil_censor_credentials($data['uri']);
+
+ if (strlen($proxy)) {
+ $desc = "{$proxy} >> {$uri}";
+ } else {
+ $desc = $uri;
+ }
+
+ break;
+ case 'lint':
+ $desc = $data['linter'];
+ if (isset($data['paths'])) {
+ $desc .= ' '.pht('', phutil_count($data['paths']));
+ }
+ break;
+ case 'lock':
+ $desc = $data['name'];
+ break;
+ case 'event':
+ $desc = $data['kind'].' ';
+ $desc .= pht('', new PhutilNumber($data['count']));
+ break;
+ case 'ldap':
+ $call = idx($data, 'call', '?');
+ $params = array();
+ switch ($call) {
+ case 'connect':
+ $params[] = $data['host'].':'.$data['port'];
+ break;
+ case 'start-tls':
+ break;
+ case 'bind':
+ $params[] = $data['user'];
+ break;
+ case 'search':
+ $params[] = $data['dn'];
+ $params[] = $data['query'];
+ break;
+ default:
+ $params[] = '?';
+ break;
+ }
+ $desc = "{$call} (".implode(', ', $params).")";
+ break;
+ }
+ } else if ($is_end) {
+ $desc = pht(
+ '%s us',
+ new PhutilNumber((int)(1000000 * $data['duration'])));
+ }
+
+ $instance = self::getInstance();
+ if (!$instance->zeroTime) {
+ $instance->zeroTime = microtime(true);
+ }
+ $elapsed = microtime(true) - $instance->zeroTime;
+
+ $console = PhutilConsole::getConsole();
+ $console->writeLog(
+ "%s [%s] (+%s) <%s> %s\n",
+ $mark,
+ $id,
+ pht('%s', new PhutilNumber((int)(1000 * $elapsed))),
+ $type,
+ self::escapeProfilerStringForDisplay($desc));
+ }
+
+ private static function escapeProfilerStringForDisplay($string) {
+ // Convert tabs and newlines to spaces and collapse blocks of whitespace,
+ // most often formatting in queries.
+ $string = preg_replace('/\s{2,}/', ' ', $string);
+
+ // Replace sequences of binary characters with printable text. We allow
+ // some printable characters to appear in between unprintable characters
+ // to try to collapse the entire run.
+ $string = preg_replace(
+ '/[\x00-\x1F\x7F-\xFF](.{0,12}[\x00-\x1F\x7F-\xFF])*/',
+ '<...binary data...>',
+ $string);
+
+ return $string;
+ }
+
+
+}
diff --git a/src/sprites/PhutilSprite.php b/src/sprites/PhutilSprite.php
new file mode 100644
--- /dev/null
+++ b/src/sprites/PhutilSprite.php
@@ -0,0 +1,76 @@
+name = $name;
+ return $this;
+ }
+
+ public function getName() {
+ return $this->name;
+ }
+
+ public function setTargetCSS($target_css) {
+ $this->targetCSS = $target_css;
+ return $this;
+ }
+
+ public function getTargetCSS() {
+ return $this->targetCSS;
+ }
+
+ public function setSourcePosition($x, $y) {
+ $this->sourceX = $x;
+ $this->sourceY = $y;
+ return $this;
+ }
+
+ public function setSourceSize($w, $h) {
+ $this->sourceW = $w;
+ $this->sourceH = $h;
+ return $this;
+ }
+
+ public function getSourceH() {
+ return $this->sourceH;
+ }
+
+ public function getSourceW() {
+ return $this->sourceW;
+ }
+
+ public function getSourceY() {
+ return $this->sourceY;
+ }
+
+ public function getSourceX() {
+ return $this->sourceX;
+ }
+
+ public function setSourceFile($source_file, $scale = 1) {
+ $this->sourceFiles[$scale] = $source_file;
+ return $this;
+ }
+
+ public function getSourceFile($scale) {
+ if (empty($this->sourceFiles[$scale])) {
+ throw new Exception(pht("No source file for scale '%s'!", $scale));
+ }
+
+ return $this->sourceFiles[$scale];
+ }
+
+}
diff --git a/src/sprites/PhutilSpriteSheet.php b/src/sprites/PhutilSpriteSheet.php
new file mode 100644
--- /dev/null
+++ b/src/sprites/PhutilSpriteSheet.php
@@ -0,0 +1,385 @@
+generated = false;
+ $this->sprites[] = $sprite;
+ return $this;
+ }
+
+ public function setCSSHeader($header) {
+ $this->generated = false;
+ $this->cssHeader = $header;
+ return $this;
+ }
+
+ public function setScales(array $scales) {
+ $this->scales = array_values($scales);
+ return $this;
+ }
+
+ public function getScales() {
+ return $this->scales;
+ }
+
+ public function setSheetType($type) {
+ $this->type = $type;
+ return $this;
+ }
+
+ public function setBasePath($base_path) {
+ $this->basePath = $base_path;
+ return $this;
+ }
+
+ private function generate() {
+ if ($this->generated) {
+ return;
+ }
+
+ $multi_row = true;
+ $multi_col = true;
+ $margin_w = 1;
+ $margin_h = 1;
+
+ $type = $this->type;
+ switch ($type) {
+ case self::TYPE_STANDARD:
+ break;
+ case self::TYPE_REPEAT_X:
+ $multi_col = false;
+ $margin_w = 0;
+
+ $width = null;
+ foreach ($this->sprites as $sprite) {
+ if ($width === null) {
+ $width = $sprite->getSourceW();
+ } else if ($width !== $sprite->getSourceW()) {
+ throw new Exception(
+ pht(
+ "All sprites in a '%s' sheet must have the same width.",
+ 'repeat-x'));
+ }
+ }
+ break;
+ case self::TYPE_REPEAT_Y:
+ $multi_row = false;
+ $margin_h = 0;
+
+ $height = null;
+ foreach ($this->sprites as $sprite) {
+ if ($height === null) {
+ $height = $sprite->getSourceH();
+ } else if ($height !== $sprite->getSourceH()) {
+ throw new Exception(
+ pht(
+ "All sprites in a '%s' sheet must have the same height.",
+ 'repeat-y'));
+ }
+ }
+ break;
+ default:
+ throw new Exception(pht("Unknown sprite sheet type '%s'!", $type));
+ }
+
+
+ $css = array();
+ if ($this->cssHeader) {
+ $css[] = $this->cssHeader;
+ }
+
+ $out_w = 0;
+ $out_h = 0;
+
+ // Lay out the sprite sheet. We attempt to build a roughly square sheet
+ // so it's easier to manage, since 2000x20 is more cumbersome for humans
+ // to deal with than 200x200.
+ //
+ // To do this, we use a simple greedy algorithm, adding sprites one at a
+ // time. For each sprite, if the sheet is at least as wide as it is tall
+ // we create a new row. Otherwise, we try to add it to an existing row.
+ //
+ // This isn't optimal, but does a reasonable job in most cases and isn't
+ // too messy.
+
+ // Group the sprites by their sizes. We lay them out in the sheet as
+ // boxes, but then put them into the boxes in the order they were added
+ // so similar sprites end up nearby on the final sheet.
+ $boxes = array();
+ foreach (array_reverse($this->sprites) as $sprite) {
+ $s_w = $sprite->getSourceW() + $margin_w;
+ $s_h = $sprite->getSourceH() + $margin_h;
+ $boxes[$s_w][$s_h][] = $sprite;
+ }
+
+ $rows = array();
+ foreach ($this->sprites as $sprite) {
+ $s_w = $sprite->getSourceW() + $margin_w;
+ $s_h = $sprite->getSourceH() + $margin_h;
+
+ // Choose a row for this sprite.
+ $maybe = array();
+ foreach ($rows as $key => $row) {
+ if ($row['h'] < $s_h) {
+ // We can only add it to a row if the row is at least as tall as the
+ // sprite.
+ continue;
+ }
+ // We prefer rows which have the same height as the sprite, and then
+ // rows which aren't yet very wide.
+ $wasted_v = ($row['h'] - $s_h);
+ $wasted_h = ($row['w'] / $out_w);
+ $maybe[$key] = $wasted_v + $wasted_h;
+ }
+
+ $row_key = null;
+ if ($maybe && $multi_col) {
+ // If there were any candidate rows, pick the best one.
+ asort($maybe);
+ $row_key = head_key($maybe);
+ }
+
+ if ($row_key !== null && $multi_row) {
+ // If there's a candidate row, but adding the sprite to it would make
+ // the sprite wider than it is tall, create a new row instead. This
+ // generally keeps the sprite square-ish.
+ if ($rows[$row_key]['w'] + $s_w > $out_h) {
+ $row_key = null;
+ }
+ }
+
+ if ($row_key === null) {
+ // Add a new row.
+ $rows[] = array(
+ 'w' => 0,
+ 'h' => $s_h,
+ 'boxes' => array(),
+ );
+ $row_key = last_key($rows);
+ $out_h += $s_h;
+ }
+
+ // Add the sprite box to the row.
+ $row = $rows[$row_key];
+ $row['w'] += $s_w;
+ $row['boxes'][] = array($s_w, $s_h);
+ $rows[$row_key] = $row;
+
+ $out_w = max($row['w'], $out_w);
+ }
+
+ $images = array();
+ foreach ($this->scales as $scale) {
+ $img = imagecreatetruecolor($out_w * $scale, $out_h * $scale);
+ imagesavealpha($img, true);
+ imagefill($img, 0, 0, imagecolorallocatealpha($img, 0, 0, 0, 127));
+
+ $images[$scale] = $img;
+ }
+
+
+ // Put the shorter rows first. At the same height, put the wider rows first.
+ // This makes the resulting sheet more human-readable.
+ foreach ($rows as $key => $row) {
+ $rows[$key]['sort'] = $row['h'] + (1 - ($row['w'] / $out_w));
+ }
+ $rows = isort($rows, 'sort');
+
+ $pos_x = 0;
+ $pos_y = 0;
+ $rules = array();
+ foreach ($rows as $row) {
+ $max_h = 0;
+ foreach ($row['boxes'] as $box) {
+ $sprite = array_pop($boxes[$box[0]][$box[1]]);
+
+ foreach ($images as $scale => $img) {
+ $src = $this->loadSource($sprite, $scale);
+ imagecopy(
+ $img,
+ $src,
+ $scale * $pos_x, $scale * $pos_y,
+ $scale * $sprite->getSourceX(), $scale * $sprite->getSourceY(),
+ $scale * $sprite->getSourceW(), $scale * $sprite->getSourceH());
+ }
+
+ $rule = $sprite->getTargetCSS();
+ $cssx = (-$pos_x).'px';
+ $cssy = (-$pos_y).'px';
+
+ $rules[$sprite->getName()] = "{$rule} {\n".
+ " background-position: {$cssx} {$cssy};\n}";
+
+ $pos_x += $sprite->getSourceW() + $margin_w;
+ $max_h = max($max_h, $sprite->getSourceH());
+ }
+ $pos_x = 0;
+ $pos_y += $max_h + $margin_h;
+ }
+
+ // Generate CSS rules in input order.
+ foreach ($this->sprites as $sprite) {
+ $css[] = $rules[$sprite->getName()];
+ }
+
+ $this->images = $images;
+ $this->css = implode("\n\n", $css)."\n";
+ $this->generated = true;
+ }
+
+ public function generateImage($path, $scale = 1) {
+ $this->generate();
+ $this->log(pht("Writing sprite '%s'...", $path));
+ imagepng($this->images[$scale], $path);
+ return $this;
+ }
+
+ public function generateCSS($path) {
+ $this->generate();
+ $this->log(pht("Writing CSS '%s'...", $path));
+
+ $out = $this->css;
+ $out = str_replace('{X}', imagesx($this->images[1]), $out);
+ $out = str_replace('{Y}', imagesy($this->images[1]), $out);
+
+ Filesystem::writeFile($path, $out);
+ return $this;
+ }
+
+ public function needsRegeneration(array $manifest) {
+ return ($this->buildManifest() !== $manifest);
+ }
+
+ private function buildManifest() {
+ $output = array();
+ foreach ($this->sprites as $sprite) {
+ $output[$sprite->getName()] = array(
+ 'name' => $sprite->getName(),
+ 'rule' => $sprite->getTargetCSS(),
+ 'hash' => $this->loadSourceHash($sprite),
+ );
+ }
+
+ ksort($output);
+
+ $data = array(
+ 'version' => self::MANIFEST_VERSION,
+ 'sprites' => $output,
+ 'scales' => $this->scales,
+ 'header' => $this->cssHeader,
+ 'type' => $this->type,
+ );
+
+ return $data;
+ }
+
+ public function generateManifest($path) {
+ $data = $this->buildManifest();
+
+ $json = new PhutilJSON();
+ $data = $json->encodeFormatted($data);
+ Filesystem::writeFile($path, $data);
+ return $this;
+ }
+
+ private function log($message) {
+ echo $message."\n";
+ }
+
+ private function loadSourceHash(PhutilSprite $sprite) {
+ $inputs = array();
+
+ foreach ($this->scales as $scale) {
+ $file = $sprite->getSourceFile($scale);
+
+ // If two users have a project in different places, like:
+ //
+ // /home/alincoln/project
+ // /home/htaft/project
+ //
+ // ...we want to ignore the `/home/alincoln` part when hashing the sheet,
+ // since the sprites don't change when the project directory moves. If
+ // the base path is set, build the hashes using paths relative to the
+ // base path.
+
+ $file_key = $file;
+ if ($this->basePath) {
+ $file_key = Filesystem::readablePath($file, $this->basePath);
+ }
+
+ if (empty($this->hashes[$file_key])) {
+ $this->hashes[$file_key] = md5(Filesystem::readFile($file));
+ }
+
+ $inputs[] = $file_key;
+ $inputs[] = $this->hashes[$file_key];
+ }
+
+ $inputs[] = $sprite->getSourceX();
+ $inputs[] = $sprite->getSourceY();
+ $inputs[] = $sprite->getSourceW();
+ $inputs[] = $sprite->getSourceH();
+
+ return md5(implode(':', $inputs));
+ }
+
+ private function loadSource(PhutilSprite $sprite, $scale) {
+ $file = $sprite->getSourceFile($scale);
+ if (empty($this->sources[$file])) {
+ $data = Filesystem::readFile($file);
+ $image = imagecreatefromstring($data);
+ $this->sources[$file] = array(
+ 'image' => $image,
+ 'x' => imagesx($image),
+ 'y' => imagesy($image),
+ );
+ }
+
+ $s_w = $sprite->getSourceW() * $scale;
+ $i_w = $this->sources[$file]['x'];
+ if ($s_w > $i_w) {
+ throw new Exception(
+ pht(
+ "Sprite source for '%s' is too small (expected width %d, found %d).",
+ $file,
+ $s_w,
+ $i_w));
+ }
+
+ $s_h = $sprite->getSourceH() * $scale;
+ $i_h = $this->sources[$file]['y'];
+ if ($s_h > $i_h) {
+ throw new Exception(
+ pht(
+ "Sprite source for '%s' is too small (expected height %d, found %d).",
+ $file,
+ $s_h,
+ $i_h));
+ }
+
+ return $this->sources[$file]['image'];
+ }
+
+}
diff --git a/src/symbols/PhutilClassMapQuery.php b/src/symbols/PhutilClassMapQuery.php
new file mode 100644
--- /dev/null
+++ b/src/symbols/PhutilClassMapQuery.php
@@ -0,0 +1,318 @@
+ancestorClass = $class;
+ return $this;
+ }
+
+
+ /**
+ * Provide a method to select a unique key for each instance.
+ *
+ * If you provide a method here, the map will be keyed with these values,
+ * instead of with class names. Exceptions will be raised if entries are
+ * not unique.
+ *
+ * You must provide a method here to use @{method:setExpandMethod}.
+ *
+ * @param string Name of the unique key method.
+ * @param bool If true, then classes which return `null` will be filtered
+ * from the results.
+ * @return this
+ * @task config
+ */
+ public function setUniqueMethod($unique_method, $filter_null = false) {
+ $this->uniqueMethod = $unique_method;
+ $this->filterNull = $filter_null;
+ return $this;
+ }
+
+
+ /**
+ * Provide a method to expand each concrete subclass into available instances.
+ *
+ * With some class maps, each class is allowed to provide multiple entries
+ * in the map by returning alternatives from some method with a default
+ * implementation like this:
+ *
+ * public function generateVariants() {
+ * return array($this);
+ * }
+ *
+ * For example, a "color" class may really generate and configure several
+ * instances in the final class map:
+ *
+ * public function generateVariants() {
+ * return array(
+ * self::newColor('red'),
+ * self::newColor('green'),
+ * self::newColor('blue'),
+ * );
+ * }
+ *
+ * This allows multiple entires in the final map to share an entire
+ * implementation, rather than requiring that they each have their own unique
+ * subclass.
+ *
+ * This pattern is most useful if several variants are nearly identical (so
+ * the stub subclasses would be essentially empty) or the available variants
+ * are driven by configuration.
+ *
+ * If a class map uses this pattern, it must also provide a unique key for
+ * each instance with @{method:setUniqueMethod}.
+ *
+ * @param string Name of the expansion method.
+ * @return this
+ * @task config
+ */
+ public function setExpandMethod($expand_method) {
+ $this->expandMethod = $expand_method;
+ return $this;
+ }
+
+
+ /**
+ * Provide a method to sort the final map.
+ *
+ * The map will be sorted using @{function:msort} and passing this method
+ * name.
+ *
+ * @param string Name of the sorting method.
+ * @return this
+ * @task config
+ */
+ public function setSortMethod($sort_method) {
+ $this->sortMethod = $sort_method;
+ return $this;
+ }
+
+
+ /**
+ * Provide a method to filter the map.
+ *
+ * @param string Name of the filtering method.
+ * @return this
+ * @task config
+ */
+ public function setFilterMethod($filter_method) {
+ $this->filterMethod = $filter_method;
+ return $this;
+ }
+
+
+/* -( Executing the Query )------------------------------------------------ */
+
+
+ /**
+ * Execute the query as configured.
+ *
+ * @return map Realized class map.
+ * @task exec
+ */
+ public function execute() {
+ $cache_key = $this->getCacheKey();
+
+ if (!isset(self::$cache[$cache_key])) {
+ self::$cache[$cache_key] = $this->loadMap();
+ }
+
+ return self::$cache[$cache_key];
+ }
+
+
+ /**
+ * Delete all class map caches.
+ *
+ * @return void
+ * @task exec
+ */
+ public static function deleteCaches() {
+ self::$cache = array();
+ }
+
+
+ /**
+ * Generate the core query results.
+ *
+ * This method is used to fill the cache.
+ *
+ * @return map Realized class map.
+ * @task exec
+ */
+ private function loadMap() {
+ $ancestor = $this->ancestorClass;
+ if (!strlen($ancestor)) {
+ throw new PhutilInvalidStateException('setAncestorClass');
+ }
+
+ if (!class_exists($ancestor) && !interface_exists($ancestor)) {
+ throw new Exception(
+ pht(
+ 'Trying to execute a class map query for descendants of class '.
+ '"%s", but no such class or interface exists.',
+ $ancestor));
+ }
+
+ $expand = $this->expandMethod;
+ $filter = $this->filterMethod;
+ $unique = $this->uniqueMethod;
+ $sort = $this->sortMethod;
+
+ if (strlen($expand)) {
+ if (!strlen($unique)) {
+ throw new Exception(
+ pht(
+ 'Trying to execute a class map query for descendants of class '.
+ '"%s", but the query specifies an "expand method" ("%s") without '.
+ 'specifying a "unique method". Class maps which support expansion '.
+ 'must have unique keys.',
+ $ancestor,
+ $expand));
+ }
+ }
+
+ $objects = id(new PhutilSymbolLoader())
+ ->setAncestorClass($ancestor)
+ ->loadObjects();
+
+ // Apply the "expand" mechanism, if it is configured.
+ if (strlen($expand)) {
+ $list = array();
+ foreach ($objects as $object) {
+ foreach (call_user_func(array($object, $expand)) as $instance) {
+ $list[] = $instance;
+ }
+ }
+ } else {
+ $list = $objects;
+ }
+
+ // Apply the "unique" mechanism, if it is configured.
+ if (strlen($unique)) {
+ $map = array();
+ foreach ($list as $object) {
+ $key = call_user_func(array($object, $unique));
+
+ if ($key === null && $this->filterNull) {
+ continue;
+ }
+
+ if (empty($map[$key])) {
+ $map[$key] = $object;
+ continue;
+ }
+
+ throw new Exception(
+ pht(
+ 'Two objects (of classes "%s" and "%s", descendants of ancestor '.
+ 'class "%s") returned the same key from "%s" ("%s"), but each '.
+ 'object in this class map must be identified by a unique key.',
+ get_class($object),
+ get_class($map[$key]),
+ $ancestor,
+ $unique.'()',
+ $key));
+ }
+ } else {
+ $map = $list;
+ }
+
+ // Apply the "filter" mechanism, if it is configured.
+ if (strlen($filter)) {
+ $map = mfilter($map, $filter);
+ }
+
+ // Apply the "sort" mechanism, if it is configured.
+ if (strlen($sort)) {
+ $map = msort($map, $sort);
+ }
+
+ return $map;
+ }
+
+
+/* -( Managing the Map Cache )--------------------------------------------- */
+
+
+ /**
+ * Return a cache key for this query.
+ *
+ * @return string Cache key.
+ * @task cache
+ */
+ public function getCacheKey() {
+ $parts = array(
+ $this->ancestorClass,
+ $this->uniqueMethod,
+ $this->filterNull,
+ $this->expandMethod,
+ $this->filterMethod,
+ $this->sortMethod,
+ );
+ return implode(':', $parts);
+ }
+
+}
diff --git a/src/symbols/PhutilSymbolLoader.php b/src/symbols/PhutilSymbolLoader.php
new file mode 100644
--- /dev/null
+++ b/src/symbols/PhutilSymbolLoader.php
@@ -0,0 +1,414 @@
+setType('class')
+ * ->setLibrary('example')
+ * ->selectAndLoadSymbols();
+ * ```
+ *
+ * When you execute the loading query, it returns a dictionary of matching
+ * symbols:
+ *
+ * ```lang=php
+ * array(
+ * 'class$Example' => array(
+ * 'type' => 'class',
+ * 'name' => 'Example',
+ * 'library' => 'libexample',
+ * 'where' => 'examples/example.php',
+ * ),
+ * // ... more ...
+ * );
+ * ```
+ *
+ * The **library** and **where** keys show where the symbol is defined. The
+ * **type** and **name** keys identify the symbol itself.
+ *
+ * NOTE: This class must not use libphutil functions, including @{function:id}
+ * and @{function:idx}.
+ *
+ * @task config Configuring the Query
+ * @task load Loading Symbols
+ * @task internal Internals
+ */
+final class PhutilSymbolLoader {
+
+ private $type;
+ private $library;
+ private $base;
+ private $name;
+ private $concrete;
+ private $pathPrefix;
+
+ private $suppressLoad;
+
+
+ /**
+ * Select the type of symbol to load, either `class`, `function` or
+ * `interface`.
+ *
+ * @param string Type of symbol to load.
+ * @return this
+ *
+ * @task config
+ */
+ public function setType($type) {
+ $this->type = $type;
+ return $this;
+ }
+
+
+ /**
+ * Restrict the symbol query to a specific library; only symbols from this
+ * library will be loaded.
+ *
+ * @param string Library name.
+ * @return this
+ *
+ * @task config
+ */
+ public function setLibrary($library) {
+ // Validate the library name; this throws if the library in not loaded.
+ $bootloader = PhutilBootloader::getInstance();
+ $bootloader->getLibraryRoot($library);
+
+ $this->library = $library;
+ return $this;
+ }
+
+
+ /**
+ * Restrict the symbol query to a specific path prefix; only symbols defined
+ * in files below that path will be selected.
+ *
+ * @param string Path relative to library root, like "apps/cheese/".
+ * @return this
+ *
+ * @task config
+ */
+ public function setPathPrefix($path) {
+ $this->pathPrefix = str_replace(DIRECTORY_SEPARATOR, '/', $path);
+ return $this;
+ }
+
+
+ /**
+ * Restrict the symbol query to a single symbol name, e.g. a specific class
+ * or function name.
+ *
+ * @param string Symbol name.
+ * @return this
+ *
+ * @task config
+ */
+ public function setName($name) {
+ $this->name = $name;
+ return $this;
+ }
+
+
+ /**
+ * Restrict the symbol query to only descendants of some class. This will
+ * strictly select descendants, the base class will not be selected. This
+ * implies loading only classes.
+ *
+ * @param string Base class name.
+ * @return this
+ *
+ * @task config
+ */
+ public function setAncestorClass($base) {
+ $this->base = $base;
+ return $this;
+ }
+
+
+ /**
+ * Restrict the symbol query to only concrete symbols; this will filter out
+ * abstract classes.
+ *
+ * NOTE: This currently causes class symbols to load, even if you run
+ * @{method:selectSymbolsWithoutLoading}.
+ *
+ * @param bool True if the query should load only concrete symbols.
+ * @return this
+ *
+ * @task config
+ */
+ public function setConcreteOnly($concrete) {
+ $this->concrete = $concrete;
+ return $this;
+ }
+
+
+/* -( Load )--------------------------------------------------------------- */
+
+
+ /**
+ * Execute the query and select matching symbols, then load them so they can
+ * be used.
+ *
+ * @return dict A dictionary of matching symbols. See top-level class
+ * documentation for details. These symbols will be loaded
+ * and available.
+ *
+ * @task load
+ */
+ public function selectAndLoadSymbols() {
+ $map = array();
+
+ $bootloader = PhutilBootloader::getInstance();
+
+ if ($this->library) {
+ $libraries = array($this->library);
+ } else {
+ $libraries = $bootloader->getAllLibraries();
+ }
+
+ if ($this->type) {
+ $types = array($this->type);
+ } else {
+ $types = array(
+ 'class',
+ 'function',
+ );
+ }
+
+ $names = null;
+ if ($this->base) {
+ $names = $this->selectDescendantsOf(
+ $bootloader->getClassTree(),
+ $this->base);
+ }
+
+ $symbols = array();
+ foreach ($libraries as $library) {
+ $map = $bootloader->getLibraryMap($library);
+ foreach ($types as $type) {
+ if ($type == 'interface') {
+ $lookup_map = $map['class'];
+ } else {
+ $lookup_map = $map[$type];
+ }
+
+ // As an optimization, we filter the list of candidate symbols in
+ // several passes, applying a name-based filter first if possible since
+ // it is highly selective and guaranteed to match at most one symbol.
+ // This is the common case and we land here through `__autoload()` so
+ // it's worthwhile to micro-optimize a bit because this code path is
+ // very hot and we save 5-10ms per page for a very moderate increase in
+ // complexity.
+
+ if ($this->name) {
+ // If we have a name filter, just pick the matching name out if it
+ // exists.
+ if (isset($lookup_map[$this->name])) {
+ $filtered_map = array(
+ $this->name => $lookup_map[$this->name],
+ );
+ } else {
+ $filtered_map = array();
+ }
+ } else if ($names !== null) {
+ $filtered_map = array();
+ foreach ($names as $name => $ignored) {
+ if (isset($lookup_map[$name])) {
+ $filtered_map[$name] = $lookup_map[$name];
+ }
+ }
+ } else {
+ // Otherwise, start with everything.
+ $filtered_map = $lookup_map;
+ }
+
+ if ($this->pathPrefix) {
+ $len = strlen($this->pathPrefix);
+ foreach ($filtered_map as $name => $where) {
+ if (strncmp($where, $this->pathPrefix, $len) !== 0) {
+ unset($filtered_map[$name]);
+ }
+ }
+ }
+
+ foreach ($filtered_map as $name => $where) {
+ $symbols[$type.'$'.$name] = array(
+ 'type' => $type,
+ 'name' => $name,
+ 'library' => $library,
+ 'where' => $where,
+ );
+ }
+ }
+ }
+
+ if (!$this->suppressLoad) {
+ $caught = null;
+ foreach ($symbols as $symbol) {
+ try {
+ $this->loadSymbol($symbol);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ }
+ if ($caught) {
+ // NOTE: We try to load everything even if we fail to load something,
+ // primarily to make it possible to remove functions from a libphutil
+ // library without breaking library startup.
+ throw $caught;
+ }
+ }
+
+
+ if ($this->concrete) {
+ // Remove 'abstract' classes.
+ foreach ($symbols as $key => $symbol) {
+ if ($symbol['type'] == 'class') {
+ $reflection = new ReflectionClass($symbol['name']);
+ if ($reflection->isAbstract()) {
+ unset($symbols[$key]);
+ }
+ }
+ }
+ }
+
+ return $symbols;
+ }
+
+
+ /**
+ * Execute the query and select matching symbols, but do not load them. This
+ * will perform slightly better if you are only interested in the existence
+ * of the symbols and don't plan to use them; otherwise, use
+ * @{method:selectAndLoadSymbols}.
+ *
+ * @return dict A dictionary of matching symbols. See top-level class
+ * documentation for details.
+ *
+ * @task load
+ */
+ public function selectSymbolsWithoutLoading() {
+ $this->suppressLoad = true;
+ $result = $this->selectAndLoadSymbols();
+ $this->suppressLoad = false;
+ return $result;
+ }
+
+
+ /**
+ * Select symbols matching the query and then instantiate them, returning
+ * concrete objects. This is a convenience method which simplifies symbol
+ * handling if you are only interested in building objects.
+ *
+ * If you want to do more than build objects, or want to build objects with
+ * varying constructor arguments, use @{method:selectAndLoadSymbols} for
+ * fine-grained control over results.
+ *
+ * This method implicitly restricts the query to match only concrete
+ * classes.
+ *
+ * @param list List of constructor arguments.
+ * @return map Map of class names to constructed objects.
+ */
+ public function loadObjects(array $argv = array()) {
+ $symbols = $this
+ ->setConcreteOnly(true)
+ ->setType('class')
+ ->selectAndLoadSymbols();
+
+ $objects = array();
+ foreach ($symbols as $symbol) {
+ $objects[$symbol['name']] = newv($symbol['name'], $argv);
+ }
+
+ return $objects;
+ }
+
+
+/* -( Internals )---------------------------------------------------------- */
+
+
+ /**
+ * @task internal
+ */
+ private function selectDescendantsOf(array $tree, $root) {
+ $result = array();
+
+ if (empty($tree[$root])) {
+ // No known descendants.
+ return array();
+ }
+
+ foreach ($tree[$root] as $child) {
+ $result[$child] = true;
+ if (!empty($tree[$child])) {
+ $result += $this->selectDescendantsOf($tree, $child);
+ }
+ }
+ return $result;
+ }
+
+
+ /**
+ * @task internal
+ */
+ private function loadSymbol(array $symbol_spec) {
+ // Check if we've already loaded the symbol; bail if we have.
+ $name = $symbol_spec['name'];
+ $is_function = ($symbol_spec['type'] == 'function');
+
+ if ($is_function) {
+ if (function_exists($name)) {
+ return;
+ }
+ } else {
+ if (class_exists($name, false) || interface_exists($name, false)) {
+ return;
+ }
+ }
+
+ $lib_name = $symbol_spec['library'];
+ $where = $symbol_spec['where'];
+ $bootloader = PhutilBootloader::getInstance();
+
+ $bootloader->loadLibrarySource($lib_name, $where);
+
+ // Check that we successfully loaded the symbol from wherever it was
+ // supposed to be defined.
+
+ $load_failed = null;
+ if ($is_function) {
+ if (!function_exists($name)) {
+ $load_failed = pht('function');
+ }
+ } else {
+ if (!class_exists($name, false) && !interface_exists($name, false)) {
+ $load_failed = pht('class or interface');
+ }
+ }
+
+ if ($load_failed !== null) {
+ $lib_path = phutil_get_library_root($lib_name);
+ throw new PhutilMissingSymbolException(
+ $name,
+ $load_failed,
+ pht(
+ "the symbol map for library '%s' (at '%s') claims this %s is ".
+ "defined in '%s', but loading that source file did not cause the ".
+ "%s to become defined.",
+ $lib_name,
+ $lib_path,
+ $load_failed,
+ $where,
+ $load_failed));
+ }
+ }
+
+}
diff --git a/src/symbols/exception/PhutilMissingSymbolException.php b/src/symbols/exception/PhutilMissingSymbolException.php
new file mode 100644
--- /dev/null
+++ b/src/symbols/exception/PhutilMissingSymbolException.php
@@ -0,0 +1,26 @@
+addNodes(
+ * array(
+ * $object->getPHID() => $object->getChildPHIDs(),
+ * ));
+ * $detector->loadGraph();
+ *
+ * Now you can query the graph, e.g. by detecting cycles:
+ *
+ * $cycle = $detector->detectCycles($object->getPHID());
+ *
+ * If ##$cycle## is empty, no graph cycle is reachable from the node. If it
+ * is nonempty, it contains a list of nodes which form a graph cycle.
+ *
+ * NOTE: Nodes must be represented with scalars.
+ *
+ * @task build Graph Construction
+ * @task cycle Cycle Detection
+ * @task explore Graph Exploration
+ */
+abstract class AbstractDirectedGraph extends Phobject {
+
+
+ private $knownNodes = array();
+ private $graphLoaded = false;
+
+
+/* -( Graph Construction )------------------------------------------------- */
+
+
+ /**
+ * Load the edges for a list of nodes. You must override this method. You
+ * will be passed a list of nodes, and should return a dictionary mapping
+ * each node to the list of nodes that can be reached by following its the
+ * edges which originate at it: for example, the child nodes of an object
+ * which has a parent-child relationship to other objects.
+ *
+ * The intent of this method is to allow you to issue a single query per
+ * graph level for graphs which are stored as edge tables in the database.
+ * Generally, you will load all the objects which correspond to the list of
+ * nodes, and then return a map from each of their IDs to all their children.
+ *
+ * NOTE: You must return an entry for every node you are passed, even if it
+ * is invalid or can not be loaded. Either return an empty array (if this is
+ * acceptable for your application) or throw an exception if you can't satisfy
+ * this requirement.
+ *
+ * @param list A list of nodes.
+ * @return dict A map of nodes to the nodes reachable along their edges.
+ * There must be an entry for each node you were provided.
+ * @task build
+ */
+ abstract protected function loadEdges(array $nodes);
+
+
+ /**
+ * Seed the graph with known nodes. Often, you will provide the candidate
+ * edges that a user is trying to create here, or the initial set of edges
+ * you know about.
+ *
+ * @param dict A map of nodes to the nodes reachable along their edges.
+ * @return this
+ * @task build
+ */
+ final public function addNodes(array $nodes) {
+ if ($this->graphLoaded) {
+ throw new Exception(
+ pht(
+ 'Call %s before calling %s. You can not add more nodes '.
+ 'once you have loaded the graph.',
+ __FUNCTION__.'()',
+ 'loadGraph()'));
+ }
+
+ $this->knownNodes += $nodes;
+ return $this;
+ }
+
+ final public function getNodes() {
+ return $this->knownNodes;
+ }
+
+ /**
+ * Utility function to get a list of topographically sorted nodes out of a
+ * graph.
+ *
+ * This could be useful for example to figure out what order you can safely
+ * apply dependencies.
+ *
+ * Note this will loop indefinitely if the graph has a cycle.
+ */
+ final public function getTopographicallySortedNodes() {
+ $sorted = array();
+ $nodes = $this->getNodes();
+
+ $inverse_map = array();
+ foreach ($nodes as $node => $edges) {
+ if (!isset($inverse_map[$node])) {
+ $inverse_map[$node] = array();
+ }
+ foreach ($edges as $edge) {
+ if (!isset($inverse_map[$edge])) {
+ $inverse_map[$edge] = array();
+ }
+ $inverse_map[$edge][$node] = $node;
+ }
+ }
+
+ $end_nodes = array();
+ foreach ($inverse_map as $node => $edges) {
+ if (empty($edges)) {
+ $end_nodes[] = $node;
+ }
+ }
+
+ while (!empty($end_nodes)) {
+ $current_node = array_pop($end_nodes);
+ $sorted[] = $current_node;
+ $current_edges = $nodes[$current_node];
+ foreach ($current_edges as $index => $current_edge) {
+ // delete the edge from the normal map
+ unset($nodes[$current_node][$index]);
+ // and from the inverse map which is modestly trickier
+ $inverse_nodes = $inverse_map[$current_edge];
+ unset($inverse_nodes[$current_node]);
+ $inverse_map[$current_edge] = $inverse_nodes;
+ // no more edges means this is an "end node" now
+ if (empty($inverse_map[$current_edge])) {
+ $end_nodes[] = $current_edge;
+ }
+ }
+ }
+
+ return $sorted;
+ }
+
+ /**
+ * Utility function to get the best effort topographically sorted
+ * nodes out of a graph.
+ */
+ final public function getBestEffortTopographicallySortedNodes() {
+ $nodes = $this->getNodes();
+ $edges = $this->loadEdges($nodes);
+
+ $results = array();
+ $completed = array();
+
+ $depth = 0;
+ while (true) {
+ $next = array();
+
+ foreach ($nodes as $node) {
+ if (isset($completed[$node])) {
+ continue;
+ }
+
+ $capable = true;
+ foreach ($edges[$node] as $edge) {
+ if (!isset($completed[$edge])) {
+ $capable = false;
+ break;
+ }
+ }
+
+ if ($capable) {
+ $next[] = $node;
+ }
+ }
+
+ if (count($next) === 0) {
+ // No more nodes to traverse; we are deadlocked if the number
+ // of completed nodes is less than the total number of nodes.
+ break;
+ }
+
+ foreach ($next as $node) {
+ $results[] = array(
+ 'node' => $node,
+ 'depth' => $depth,
+ 'cycle' => false,
+ );
+
+ $completed[$node] = true;
+ }
+
+ $depth++;
+ }
+
+ foreach ($nodes as $node) {
+ if (!isset($completed[$node])) {
+ $results[] = array(
+ 'node' => $node,
+ 'depth' => $depth,
+ 'cycle' => true,
+ );
+ }
+ }
+
+ return $results;
+ }
+
+ /**
+ * Load the graph, building it out so operations can be performed on it. This
+ * constructs the graph level-by-level, calling @{method:loadEdges} to
+ * expand the graph at each stage until it is complete.
+ *
+ * @return this
+ * @task build
+ */
+ final public function loadGraph() {
+
+ $new_nodes = $this->knownNodes;
+ while (true) {
+ $load = array();
+ foreach ($new_nodes as $node => $edges) {
+ foreach ($edges as $edge) {
+ if (!isset($this->knownNodes[$edge])) {
+ $load[$edge] = true;
+ }
+ }
+ }
+
+ if (empty($load)) {
+ break;
+ }
+
+ $load = array_keys($load);
+
+ $new_nodes = $this->loadEdges($load);
+ foreach ($load as $node) {
+ if (!isset($new_nodes[$node]) || !is_array($new_nodes[$node])) {
+ throw new Exception(
+ pht(
+ '%s must return an edge list array for each provided '.
+ 'node, or the cycle detection algorithm may not terminate.',
+ 'loadEdges()'));
+ }
+ }
+
+ $this->addNodes($new_nodes);
+ }
+
+ $this->graphLoaded = true;
+ return $this;
+ }
+
+
+/* -( Cycle Detection )---------------------------------------------------- */
+
+
+ /**
+ * Detect if there are any cycles reachable from a given node.
+ *
+ * If cycles are reachable, it returns a list of nodes which create a cycle.
+ * Note that this list may include nodes which aren't actually part of the
+ * cycle, but lie on the graph between the specified node and the cycle.
+ * For example, it might return something like this (when passed "A"):
+ *
+ * A, B, C, D, E, C
+ *
+ * This means you can walk from A to B to C to D to E and then back to C,
+ * which forms a cycle. A and B are included even though they are not part
+ * of the cycle. When presenting information about graph cycles to users,
+ * including these nodes is generally useful. This also shouldn't ever happen
+ * if you've vetted prior edges before writing them, because it means there
+ * is a preexisting cycle in the graph.
+ *
+ * NOTE: This only detects cycles reachable from a node. It does not detect
+ * cycles in the entire graph.
+ *
+ * @param scalar The node to walk from, looking for graph cycles.
+ * @return list|null Returns null if no cycles are reachable from the node,
+ * or a list of nodes that form a cycle.
+ * @task cycle
+ */
+ final public function detectCycles($node) {
+ if (!$this->graphLoaded) {
+ throw new Exception(
+ pht(
+ 'Call %s to build the graph out before calling %s.',
+ 'loadGraph()',
+ __FUNCTION__.'()'));
+ }
+ if (!isset($this->knownNodes[$node])) {
+ throw new Exception(
+ pht(
+ "The node '%s' is not known. Call %s to seed the graph with nodes.",
+ $node,
+ 'addNodes()'));
+ }
+
+ $visited = array();
+ return $this->performCycleDetection($node, $visited);
+ }
+
+
+ /**
+ * Internal cycle detection implementation. Recursively walks the graph,
+ * keeping track of where it's been, and returns the first cycle it finds.
+ *
+ * @param scalar The node to walk from.
+ * @param list Previously visited nodes.
+ * @return null|list Null if no cycles are found, or a list of nodes
+ * which cycle.
+ * @task cycle
+ */
+ final private function performCycleDetection($node, array $visited) {
+ $visited[$node] = true;
+ foreach ($this->knownNodes[$node] as $edge) {
+ if (isset($visited[$edge])) {
+ $result = array_keys($visited);
+ $result[] = $edge;
+ return $result;
+ }
+ $result = $this->performCycleDetection($edge, $visited);
+ if ($result) {
+ return $result;
+ }
+ }
+ return null;
+ }
+
+}
diff --git a/src/utils/CaseInsensitiveArray.php b/src/utils/CaseInsensitiveArray.php
new file mode 100644
--- /dev/null
+++ b/src/utils/CaseInsensitiveArray.php
@@ -0,0 +1,121 @@
+toArray()); // array('key' => 'foobar')
+ * ```
+ *
+ * Note that it is not possible to reuse case variants of a key. That is, if
+ * the array contains key `xyz` then it is not possible to use any of the
+ * following case variants as an array key: `xyZ`, `xYz`, `xYZ`, `Xyz`, `XyZ`,
+ * `XYz`, `XYZ`. In order to use a case variant as a key, it is necessary to
+ * first unset the original case variant.
+ *
+ * ```lang=php
+ * $array = new CaseInsensitiveArray(array('key' => 'foo', 'KEY' => 'bar'));
+ * var_dump($array->toArray()); // array('key' => 'bar')
+ *
+ * $array['KEY'] = 'baz';
+ * var_dump($array->toArray()); // array('key' => 'baz')
+ *
+ * unset($array['key']);
+ * $array['KEY'] = 'baz';
+ * var_dump($array->toArray()); // array('KEY' => 'baz')
+ * ```
+ */
+final class CaseInsensitiveArray extends PhutilArray {
+
+ /**
+ * Mapping between original and case-invariant keys.
+ *
+ * All keys in the parent `PhutilArray` are indexed using the case-invariant
+ * key rather than the original key.
+ *
+ * @var map
+ */
+ private $keys = array();
+
+ /**
+ * Construct a new array object.
+ *
+ * @param array The input array.
+ */
+ public function __construct(array $data = array()) {
+ foreach ($data as $key => $value) {
+ $this->offsetSet($key, $value);
+ }
+ }
+
+ public function getKeys() {
+ return array_values($this->keys);
+ }
+
+ public function offsetExists($key) {
+ $key = $this->transformKey($key);
+ return array_key_exists($key, $this->keys);
+ }
+
+ public function offsetGet($key) {
+ $key = $this->transformKey($key);
+ return parent::offsetGet($this->keys[$key]);
+ }
+
+ public function offsetSet($key, $value) {
+ $transformed_key = $this->transformKey($key);
+
+ if (isset($this->keys[$transformed_key])) {
+ // If the key already exists, reuse it and override the
+ // existing value.
+ $key = $this->keys[$transformed_key];
+ } else {
+ // If the key doesn't yet, create a new array element.
+ $this->keys[$transformed_key] = $key;
+ }
+
+ parent::offsetSet($key, $value);
+ }
+
+ public function offsetUnset($key) {
+ $key = $this->transformKey($key);
+
+ parent::offsetUnset($this->keys[$key]);
+ unset($this->keys[$key]);
+ }
+
+ /**
+ * Transform an array key.
+ *
+ * This method transforms an array key to be case-invariant. We //could//
+ * just call [[http://php.net/manual/en/function.strtolower.php |
+ * `strtolower`]] directly, but this method allows us to contain the key
+ * transformation logic within a single method, should it ever change.
+ *
+ * Theoretically, we should be able to use any of the following functions
+ * for the purpose of key transformations:
+ *
+ * - [[http://php.net/manual/en/function.strtolower.php | `strtolower`]]
+ * - [[http://php.net/manual/en/function.strtoupper.php | `strtoupper`]]
+ * - Some creative use of other
+ * [[http://php.net/manual/en/book.strings.php | string transformation]]
+ * functions.
+ *
+ * @param string The input key.
+ * @return string The transformed key.
+ */
+ private function transformKey($key) {
+ return phutil_utf8_strtolower($key);
+ }
+
+}
diff --git a/src/utils/PhutilArray.php b/src/utils/PhutilArray.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilArray.php
@@ -0,0 +1,80 @@
+data = $initial_value;
+ }
+
+
+/* -( Conversion )--------------------------------------------------------- */
+
+
+ public function toArray() {
+ return iterator_to_array($this, true);
+ }
+
+
+/* -( Countable Interface )------------------------------------------------ */
+
+
+ public function count() {
+ return count($this->data);
+ }
+
+
+/* -( Iterator Interface )------------------------------------------------- */
+
+
+ public function current() {
+ return current($this->data);
+ }
+
+ public function key() {
+ return key($this->data);
+ }
+
+ public function next() {
+ return next($this->data);
+ }
+
+ public function rewind() {
+ reset($this->data);
+ }
+
+ public function valid() {
+ return (key($this->data) !== null);
+ }
+
+
+/* -( ArrayAccess Interface )---------------------------------------------- */
+
+
+ public function offsetExists($key) {
+ return array_key_exists($key, $this->data);
+ }
+
+ public function offsetGet($key) {
+ return $this->data[$key];
+ }
+
+ public function offsetSet($key, $value) {
+ $this->data[$key] = $value;
+ }
+
+ public function offsetUnset($key) {
+ unset($this->data[$key]);
+ }
+
+}
diff --git a/src/utils/PhutilArrayWithDefaultValue.php b/src/utils/PhutilArrayWithDefaultValue.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilArrayWithDefaultValue.php
@@ -0,0 +1,49 @@
+defaultValue = $default_value;
+ return $this;
+ }
+
+ public function offsetExists($key) {
+ return true;
+ }
+
+ public function offsetGet($key) {
+ if (!parent::offsetExists($key)) {
+ $this->offsetSet($key, $this->defaultValue);
+ }
+ return parent::offsetGet($key);
+ }
+
+}
diff --git a/src/utils/PhutilBufferedIterator.php b/src/utils/PhutilBufferedIterator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilBufferedIterator.php
@@ -0,0 +1,138 @@
+ List of results.
+ * @task impl
+ */
+ abstract protected function loadPage();
+
+
+/* -( Configuration )------------------------------------------------------ */
+
+
+ /**
+ * Get the configured page size.
+ *
+ * @return int Page size.
+ * @task config
+ */
+ final public function getPageSize() {
+ return $this->pageSize;
+ }
+
+
+ /**
+ * Configure the page size. Note that implementations may ignore this.
+ *
+ * @param int Page size.
+ * @return this
+ * @task config
+ */
+ final public function setPageSize($size) {
+ $this->pageSize = $size;
+ return $this;
+ }
+
+
+/* -( Iterator Implementation )-------------------------------------------- */
+
+
+ /**
+ * @task iterator
+ */
+ final public function rewind() {
+ $this->didRewind();
+ $this->data = array();
+ $this->naturalKey = 0;
+ $this->next();
+ }
+
+
+ /**
+ * @task iterator
+ */
+ final public function valid() {
+ return (bool)count($this->data);
+ }
+
+
+ /**
+ * @task iterator
+ */
+ final public function current() {
+ return end($this->data);
+ }
+
+
+ /**
+ * By default, the iterator assigns a "natural" key (0, 1, 2, ...) to each
+ * result. This method is intentionally nonfinal so you can substitute a
+ * different behavior by overriding it if you prefer.
+ *
+ * @return scalar Key for the current result (as per @{method:current}).
+ * @task iterator
+ */
+ public function key() {
+ return $this->naturalKey;
+ }
+
+
+ /**
+ * @task iterator
+ */
+ final public function next() {
+ if ($this->data) {
+ $this->naturalKey++;
+ array_pop($this->data);
+ if ($this->data) {
+ return;
+ }
+ }
+
+ $data = $this->loadPage();
+
+ // NOTE: Reverse the results so we can use array_pop() to discard them,
+ // since it doesn't have the O(N) key reassignment behavior of
+ // array_shift().
+
+ $this->data = array_reverse($data);
+ }
+
+}
diff --git a/src/utils/PhutilCallbackFilterIterator.php b/src/utils/PhutilCallbackFilterIterator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilCallbackFilterIterator.php
@@ -0,0 +1,25 @@
+callback = $callback;
+ }
+
+ public function accept() {
+ return call_user_func($this->callback, $this->current());
+ }
+
+}
diff --git a/src/utils/PhutilChunkedIterator.php b/src/utils/PhutilChunkedIterator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilChunkedIterator.php
@@ -0,0 +1,60 @@
+iterator = $iterator;
+ $this->size = $size;
+ }
+
+ public function rewind() {
+ $this->iterator->rewind();
+ $this->next();
+ $this->key = 0;
+ }
+
+ /**
+ * @return int
+ */
+ public function key() {
+ return $this->key;
+ }
+
+ /**
+ * @return array
+ */
+ public function current() {
+ return $this->current;
+ }
+
+ public function next() {
+ $this->current = array();
+ while ($this->iterator->valid()) {
+ $key = $this->iterator->key();
+ $this->current[$key] = $this->iterator->current();
+ $this->iterator->next();
+ if (count($this->current) >= $this->size) {
+ break;
+ }
+ }
+ $this->key++;
+ }
+
+ public function valid() {
+ return (bool)$this->current;
+ }
+
+}
diff --git a/src/utils/PhutilCowsay.php b/src/utils/PhutilCowsay.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilCowsay.php
@@ -0,0 +1,147 @@
+template = $template;
+ return $this;
+ }
+
+ public function setEyes($eyes) {
+ $this->eyes = $eyes;
+ return $this;
+ }
+
+ public function setTongue($tongue) {
+ $this->tongue = $tongue;
+ return $this;
+ }
+
+ public function setAction($action) {
+ $this->action = $action;
+ return $this;
+ }
+
+ public function setText($text) {
+ $this->text = $text;
+ return $this;
+ }
+
+ public function renderCow() {
+ $width = 40;
+ $template = $this->template;
+
+ // Real ".cow" files are Perl scripts which define a variable called
+ // "$the_cow". We aren't going to interpret Perl, so strip all this stuff
+ // (and any comments in the file) away.
+ $template = phutil_split_lines($template, true);
+ $keep = array();
+ $is_perl_cowfile = false;
+ foreach ($template as $key => $line) {
+ if (preg_match('/^#/', $line)) {
+ continue;
+ }
+ if (preg_match('/^\s*\\$the_cow/', $line)) {
+ $is_perl_cowfile = true;
+ continue;
+ }
+ if (preg_match('/^\s*EOC\s*$/', $line)) {
+ continue;
+ }
+ $keep[] = $line;
+ }
+ $template = implode('', $keep);
+
+ // Original .cow files are perl scripts which contain escaped sequences.
+ // We attempt to unescape here by replacing any character preceded by a
+ // backslash/escape with just that character.
+ if ($is_perl_cowfile) {
+ $template = preg_replace(
+ '/\\\\(.)/',
+ '$1',
+ $template);
+ }
+
+ $template = preg_replace_callback(
+ '/\\$([a-z]+)/',
+ array($this, 'replaceTemplateVariable'),
+ $template);
+ if ($template === false) {
+ throw new Exception(
+ pht(
+ 'Failed to replace template variables while rendering cow!'));
+ }
+
+ $lines = $this->text;
+
+ // TODO: It would be nice to use a utf8 soft wrap here instead, but we
+ // do not currently have one. Soft wrap first, then force to utf8.
+ $lines = wordwrap($lines, $width - 4, "\n", true);
+ $lines = phutil_split_lines($lines, false);
+ foreach ($lines as $key => $line) {
+ $lines[$key] = phutil_utf8ize($line);
+ }
+
+ if ($this->action == 'think') {
+ $borders = '((()))';
+ } else {
+ if (count($lines) == 1) {
+ $borders = '<<<>>>';
+ } else {
+ $borders = '/|\\\\|/';
+ }
+ }
+
+ $size = 0;
+ foreach ($lines as $line) {
+ $size = max(strlen($line), $size);
+ }
+
+ $balloon = array();
+ $balloon[] = ' '.str_repeat('_', $size + 2);
+ $lines = array_values($lines);
+ $last = (count($lines) - 1);
+ foreach ($lines as $idx => $line) {
+ if ($idx == 0) {
+ $l = $borders[0];
+ $r = $borders[3];
+ } else if ($idx == $last) {
+ $l = $borders[2];
+ $r = $borders[5];
+ } else {
+ $l = $borders[1];
+ $r = $borders[4];
+ }
+ $balloon[] = $l.' '.str_pad($line, $size).' '.$r;
+
+ }
+ $balloon[] = ' '.str_repeat('-', $size + 2);
+ $balloon = implode("\n", $balloon);
+
+ return rtrim($balloon."\n".$template);
+ }
+
+ public function replaceTemplateVariable($matches) {
+ switch ($matches[1]) {
+ case 'eyes':
+ return str_pad($this->eyes, 2);
+ case 'tongue':
+ return str_pad($this->tongue, 2);
+ case 'thoughts':
+ return ($this->action == 'say' ? '\\' : 'o');
+ default:
+ return $matches[0];
+ }
+ }
+
+
+}
diff --git a/src/utils/PhutilDirectedScalarGraph.php b/src/utils/PhutilDirectedScalarGraph.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilDirectedScalarGraph.php
@@ -0,0 +1,17 @@
+setSequences(str_split('ran'), str_split('rat'));
+ *
+ * $cost = $matrix->getEditDistance();
+ *
+ * Edit distance computation is slow and requires a large amount of memory;
+ * both are roughly O(N * M) in the length of the strings.
+ *
+ * You can customize the cost of insertions, deletions and replacements. By
+ * default, each has a cost of 1.
+ *
+ * $matrix->setReplaceCost(1);
+ *
+ * By default, transpositions are not evaluated (i.e., the algorithm is
+ * Levenshtein). You can cause transpositions to be evaluated by setting a
+ * transpose cost (which will change the algorithm to Damerau-Levenshtein):
+ *
+ * $matrix->setTransposeCost(1);
+ *
+ * You can also provide a cost to alter the type of operation being applied.
+ * Many strings have several equivalently expensive edit sequences, but one
+ * some sequences are more readable to humans than others. Providing a small
+ * cost to alter operation type tends to smooth out the sequence and produce
+ * long runs of a single operation, which are generally more readable. For
+ * example, these strings:
+ *
+ * (x)
+ * ((x))
+ *
+ * ...have edit strings "issis" and "isssi", which describe edit operations with
+ * the same cost, but the latter string is more comprehensible to human viewers.
+ *
+ * If you set an alter cost, you must call @{method:setComputeString} to enable
+ * type computation. The alter cost should generally be smaller than `c / N`,
+ * where `c` is the smallest operational cost and `N` is the length of the
+ * longest string. For example, if you are using the default costs (insert = 1,
+ * delete = 1, replace = 1) and computing edit distances for strings of fewer
+ * than 1,000 characters, you might set the alter cost to 0.001.
+ */
+final class PhutilEditDistanceMatrix extends Phobject {
+
+ private $insertCost = 1;
+ private $deleteCost = 1;
+ private $replaceCost = 1;
+ private $transposeCost = null;
+ private $alterCost = 0;
+ private $maximumLength;
+ private $computeString;
+ private $applySmoothing = self::SMOOTHING_NONE;
+ private $reachedMaximumLength;
+
+ private $x;
+ private $y;
+ private $prefix;
+ private $suffix;
+
+ private $distanceMatrix = null;
+ private $typeMatrix = null;
+
+ const SMOOTHING_NONE = 'none';
+ const SMOOTHING_INTERNAL = 'internal';
+ const SMOOTHING_FULL = 'full';
+
+ public function setMaximumLength($maximum_length) {
+ $this->maximumLength = $maximum_length;
+ return $this;
+ }
+
+ public function getMaximumLength() {
+ return coalesce($this->maximumLength, $this->getInfinity());
+ }
+
+ public function didReachMaximumLength() {
+ return $this->reachedMaximumLength;
+ }
+
+ public function setComputeString($compute_string) {
+ $this->computeString = $compute_string;
+ return $this;
+ }
+
+ public function getComputeString() {
+ return $this->computeString;
+ }
+
+ public function setTransposeCost($transpose_cost) {
+ $this->transposeCost = $transpose_cost;
+ return $this;
+ }
+
+ public function getTransposeCost() {
+ return $this->transposeCost;
+ }
+
+ public function setReplaceCost($replace_cost) {
+ $this->replaceCost = $replace_cost;
+ return $this;
+ }
+
+ public function getReplaceCost() {
+ return $this->replaceCost;
+ }
+
+ public function setDeleteCost($delete_cost) {
+ $this->deleteCost = $delete_cost;
+ return $this;
+ }
+
+ public function getDeleteCost() {
+ return $this->deleteCost;
+ }
+
+ public function setInsertCost($insert_cost) {
+ $this->insertCost = $insert_cost;
+ return $this;
+ }
+
+ public function getInsertCost() {
+ return $this->insertCost;
+ }
+
+ public function setAlterCost($alter_cost) {
+ $this->alterCost = $alter_cost;
+ return $this;
+ }
+
+ public function getAlterCost() {
+ return $this->alterCost;
+ }
+
+ public function setApplySmoothing($apply_smoothing) {
+ $this->applySmoothing = $apply_smoothing;
+ return $this;
+ }
+
+ public function getApplySmoothing() {
+ return $this->applySmoothing;
+ }
+
+ public function setSequences(array $x, array $y) {
+
+ // NOTE: We strip common prefixes and suffixes from the inputs because
+ // the runtime of the edit distance algorithm is large and it is common
+ // to diff similar strings.
+
+ $xl = count($x);
+ $yl = count($y);
+ $l = min($xl, $yl);
+
+ $prefix_l = 0;
+ $suffix_l = 0;
+
+ for ($ii = 0; $ii < $l; $ii++) {
+ if ($x[$ii] !== $y[$ii]) {
+ break;
+ }
+ $prefix_l++;
+ }
+
+ for ($ii = 1; $ii <= ($l - $prefix_l); $ii++) {
+ if ($x[$xl - $ii] !== $y[$yl - $ii]) {
+ break;
+ }
+ $suffix_l++;
+ }
+
+ $this->prefix = array_slice($x, 0, $prefix_l);
+ $this->suffix = array_slice($x, $xl - $suffix_l);
+
+ $this->x = array_slice($x, $prefix_l, $xl - ($suffix_l + $prefix_l));
+ $this->y = array_slice($y, $prefix_l, $yl - ($suffix_l + $prefix_l));
+ $this->distanceMatrix = null;
+
+ return $this;
+ }
+
+ private function requireSequences() {
+ if ($this->x === null) {
+ throw new PhutilInvalidStateException('setSequences');
+ }
+ }
+
+ public function getEditDistance() {
+ $this->requireSequences();
+
+ $x = $this->x;
+ $y = $this->y;
+
+ if (!$x) {
+ return $this->insertCost * count($y);
+ }
+
+ if (!$y) {
+ return $this->deleteCost * count($x);
+ }
+
+ $max = $this->getMaximumLength();
+ if (count($x) > $max || count($y) > $max) {
+ $this->reachedMaximumLength = true;
+ return ($this->insertCost * count($y)) + ($this->deleteCost * count($x));
+ }
+
+ if ($x === $y) {
+ return 0;
+ }
+
+ $matrix = $this->getDistanceMatrix();
+
+ return $matrix[count($x)][count($y)];
+ }
+
+ /**
+ * Return a string representing the edits between the sequences. The string
+ * has these characters:
+ *
+ * - s (same): Same character in both strings.
+ * - i (insert): Character inserted.
+ * - d (delete): Character deleted.
+ * - x (replace): Character replaced.
+ * - t (transpose): Character transposed.
+ */
+ public function getEditString() {
+ $this->requireSequences();
+
+ $x = $this->x;
+ $y = $this->y;
+
+ if (!$x && !$y) {
+ return $this->padEditString('');
+ }
+
+ if (!$x) {
+ return $this->padEditString(str_repeat('i', count($y)));
+ }
+
+ if (!$y) {
+ return $this->padEditString(str_repeat('d', count($x)));
+ }
+
+ if ($x === $y) {
+ return $this->padEditString(str_repeat('s', count($x)));
+ }
+
+ $max = $this->getMaximumLength();
+ if (count($x) > $max || count($y) > $max) {
+ $this->reachedMaximumLength = true;
+ return $this->padEditString(
+ str_repeat('d', count($x)).
+ str_repeat('i', count($y)));
+ }
+
+ $matrix = $this->getTypeMatrix();
+
+ $xx = count($x);
+ $yy = count($y);
+
+ $transposes = array();
+ $str = '';
+ while (true) {
+ $type = $matrix[$xx][$yy];
+
+ if (is_array($type)) {
+ $chr = 't';
+ $transposes[$type[0]][$type[1]] = true;
+ $type = $type[2];
+ } else {
+ $chr = $type;
+ }
+
+ if (isset($transposes[$xx][$yy])) {
+ $chr = 't';
+ }
+
+ if ($type == 's' || $type == 'x') {
+ $xx -= 1;
+ $yy -= 1;
+ } else if ($type == 'i') {
+ $yy -= 1;
+ } else if ($type == 'd') {
+ $xx -= 1;
+ } else {
+ throw new Exception(pht("Unknown type '%s' in type matrix.", $type));
+ }
+
+ $str .= $chr;
+
+ if ($xx <= 0 && $yy <= 0) {
+ break;
+ }
+ }
+
+ $str = strrev($str);
+
+ // For full smoothing, we pad the edit string before smoothing it, so
+ // ranges of similar characters at the beginning or end of the string can
+ // also be smoothed.
+
+ // For internal smoothing, we only smooth ranges within the change itself.
+
+ $smoothing = $this->getApplySmoothing();
+ switch ($smoothing) {
+ case self::SMOOTHING_FULL:
+ $str = $this->padEditString($str);
+ $str = $this->applySmoothing($str, true);
+ break;
+ case self::SMOOTHING_INTERNAL:
+ $str = $this->applySmoothing($str, false);
+ $str = $this->padEditString($str);
+ break;
+ case self::SMOOTHING_NONE:
+ $str = $this->padEditString($str);
+ break;
+ default:
+ throw new Exception(
+ pht(
+ 'Unknown smoothing type "%s".',
+ $smoothing));
+ }
+
+ return $str;
+ }
+
+ private function padEditString($str) {
+ if ($this->prefix) {
+ $str = str_repeat('s', count($this->prefix)).$str;
+ }
+ if ($this->suffix) {
+ $str = $str.str_repeat('s', count($this->suffix));
+ }
+ return $str;
+ }
+
+ private function getTypeMatrix() {
+ if (!$this->computeString) {
+ throw new PhutilInvalidStateException('setComputeString');
+ }
+ if ($this->typeMatrix === null) {
+ $this->computeMatrix($this->x, $this->y);
+ }
+ return $this->typeMatrix;
+ }
+
+ private function getDistanceMatrix() {
+ if ($this->distanceMatrix === null) {
+ $this->computeMatrix($this->x, $this->y);
+ }
+ return $this->distanceMatrix;
+ }
+
+ private function computeMatrix(array $x, array $y) {
+ $xl = count($x);
+ $yl = count($y);
+
+ $m = array();
+
+ $infinity = $this->getInfinity();
+
+ $use_damerau = ($this->transposeCost !== null);
+ if ($use_damerau) {
+ // Initialize the default cost of a transpose.
+ $m[-1][-1] = $infinity;
+
+ // Initialize the character position dictionary for Damerau.
+ $d = array();
+ foreach ($x as $c) {
+ $d[$c] = -1;
+ }
+ foreach ($y as $c) {
+ $d[$c] = -1;
+ }
+
+ // Initialize the transpose costs for Damerau.
+ for ($xx = 0; $xx <= $xl; $xx++) {
+ $m[$xx][-1] = $infinity;
+ }
+
+ for ($yy = 0; $yy <= $yl; $yy++) {
+ $m[-1][$yy] = $infinity;
+ }
+ }
+
+ // Initialize the top row of the matrix.
+ for ($xx = 0; $xx <= $xl; $xx++) {
+ $m[$xx][0] = $xx * $this->deleteCost;
+ }
+
+ // Initialize the left column of the matrix.
+ $cost = 0;
+ for ($yy = 0; $yy <= $yl; $yy++) {
+ $m[0][$yy] = $yy * $this->insertCost;
+ }
+
+ $use_types = ($this->computeString);
+ if ($use_types) {
+ $t = array();
+ for ($xx = 0; $xx <= $xl; $xx++) {
+ $t[$xx][0] = 'd';
+ }
+ for ($yy = 0; $yy <= $yl; $yy++) {
+ $t[0][$yy] = 'i';
+ }
+ $t[0][0] = 's';
+ }
+
+ $alt_cost = $this->getAlterCost();
+ if ($alt_cost && !$use_types) {
+ throw new Exception(
+ pht(
+ 'If you provide an alter cost with %s, you must enable '.
+ 'type computation with %s.',
+ 'setAlterCost()',
+ 'setComputeStrings()'));
+ }
+
+ // Build the edit distance matrix.
+ for ($xx = 1; $xx <= $xl; $xx++) {
+ $last_dy = -1;
+ for ($yy = 1; $yy <= $yl; $yy++) {
+ if ($use_damerau) {
+ $dx = $d[$y[$yy - 1]];
+ $dy = $last_dy;
+ }
+
+ if ($x[$xx - 1] === $y[$yy - 1]) {
+ $rep_cost = $m[$xx - 1][$yy - 1] + 0;
+ $rep_type = 's';
+ } else {
+ $rep_cost = $m[$xx - 1][$yy - 1] + $this->replaceCost;
+ $rep_type = 'x';
+ }
+
+ $del_cost = $m[$xx - 1][$yy ] + $this->deleteCost;
+ $ins_cost = $m[$xx ][$yy - 1] + $this->insertCost;
+ if ($alt_cost) {
+ $del_char = $t[$xx - 1][$yy ];
+ $ins_char = $t[$xx ][$yy - 1];
+ $rep_char = $t[$xx - 1][$yy - 1];
+
+ if ($del_char !== 'd') {
+ $del_cost += $alt_cost;
+ }
+ if ($ins_char !== 'i') {
+ $ins_cost += $alt_cost;
+ }
+ if ($rep_char !== $rep_type) {
+ $rep_cost += $alt_cost;
+ }
+ }
+
+ if ($rep_cost <= $del_cost && $rep_cost <= $ins_cost) {
+ $cost = $rep_cost;
+ $type = $rep_type;
+ if ($rep_type === 's') {
+ $last_dy = $yy - 1;
+ }
+ } else if ($ins_cost <= $del_cost) {
+ $cost = $ins_cost;
+ $type = 'i';
+ } else {
+ $cost = $del_cost;
+ $type = 'd';
+ }
+
+ if ($use_damerau) {
+ $trn_count = (($xx - $dx - 2) + ($yy - $dy - 2) + 1);
+ $trn_cost = $m[$dx][$dy] + ($trn_count * $this->transposeCost);
+ if ($trn_cost < $cost) {
+ $cost = $trn_cost;
+ $type = array($dx + 1, $dy + 1, $type);
+ }
+ }
+
+ $m[$xx][$yy] = $cost;
+ if ($use_types) {
+ $t[$xx][$yy] = $type;
+ }
+ }
+
+ if ($use_damerau) {
+ $d[$x[$xx - 1]] = ($xx - 1);
+ }
+ }
+
+ $this->distanceMatrix = $m;
+ if ($use_types) {
+ $this->typeMatrix = $t;
+ }
+ }
+
+ private function getInfinity() {
+ return INF;
+ }
+
+ private function printMatrix(array $m) {
+ $x = $this->x;
+ $y = $this->y;
+
+ $p = '% 8s ';
+ printf($p, ' ');
+ foreach (head($m) as $yk => $yv) {
+ printf($p, idx($y, $yk - 1, '-'));
+ }
+ echo "\n";
+ foreach ($m as $xk => $xv) {
+ printf($p, idx($x, $xk - 1, '-'));
+ foreach ($xv as $yk => $yv) {
+ printf($p, ($yv == $this->getInfinity() ? 'inf' : $yv));
+ }
+ echo "\n";
+ }
+ }
+
+ private function printTypeMatrix(array $t) {
+ $x = $this->x;
+ $y = $this->y;
+
+ $p = '% 8s ';
+ printf($p, ' ');
+ foreach (head($t) as $yk => $yv) {
+ printf($p, idx($y, $yk - 1, '-'));
+ }
+ echo "\n";
+ foreach ($t as $xk => $xv) {
+ printf($p, idx($x, $xk - 1, '-'));
+ foreach ($xv as $yk => $yv) {
+ printf($p, ($yv == $this->getInfinity() ? 'inf' : $yv));
+ }
+ echo "\n";
+ }
+ }
+
+ private function applySmoothing($str, $full) {
+ if ($full) {
+ $prefix = '(^|[xdi])';
+ $suffix = '([xdi]|\z)';
+ } else {
+ $prefix = '([xdi])';
+ $suffix = '([xdi])';
+ }
+
+ // Smooth the string out, by replacing short runs of similar characters
+ // with 'x' operations. This makes the result more readable to humans,
+ // since there are fewer choppy runs of short added and removed substrings.
+ do {
+ $original = $str;
+ $str = preg_replace('/'.$prefix.'(s{3})'.$suffix.'/', '$1xxx$3', $str);
+ $str = preg_replace('/'.$prefix.'(s{2})'.$suffix.'/', '$1xx$3', $str);
+ $str = preg_replace('/'.$prefix.'(s{1})'.$suffix.'/', '$1x$3', $str);
+ } while ($str != $original);
+
+ return $str;
+ }
+
+}
diff --git a/src/utils/PhutilExampleBufferedIterator.php b/src/utils/PhutilExampleBufferedIterator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilExampleBufferedIterator.php
@@ -0,0 +1,32 @@
+cursor = 0;
+ }
+
+ protected function loadPage() {
+ $result = $this->query($this->cursor, $this->getPageSize());
+ $this->cursor += count($result);
+ return $result;
+ }
+
+ public function setExampleData(array $data) {
+ $this->data = $data;
+ }
+
+ private function query($cursor, $limit) {
+ // NOTE: Normally you'd load or generate results from some external source
+ // here. Since this is an example, we just use a premade dataset.
+
+ return array_slice($this->data, $cursor, $limit);
+ }
+
+}
diff --git a/src/utils/PhutilExecutionEnvironment.php b/src/utils/PhutilExecutionEnvironment.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilExecutionEnvironment.php
@@ -0,0 +1,46 @@
+algorithm = $algorithm;
+ return $this;
+ }
+
+ public function getAlgorithm() {
+ return $this->algorithm;
+ }
+
+ public function getHash() {
+ $hash = $this->getHashResource();
+ return hash_final($hash, $raw_output = false);
+ }
+
+ protected function didReadValue($value) {
+ $hash = $this->getHashResource();
+
+ hash_update($hash, $value);
+
+ return $value;
+ }
+
+ private function getHashResource() {
+ if (!$this->hash) {
+ $algorithm = $this->getAlgorithm();
+ $this->hash = hash_init($algorithm);
+ }
+ return $this->hash;
+ }
+
+}
diff --git a/src/utils/PhutilLunarPhase.php b/src/utils/PhutilLunarPhase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilLunarPhase.php
@@ -0,0 +1,43 @@
+isFull();
+ */
+final class PhutilLunarPhase extends Phobject {
+
+ private $epoch;
+
+ public function __construct($epoch) {
+ $this->epoch = $epoch;
+ }
+
+ private function getPhase() {
+ // (Aug 11, 1999) A new moon.
+ $new_moon_epoch = 934354800;
+
+ // Number of seconds in the lunar phase.
+ $phase_length = 2551442.8768992;
+
+ return fmod($this->epoch - $new_moon_epoch, $phase_length) / $phase_length;
+ }
+
+ public function isFull() {
+ return abs($this->getPhase() - 0.5) < 0.02;
+ }
+
+ public function isNew() {
+ return $this->getPhase() < 0.02 || $this->getPhase() > 0.98;
+ }
+
+ public function isWaxing() {
+ return $this->getPhase() < 0.5;
+ }
+
+ public function isWaning() {
+ return $this->getPhase() > 0.5;
+ }
+
+}
diff --git a/src/utils/PhutilProseDiff.php b/src/utils/PhutilProseDiff.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilProseDiff.php
@@ -0,0 +1,292 @@
+parts[] = array(
+ 'type' => $type,
+ 'text' => $text,
+ );
+ return $this;
+ }
+
+ public function getParts() {
+ return $this->parts;
+ }
+
+ /**
+ * Get diff parts, but replace large blocks of unchanged text with "."
+ * parts representing missing context.
+ */
+ public function getSummaryParts() {
+ $parts = $this->getParts();
+
+ $head_key = head_key($parts);
+ $last_key = last_key($parts);
+
+ $results = array();
+ foreach ($parts as $key => $part) {
+ $is_head = ($key == $head_key);
+ $is_last = ($key == $last_key);
+
+ switch ($part['type']) {
+ case '=':
+ $pieces = $this->splitTextForSummary($part['text']);
+
+ if ($is_head || $is_last) {
+ $need = 2;
+ } else {
+ $need = 3;
+ }
+
+ // We don't have enough pieces to omit anything, so just continue.
+ if (count($pieces) < $need) {
+ $results[] = $part;
+ break;
+ }
+
+ if (!$is_head) {
+ $results[] = array(
+ 'type' => '=',
+ 'text' => head($pieces),
+ );
+ }
+
+ $results[] = array(
+ 'type' => '.',
+ 'text' => null,
+ );
+
+ if (!$is_last) {
+ $results[] = array(
+ 'type' => '=',
+ 'text' => last($pieces),
+ );
+ }
+ break;
+ default:
+ $results[] = $part;
+ break;
+ }
+ }
+
+ return $results;
+ }
+
+
+ public function reorderParts() {
+ // Reorder sequences of removed and added sections to put all the "-"
+ // parts together first, then all the "+" parts together. This produces
+ // a more human-readable result than intermingling them.
+
+ $o_run = array();
+ $n_run = array();
+ $result = array();
+ foreach ($this->parts as $part) {
+ $type = $part['type'];
+ switch ($type) {
+ case '-':
+ $o_run[] = $part;
+ break;
+ case '+':
+ $n_run[] = $part;
+ break;
+ default:
+ if ($o_run || $n_run) {
+ foreach ($this->combineRuns($o_run, $n_run) as $merged_part) {
+ $result[] = $merged_part;
+ }
+ $o_run = array();
+ $n_run = array();
+ }
+ $result[] = $part;
+ break;
+ }
+ }
+
+ if ($o_run || $n_run) {
+ foreach ($this->combineRuns($o_run, $n_run) as $part) {
+ $result[] = $part;
+ }
+ }
+
+ // Now, combine consecuitive runs of the same type of change (like a
+ // series of "-" parts) into a single run.
+ $combined = array();
+
+ $last = null;
+ $last_text = null;
+ foreach ($result as $part) {
+ $type = $part['type'];
+
+ if ($last !== $type) {
+ if ($last !== null) {
+ $combined[] = array(
+ 'type' => $last,
+ 'text' => $last_text,
+ );
+ }
+ $last_text = null;
+ $last = $type;
+ }
+
+ $last_text .= $part['text'];
+ }
+
+ if ($last_text !== null) {
+ $combined[] = array(
+ 'type' => $last,
+ 'text' => $last_text,
+ );
+ }
+
+ $this->parts = $combined;
+
+ return $this;
+ }
+
+ private function combineRuns($o_run, $n_run) {
+ $o_merge = $this->mergeParts($o_run);
+ $n_merge = $this->mergeParts($n_run);
+
+ // When removed and added blocks share a prefix or suffix, we sometimes
+ // want to count it as unchanged (for example, if it is whitespace) but
+ // sometimes want to count it as changed (for example, if it is a word
+ // suffix like "ing"). Find common prefixes and suffixes of these layout
+ // characters and emit them as "=" (unchanged) blocks.
+
+ $layout_characters = array(
+ ' ' => true,
+ "\n" => true,
+ '.' => true,
+ '!' => true,
+ ',' => true,
+ '?' => true,
+ ']' => true,
+ '[' => true,
+ '(' => true,
+ ')' => true,
+ '<' => true,
+ '>' => true,
+ );
+
+ $o_text = $o_merge['text'];
+ $n_text = $n_merge['text'];
+ $o_len = strlen($o_text);
+ $n_len = strlen($n_text);
+ $min_len = min($o_len, $n_len);
+
+ $prefix_len = 0;
+ for ($pos = 0; $pos < $min_len; $pos++) {
+ $o = $o_text[$pos];
+ $n = $n_text[$pos];
+ if ($o !== $n) {
+ break;
+ }
+ if (empty($layout_characters[$o])) {
+ break;
+ }
+ $prefix_len++;
+ }
+
+ $suffix_len = 0;
+ for ($pos = 0; $pos < ($min_len - $prefix_len); $pos++) {
+ $o = $o_text[$o_len - ($pos + 1)];
+ $n = $n_text[$n_len - ($pos + 1)];
+ if ($o !== $n) {
+ break;
+ }
+ if (empty($layout_characters[$o])) {
+ break;
+ }
+ $suffix_len++;
+ }
+
+ $results = array();
+
+ if ($prefix_len) {
+ $results[] = array(
+ 'type' => '=',
+ 'text' => substr($o_text, 0, $prefix_len),
+ );
+ }
+
+ if ($prefix_len < $o_len) {
+ $results[] = array(
+ 'type' => '-',
+ 'text' => substr(
+ $o_text,
+ $prefix_len,
+ $o_len - $prefix_len - $suffix_len),
+ );
+ }
+
+ if ($prefix_len < $n_len) {
+ $results[] = array(
+ 'type' => '+',
+ 'text' => substr(
+ $n_text,
+ $prefix_len,
+ $n_len - $prefix_len - $suffix_len),
+ );
+ }
+
+ if ($suffix_len) {
+ $results[] = array(
+ 'type' => '=',
+ 'text' => substr($o_text, -$suffix_len),
+ );
+ }
+
+ return $results;
+ }
+
+ private function mergeParts(array $parts) {
+ $text = '';
+ $type = null;
+ foreach ($parts as $part) {
+ $part_type = $part['type'];
+ if ($type === null) {
+ $type = $part_type;
+ }
+ if ($type !== $part_type) {
+ throw new Exception(pht('Can not merge parts of dissimilar types!'));
+ }
+ $text .= $part['text'];
+ }
+
+ return array(
+ 'type' => $type,
+ 'text' => $text,
+ );
+ }
+
+ private function splitTextForSummary($text) {
+ $matches = null;
+
+ $ok = preg_match('/^(\n*[^\n]+)\n/', $text, $matches);
+ if (!$ok) {
+ return array($text);
+ }
+
+ $head = $matches[1];
+ $text = substr($text, strlen($head));
+
+ $ok = preg_match('/\n([^\n]+\n*)\z/', $text, $matches);
+ if (!$ok) {
+ return array($text);
+ }
+
+ $last = $matches[1];
+ $text = substr($text, 0, -strlen($last));
+
+ if (!strlen(trim($text))) {
+ return array($head, $last);
+ } else {
+ return array($head, $text, $last);
+ }
+ }
+
+}
diff --git a/src/utils/PhutilProseDifferenceEngine.php b/src/utils/PhutilProseDifferenceEngine.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilProseDifferenceEngine.php
@@ -0,0 +1,209 @@
+buildDiff($u, $v, 0);
+ }
+
+ private function buildDiff($u, $v, $level) {
+ $u_parts = $this->splitCorpus($u, $level);
+ $v_parts = $this->splitCorpus($v, $level);
+
+ $matrix = id(new PhutilEditDistanceMatrix())
+ ->setMaximumLength(128)
+ ->setSequences($u_parts, $v_parts)
+ ->setComputeString(true);
+
+ // For word-level and character-level changes, smooth the output string
+ // to reduce the choppiness of the diff.
+ if ($level > 1) {
+ $matrix->setApplySmoothing(PhutilEditDistanceMatrix::SMOOTHING_FULL);
+ }
+
+ $u_pos = 0;
+ $v_pos = 0;
+
+ $edits = $matrix->getEditString();
+ $edits_length = strlen($edits);
+
+ $diff = new PhutilProseDiff();
+ for ($ii = 0; $ii < $edits_length; $ii++) {
+ $c = $edits[$ii];
+ if ($c == 's') {
+ $diff->addPart('=', $u_parts[$u_pos]);
+ $u_pos++;
+ $v_pos++;
+ } else if ($c == 'd') {
+ $diff->addPart('-', $u_parts[$u_pos]);
+ $u_pos++;
+ } else if ($c == 'i') {
+ $diff->addPart('+', $v_parts[$v_pos]);
+ $v_pos++;
+ } else if ($c == 'x') {
+ $diff->addPart('-', $u_parts[$u_pos]);
+ $diff->addPart('+', $v_parts[$v_pos]);
+ $u_pos++;
+ $v_pos++;
+ } else {
+ throw new Exception(
+ pht(
+ 'Unexpected character ("%s") in edit string.',
+ $c));
+ }
+ }
+
+ $diff->reorderParts();
+
+ // If we just built a character-level diff, we're all done and do not
+ // need to go any deeper.
+ if ($level == 3) {
+ return $diff;
+ }
+
+ $blocks = array();
+ $block = null;
+ foreach ($diff->getParts() as $part) {
+ $type = $part['type'];
+ $text = $part['text'];
+ switch ($type) {
+ case '=':
+ if ($block) {
+ $blocks[] = $block;
+ $block = null;
+ }
+ $blocks[] = array(
+ 'type' => $type,
+ 'text' => $text,
+ );
+ break;
+ case '-':
+ if (!$block) {
+ $block = array(
+ 'type' => '!',
+ 'old' => '',
+ 'new' => '',
+ );
+ }
+ $block['old'] .= $text;
+ break;
+ case '+':
+ if (!$block) {
+ $block = array(
+ 'type' => '!',
+ 'old' => '',
+ 'new' => '',
+ );
+ }
+ $block['new'] .= $text;
+ break;
+ }
+ }
+
+ if ($block) {
+ $blocks[] = $block;
+ }
+
+ $result = new PhutilProseDiff();
+ foreach ($blocks as $block) {
+ $type = $block['type'];
+ if ($type == '=') {
+ $result->addPart('=', $block['text']);
+ } else {
+ $old = $block['old'];
+ $new = $block['new'];
+ if (!strlen($old) && !strlen($new)) {
+ // Nothing to do.
+ } else if (!strlen($old)) {
+ $result->addPart('+', $new);
+ } else if (!strlen($new)) {
+ $result->addPart('-', $old);
+ } else {
+ if ($matrix->didReachMaximumLength()) {
+ // If this text was too big to diff, don't try to subdivide it.
+ $result->addPart('-', $old);
+ $result->addPart('+', $new);
+ } else {
+ $subdiff = $this->buildDiff(
+ $old,
+ $new,
+ $level + 1);
+
+ foreach ($subdiff->getParts() as $part) {
+ $result->addPart($part['type'], $part['text']);
+ }
+ }
+ }
+ }
+ }
+
+ $result->reorderParts();
+
+ return $result;
+ }
+
+ private function splitCorpus($corpus, $level) {
+ switch ($level) {
+ case 0:
+ // Level 0: Split into paragraphs.
+ $expr = '/([\n]+)/';
+ break;
+ case 1:
+ // Level 1: Split into sentences.
+ $expr = '/([\n,!;?\.]+)/';
+ break;
+ case 2:
+ // Level 2: Split into words.
+ $expr = '/(\s+)/';
+ break;
+ case 3:
+ // Level 3: Split into characters.
+ return phutil_utf8v_combined($corpus);
+ }
+
+ $pieces = preg_split($expr, $corpus, -1, PREG_SPLIT_DELIM_CAPTURE);
+ return $this->stitchPieces($pieces, $level);
+ }
+
+ private function stitchPieces(array $pieces, $level) {
+ $results = array();
+ $count = count($pieces);
+ for ($ii = 0; $ii < $count; $ii += 2) {
+ $result = $pieces[$ii];
+ if ($ii + 1 < $count) {
+ $result .= $pieces[$ii + 1];
+ }
+
+ if ($level < 2) {
+ // Split pieces into separate text and whitespace sections: make one
+ // piece out of all the whitespace at the beginning, one piece out of
+ // all the actual text in the middle, and one piece out of all the
+ // whitespace at the end.
+
+ $matches = null;
+ preg_match('/^(\s*)(.*?)(\s*)\z/', $result, $matches);
+
+ if (strlen($matches[1])) {
+ $results[] = $matches[1];
+ }
+ if (strlen($matches[2])) {
+ $results[] = $matches[2];
+ }
+ if (strlen($matches[3])) {
+ $results[] = $matches[3];
+ }
+ } else {
+ $results[] = $result;
+ }
+ }
+
+ // If the input ended with a delimiter, we can get an empty final piece.
+ // Just discard it.
+ if (last($results) == '') {
+ array_pop($results);
+ }
+
+ return $results;
+ }
+
+}
diff --git a/src/utils/PhutilProxyIterator.php b/src/utils/PhutilProxyIterator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilProxyIterator.php
@@ -0,0 +1,57 @@
+iterator = $iterator;
+ }
+
+ protected function didReadValue($value) {
+ return $value;
+ }
+
+
+/* -( Iterator Implementation )-------------------------------------------- */
+
+
+ final public function rewind() {
+ $this->iterator->rewind();
+ $this->update();
+ }
+
+ final public function valid() {
+ return $this->valid;
+ }
+
+ final public function current() {
+ return $this->value;
+ }
+
+ final public function key() {
+ return $this->key;
+ }
+
+ final public function next() {
+ $this->iterator->next();
+ $this->update();
+ }
+
+ private function update() {
+ $this->key = $this->iterator->key();
+ $this->valid = $this->iterator->valid();
+
+ if ($this->valid) {
+ $value = $this->iterator->current();
+ $value = $this->didReadValue($value);
+ $this->value = $value;
+ }
+ }
+
+}
diff --git a/src/utils/PhutilRope.php b/src/utils/PhutilRope.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilRope.php
@@ -0,0 +1,144 @@
+length += $len;
+
+ if ($len <= $this->segmentSize) {
+ $this->buffers[] = $string;
+ } else {
+ for ($cursor = 0; $cursor < $len; $cursor += $this->segmentSize) {
+ $this->buffers[] = substr($string, $cursor, $this->segmentSize);
+ }
+ }
+
+ return $this;
+ }
+
+
+ /**
+ * Get the length of the rope.
+ *
+ * @return int Length of the rope in bytes.
+ */
+ public function getByteLength() {
+ return $this->length;
+ }
+
+
+ /**
+ * Get an arbitrary, nonempty prefix of the rope.
+ *
+ * @return string Some rope prefix.
+ */
+ public function getAnyPrefix() {
+ $result = reset($this->buffers);
+ if ($result === false) {
+ return null;
+ }
+
+ return $result;
+ }
+
+
+ /**
+ * Get prefix bytes of the rope, up to some maximum size.
+ *
+ * @param int Maximum number of bytes to read.
+ * @return string Bytes.
+ */
+ public function getPrefixBytes($length) {
+ $result = array();
+
+ $remaining_bytes = $length;
+ foreach ($this->buffers as $buf) {
+ $length = strlen($buf);
+ if ($length <= $remaining_bytes) {
+ $result[] = $buf;
+ $remaining_bytes -= $length;
+ } else {
+ $result[] = substr($buf, 0, $remaining_bytes);
+ $remaining_bytes = 0;
+ }
+ if (!$remaining_bytes) {
+ break;
+ }
+ }
+
+ return implode('', $result);
+ }
+
+
+ /**
+ * Return the entire rope as a normal string.
+ *
+ * @return string Normal string.
+ */
+ public function getAsString() {
+ return implode('', $this->buffers);
+ }
+
+
+ /**
+ * Remove a specified number of bytes from the head of the rope.
+ *
+ * @param int Bytes to remove.
+ * @return this
+ */
+ public function removeBytesFromHead($remove) {
+ if ($remove <= 0) {
+ throw new InvalidArgumentException(
+ pht('Length must be larger than 0!'));
+ }
+
+ $remaining_bytes = $remove;
+ foreach ($this->buffers as $key => $buf) {
+ $len = strlen($buf);
+ if ($len <= $remaining_bytes) {
+ unset($this->buffers[$key]);
+ $remaining_bytes -= $len;
+ if (!$remaining_bytes) {
+ break;
+ }
+ } else {
+ $this->buffers[$key] = substr($buf, $remaining_bytes);
+ break;
+ }
+ }
+
+ if ($this->buffers) {
+ $this->length -= $remove;
+ } else {
+ $this->length = 0;
+ }
+
+ return $this;
+ }
+
+}
diff --git a/src/utils/PhutilSortVector.php b/src/utils/PhutilSortVector.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilSortVector.php
@@ -0,0 +1,54 @@
+parts[] = sprintf('%s%020u', $prefix, $value);
+ return $this;
+ }
+
+ public function addString($value) {
+ if (strlen($value) && (strpos("\0", $value) !== false)) {
+ throw new Exception(
+ pht(
+ 'String components of a sort vector must not contain NULL bytes.'));
+ }
+
+ $this->parts[] = $value;
+ return $this;
+ }
+
+ public function __toString() {
+ return implode("\0", $this->parts);
+ }
+
+ /**
+ * This allows you to sort a list of sort vectors using @{function:msortv}.
+ */
+ public function getSelf() {
+ return $this;
+ }
+
+}
diff --git a/src/utils/PhutilStreamIterator.php b/src/utils/PhutilStreamIterator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilStreamIterator.php
@@ -0,0 +1,68 @@
+stream = $stream;
+ }
+
+/* -( Iterator Implementation )-------------------------------------------- */
+
+
+ public function rewind() {
+ if ($this->started) {
+ // When you first foreach() an iterator the rewind() method gets called
+ // so we have to work the first time.
+ throw new Exception(
+ pht('Stream iterators can not be rewound!'));
+ }
+
+ $this->started = true;
+ $this->naturalKey = -1;
+ $this->next();
+ }
+
+ public function valid() {
+ return ($this->data !== null);
+ }
+
+ public function current() {
+ return $this->data;
+ }
+
+ public function key() {
+ return $this->naturalKey;
+ }
+
+ public function next() {
+ $stream = $this->stream;
+
+ if (!$stream) {
+ return;
+ }
+
+ if (feof($stream)) {
+ fclose($stream);
+ $this->stream = null;
+ $this->data = null;
+ return;
+ }
+
+ $bytes = fread($stream, 64 * 1024);
+ if ($bytes === false) {
+ throw new Exception(
+ pht('Failed to fread() from request input stream.'));
+ }
+
+ $this->data = $bytes;
+ $this->naturalKey++;
+ }
+
+}
diff --git a/src/utils/PhutilSystem.php b/src/utils/PhutilSystem.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilSystem.php
@@ -0,0 +1,164 @@
+ Dictionary of memory information.
+ * @task memory
+ */
+ public static function getSystemMemoryInformation() {
+ $meminfo_path = '/proc/meminfo';
+ if (Filesystem::pathExists($meminfo_path)) {
+ $meminfo_data = Filesystem::readFile($meminfo_path);
+ return self::parseMemInfo($meminfo_data);
+ } else if (Filesystem::binaryExists('vm_stat')) {
+ list($vm_stat_stdout) = execx('vm_stat');
+ return self::parseVMStat($vm_stat_stdout);
+ } else {
+ throw new Exception(
+ pht(
+ 'Unable to access %s or `%s` on this system to '.
+ 'get system memory information.',
+ '/proc/meminfo',
+ 'vm_stat'));
+ }
+ }
+
+
+ /**
+ * Parse the output of `/proc/meminfo`.
+ *
+ * See @{method:getSystemMemoryInformation}. This method is used to get memory
+ * information on Linux.
+ *
+ * @param string Raw `/proc/meminfo`.
+ * @return map Parsed memory information.
+ * @task memory
+ */
+ public static function parseMemInfo($data) {
+ $data = phutil_split_lines($data);
+
+ $map = array();
+ foreach ($data as $line) {
+ list($key, $value) = explode(':', $line, 2);
+ $key = trim($key);
+ $value = trim($value);
+
+ $matches = null;
+ if (preg_match('/^(\d+) kB\z/', $value, $matches)) {
+ $value = (int)$matches[1] * 1024;
+ }
+
+ $map[$key] = $value;
+ }
+
+ $expect = array(
+ 'MemTotal',
+ 'MemFree',
+ 'Buffers',
+ 'Cached',
+ );
+ foreach ($expect as $key) {
+ if (!array_key_exists($key, $map)) {
+ throw new Exception(
+ pht(
+ 'Expected to find "%s" in "%s" output, but did not.',
+ $key,
+ '/proc/meminfo'));
+ }
+ }
+
+ $total = $map['MemTotal'];
+ $free = $map['MemFree'] + $map['Buffers'] + $map['Cached'];
+
+ return array(
+ 'total' => $total,
+ 'free' => $free,
+ );
+ }
+
+
+ /**
+ * Parse the output of `vm_stat`.
+ *
+ * See @{method:getSystemMemoryInformation}. This method is used to get memory
+ * information on Mac OS X.
+ *
+ * @param string Raw `vm_stat` output.
+ * @return map Parsed memory information.
+ * @task memory
+ */
+ public static function parseVMStat($data) {
+ $data = phutil_split_lines($data);
+
+ $page_size = null;
+ $map = array();
+
+ foreach ($data as $line) {
+ list($key, $value) = explode(':', $line, 2);
+ $key = trim($key);
+ $value = trim($value);
+
+ $matches = null;
+ if (preg_match('/page size of (\d+) bytes/', $value, $matches)) {
+ $page_size = (int)$matches[1];
+ continue;
+ }
+
+ $value = trim($value, '.');
+ $map[$key] = $value;
+ }
+
+ if (!$page_size) {
+ throw new Exception(
+ pht(
+ 'Expected to find "%s" in `%s` output, but did not.',
+ 'page size',
+ 'vm_stat'));
+ }
+
+ $expect = array(
+ 'Pages free',
+ 'Pages active',
+ 'Pages inactive',
+ 'Pages wired down',
+ );
+ foreach ($expect as $key) {
+ if (!array_key_exists($key, $map)) {
+ throw new Exception(
+ pht(
+ 'Expected to find "%s" in `%s` output, but did not.',
+ $key,
+ 'vm_stat'));
+ }
+ }
+
+ // NOTE: This calculation probably isn't quite right. In particular,
+ // the numbers don't exactly add up, and "Pages inactive" includes a
+ // bunch of disk cache. So these numbers aren't totally reliable and they
+ // aren't directly comparable to the /proc/meminfo numbers.
+
+ $free = $map['Pages free'];
+ $active = $map['Pages active'];
+ $inactive = $map['Pages inactive'];
+ $wired = $map['Pages wired down'];
+
+ return array(
+ 'total' => ($free + $active + $inactive + $wired) * $page_size,
+ 'free' => ($free) * $page_size,
+ );
+ }
+
+}
diff --git a/src/utils/PhutilUTF8StringTruncator.php b/src/utils/PhutilUTF8StringTruncator.php
new file mode 100644
--- /dev/null
+++ b/src/utils/PhutilUTF8StringTruncator.php
@@ -0,0 +1,295 @@
+setMaximumGlyphs(80)
+ * ->truncateString($long);
+ *
+ * Byte limits restrict the number of bytes the result may contain. They are
+ * appropriate when you care about how much storage a string requires.
+ *
+ * Codepoint limits restrict the number of codepoints the result may contain.
+ * Since codepoints may have up to 4 bytes, the resulting strings may require
+ * have more than this many bytes. This kind of limit is appropriate when you
+ * are using UTF-8 storage.
+ *
+ * Glyph limits restrict the display size of the string. Because a single glyph
+ * may have an arbitrary number of combining characters, this does not impose
+ * a storage size limit on the string: a string with only one glyph may require
+ * an arbitrarily large number of bytes.
+ *
+ * You can set more than one limit; the smallest limit will be used.
+ *
+ * NOTE: This function makes a best effort to apply some reasonable rules but
+ * will not work well for the full range of unicode languages.
+ */
+final class PhutilUTF8StringTruncator extends Phobject {
+
+ private $maximumBytes;
+ private $maximumCodepoints;
+ private $maximumGlyphs;
+ private $minimumLimit;
+
+ private $terminator = "\xE2\x80\xA6";
+ private $terminatorBytes = 3;
+ private $terminatorCodepoints = 1;
+ private $terminatorGlyphs = 1;
+
+ public function setMaximumBytes($maximum_bytes) {
+ $this->maximumBytes = $maximum_bytes;
+ $this->didUpdateMaxima();
+ return $this;
+ }
+
+ public function setMaximumCodepoints($maximum_codepoints) {
+ $this->maximumCodepoints = $maximum_codepoints;
+ $this->didUpdateMaxima();
+ return $this;
+ }
+
+ public function setMaximumGlyphs($maximum_glyphs) {
+ $this->maximumGlyphs = $maximum_glyphs;
+ $this->didUpdateMaxima();
+ return $this;
+ }
+
+ private function didUpdateMaxima() {
+ $this->minimumLimit = INF;
+
+ if ($this->maximumBytes) {
+ $this->minimumLimit = min($this->minimumLimit, $this->maximumBytes);
+ }
+
+ if ($this->maximumCodepoints) {
+ $this->minimumLimit = min($this->minimumLimit, $this->maximumCodepoints);
+ }
+
+ if ($this->maximumGlyphs) {
+ $this->minimumLimit = min($this->minimumLimit, $this->maximumGlyphs);
+ }
+ }
+
+ public function setTerminator($terminator) {
+ $this->terminator = $terminator;
+ $this->terminatorBytes = strlen($terminator);
+ $this->terminatorCodepoints = count(phutil_utf8v($terminator));
+ $this->terminatorGlyphs = count(phutil_utf8v_combined($terminator));
+ return $this;
+ }
+
+ public function truncateString($string) {
+ // First, check if the string has fewer bytes than the most restrictive
+ // limit. Codepoints and glyphs always take up at least one byte, so we can
+ // just return the string unmodified if we're under all of the limits.
+ $byte_len = strlen($string);
+ if ($byte_len <= $this->minimumLimit) {
+ return $string;
+ }
+
+ // We're going to vectorize the string so we can deal with it in terms
+ // of unicode characters. If the string is huge (like 10MB) and we are
+ // only extracting a tiny piece of it (like the first 1024 bytes), we
+ // want to avoid vectorizing the entire string in cases where there is
+ // no possibility that we'll need all of it. Try to compute a "hard limit":
+ // an upper bound on the number of bytes we can ever need to process.
+
+ $hard_limits = array();
+ if ($this->maximumBytes) {
+ $hard_limits[] = $this->maximumBytes;
+ }
+
+ if ($this->maximumCodepoints) {
+ // No UTF8 character is longer than 6 bytes, so we can impose a ceiling
+ // if we have a codepoint limit.
+ $hard_limits[] = ($this->maximumCodepoints * 6);
+ }
+
+ if ($hard_limits) {
+ // Add a few more bytes onto the end so that we have a little more of
+ // the string than we actually need and can get the right terminator
+ // behavior.
+ $hard_limit = max($hard_limits) + 32;
+ } else {
+ $hard_limit = null;
+ }
+
+ // Build a vector of characters first.
+ $string_pv = phutil_utf8v($string, $hard_limit);
+ $point_len = count($string_pv);
+
+ // We always need the combined vector, even if we're only doing byte or
+ // codepoint truncation, because we don't want to truncate to half of a
+ // combining character.
+ $string_gv = phutil_utf8v_combine_characters($string_pv);
+ $glyph_len = count($string_gv);
+
+ // Now, check if we're still over the limits. For example, a string may
+ // be over the raw byte limit but under the glyph limit if it contains
+ // several multibyte characters.
+
+ $too_long = false;
+ if ($this->maximumBytes && ($byte_len > $this->maximumBytes)) {
+ $too_long = true;
+ }
+ if ($this->maximumCodepoints && ($point_len > $this->maximumCodepoints)) {
+ $too_long = true;
+ }
+ if ($this->maximumGlyphs && ($glyph_len > $this->maximumGlyphs)) {
+ $too_long = true;
+ }
+
+ if (!$too_long) {
+ return $string;
+ }
+
+ // This string is legitimately longer than at least one of the limits, so
+ // we need to truncate it. Find the minimum cutoff point: this is the last
+ // glyph we can possibly return while satisfying the limits and having space
+ // for the terminator.
+
+ $cutoff = $glyph_len;
+ if ($this->maximumBytes) {
+ if ($byte_len <= $this->maximumBytes) {
+ $cutoff = $glyph_len;
+ } else {
+ $bytes = $this->terminatorBytes;
+ for ($ii = 0; $ii < $glyph_len; $ii++) {
+ $bytes += strlen($string_gv[$ii]);
+ if ($bytes > $this->maximumBytes) {
+ $cutoff = $ii;
+ break;
+ }
+ }
+ }
+ }
+
+ if ($this->maximumCodepoints) {
+ if ($point_len <= $this->maximumCodepoints) {
+ $cutoff = min($cutoff, $glyph_len);
+ } else {
+ $points = 0;
+ for ($ii = 0; $ii < $glyph_len; $ii++) {
+ $glyph_bytes = strlen($string_gv[$ii]);
+ while ($points < $point_len) {
+ $glyph_bytes -= strlen($string_pv[$points]);
+ $points++;
+ if ($glyph_bytes <= 0) {
+ break;
+ }
+ }
+ $points_total = $points + $this->terminatorCodepoints;
+ if ($points_total > $this->maximumCodepoints) {
+ $cutoff = min($cutoff, $ii);
+ break;
+ }
+ }
+ }
+ }
+
+ if ($this->maximumGlyphs) {
+ if ($glyph_len <= $this->maximumGlyphs) {
+ $cutoff = min($cutoff, $glyph_len);
+ } else {
+ $cutoff = min($cutoff, $this->maximumGlyphs - $this->terminatorGlyphs);
+ }
+ }
+
+ // If we don't have enough characters for anything, just return the
+ // terminator.
+ if ($cutoff <= 0) {
+ return $this->terminator;
+ }
+
+ // Otherwise, we're going to try to cut the string off somewhere reasonable
+ // rather than somewhere arbitrary.
+
+ // NOTE: This is not complete, and there are many other word boundary
+ // characters and reasonable places to break words in the UTF-8 character
+ // space. For now, this gives us reasonable behavior for latin languages. We
+ // don't necessarily have access to PCRE+Unicode so there isn't a great way
+ // for us to look up character attributes.
+
+ // If we encounter these, prefer to break on them instead of cutting the
+ // string off in the middle of a word.
+ static $break_characters = array(
+ ' ' => true,
+ "\n" => true,
+ ';' => true,
+ ':' => true,
+ '[' => true,
+ '(' => true,
+ ',' => true,
+ '-' => true,
+ );
+
+ // If we encounter these, shorten to this character exactly without
+ // appending the terminal.
+ static $stop_characters = array(
+ '.' => true,
+ '!' => true,
+ '?' => true,
+ );
+
+ // Search backward in the string, looking for reasonable places to break it.
+ $word_boundary = null;
+ $stop_boundary = null;
+ $any_nonboundary = false;
+
+ // If we do a word break with a terminal, we have to look beyond at least
+ // the number of characters in the terminal. If the terminal is longer than
+ // the required length, we'll skip this whole block and return it on its
+ // own.
+
+ // Only search backward for a while. At some point we don't get a better
+ // result by looking through the whole string, and if this is "MMM..." or
+ // a non-latin language without word break characters we're just wasting
+ // time.
+
+ // See PHI654. We also only look for a break near the end of the text,
+ // relative to the length of the text. If the text is something like
+ // "O123: MMMMMM..." or "See path/to/long/thing", we want to cut the very
+ // long word in half, not just render "O123..." or "See...".
+
+ $search = max(0, $cutoff - 256, $cutoff / 2);
+ for ($ii = min($cutoff, $glyph_len - 1); $ii >= $search; $ii--) {
+ $c = $string_gv[$ii];
+
+ if (isset($break_characters[$c])) {
+ $word_boundary = $ii;
+ } else if (isset($stop_characters[$c])) {
+ $stop_boundary = $ii + 1;
+ break;
+ } else {
+ $any_nonboundary = true;
+ if ($word_boundary !== null) {
+ break;
+ }
+ }
+ }
+
+ if ($stop_boundary !== null) {
+ // We found a character like ".". Cut the string there, without appending
+ // the terminal.
+ $string_part = array_slice($string_gv, 0, $stop_boundary);
+ return implode('', $string_part);
+ }
+
+ // If we didn't find any boundary characters or we found ONLY boundary
+ // characters, just break at the maximum character length.
+ if ($word_boundary === null || !$any_nonboundary) {
+ $word_boundary = $cutoff;
+ }
+
+ $string_part = array_slice($string_gv, 0, $word_boundary);
+ $string_part = implode('', $string_part);
+
+ return $string_part.$this->terminator;
+ }
+
+}
diff --git a/src/utils/__tests__/AbstractDirectedGraphTestCase.php b/src/utils/__tests__/AbstractDirectedGraphTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/AbstractDirectedGraphTestCase.php
@@ -0,0 +1,179 @@
+ array(),
+ );
+
+ $cycle = $this->findGraphCycle($graph);
+ $this->assertEqual(null, $cycle, pht('Trivial Graph'));
+ }
+
+ public function testNoncyclicGraph() {
+ $graph = array(
+ 'A' => array('B', 'C'),
+ 'B' => array('D'),
+ 'C' => array(),
+ 'D' => array(),
+ );
+
+ $cycle = $this->findGraphCycle($graph);
+ $this->assertEqual(null, $cycle, pht('Noncyclic Graph'));
+ }
+
+ public function testTrivialCyclicGraph() {
+ $graph = array(
+ 'A' => array('A'),
+ );
+
+ $cycle = $this->findGraphCycle($graph);
+ $this->assertEqual(array('A', 'A'), $cycle, pht('Trivial Cycle'));
+ }
+
+ public function testCyclicGraph() {
+ $graph = array(
+ 'A' => array('B', 'C'),
+ 'B' => array('D'),
+ 'C' => array('E', 'F'),
+ 'D' => array(),
+ 'E' => array(),
+ 'F' => array('G', 'C'),
+ 'G' => array(),
+ );
+
+ $cycle = $this->findGraphCycle($graph);
+ $this->assertEqual(array('A', 'C', 'F', 'C'), $cycle, pht('Cyclic Graph'));
+ }
+
+ public function testNonTreeGraph() {
+ // This graph is non-cyclic, but C is both a child and a grandchild of A.
+ // This is permitted.
+ $graph = array(
+ 'A' => array('B', 'C'),
+ 'B' => array('C'),
+ 'C' => array(),
+ );
+
+ $cycle = $this->findGraphCycle($graph);
+ $this->assertEqual(null, $cycle, pht('Non-tree graph'));
+ }
+
+ public function testEdgeLoadFailure() {
+ $graph = array(
+ 'A' => array('B'),
+ );
+
+ $raised = null;
+ try {
+ $this->findGraphCycle($graph);
+ } catch (Exception $ex) {
+ $raised = $ex;
+ }
+
+ $this->assertTrue(
+ (bool)$raised,
+ pht('Exception raised by unloadable edges.'));
+ }
+
+ public function testTopographicSortTree() {
+ $graph = array(
+ 'A' => array('B', 'C'),
+ 'B' => array('D', 'E'),
+ 'C' => array(),
+ 'D' => array(),
+ 'E' => array(),
+ );
+
+ $sorted = $this->getTopographicSort($graph);
+
+ $this->assertEqual(
+ array('A', 'C', 'B', 'E', 'D'),
+ $sorted,
+ pht('Topographically sorted tree.'));
+
+ $graph = array(
+ 'A' => array('B', 'C'),
+ 'B' => array('C'),
+ 'C' => array('D', 'E'),
+ 'D' => array('E'),
+ 'E' => array(),
+ );
+
+ $sorted = $this->getTopographicSort($graph);
+
+ $this->assertEqual(
+ array('A', 'B', 'C', 'D', 'E'),
+ $sorted,
+ pht('Topographically sorted tree with nesting.'));
+ }
+
+ public function testBestEffortTopographicSortTree() {
+ $graph = array(
+ 'A' => array('B', 'C'),
+ 'B' => array('D', 'E'),
+ 'C' => array(),
+ 'D' => array(),
+ 'E' => array(),
+ 'F' => array('H'),
+ 'G' => array('F', 'E'),
+ 'H' => array('G'),
+ );
+
+ $sorted = $this->getBestEffortTopographicSort($graph);
+
+ $this->assertEqual(count($graph), count($sorted));
+
+ $this->assertEqual('C', $sorted[0]['node']);
+ $this->assertEqual('D', $sorted[1]['node']);
+ $this->assertEqual('E', $sorted[2]['node']);
+ $this->assertEqual('B', $sorted[3]['node']);
+ $this->assertEqual('A', $sorted[4]['node']);
+ $this->assertEqual('F', $sorted[5]['node']);
+ $this->assertEqual('G', $sorted[6]['node']);
+ $this->assertEqual('H', $sorted[7]['node']);
+
+ $this->assertEqual(0, $sorted[0]['depth']);
+ $this->assertEqual(0, $sorted[1]['depth']);
+ $this->assertEqual(0, $sorted[2]['depth']);
+ $this->assertEqual(1, $sorted[3]['depth']);
+ $this->assertEqual(2, $sorted[4]['depth']);
+ $this->assertEqual(3, $sorted[5]['depth']);
+ $this->assertEqual(3, $sorted[6]['depth']);
+ $this->assertEqual(3, $sorted[7]['depth']);
+
+ $this->assertEqual(false, $sorted[0]['cycle']);
+ $this->assertEqual(false, $sorted[1]['cycle']);
+ $this->assertEqual(false, $sorted[2]['cycle']);
+ $this->assertEqual(false, $sorted[3]['cycle']);
+ $this->assertEqual(false, $sorted[4]['cycle']);
+ $this->assertEqual(true, $sorted[5]['cycle']);
+ $this->assertEqual(true, $sorted[6]['cycle']);
+ $this->assertEqual(true, $sorted[7]['cycle']);
+ }
+
+ private function findGraphCycle(array $graph, $seed = 'A', $search = 'A') {
+ $detector = new TestAbstractDirectedGraph();
+ $detector->setTestData($graph);
+ $detector->addNodes(array_select_keys($graph, array($seed)));
+ $detector->loadGraph();
+ return $detector->detectCycles($search);
+ }
+
+ private function getTopographicSort(array $graph, $seed = 'A') {
+ $detector = new TestAbstractDirectedGraph();
+ $detector->setTestData($graph);
+ $detector->addNodes(array_select_keys($graph, array($seed)));
+ $detector->loadGraph();
+ return $detector->getTopographicallySortedNodes();
+ }
+
+ private function getBestEffortTopographicSort(array $graph) {
+ $detector = new TestAbstractDirectedGraph();
+ $detector->setTestData($graph);
+ $detector->addNodes(array_keys($graph));
+ return $detector->getBestEffortTopographicallySortedNodes();
+ }
+
+}
diff --git a/src/utils/__tests__/CaseInsensitiveArrayTestCase.php b/src/utils/__tests__/CaseInsensitiveArrayTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/CaseInsensitiveArrayTestCase.php
@@ -0,0 +1,109 @@
+assertEqual(0, count($array));
+
+ $array['key'] = 'foo';
+ $this->assertEqual(1, count($array));
+
+ $array['KEY'] = 'bar';
+ $this->assertEqual(1, count($array));
+ }
+
+ public function testGetKeys() {
+ $input = array(
+ 'key' => true,
+ 'KEY' => true,
+ 'kEy' => true,
+
+ 'foo' => false,
+ 'value' => false,
+ );
+ $expected = array(
+ 'key',
+ 'foo',
+ 'value',
+ );
+
+ $array = new CaseInsensitiveArray($input);
+ $this->assertEqual($expected, $array->getKeys());
+ }
+
+ public function testOffsetExists() {
+ $input = array('key' => 'value');
+ $expectations = array(
+ 'key' => true,
+ 'KEY' => true,
+ 'kEy' => true,
+
+ 'foo' => false,
+ 'value' => false,
+ );
+
+ $array = new CaseInsensitiveArray($input);
+
+ foreach ($expectations as $key => $expectation) {
+ if ($expectation) {
+ $this->assertTrue(isset($array[$key]));
+ } else {
+ $this->assertFalse(isset($array[$key]));
+ }
+ }
+ }
+
+ public function testOffsetGet() {
+ $input = array('key' => 'value');
+ $expectations = array(
+ 'key' => 'value',
+ 'KEY' => 'value',
+ 'kEy' => 'value',
+
+ 'foo' => null,
+ 'value' => null,
+ );
+
+ $array = new CaseInsensitiveArray($input);
+
+ foreach ($expectations as $key => $expectation) {
+ $this->assertEqual($expectation, @$array[$key]);
+ }
+ }
+
+ public function testOffsetSet() {
+ $input = array();
+ $data = array(
+ 'key' => 'foo',
+ 'KEY' => 'bar',
+ 'kEy' => 'baz',
+ );
+ $expected = array('key' => 'baz');
+
+ $array = new CaseInsensitiveArray($input);
+
+ foreach ($data as $key => $value) {
+ $array[$key] = $value;
+ }
+
+ $this->assertEqual($expected, $array->toArray());
+ }
+
+ public function testOffsetUnset() {
+ $input = array('key' => 'value');
+ $data = array(
+ 'KEY',
+ );
+ $expected = array();
+
+ $array = new CaseInsensitiveArray($input);
+
+ foreach ($data as $key) {
+ unset($array[$key]);
+ }
+
+ $this->assertEqual($expected, $array->toArray());
+ }
+
+}
diff --git a/src/utils/__tests__/MFilterTestHelper.php b/src/utils/__tests__/MFilterTestHelper.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/MFilterTestHelper.php
@@ -0,0 +1,27 @@
+h = $h_value;
+ $this->i = $i_value;
+ $this->j = $j_value;
+ }
+
+ public function getH() {
+ return $this->h;
+ }
+
+ public function getI() {
+ return $this->i;
+ }
+
+ public function getJ() {
+ return $this->j;
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilArrayTestCase.php b/src/utils/__tests__/PhutilArrayTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilArrayTestCase.php
@@ -0,0 +1,72 @@
+assertEqual(0, $a[99]);
+ $a[99] = 1;
+ $this->assertEqual(1, $a[99]);
+
+ $a->setDefaultValue('default');
+ $this->assertEqual('default', $a['key']);
+
+ $this->assertEqual(
+ array(
+ 99 => 1,
+ 'key' => 'default',
+ ),
+ $a->toArray());
+
+ $init = array(
+ 'apple' => 'red',
+ );
+
+ $b = new PhutilArrayWithDefaultValue($init);
+ $this->assertEqual($init, $b->toArray());
+
+ $fruits = array(
+ 'apple',
+ 'cherry',
+ 'banana',
+ 'cherry',
+ 'cherry',
+ 'apple',
+ 'banana',
+ 'plum',
+ 'cherry',
+ 'cherry',
+ );
+
+ $counts = new PhutilArrayWithDefaultValue();
+ foreach ($fruits as $fruit) {
+ $counts[$fruit] += 1;
+ }
+ $this->assertEqual(
+ array(
+ 'apple' => 2,
+ 'cherry' => 5,
+ 'banana' => 2,
+ 'plum' => 1,
+ ),
+ $counts->toArray());
+
+ $masks = array(
+ 1,
+ 2,
+ 4,
+ );
+
+ $bitmask = new PhutilArrayWithDefaultValue();
+ foreach ($masks as $mask) {
+ $bitmask['value'] |= $mask;
+ }
+
+ $this->assertEqual(7, $bitmask['value']);
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilBufferedIteratorTestCase.php b/src/utils/__tests__/PhutilBufferedIteratorTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilBufferedIteratorTestCase.php
@@ -0,0 +1,25 @@
+setPageSize(3);
+ $iterator->setExampleData($expect);
+
+ $results = array();
+ foreach ($iterator as $key => $value) {
+ $results[$key] = $value;
+ }
+
+ $this->assertEqual(
+ $expect,
+ $results);
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilChunkedIteratorTestCase.php b/src/utils/__tests__/PhutilChunkedIteratorTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilChunkedIteratorTestCase.php
@@ -0,0 +1,29 @@
+ 1, 1 => 3),
+ array(2 => 5),
+ );
+
+ $iterator = new PhutilChunkedIterator(
+ new ArrayIterator(array(1, 3, 5)),
+ 2);
+
+ $this->assertEqual(
+ $expect,
+ iterator_to_array($iterator));
+
+ for ($i = 0; $i < 2; $i++) {
+ foreach ($iterator as $key => $actual) {
+ $this->assertEqual(idx($expect, $key), $actual);
+ }
+ }
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilCowsayTestCase.php b/src/utils/__tests__/PhutilCowsayTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilCowsayTestCase.php
@@ -0,0 +1,60 @@
+setTemplate($template);
+
+ if (idx($spec, 'text') !== null) {
+ $cowsay->setText($spec['text']);
+ }
+
+ if (idx($spec, 'eyes') !== null) {
+ $cowsay->setEyes($spec['eyes']);
+ }
+
+ if (idx($spec, 'tongue') !== null) {
+ $cowsay->setTongue($spec['tongue']);
+ }
+
+ if (idx($spec, 'action') !== null) {
+ $cowsay->setAction($spec['action']);
+ }
+
+ $actual = $cowsay->renderCow();
+
+ $this->assertEqual(
+ rtrim($expect),
+ rtrim($actual),
+ pht('Cowsay Test Case "%s"', $test));
+ }
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilEditDistanceMatrixTestCase.php b/src/utils/__tests__/PhutilEditDistanceMatrixTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilEditDistanceMatrixTestCase.php
@@ -0,0 +1,207 @@
+assertDistance(0, '', '');
+ $this->assertDistance(27, '', 'xxx', 9);
+ $this->assertDistance(27, 'xxx', '', 1, 9);
+
+ // Both inputs identical.
+ $this->assertDistance(0, 'x', 'x');
+ $this->assertDistance(0, 'xyzabc', 'xyzabc');
+
+ // Simple edits.
+ $this->assertDistance(1, 'cat', 'car');
+ $this->assertDistance(1, 'cat', 'cut');
+ $this->assertDistance(1, 'cat', 'bat');
+ $this->assertDistance(2, 'cat', 'bar');
+ $this->assertDistance(3, 'cat', 'dog');
+
+ // Inserts.
+ $this->assertDistance(1, 'cat', 'cats');
+ $this->assertDistance(1, 'cat', 'cast');
+ $this->assertDistance(1, 'cat', 'xcat');
+ $this->assertDistance(1, 'cat', 'cxat');
+
+ // Deletes.
+ $this->assertDistance(1, 'cat', 'ca');
+ $this->assertDistance(1, 'cat', 'ct');
+ $this->assertDistance(1, 'cat', 'at');
+
+ // Replacements.
+ $this->assertDistance(1, 'xxxxx', 'xxxxy');
+ $this->assertDistance(1, 'xxxxx', 'xxyxx');
+ $this->assertDistance(1, 'yxxxx', 'xxxxx');
+
+ // Costs.
+ $this->assertDistance(27, 'x', 'xxxx', 9);
+ $this->assertDistance(27, 'xxxx', 'x', 1, 9);
+ $this->assertDistance(27, 'xxxxx', 'xyyyx', 5, 5, 9);
+
+ // Misc.
+ $this->assertDistance(
+ 13,
+ 'The quick brown fox jumped over the lazy dog!',
+ // dddddd r ii i iii
+ 'The brown fox pumped over those lazy dogs!~~~');
+ }
+
+ public function testDamerauEditDistance() {
+
+ // Simple adjacent transpositions.
+ $this->assertDistance(1, 'abcd', 'abdc', 3, 3, 3, 1);
+ $this->assertDistance(1, 'abcd', 'bacd', 3, 3, 3, 1);
+ $this->assertDistance(2, 'abcd', 'badc', 3, 3, 3, 1);
+
+ // Transpositions with other edits.
+ $this->assertDistance(7, 'abcd', 'baaa', 3, 3, 3, 1);
+ $this->assertDistance(7, 'abcd', 'babb', 3, 3, 3, 1);
+
+ // Sequences of adjacent transpositions.
+ $this->assertDistance(3, 'abcd', 'cbad', 3, 3, 3, 1);
+ $this->assertDistance(5, 'abcd', 'dbca', 3, 3, 3, 1);
+
+ // Misc.
+ $this->assertDistance(
+ 11,
+ 'Cozy lummox gives smart squid who asks for job pen.',
+ // t d r i i i ttt ii
+ 'Cozy lummxo give smarp squid, whom tasks for boj a pen.');
+ }
+
+ public function testEditString() {
+ $this->assertEditString('', '', '');
+ $this->assertEditString('iii', '', 'aaa');
+ $this->assertEditString('ddd', 'aaa', '');
+
+ $this->assertEditString('sss', 'aaa', 'aaa');
+ $this->assertEditString(
+ 'xssisssisx',
+ 'Qz(ab)zQ',
+ 'Rz((ab))zR',
+ 1, 1, 1, null, 0.001);
+
+ $this->assertEditString('xxs', 'cat', 'rot');
+
+ $this->assertEditString(
+ 'xxsssxxsssixsxxxsssdssssssssxssxsixsissssddddsdxxsssss',
+ 'Cozy lummox gives smart squid who asks for job pen.',
+ 'Lazy hammock takes mart squad that basks in pen.');
+ }
+
+ public function testDamerauEditString() {
+ $this->assertEditString('xxss', 'land', 'alnd');
+ $this->assertEditString('ttss', 'land', 'alnd', 1, 1, 1, 1);
+ $this->assertEditString('tsts', 'land', 'nald', 3, 3, 3, 1);
+ }
+
+ public function testEditMatrixMaximumLength() {
+ // These tests are hitting the maximum length limit; the expected costs
+ // and strings are degenerate.
+
+ $matrix = id(new PhutilEditDistanceMatrix())
+ ->setInsertCost(3)
+ ->setDeleteCost(7)
+ ->setMaximumLength(1)
+ ->setSequences(array('X', 'a', 'a', 'Y'), array('Q', 'a', 'a', 'R'));
+
+ $this->assertEqual(
+ 40,
+ $matrix->getEditDistance());
+
+ $this->assertEqual(
+ 'ddddiiii',
+ $matrix->getEditString());
+
+ $matrix = id(new PhutilEditDistanceMatrix())
+ ->setInsertCost(3)
+ ->setDeleteCost(7)
+ ->setMaximumLength(1)
+ ->setSequences(
+ array('f', 'f', 'X', 'a', 'a', 'Y', 'g', 'g'),
+ array('f', 'f', 'Q', 'a', 'a', 'R', 'g', 'g'));
+
+ $this->assertEqual(
+ 40,
+ $matrix->getEditDistance());
+
+ $this->assertEqual(
+ 'ssddddiiiiss',
+ $matrix->getEditString());
+ }
+
+ private function assertDistance(
+ $expect,
+ $x, $y,
+ $ins = 1, $del = 1,
+ $rep = 1, $trn = null,
+ $alt = 0) {
+
+ $matrix = $this->buildMatrix($x, $y, $ins, $del, $rep, $trn, $alt);
+ $cost = $matrix->getEditDistance();
+
+ $desc = array($ins, $del, $rep, ($trn === null ? '-' : $trn));
+ $desc = implode(', ', $desc);
+
+ $this->assertEqual(
+ $expect,
+ $cost,
+ pht(
+ "Edit distance of '%s' -> '%s' with costs (%s).",
+ $x,
+ $y,
+ $desc));
+ }
+
+ private function assertEditString(
+ $expect,
+ $x, $y,
+ $ins = 1, $del = 1,
+ $rep = 1, $trn = null,
+ $alt = 0) {
+
+ $matrix = $this->buildMatrix($x, $y, $ins, $del, $rep, $trn, $alt);
+ $matrix->setComputeString(true);
+
+ $string = $matrix->getEditString();
+
+ $desc = array($ins, $del, $rep);
+ $desc[] = ($trn === null ? '-' : $trn);
+ $desc[] = ($alt === 0 ? '-' : $alt);
+ $desc = implode(', ', $desc);
+
+ $this->assertEqual(
+ $expect,
+ $string,
+ pht(
+ "Edit string of '%s' -> '%s' with costs (%s).",
+ $x,
+ $y,
+ $desc));
+ }
+
+ private function buildMatrix($x, $y, $ins, $del, $rep, $trn, $alt) {
+ if (!strlen($x)) {
+ $xv = array();
+ } else {
+ $xv = str_split($x);
+ }
+
+ if (!strlen($y)) {
+ $yv = array();
+ } else {
+ $yv = str_split($y);
+ }
+
+ return id(new PhutilEditDistanceMatrix())
+ ->setSequences($xv, $yv)
+ ->setInsertCost($ins)
+ ->setDeleteCost($del)
+ ->setReplaceCost($rep)
+ ->setTransposeCost($trn)
+ ->setAlterCost($alt);
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilHashingIteratorTestCase.php b/src/utils/__tests__/PhutilHashingIteratorTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilHashingIteratorTestCase.php
@@ -0,0 +1,45 @@
+setAlgorithm($algorithm);
+
+ $rope = new PhutilRope();
+ foreach ($hashing_iterator as $block) {
+ $rope->append($block);
+ }
+
+ $expect_data = Filesystem::readFile($path);
+ $actual_data = $rope->getAsString();
+
+ $this->assertEqual(
+ $expect_data,
+ $actual_data,
+ pht('Data should be read correctly.'));
+
+ $expect_hash =
+ 'd50af03db6c8b63084664f352d12bffb8f58022bdd67e3aba21f01e11c3b8939';
+
+ $single_hash = hash($algorithm, $expect_data, $raw_output = false);
+ $actual_hash = $hashing_iterator->getHash();
+
+ $this->assertEqual(
+ $expect_hash,
+ $single_hash,
+ pht('Expected hash should match freshly computed hash.'));
+
+ $this->assertEqual(
+ $expect_hash,
+ $actual_hash,
+ pht('Expected hash should also match iterator actual hash.'));
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilLunarPhaseTestCase.php b/src/utils/__tests__/PhutilLunarPhaseTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilLunarPhaseTestCase.php
@@ -0,0 +1,58 @@
+assertFalse($moon->isFull());
+ $this->assertTrue($moon->isNew());
+ $this->assertTrue($moon->isWaxing());
+ $this->assertFalse($moon->isWaning());
+
+ // May 22, 2005
+ $moon = new PhutilLunarPhase(1116745200);
+ $this->assertTrue($moon->isFull());
+ $this->assertFalse($moon->isNew());
+ $this->assertTrue($moon->isWaxing());
+ $this->assertFalse($moon->isWaning());
+
+ // May 23, 2005
+ $moon = new PhutilLunarPhase(1116831600);
+ $this->assertTrue($moon->isFull());
+ $this->assertFalse($moon->isNew());
+ $this->assertFalse($moon->isWaxing());
+ $this->assertTrue($moon->isWaning());
+
+ // May 30, 2005
+ $moon = new PhutilLunarPhase(1117436400);
+ $this->assertFalse($moon->isFull());
+ $this->assertFalse($moon->isNew());
+ $this->assertFalse($moon->isWaxing());
+ $this->assertTrue($moon->isWaning());
+
+ // June 05, 2005
+ $moon = new PhutilLunarPhase(1117954800);
+ $this->assertFalse($moon->isFull());
+ $this->assertFalse($moon->isNew());
+ $this->assertFalse($moon->isWaxing());
+ $this->assertTrue($moon->isWaning());
+
+ // June 06, 2005
+ $moon = new PhutilLunarPhase(1118041200);
+ $this->assertFalse($moon->isFull());
+ $this->assertTrue($moon->isNew());
+ $this->assertFalse($moon->isWaxing());
+ $this->assertTrue($moon->isWaning());
+
+ // Oct 4, 2013
+ $moon = new PhutilLunarPhase(1380897327);
+ $this->assertFalse($moon->isFull());
+ $this->assertTrue($moon->isNew());
+ $this->assertTrue($moon->isWaxing());
+ $this->assertFalse($moon->isWaning());
+
+ }
+
+
+}
diff --git a/src/utils/__tests__/PhutilProseDiffTestCase.php b/src/utils/__tests__/PhutilProseDiffTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilProseDiffTestCase.php
@@ -0,0 +1,245 @@
+assertProseParts(
+ '',
+ '',
+ array(),
+ pht('Empty'));
+
+ $this->assertProseParts(
+ "xxx\nyyy",
+ "xxx\nzzz\nyyy",
+ array(
+ "= xxx\n",
+ "+ zzz\n",
+ '= yyy',
+ ),
+ pht('Add Paragraph'));
+
+ $this->assertProseParts(
+ "xxx\nzzz\nyyy",
+ "xxx\nyyy",
+ array(
+ "= xxx\n",
+ "- zzz\n",
+ '= yyy',
+ ),
+ pht('Remove Paragraph'));
+
+
+ // Without smoothing, the alogorithm identifies that "shark" and "cat"
+ // both contain the letter "a" and tries to express this as a very
+ // fine-grained edit which replaces "sh" with "c" and then "rk" with "t".
+ // This is technically correct, but it is much easier for human viewers to
+ // parse if we smooth this into a single removal and a single addition.
+
+ $this->assertProseParts(
+ 'They say the shark has nine lives.',
+ 'They say the cat has nine lives.',
+ array(
+ '= They say the ',
+ '- shark',
+ '+ cat',
+ '= has nine lives.',
+ ),
+ pht('"Shark/cat" word edit smoothenss.'));
+
+ $this->assertProseParts(
+ 'Rising quickly, she says',
+ 'Rising quickly, she remarks:',
+ array(
+ '= Rising quickly, she ',
+ '- says',
+ '+ remarks:',
+ ),
+ pht('"Says/remarks" word edit smoothenss.'));
+
+ $this->assertProseParts(
+ 'See screenshots',
+ 'Viewed video files',
+ array(
+ '- See screenshots',
+ '+ Viewed video files',
+ ),
+ pht('Complete paragraph rewrite.'));
+
+ $this->assertProseParts(
+ 'xaaax',
+ 'xbbbx',
+ array(
+ '- xaaax',
+ '+ xbbbx',
+ ),
+ pht('Whole word rewrite with common prefix and suffix.'));
+
+ $this->assertProseParts(
+ ' aaa ',
+ ' bbb ',
+ array(
+ '= ',
+ '- aaa',
+ '+ bbb',
+ '= ',
+ ),
+ pht('Whole word rewrite with whitespace prefix and suffix.'));
+
+ $this->assertSummaryProseParts(
+ "a\nb\nc\nd\ne\nf\ng\nh\n",
+ "a\nb\nc\nd\nX\nf\ng\nh\n",
+ array(
+ '.',
+ "= d\n",
+ '- e',
+ '+ X',
+ "= \nf",
+ '.',
+ ),
+ pht('Summary diff with middle change.'));
+
+ $this->assertSummaryProseParts(
+ "a\nb\nc\nd\ne\nf\ng\nh\n",
+ "X\nb\nc\nd\ne\nf\ng\nh\n",
+ array(
+ '- a',
+ '+ X',
+ "= \nb",
+ '.',
+ ),
+ pht('Summary diff with head change.'));
+
+ $this->assertSummaryProseParts(
+ "a\nb\nc\nd\ne\nf\ng\nh\n",
+ "a\nb\nc\nd\ne\nf\ng\nX\n",
+ array(
+ '.',
+ "= g\n",
+ '- h',
+ '+ X',
+ "= \n",
+ ),
+ pht('Summary diff with last change.'));
+
+ $this->assertProseParts(
+ 'aaa aaa aaa aaa, bbb bbb bbb bbb.',
+ "aaa aaa aaa aaa, bbb bbb bbb bbb.\n\n- ccc ccc ccc",
+ array(
+ '= aaa aaa aaa aaa, bbb bbb bbb bbb.',
+ "+ \n\n- ccc ccc ccc",
+ ),
+ pht('Diff with new trailing content.'));
+
+ $this->assertProseParts(
+ 'aaa aaa aaa aaa, bbb bbb bbb bbb.',
+ 'aaa aaa aaa aaa bbb bbb bbb bbb.',
+ array(
+ '= aaa aaa aaa aaa',
+ '- ,',
+ '= bbb bbb bbb bbb.',
+ ),
+ pht('Diff with a removed comma.'));
+
+ $this->assertProseParts(
+ 'aaa aaa aaa aaa, bbb bbb bbb bbb.',
+ "aaa aaa aaa aaa bbb bbb bbb bbb.\n\n- ccc ccc ccc!",
+ array(
+ '= aaa aaa aaa aaa',
+ '- ,',
+ '= bbb bbb bbb bbb.',
+ "+ \n\n- ccc ccc ccc!",
+ ),
+ pht('Diff with a removed comma and new trailing content.'));
+
+ $this->assertProseParts(
+ '[ ] Walnuts',
+ '[X] Walnuts',
+ array(
+ '= [',
+ '- ',
+ '+ X',
+ '= ] Walnuts',
+ ),
+ pht('Diff adding a tickmark to a checkbox list.'));
+
+ $this->assertProseParts(
+ '[[ ./week49 ]]',
+ '[[ ./week50 ]]',
+ array(
+ '= [[ ./week',
+ '- 49',
+ '+ 50',
+ '= ]]',
+ ),
+ pht('Diff changing a remarkup wiki link target.'));
+
+ // Create a large corpus with many sentences and paragraphs.
+ $large_paragraph = 'xyz. ';
+ $large_paragraph = str_repeat($large_paragraph, 50);
+ $large_paragraph = rtrim($large_paragraph);
+
+ $large_corpus = $large_paragraph."\n\n";
+ $large_corpus = str_repeat($large_corpus, 50);
+ $large_corpus = rtrim($large_corpus);
+
+ $this->assertProseParts(
+ $large_corpus,
+ "aaa\n\n".$large_corpus."\n\nzzz",
+ array(
+ "+ aaa\n\n",
+ '= '.$large_corpus,
+ "+ \n\nzzz",
+ ),
+ pht('Adding initial and final lines to a large corpus.'));
+
+ }
+
+ private function assertProseParts($old, $new, array $expect_parts, $label) {
+ $engine = new PhutilProseDifferenceEngine();
+ $diff = $engine->getDiff($old, $new);
+
+ $parts = $diff->getParts();
+
+ $this->assertParts($expect_parts, $parts, $label);
+ }
+
+ private function assertSummaryProseParts(
+ $old,
+ $new,
+ array $expect_parts,
+ $label) {
+
+ $engine = new PhutilProseDifferenceEngine();
+ $diff = $engine->getDiff($old, $new);
+
+ $parts = $diff->getSummaryParts();
+
+ $this->assertParts($expect_parts, $parts, $label);
+ }
+
+ private function assertParts(
+ array $expect,
+ array $actual_parts,
+ $label) {
+
+ $actual = array();
+ foreach ($actual_parts as $actual_part) {
+ $type = $actual_part['type'];
+ $text = $actual_part['text'];
+
+ switch ($type) {
+ case '.':
+ $actual[] = $type;
+ break;
+ default:
+ $actual[] = "{$type} {$text}";
+ break;
+ }
+ }
+
+ $this->assertEqual($expect, $actual, $label);
+ }
+
+
+}
diff --git a/src/utils/__tests__/PhutilRopeTestCase.php b/src/utils/__tests__/PhutilRopeTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilRopeTestCase.php
@@ -0,0 +1,56 @@
+append('aaa');
+ $rope->append('bbb');
+
+ $this->assertEqual(6, $rope->getByteLength());
+ $this->assertEqual('aaabbb', $rope->getAsString());
+
+ $rope->removeBytesFromHead(2);
+
+ $this->assertEqual(4, $rope->getByteLength());
+ $this->assertEqual('abbb', $rope->getAsString());
+
+ $rope->removeBytesFromHead(4);
+
+ $this->assertEqual(0, $rope->getByteLength());
+ $this->assertEqual('', $rope->getAsString());
+ }
+
+ public function testMoreRopeOperations() {
+ $rope = new PhutilRope();
+ $rope->append('aaa');
+ $rope->append('bbb');
+ $rope->append('ccc');
+ $rope->append('rrrrddddddddd');
+ $rope->removeBytesFromHead(4);
+
+ $string = $rope->getAsString();
+ $this->assertEqual('bbcccrrrrddddddddd', $string);
+ $this->assertEqual(strlen($string), $rope->getByteLength());
+
+ $rope = new PhutilRope();
+ $rope->append('aaa');
+ $rope->append('bbb');
+ $rope->removeBytesFromHead(6);
+
+ $string = $rope->getAsString();
+ $this->assertEqual('', $string);
+ $this->assertEqual(0, $rope->getByteLength());
+
+
+ $rope = new PhutilRope();
+ $rope->append('a');
+ $rope->append('b');
+ $rope->append('c');
+ $rope->removeBytesFromHead(1024);
+
+ $string = $rope->getAsString();
+ $this->assertEqual('', $string);
+ $this->assertEqual(0, $rope->getByteLength());
+ }
+}
diff --git a/src/utils/__tests__/PhutilSystemTestCase.php b/src/utils/__tests__/PhutilSystemTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilSystemTestCase.php
@@ -0,0 +1,43 @@
+ array(
+ 'total' => 16503578624,
+ 'free' => 1732366336,
+ ),
+ );
+
+ $dir = dirname(__FILE__).'/memory';
+ foreach ($tests as $input => $expect) {
+ $raw = Filesystem::readFile($dir.'/'.$input);
+ $actual = PhutilSystem::parseVMStat($raw);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('Parse of "%s".', $input));
+ }
+ }
+
+ public function testParseMeminfo() {
+ $tests = array(
+ 'meminfo.ubuntu14.txt' => array(
+ 'total' => 7843336192,
+ 'free' => 3758297088,
+ ),
+ );
+
+ $dir = dirname(__FILE__).'/memory';
+ foreach ($tests as $input => $expect) {
+ $raw = Filesystem::readFile($dir.'/'.$input);
+ $actual = PhutilSystem::parseMemInfo($raw);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('Parse of "%s".', $input));
+ }
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilUTF8TestCase.php b/src/utils/__tests__/PhutilUTF8TestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilUTF8TestCase.php
@@ -0,0 +1,813 @@
+assertEqual($input, phutil_utf8ize($input));
+ }
+
+ public function testUTF8izeUTF8Ignored() {
+ $input = "\xc3\x9c \xc3\xbc \xe6\x9d\xb1!";
+ $this->assertEqual($input, phutil_utf8ize($input));
+ }
+
+ public function testUTF8izeLongStringNosegfault() {
+ // For some reason my laptop is segfaulting on long inputs inside
+ // preg_match(). Forestall this craziness in the common case, at least.
+ phutil_utf8ize(str_repeat('x', 1024 * 1024));
+ $this->assertTrue(true);
+ }
+
+ public function testUTF8izeInvalidUTF8Fixed() {
+ $input =
+ "\xc3 this has \xe6\x9d some invalid utf8 \xe6";
+ $expect =
+ "\xEF\xBF\xBD this has \xEF\xBF\xBD\xEF\xBF\xBD some invalid utf8 ".
+ "\xEF\xBF\xBD";
+ $result = phutil_utf8ize($input);
+ $this->assertEqual($expect, $result);
+ }
+
+ public function testUTF8izeOwlIsCuteAndFerocious() {
+ // This was once a ferocious owl when we used to use "?" as the replacement
+ // character instead of U+FFFD, but now he is sort of not as cute or
+ // ferocious.
+ $input = "M(o\xEE\xFF\xFFo)M";
+ $expect = "M(o\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBDo)M";
+ $result = phutil_utf8ize($input);
+ $this->assertEqual($expect, $result);
+ }
+
+ public function testOverlongFormFiltering() {
+ $bad = "\xEF\xBF\xBD";
+
+ $map = array(
+ 'quack' => 'quack',
+
+ // This is U+1000, a valid character.
+ "\xE1\x80\x80" => "\xE1\x80\x80",
+
+ // This is a 2-byte encoding of U+0000.
+ "\xC0\x80" => "{$bad}{$bad}",
+
+ // This is a 3-byte encoding of U+0020.
+ "\xE0\x80\xA0" => "{$bad}{$bad}{$bad}",
+
+ "A \xE0\x83\x83" => "A {$bad}{$bad}{$bad}",
+ );
+
+ foreach ($map as $input => $expect) {
+ $actual = phutil_utf8ize($input);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('Overlong form canonicalization of: %s', $input));
+ }
+ }
+
+ public function testSurrogateFiltering() {
+ $bad = "\xEF\xBF\xBD";
+
+ $map = array(
+ "A \xED\xA9\x98" => "A {$bad}{$bad}{$bad}",
+ );
+
+ foreach ($map as $input => $expect) {
+ $actual = phutil_utf8ize($input);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('Surrogate filtering: %s', $input));
+ }
+ }
+
+
+ public function testUTF8CodepointEncoding() {
+ $map = array(
+ 0x20 => ' ',
+ 0x7E => '~',
+ 0xE9 => "\xC3\xA9",
+ 0x2603 => "\xE2\x98\x83",
+ 0x1F417 => "\xF0\x9F\x90\x97",
+ );
+
+ foreach ($map as $input => $expect) {
+ $actual = phutil_utf8_encode_codepoint($input);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('UTF8 codepoint encoding of "%s".', $input));
+ }
+ }
+
+ public function testUTF8len() {
+ $strings = array(
+ '' => 0,
+ 'x' => 1,
+ "\xEF\xBF\xBD" => 1,
+ "x\xe6\x9d\xb1y" => 3,
+ 'xyz' => 3,
+ 'quack' => 5,
+ );
+ foreach ($strings as $str => $expect) {
+ $this->assertEqual($expect, phutil_utf8_strlen($str), 'Length of '.$str);
+ }
+ }
+
+ public function testUTF8v() {
+ $strings = array(
+ '' => array(),
+ 'x' => array('x'),
+ 'quack' => array('q', 'u', 'a', 'c', 'k'),
+ "x\xe6\x9d\xb1y" => array('x', "\xe6\x9d\xb1", 'y'),
+
+ // This is a combining character.
+ "x\xCD\xA0y" => array('x', "\xCD\xA0", 'y'),
+ );
+ foreach ($strings as $str => $expect) {
+ $this->assertEqual($expect, phutil_utf8v($str), 'Vector of '.$str);
+ }
+ }
+
+ public function testUTF8vCodepoints() {
+ $strings = array(
+ '' => array(),
+ 'x' => array(0x78),
+ 'quack' => array(0x71, 0x75, 0x61, 0x63, 0x6B),
+ "x\xe6\x9d\xb1y" => array(0x78, 0x6771, 0x79),
+
+ "\xC2\xBB" => array(0x00BB),
+ "\xE2\x98\x83" => array(0x2603),
+ "\xEF\xBF\xBF" => array(0xFFFF),
+ "\xF0\x9F\x92\xA9" => array(0x1F4A9),
+
+ // This is a combining character.
+ "x\xCD\xA0y" => array(0x78, 0x0360, 0x79),
+ );
+ foreach ($strings as $str => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_utf8v_codepoints($str),
+ pht('Codepoint Vector of %s', $str));
+ }
+ }
+
+ public function testUTF8ConsoleStrlen() {
+ $strings = array(
+ '' => 0,
+ "\0" => 0,
+ 'x' => 1,
+
+ // Double-width chinese character.
+ "\xe6\x9d\xb1" => 2,
+
+ // Combining character.
+ "x\xCD\xA0y" => 2,
+
+ // Combining plus double-width.
+ "\xe6\x9d\xb1\xCD\xA0y" => 3,
+
+ // Colors and formatting.
+ "\x1B[1mx\x1B[m" => 1,
+ "\x1B[1m\x1B[31mx\x1B[m" => 1,
+ );
+ foreach ($strings as $str => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_utf8_console_strlen($str),
+ pht('Console Length of %s', $str));
+ }
+ }
+
+ public function testUTF8shorten() {
+ $inputs = array(
+ array('1erp derp derp', 9, '', '1erp derp'),
+ array('2erp derp derp', 12, '...', '2erp derp...'),
+ array('derpxderpxderp', 12, '...', 'derpxderp...'),
+ array("derp\xE2\x99\x83derpderp", 12, '...', "derp\xE2\x99\x83derp..."),
+ array('', 12, '...', ''),
+ array('derp', 12, '...', 'derp'),
+ array('11111', 5, '2222', '11111'),
+ array('111111', 5, '2222', '12222'),
+
+ array('D1rp. Derp derp.', 7, '...', 'D1rp.'),
+
+ // "D2rp." is a better shortening of this, but it's dramatically more
+ // complicated to implement with the newer byte/glyph/character
+ // shortening code.
+ array('D2rp. Derp derp.', 5, '...', 'D2...'),
+ array('D3rp. Derp derp.', 4, '...', 'D...'),
+ array('D4rp. Derp derp.', 14, '...', 'D4rp. Derp...'),
+ array('D5rpderp, derp derp', 16, '...', 'D5rpderp...'),
+ array('D6rpderp, derp derp', 17, '...', 'D6rpderp, derp...'),
+
+ // Strings with combining characters.
+ array("Gr\xCD\xA0mpyCatSmiles", 8, '...', "Gr\xCD\xA0mpy..."),
+ array("X\xCD\xA0\xCD\xA0\xCD\xA0Y", 1, '', "X\xCD\xA0\xCD\xA0\xCD\xA0"),
+
+ array(
+ 'Derp, supercalafragalisticexpialadoshus',
+ 30,
+ '...',
+ 'Derp, supercalafragalistice...',
+ ),
+
+ // If a string has only word-break characters in it, we should just cut
+ // it, not produce only the terminal.
+ array('((((((((((', 8, '...', '(((((...'),
+
+ // Terminal is longer than requested input.
+ array('derp', 3, 'quack', 'quack'),
+
+ array(
+ 'O123: com/oracle/java/path/to/application/source/ThingFactory.java',
+ 32,
+ '...',
+ 'O123: com/oracle/java/path/to...',
+ ),
+ );
+
+ foreach ($inputs as $input) {
+ list($string, $length, $terminal, $expect) = $input;
+ $result = id(new PhutilUTF8StringTruncator())
+ ->setMaximumGlyphs($length)
+ ->setTerminator($terminal)
+ ->truncateString($string);
+ $this->assertEqual($expect, $result, pht('Shortening of %s', $string));
+ }
+ }
+
+ public function testUTF8StringTruncator() {
+ $cases = array(
+ array(
+ "o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0",
+ 6,
+ "o\xCD\xA0!",
+ 6,
+ "o\xCD\xA0o\xCD\xA0!",
+ 6,
+ "o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0",
+ ),
+ array(
+ "X\xCD\xA0\xCD\xA0\xCD\xA0Y",
+ 6,
+ '!',
+ 6,
+ "X\xCD\xA0\xCD\xA0\xCD\xA0Y",
+ 6,
+ "X\xCD\xA0\xCD\xA0\xCD\xA0Y",
+ ),
+ array(
+ "X\xCD\xA0\xCD\xA0\xCD\xA0YZ",
+ 6,
+ '!',
+ 5,
+ "X\xCD\xA0\xCD\xA0\xCD\xA0!",
+ 2,
+ "X\xCD\xA0\xCD\xA0\xCD\xA0!",
+ ),
+ array(
+ "\xE2\x98\x83\xE2\x98\x83\xE2\x98\x83\xE2\x98\x83",
+ 4,
+ "\xE2\x98\x83!",
+ 3,
+ "\xE2\x98\x83\xE2\x98\x83!",
+ 3,
+ "\xE2\x98\x83\xE2\x98\x83!",
+ ),
+ );
+
+ foreach ($cases as $case) {
+ list($input, $b_len, $b_out, $p_len, $p_out, $g_len, $g_out) = $case;
+
+ $result = id(new PhutilUTF8StringTruncator())
+ ->setMaximumBytes($b_len)
+ ->setTerminator('!')
+ ->truncateString($input);
+ $this->assertEqual($b_out, $result, pht('byte-short of %s', $input));
+
+ $result = id(new PhutilUTF8StringTruncator())
+ ->setMaximumCodepoints($p_len)
+ ->setTerminator('!')
+ ->truncateString($input);
+ $this->assertEqual($p_out, $result, pht('codepoint-short of %s', $input));
+
+ $result = id(new PhutilUTF8StringTruncator())
+ ->setMaximumGlyphs($g_len)
+ ->setTerminator('!')
+ ->truncateString($input);
+ $this->assertEqual($g_out, $result, pht('glyph-short of %s', $input));
+ }
+ }
+
+ public function testUTF8LargeTruncation() {
+ // This is testing that our performance is reasonable when truncating a
+ // large input into a small output. Runtime should be on the order of the
+ // output size, not the input size.
+
+ $whale = "\xF0\x9F\x90\xB3";
+ $input = str_repeat($whale, 1024 * 1024);
+
+ $result = id(new PhutilUTF8StringTruncator())
+ ->setMaximumBytes(16)
+ ->setTerminator('!')
+ ->truncateString($input);
+
+ $this->assertEqual(
+ str_repeat($whale, 3).'!',
+ $result,
+ pht('Large truncation.'));
+ }
+
+ public function testUTF8Wrap() {
+ $inputs = array(
+ array(
+ 'aaaaaaa',
+ 3,
+ array(
+ 'aaa',
+ 'aaa',
+ 'a',
+ ),
+ ),
+ array(
+ 'aaaaaaa',
+ 3,
+ array(
+ 'aaa',
+ 'aaa',
+ 'a',
+ ),
+ ),
+ array(
+ 'aa&aaaa',
+ 3,
+ array(
+ 'aa&',
+ 'aaa',
+ 'a',
+ ),
+ ),
+ array(
+ "aa\xe6\x9d\xb1aaaa",
+ 3,
+ array(
+ "aa\xe6\x9d\xb1",
+ 'aaa',
+ 'a',
+ ),
+ ),
+ array(
+ '',
+ 80,
+ array(
+ ),
+ ),
+ array(
+ 'a',
+ 80,
+ array(
+ 'a',
+ ),
+ ),
+ );
+
+ foreach ($inputs as $input) {
+ list($string, $width, $expect) = $input;
+ $this->assertEqual(
+ $expect,
+ phutil_utf8_hard_wrap_html($string, $width),
+ pht("Wrapping of '%s'.", $string));
+ }
+ }
+
+ public function testUTF8NonHTMLWrap() {
+ $inputs = array(
+ array(
+ 'aaaaaaa',
+ 3,
+ array(
+ 'aaa',
+ 'aaa',
+ 'a',
+ ),
+ ),
+ array(
+ 'abracadabra!',
+ 4,
+ array(
+ 'abra',
+ 'cada',
+ 'bra!',
+ ),
+ ),
+ array(
+ '',
+ 10,
+ array(
+ ),
+ ),
+ array(
+ 'a',
+ 20,
+ array(
+ 'a',
+ ),
+ ),
+ array(
+ "aa\xe6\x9d\xb1aaaa",
+ 3,
+ array(
+ "aa\xe6\x9d\xb1",
+ 'aaa',
+ 'a',
+ ),
+ ),
+ array(
+ "mmm\nmmm\nmmmm",
+ 3,
+ array(
+ 'mmm',
+ 'mmm',
+ 'mmm',
+ 'm',
+ ),
+ ),
+ );
+
+ foreach ($inputs as $input) {
+ list($string, $width, $expect) = $input;
+ $this->assertEqual(
+ $expect,
+ phutil_utf8_hard_wrap($string, $width),
+ pht("Wrapping of '%s'", $string));
+ }
+ }
+
+ public function testUTF8ConvertParams() {
+ $caught = null;
+ try {
+ phutil_utf8_convert('', 'utf8', '');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue((bool)$caught, pht('Requires source encoding.'));
+
+ $caught = null;
+ try {
+ phutil_utf8_convert('', '', 'utf8');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue((bool)$caught, pht('Requires target encoding.'));
+ }
+
+
+ public function testUTF8Convert() {
+ if (!function_exists('mb_convert_encoding')) {
+ $this->assertSkipped(pht('Requires %s extension.', 'mbstring'));
+ }
+
+ // "[ae]gis se[n]or [(c)] 1970 [+/-] 1 [degree]"
+ $input = "\xE6gis SE\xD1OR \xA9 1970 \xB11\xB0";
+ $expect = "\xC3\xA6gis SE\xC3\x91OR \xC2\xA9 1970 \xC2\xB11\xC2\xB0";
+ $output = phutil_utf8_convert($input, 'UTF-8', 'ISO-8859-1');
+
+ $this->assertEqual($expect, $output, pht('Conversion from ISO-8859-1.'));
+
+ $caught = null;
+ try {
+ phutil_utf8_convert('xyz', 'moon language', 'UTF-8');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue((bool)$caught, pht('Conversion with bogus encoding.'));
+ }
+
+
+ public function testUTF8ucwords() {
+ $tests = array(
+ '' => '',
+ 'x' => 'X',
+ 'X' => 'X',
+ 'five short graybles' => 'Five Short Graybles',
+ 'xXxSNiPeRKiLLeRxXx' => 'XXxSNiPeRKiLLeRxXx',
+ );
+
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_utf8_ucwords($input),
+ 'phutil_utf8_ucwords("'.$input.'")');
+ }
+ }
+
+ public function testUTF8strtolower() {
+ $tests = array(
+ '' => '',
+ 'a' => 'a',
+ 'A' => 'a',
+ '!' => '!',
+ 'OMG!~ LOLolol ROFLwaffle11~' => 'omg!~ lololol roflwaffle11~',
+ "\xE2\x98\x83" => "\xE2\x98\x83",
+ );
+
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_utf8_strtolower($input),
+ 'phutil_utf8_strtolower("'.$input.'")');
+ }
+ }
+
+ public function testUTF8strtoupper() {
+ $tests = array(
+ '' => '',
+ 'a' => 'A',
+ 'A' => 'A',
+ '!' => '!',
+ 'Cats have 9 lives.' => 'CATS HAVE 9 LIVES.',
+ "\xE2\x98\x83" => "\xE2\x98\x83",
+ );
+
+ foreach ($tests as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_utf8_strtoupper($input),
+ 'phutil_utf8_strtoupper("'.$input.'")');
+ }
+ }
+
+ public function testUTF8IsCombiningCharacter() {
+ $character = "\xCD\xA0";
+ $this->assertEqual(
+ true,
+ phutil_utf8_is_combining_character($character));
+
+ $character = 'a';
+ $this->assertEqual(
+ false,
+ phutil_utf8_is_combining_character($character));
+ }
+
+ public function testUTF8vCombined() {
+ // Empty string.
+ $string = '';
+ $this->assertEqual(array(), phutil_utf8v_combined($string));
+
+ // Single character.
+ $string = 'x';
+ $this->assertEqual(array('x'), phutil_utf8v_combined($string));
+
+ // No combining characters.
+ $string = 'cat';
+ $this->assertEqual(array('c', 'a', 't'), phutil_utf8v_combined($string));
+
+ // String with a combining character in the middle.
+ $string = "ca\xCD\xA0t";
+ $this->assertEqual(
+ array('c', "a\xCD\xA0", 't'),
+ phutil_utf8v_combined($string));
+
+ // String starting with a combined character.
+ $string = "c\xCD\xA0at";
+ $this->assertEqual(
+ array("c\xCD\xA0", 'a', 't'),
+ phutil_utf8v_combined($string));
+
+ // String with trailing combining character.
+ $string = "cat\xCD\xA0";
+ $this->assertEqual(
+ array('c', 'a', "t\xCD\xA0"),
+ phutil_utf8v_combined($string));
+
+ // String with muliple combined characters.
+ $string = "c\xCD\xA0a\xCD\xA0t\xCD\xA0";
+ $this->assertEqual(
+ array("c\xCD\xA0", "a\xCD\xA0", "t\xCD\xA0"),
+ phutil_utf8v_combined($string));
+
+ // String with multiple combining characters.
+ $string = "ca\xCD\xA0\xCD\xA0t";
+ $this->assertEqual(
+ array('c', "a\xCD\xA0\xCD\xA0", 't'),
+ phutil_utf8v_combined($string));
+
+ // String beginning with a combining character.
+ $string = "\xCD\xA0\xCD\xA0c";
+ $this->assertEqual(
+ array(" \xCD\xA0\xCD\xA0", 'c'),
+ phutil_utf8v_combined($string));
+ }
+
+ public function testUTF8BMPSegfaults() {
+ // This test case fails by segfaulting, or passes by not segfaulting. See
+ // the function implementation for details.
+ $input = str_repeat("\xEF\xBF\xBF", 1024 * 32);
+ phutil_is_utf8_with_only_bmp_characters($input);
+
+ $this->assertTrue(true);
+ }
+
+ public function testCJK() {
+ $map = array(
+ '' => false,
+ 'a' => false,
+ '.' => false,
+ "\xE2\x98\x83" => false,
+ "\xE5\xA0\xB1" => true,
+ );
+
+ foreach ($map as $input => $expect) {
+ $actual = phutil_utf8_is_cjk($input);
+
+ $this->assertEqual($expect, $actual, pht('CJK: "%s"', $input));
+ }
+ }
+
+ public function testUTF8BMP() {
+ $tests = array(
+ '' => array(
+ true,
+ true,
+ pht('empty string'),
+ ),
+ 'a' => array(
+ true,
+ true,
+ 'a',
+ ),
+ "a\xCD\xA0\xCD\xA0" => array(
+ true,
+ true,
+ pht('%s with combining', 'a'),
+ ),
+ "\xE2\x98\x83" => array(
+ true,
+ true,
+ pht('snowman'),
+ ),
+
+ // This is the last character in BMP, U+FFFF.
+ "\xEF\xBF\xBF" => array(
+ true,
+ true,
+ 'U+FFFF',
+ ),
+
+ // This isn't valid.
+ "\xEF\xBF\xC0" => array(
+ false,
+ false,
+ pht('Invalid, byte range.'),
+ ),
+
+ // This is an invalid nonminimal representation.
+ "\xF0\x81\x80\x80" => array(
+ false,
+ false,
+ pht('Nonminimal 4-byte character.'),
+ ),
+
+ // This is the first character above BMP, U+10000.
+ "\xF0\x90\x80\x80" => array(
+ true,
+ false,
+ 'U+10000',
+ ),
+ "\xF0\x9D\x84\x9E" => array(
+ true,
+ false,
+ 'gclef',
+ ),
+
+ "musical \xF0\x9D\x84\x9E g-clef" => array(
+ true,
+ false,
+ pht('gclef text'),
+ ),
+ "\xF0\x9D\x84" => array(
+ false,
+ false,
+ pht('Invalid, truncated.'),
+ ),
+
+ "\xE0\x80\x80" => array(
+ false,
+ false,
+ pht('Nonminimal 3-byte character.'),
+ ),
+
+ // Partial BMP characters.
+ "\xCD" => array(
+ false,
+ false,
+ pht('Partial 2-byte character.'),
+ ),
+ "\xE0\xA0" => array(
+ false,
+ false,
+ pht('Partial BMP 0xE0 character.'),
+ ),
+ "\xE2\x98" => array(
+ false,
+ false,
+ pht('Partial BMP cahracter.'),
+ ),
+ );
+
+ foreach ($tests as $input => $test) {
+ list($expect_utf8, $expect_bmp, $test_name) = $test;
+
+ // Depending on what's installed on the system, this may use an
+ // extension.
+ $this->assertEqual(
+ $expect_utf8,
+ phutil_is_utf8($input),
+ pht('is_utf(%s)', $test_name));
+
+ // Also test this against the pure PHP implementation, explicitly.
+ $this->assertEqual(
+ $expect_utf8,
+ phutil_is_utf8_slowly($input),
+ pht('is_utf_slowly(%s)', $test_name));
+
+ $this->assertEqual(
+ $expect_bmp,
+ phutil_is_utf8_with_only_bmp_characters($input),
+ pht('is_utf_bmp(%s)', $test_name));
+ }
+ }
+
+ public function testSystemLocaleManagement() {
+ $original_locale = phutil_get_system_locale();
+ $this->assertTrue(
+ (strlen($original_locale) > 0),
+ pht('System has some identifiable locale.'));
+
+ $this->assertFalse(
+ phutil_is_system_locale_available('duck.quack'),
+ pht('Imaginary locale should be unavailable.'));
+
+ $this->assertEqual(
+ $original_locale,
+ phutil_get_system_locale(),
+ pht('Testing locale availability should not change the locale.'));
+
+ $this->assertTrue(
+ phutil_is_system_locale_available($original_locale),
+ pht('The current locale should be available.'));
+
+ $caught = null;
+ try {
+ phutil_set_system_locale('duck.quack');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue(
+ ($caught instanceof Exception),
+ pht('Setting an imaginary locale should raise an exception.'));
+
+ // We need two locales for the next part because one of them might be the
+ // current locale, and we want to make sure we can actually change the
+ // locale value.
+
+ // If the current locale was "zz_ZZ", and then we do this:
+ //
+ // set_locale("zz_ZZ");
+ // assert("zz_ZZ" == get_locale());
+ //
+ // ...the test could pass even if "set_locale(...)" does nothing.
+
+ $has_us = phutil_is_system_locale_available('en_US.UTF-8');
+ $has_gb = phutil_is_system_locale_available('en_GB.UTF-8');
+ if (!$has_us || !$has_gb) {
+ $this->assertSkipped(
+ pht(
+ 'System does not have en_US + en_GB to do locale adjustment '.
+ 'tests.'));
+ }
+
+ phutil_set_system_locale('en_US.UTF-8');
+ $this->assertEqual(
+ 'en_US.UTF-8',
+ phutil_get_system_locale(),
+ pht('Set locale to en_US.'));
+
+ phutil_set_system_locale('en_GB.UTF-8');
+ $this->assertEqual(
+ 'en_GB.UTF-8',
+ phutil_get_system_locale(),
+ pht('Set locale to en_GB.'));
+
+ // Put things back the way they were.
+ phutil_set_system_locale($original_locale);
+ }
+
+}
diff --git a/src/utils/__tests__/PhutilUtilsTestCase.php b/src/utils/__tests__/PhutilUtilsTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/PhutilUtilsTestCase.php
@@ -0,0 +1,885 @@
+assertTrue($caught instanceof InvalidArgumentException);
+ }
+
+
+ public function testMFilterWithEmptyValueFiltered() {
+ $a = new MFilterTestHelper('o', 'p', 'q');
+ $b = new MFilterTestHelper('o', '', 'q');
+ $c = new MFilterTestHelper('o', 'p', 'q');
+
+ $list = array(
+ 'a' => $a,
+ 'b' => $b,
+ 'c' => $c,
+ );
+
+ $actual = mfilter($list, 'getI');
+ $expected = array(
+ 'a' => $a,
+ 'c' => $c,
+ );
+
+ $this->assertEqual($expected, $actual);
+ }
+
+ public function testMFilterWithEmptyValueNegateFiltered() {
+ $a = new MFilterTestHelper('o', 'p', 'q');
+ $b = new MFilterTestHelper('o', '', 'q');
+ $c = new MFilterTestHelper('o', 'p', 'q');
+
+ $list = array(
+ 'a' => $a,
+ 'b' => $b,
+ 'c' => $c,
+ );
+
+ $actual = mfilter($list, 'getI', true);
+ $expected = array(
+ 'b' => $b,
+ );
+
+ $this->assertEqual($expected, $actual);
+ }
+
+ public function testIFilterInvalidIndexThrowException() {
+ $caught = null;
+ try {
+ ifilter(array(), null);
+ } catch (InvalidArgumentException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+ }
+
+ public function testIFilterWithEmptyValueFiltered() {
+ $list = array(
+ 'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
+ 'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
+ 'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
+ 'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
+ );
+
+ $actual = ifilter($list, 'i');
+ $expected = array(
+ 'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ );
+
+ $this->assertEqual($expected, $actual);
+ }
+
+ public function testIFilterIndexNotExistsAllFiltered() {
+ $list = array(
+ 'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
+ );
+
+ $actual = ifilter($list, 'NoneExisting');
+ $expected = array();
+
+ $this->assertEqual($expected, $actual);
+ }
+
+
+ public function testIFilterWithEmptyValueNegateFiltered() {
+ $list = array(
+ 'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
+ 'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
+ 'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
+ 'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
+ );
+
+ $actual = ifilter($list, 'i', true);
+ $expected = array(
+ 'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
+ 'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
+ 'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
+ 'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
+ );
+
+ $this->assertEqual($expected, $actual);
+ }
+
+ public function testIFilterIndexNotExistsNotFiltered() {
+ $list = array(
+ 'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
+ );
+
+ $actual = ifilter($list, 'NoneExisting', true);
+ $expected = array(
+ 'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
+ 'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
+ );
+
+ $this->assertEqual($expected, $actual);
+ }
+
+ public function testmergevMergingBasicallyWorksCorrectly() {
+ $this->assertEqual(
+ array(),
+ array_mergev(
+ array(
+ //
+ )));
+
+ $this->assertEqual(
+ array(),
+ array_mergev(
+ array(
+ array(),
+ array(),
+ array(),
+ )));
+
+ $this->assertEqual(
+ array(1, 2, 3, 4, 5),
+ array_mergev(
+ array(
+ array(1, 2),
+ array(3),
+ array(),
+ array(4, 5),
+ )));
+
+ $not_valid = array(
+ 'scalar' => array(1),
+ 'array plus scalar' => array(array(), 1),
+ 'null' => array(null),
+ );
+
+ foreach ($not_valid as $key => $invalid_input) {
+ $caught = null;
+ try {
+ array_mergev($invalid_input);
+ } catch (InvalidArgumentException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue(
+ ($caught instanceof InvalidArgumentException),
+ pht('%s invalid on %s', 'array_mergev()', $key));
+ }
+ }
+
+ public function testNonempty() {
+ $this->assertEqual(
+ 'zebra',
+ nonempty(false, null, 0, '', array(), 'zebra'));
+
+ $this->assertEqual(
+ null,
+ nonempty());
+
+ $this->assertEqual(
+ false,
+ nonempty(null, false));
+
+ $this->assertEqual(
+ null,
+ nonempty(false, null));
+ }
+
+ protected function tryAssertInstancesOfArray($input) {
+ assert_instances_of($input, 'array');
+ }
+
+ protected function tryAssertInstancesOfStdClass($input) {
+ assert_instances_of($input, 'stdClass');
+ }
+
+ public function testAssertInstancesOf() {
+ $object = new stdClass();
+ $inputs = array(
+ 'empty' => array(),
+ 'stdClass' => array($object, $object),
+ __CLASS__ => array($object, $this),
+ 'array' => array(array(), array()),
+ 'integer' => array($object, 1),
+ );
+
+ $this->tryTestCases(
+ $inputs,
+ array(true, true, false, false, false),
+ array($this, 'tryAssertInstancesOfStdClass'),
+ 'InvalidArgumentException');
+
+ $this->tryTestCases(
+ $inputs,
+ array(true, false, false, true, false),
+ array($this, 'tryAssertInstancesOfArray'),
+ 'InvalidArgumentException');
+ }
+
+ public function testAssertStringLike() {
+ $this->assertEqual(
+ null,
+ assert_stringlike(null));
+
+ $this->assertEqual(
+ null,
+ assert_stringlike(''));
+
+ $this->assertEqual(
+ null,
+ assert_stringlike('Hello World'));
+
+ $this->assertEqual(
+ null,
+ assert_stringlike(1));
+
+ $this->assertEqual(
+ null,
+ assert_stringlike(9.9999));
+
+ $this->assertEqual(
+ null,
+ assert_stringlike(true));
+
+ $obj = new Exception('.');
+ $this->assertEqual(
+ null,
+ assert_stringlike($obj));
+
+ $obj = (object)array();
+
+ try {
+ assert_stringlike($obj);
+ } catch (InvalidArgumentException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+
+ $array = array(
+ 'foo' => 'bar',
+ 'bar' => 'foo',
+ );
+
+ try {
+ assert_stringlike($array);
+ } catch (InvalidArgumentException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+
+ $tmp = new TempFile();
+ $resource = fopen($tmp, 'r');
+
+ try {
+ assert_stringlike($resource);
+ } catch (InvalidArgumentException $ex) {
+ $caught = $ex;
+ }
+
+ fclose($resource);
+
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+ }
+
+ public function testCoalesce() {
+ $this->assertEqual(
+ 'zebra',
+ coalesce(null, 'zebra'));
+
+ $this->assertEqual(
+ null,
+ coalesce());
+
+ $this->assertEqual(
+ false,
+ coalesce(false, null));
+
+ $this->assertEqual(
+ false,
+ coalesce(null, false));
+ }
+
+ public function testHeadLast() {
+ $this->assertEqual(
+ 'a',
+ head(explode('.', 'a.b')));
+ $this->assertEqual(
+ 'b',
+ last(explode('.', 'a.b')));
+ }
+
+ public function testHeadKeyLastKey() {
+ $this->assertEqual(
+ 'a',
+ head_key(array('a' => 0, 'b' => 1)));
+ $this->assertEqual(
+ 'b',
+ last_key(array('a' => 0, 'b' => 1)));
+ $this->assertEqual(null, head_key(array()));
+ $this->assertEqual(null, last_key(array()));
+ }
+
+ public function testID() {
+ $this->assertEqual(true, id(true));
+ $this->assertEqual(false, id(false));
+ }
+
+ public function testIdx() {
+ $array = array(
+ 'present' => true,
+ 'null' => null,
+ );
+ $this->assertEqual(true, idx($array, 'present'));
+ $this->assertEqual(true, idx($array, 'present', false));
+ $this->assertEqual(null, idx($array, 'null'));
+ $this->assertEqual(null, idx($array, 'null', false));
+ $this->assertEqual(null, idx($array, 'missing'));
+ $this->assertEqual(false, idx($array, 'missing', false));
+ }
+
+ public function testSplitLines() {
+ $retain_cases = array(
+ '' => array(''),
+ 'x' => array('x'),
+ "x\n" => array("x\n"),
+ "\n" => array("\n"),
+ "\n\n\n" => array("\n", "\n", "\n"),
+ "\r\n" => array("\r\n"),
+ "x\r\ny\n" => array("x\r\n", "y\n"),
+ "x\ry\nz\r\n" => array("x\ry\n", "z\r\n"),
+ "x\ry\nz\r\n\n" => array("x\ry\n", "z\r\n", "\n"),
+ );
+
+ foreach ($retain_cases as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_split_lines($input, $retain_endings = true),
+ pht('(Retained) %s', addcslashes($input, "\r\n\\")));
+ }
+
+ $discard_cases = array(
+ '' => array(''),
+ 'x' => array('x'),
+ "x\n" => array('x'),
+ "\n" => array(''),
+ "\n\n\n" => array('', '', ''),
+ "\r\n" => array(''),
+ "x\r\ny\n" => array('x', 'y'),
+ "x\ry\nz\r\n" => array("x\ry", 'z'),
+ "x\ry\nz\r\n\n" => array("x\ry", 'z', ''),
+ );
+
+ foreach ($discard_cases as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_split_lines($input, $retain_endings = false),
+ pht('(Discarded) %s', addcslashes($input, "\r\n\\")));
+ }
+ }
+
+ public function testArrayFuse() {
+ $this->assertEqual(array(), array_fuse(array()));
+ $this->assertEqual(array('x' => 'x'), array_fuse(array('x')));
+ }
+
+ public function testArrayInterleave() {
+ $this->assertEqual(array(), array_interleave('x', array()));
+ $this->assertEqual(array('y'), array_interleave('x', array('y')));
+
+ $this->assertEqual(
+ array('y', 'x', 'z'),
+ array_interleave('x', array('y', 'z')));
+
+ $this->assertEqual(
+ array('y', 'x', 'z'),
+ array_interleave(
+ 'x',
+ array(
+ 'kangaroo' => 'y',
+ 'marmoset' => 'z',
+ )));
+
+ $obj1 = (object)array();
+ $obj2 = (object)array();
+
+ $this->assertEqual(
+ array($obj1, $obj2, $obj1, $obj2, $obj1),
+ array_interleave(
+ $obj2,
+ array(
+ $obj1,
+ $obj1,
+ $obj1,
+ )));
+
+ $implode_tests = array(
+ '' => array(1, 2, 3),
+ 'x' => array(1, 2, 3),
+ 'y' => array(),
+ 'z' => array(1),
+ );
+
+ foreach ($implode_tests as $x => $y) {
+ $this->assertEqual(
+ implode('', array_interleave($x, $y)),
+ implode($x, $y));
+ }
+ }
+
+ public function testLoggableString() {
+ $this->assertEqual(
+ '',
+ phutil_loggable_string(''));
+
+ $this->assertEqual(
+ "a\\nb",
+ phutil_loggable_string("a\nb"));
+
+ $this->assertEqual(
+ "a\\x01b",
+ phutil_loggable_string("a\x01b"));
+
+ $this->assertEqual(
+ "a\\x1Fb",
+ phutil_loggable_string("a\x1Fb"));
+ }
+
+ public function testPhutilUnits() {
+ $cases = array(
+ '0 seconds in seconds' => 0,
+ '1 second in seconds' => 1,
+ '2 seconds in seconds' => 2,
+ '100 seconds in seconds' => 100,
+ '2 minutes in seconds' => 120,
+ '1 hour in seconds' => 3600,
+ '1 day in seconds' => 86400,
+ '3 days in seconds' => 259200,
+ '128 bits in bytes' => 16,
+ '1 byte in bytes' => 1,
+ '8 bits in bytes' => 1,
+ );
+
+ foreach ($cases as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_units($input),
+ 'phutil_units("'.$input.'")');
+ }
+
+ $bad_cases = array(
+ 'quack',
+ '3 years in seconds',
+ '1 minute in milliseconds',
+ '1 day in days',
+ '-1 minutes in seconds',
+ '1.5 minutes in seconds',
+ '7 bits in bytes',
+ '2 hours in bytes',
+ '1 dram in bytes',
+ '24 bits in seconds',
+ );
+
+ foreach ($bad_cases as $input) {
+ $caught = null;
+ try {
+ phutil_units($input);
+ } catch (InvalidArgumentException $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue(
+ ($caught instanceof InvalidArgumentException),
+ 'phutil_units("'.$input.'")');
+ }
+ }
+
+ public function testPhutilJSONDecode() {
+ $valid_cases = array(
+ '{}' => array(),
+ '[]' => array(),
+ '[1, 2]' => array(1, 2),
+ '{"a":"b"}' => array('a' => 'b'),
+ );
+
+ foreach ($valid_cases as $input => $expect) {
+ $result = phutil_json_decode($input);
+ $this->assertEqual($expect, $result, 'phutil_json_decode('.$input.')');
+ }
+
+ $invalid_cases = array(
+ '',
+ '"a"',
+ '{,}',
+ 'null',
+ '"null"',
+ );
+
+ foreach ($invalid_cases as $input) {
+ $caught = null;
+ try {
+ phutil_json_decode($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof PhutilJSONParserException);
+ }
+ }
+
+ public function testPhutilINIDecode() {
+ // Skip the test if we are using an older version of PHP that doesn't
+ // have the `parse_ini_string` function.
+ try {
+ phutil_ini_decode('');
+ } catch (PhutilMethodNotImplementedException $ex) {
+ $this->assertSkipped($ex->getMessage());
+ }
+
+ $valid_cases = array(
+ '' => array(),
+ 'foo=' => array('foo' => ''),
+ 'foo=bar' => array('foo' => 'bar'),
+ 'foo = bar' => array('foo' => 'bar'),
+ "foo = bar\n" => array('foo' => 'bar'),
+ "foo\nbar = baz" => array('bar' => 'baz'),
+
+ "[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
+ "[foo]\n[bar]\nbaz = foo" => array(
+ 'foo' => array(),
+ 'bar' => array('baz' => 'foo'),
+ ),
+ "[foo]\nbar = baz\n\n[bar]\nbaz = foo" => array(
+ 'foo' => array('bar' => 'baz'),
+ 'bar' => array('baz' => 'foo'),
+ ),
+
+ "; Comment\n[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
+ "# Comment\n[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
+
+ "foo = true\n[bar]\nbaz = false"
+ => array('foo' => true, 'bar' => array('baz' => false)),
+ "foo = 1\nbar = 1.234" => array('foo' => 1, 'bar' => 1.234),
+ 'x = {"foo": "bar"}' => array('x' => '{"foo": "bar"}'),
+ );
+
+ foreach ($valid_cases as $input => $expect) {
+ $result = phutil_ini_decode($input);
+ $this->assertEqual($expect, $result, 'phutil_ini_decode('.$input.')');
+ }
+
+ $invalid_cases = array(
+ '[' => new PhutilINIParserException(),
+ );
+
+ foreach ($invalid_cases as $input => $expect) {
+ $caught = null;
+ try {
+ phutil_ini_decode($input);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof $expect);
+ }
+ }
+
+ public function testCensorCredentials() {
+ $cases = array(
+ '' => '',
+ 'abc' => 'abc',
+
+ // NOTE: We're liberal about censoring here, since we can't tell
+ // if this is a truncated password at the end of an input string
+ // or a domain name. The version with a "/" isn't censored.
+ 'http://example.com' => 'http://********',
+ 'http://example.com/' => 'http://example.com/',
+
+ 'http://username@example.com' => 'http://********@example.com',
+ 'http://user:pass@example.com' => 'http://********@example.com',
+
+ // We censor these because they might be truncated credentials at the end
+ // of the string.
+ 'http://user' => 'http://********',
+ "http://user\n" => "http://********\n",
+
+ 'svn+ssh://user:pass@example.com' => 'svn+ssh://********@example.com',
+ );
+
+ foreach ($cases as $input => $expect) {
+ $this->assertEqual(
+ $expect,
+ phutil_censor_credentials($input),
+ pht('Credential censoring for: %s', $input));
+ }
+ }
+
+ public function testVarExport() {
+ // Constants
+ $this->assertEqual('null', phutil_var_export(null));
+ $this->assertEqual('true', phutil_var_export(true));
+ $this->assertEqual('false', phutil_var_export(false));
+ $this->assertEqual("'quack'", phutil_var_export('quack'));
+ $this->assertEqual('1234567', phutil_var_export(1234567));
+
+ // Arrays
+ $this->assertEqual(
+ 'array()',
+ phutil_var_export(array()));
+ $this->assertEqual(
+ implode("\n", array(
+ 'array(',
+ ' 1,',
+ ' 2,',
+ ' 3,',
+ ')',
+ )),
+ phutil_var_export(array(1, 2, 3)));
+ $this->assertEqual(
+ implode("\n", array(
+ 'array(',
+ " 'foo' => 'bar',",
+ " 'bar' => 'baz',",
+ ')',
+ )),
+ phutil_var_export(array('foo' => 'bar', 'bar' => 'baz')));
+ $this->assertEqual(
+ implode("\n", array(
+ 'array(',
+ " 'foo' => array(",
+ " 'bar' => array(",
+ " 'baz' => array(),",
+ ' ),',
+ ' ),',
+ ')',
+ )),
+ phutil_var_export(
+ array('foo' => array('bar' => array('baz' => array())))));
+
+ // Objects
+ $this->assertEqual(
+ "stdClass::__set_state(array(\n))",
+ phutil_var_export(new stdClass()));
+ $this->assertEqual(
+ "PhutilTestPhobject::__set_state(array(\n))",
+ phutil_var_export(new PhutilTestPhobject()));
+ }
+
+ public function testFnmatch() {
+ $cases = array(
+ '' => array(
+ array(''),
+ array('.', '/'),
+ ),
+ '*' => array(
+ array('file'),
+ array('dir/', '/dir'),
+ ),
+ '**' => array(
+ array('file', 'dir/', '/dir', 'dir/subdir/file'),
+ array(),
+ ),
+ '**/file' => array(
+ array('file', 'dir/file', 'dir/subdir/file', 'dir/subdir/subdir/file'),
+ array('file/', 'file/dir'),
+ ),
+ 'file.*' => array(
+ array('file.php', 'file.a', 'file.'),
+ array('files.php', 'file.php/blah'),
+ ),
+ 'fo?' => array(
+ array('foo', 'fot'),
+ array('fooo', 'ffoo', 'fo/', 'foo/'),
+ ),
+ 'fo{o,t}' => array(
+ array('foo', 'fot'),
+ array('fob', 'fo/', 'foo/'),
+ ),
+ 'fo{o,\\,}' => array(
+ array('foo', 'fo,'),
+ array('foo/', 'fo,/'),
+ ),
+ 'fo{o,\\\\}' => array(
+ array('foo', 'fo\\'),
+ array('foo/', 'fo\\/'),
+ ),
+ '/foo' => array(
+ array('/foo'),
+ array('foo', '/foo/'),
+ ),
+
+ // Tests for various `fnmatch` flags.
+ '*.txt' => array(
+ array(
+ 'file.txt',
+
+ // FNM_PERIOD
+ '.secret-file.txt',
+ ),
+ array(
+ // FNM_PATHNAME
+ 'dir/file.txt',
+
+ // FNM_CASEFOLD
+ 'file.TXT',
+ ),
+ '\\*.txt' => array(
+ array(
+ // FNM_NOESCAPE
+ '*.txt',
+ ),
+ array(
+ 'file.txt',
+ ),
+ ),
+ ),
+ );
+
+ $invalid = array(
+ '{',
+ 'asdf\\',
+ );
+
+ foreach ($cases as $input => $expect) {
+ list($matches, $no_matches) = $expect;
+
+ foreach ($matches as $match) {
+ $this->assertTrue(
+ phutil_fnmatch($input, $match),
+ pht('Expecting "%s" to match "%s".', $input, $match));
+ }
+
+ foreach ($no_matches as $no_match) {
+ $this->assertFalse(
+ phutil_fnmatch($input, $no_match),
+ pht('Expecting "%s" not to match "%s".', $input, $no_match));
+ }
+ }
+
+ foreach ($invalid as $input) {
+ $caught = null;
+ try {
+ phutil_fnmatch($input, '');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+ }
+ }
+
+ public function testJSONEncode() {
+ $in = array(
+ 'example' => "Not Valid UTF8: \x80",
+ );
+
+ $caught = null;
+ try {
+ $value = phutil_json_encode($in);
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+
+ $this->assertTrue(($caught instanceof Exception));
+ }
+
+ public function testHashComparisons() {
+ $tests = array(
+ array('1', '12', false),
+ array('0', '0e123', false),
+ array('0e123', '0e124', false),
+ array('', '0', false),
+ array('000', '0e0', false),
+ array('001', '002', false),
+ array('0', '', false),
+ array('987654321', '123456789', false),
+ array('A', 'a', false),
+ array('123456789', '123456789', true),
+ array('hunter42', 'hunter42', true),
+ );
+
+ foreach ($tests as $key => $test) {
+ list($u, $v, $expect) = $test;
+ $actual = phutil_hashes_are_identical($u, $v);
+ $this->assertEqual(
+ $expect,
+ $actual,
+ pht('Test Case: "%s" vs "%s"', $u, $v));
+ }
+ }
+
+ public function testVectorSortInt() {
+ $original = array(
+ ~PHP_INT_MAX,
+ -2147483648,
+ -5,
+ -3,
+ -1,
+ 0,
+ 1,
+ 2,
+ 3,
+ 100,
+ PHP_INT_MAX,
+ );
+
+ $items = $this->shuffleMap($original);
+
+ foreach ($items as $key => $value) {
+ $items[$key] = (string)id(new PhutilSortVector())
+ ->addInt($value);
+ }
+
+ asort($items, SORT_STRING);
+
+ $this->assertEqual(
+ array_keys($original),
+ array_keys($items));
+ }
+
+ public function testVectorSortString() {
+ $original = array(
+ '',
+ "\1",
+ 'A',
+ 'AB',
+ 'Z',
+ "Z\1",
+ 'ZZZ',
+ );
+
+ $items = $this->shuffleMap($original);
+
+ foreach ($items as $key => $value) {
+ $items[$key] = (string)id(new PhutilSortVector())
+ ->addString($value);
+ }
+
+ asort($items, SORT_STRING);
+
+ $this->assertEqual(
+ array_keys($original),
+ array_keys($items));
+ }
+
+ private function shuffleMap(array $map) {
+ $keys = array_keys($map);
+ shuffle($keys);
+ return array_select_keys($map, $keys);
+ }
+
+}
diff --git a/src/utils/__tests__/TestAbstractDirectedGraph.php b/src/utils/__tests__/TestAbstractDirectedGraph.php
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/TestAbstractDirectedGraph.php
@@ -0,0 +1,16 @@
+nodes = $nodes;
+ return $this;
+ }
+
+ protected function loadEdges(array $nodes) {
+ return array_select_keys($this->nodes, $nodes);
+ }
+
+}
diff --git a/src/utils/__tests__/cowsay/cube.expect b/src/utils/__tests__/cowsay/cube.expect
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/cowsay/cube.expect
@@ -0,0 +1,12 @@
+ __________________
+( I made a friend! )
+ ------------------
+ o
+ o
+ /---\__/---\\
+ | / .... \ ||
+ \ ..--.. //
+ |..(<3). ||
+ / ..--.. \\
+ | \ .... / ||
+ \---/--\---//
diff --git a/src/utils/__tests__/cowsay/cube.test b/src/utils/__tests__/cowsay/cube.test
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/cowsay/cube.test
@@ -0,0 +1,15 @@
+ $thoughts
+ $thoughts
+ /---\__/---\\
+ | / .... \ ||
+ \ ..--.. //
+ |..($eyes). ||
+ / ..--.. \\
+ | \ .... / ||
+ \---/--\---//
+~~~~~~~~~~
+{
+ "text": "I made a friend!",
+ "action": "think",
+ "eyes": "<3"
+}
diff --git a/src/utils/__tests__/cowsay/cube_perl.expect b/src/utils/__tests__/cowsay/cube_perl.expect
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/cowsay/cube_perl.expect
@@ -0,0 +1,12 @@
+ __________________
+( I made a friend! )
+ ------------------
+ o
+ o
+ /---\__/---\\
+ | / .... \ ||
+ \ ..--.. //
+ |..(<3). ||
+ / ..--.. \\
+ | \ .... / ||
+ \---/--\---//
diff --git a/src/utils/__tests__/cowsay/cube_perl.test b/src/utils/__tests__/cowsay/cube_perl.test
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/cowsay/cube_perl.test
@@ -0,0 +1,17 @@
+# test case for original perl-script cowfile
+$the_cow =
+ $thoughts
+ $thoughts
+ /---\\__/---\\\\
+ | / .... \\ ||
+ \\ ..--.. //
+ |..($eyes). ||
+ / ..--.. \\\\
+ | \\ .... / ||
+ \\---/--\\---//
+~~~~~~~~~~
+{
+ "text": "I made a friend!",
+ "action": "think",
+ "eyes": "<3"
+}
diff --git a/src/utils/__tests__/hashingiterator/mostlyprime.txt b/src/utils/__tests__/hashingiterator/mostlyprime.txt
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/hashingiterator/mostlyprime.txt
@@ -0,0 +1,1007 @@
+This is a data file which we compute a hash of. The contents are meaningless
+but it's a slightly better test if it has enough data that it won't fit into
+a single stream buffer, since that exercises more code.
+
+Thus, here is a list of 9,999 of the first 10,000 prime numbers, plus one
+number which I have changed so it is not prime.
+
+ 2 3 5 7 9 11 13 17 19 23
+ 31 37 41 43 47 53 59 61 67 71
+ 73 79 83 89 97 101 103 107 109 113
+ 127 131 137 139 149 151 157 163 167 173
+ 179 181 191 193 197 199 211 223 227 229
+ 233 239 241 251 257 263 269 271 277 281
+ 283 293 307 311 313 317 331 337 347 349
+ 353 359 367 373 379 383 389 397 401 409
+ 419 421 431 433 439 443 449 457 461 463
+ 467 479 487 491 499 503 509 521 523 541
+ 547 557 563 569 571 577 587 593 599 601
+ 607 613 617 619 631 641 643 647 653 659
+ 661 673 677 683 691 701 709 719 727 733
+ 739 743 751 757 761 769 773 787 797 809
+ 811 821 823 827 829 839 853 857 859 863
+ 877 881 883 887 907 911 919 929 937 941
+ 947 953 967 971 977 983 991 997 1009 1013
+ 1019 1021 1031 1033 1039 1049 1051 1061 1063 1069
+ 1087 1091 1093 1097 1103 1109 1117 1123 1129 1151
+ 1153 1163 1171 1181 1187 1193 1201 1213 1217 1223
+ 1229 1231 1237 1249 1259 1277 1279 1283 1289 1291
+ 1297 1301 1303 1307 1319 1321 1327 1361 1367 1373
+ 1381 1399 1409 1423 1427 1429 1433 1439 1447 1451
+ 1453 1459 1471 1481 1483 1487 1489 1493 1499 1511
+ 1523 1531 1543 1549 1553 1559 1567 1571 1579 1583
+ 1597 1601 1607 1609 1613 1619 1621 1627 1637 1657
+ 1663 1667 1669 1693 1697 1699 1709 1721 1723 1733
+ 1741 1747 1753 1759 1777 1783 1787 1789 1801 1811
+ 1823 1831 1847 1861 1867 1871 1873 1877 1879 1889
+ 1901 1907 1913 1931 1933 1949 1951 1973 1979 1987
+ 1993 1997 1999 2003 2011 2017 2027 2029 2039 2053
+ 2063 2069 2081 2083 2087 2089 2099 2111 2113 2129
+ 2131 2137 2141 2143 2153 2161 2179 2203 2207 2213
+ 2221 2237 2239 2243 2251 2267 2269 2273 2281 2287
+ 2293 2297 2309 2311 2333 2339 2341 2347 2351 2357
+ 2371 2377 2381 2383 2389 2393 2399 2411 2417 2423
+ 2437 2441 2447 2459 2467 2473 2477 2503 2521 2531
+ 2539 2543 2549 2551 2557 2579 2591 2593 2609 2617
+ 2621 2633 2647 2657 2659 2663 2671 2677 2683 2687
+ 2689 2693 2699 2707 2711 2713 2719 2729 2731 2741
+ 2749 2753 2767 2777 2789 2791 2797 2801 2803 2819
+ 2833 2837 2843 2851 2857 2861 2879 2887 2897 2903
+ 2909 2917 2927 2939 2953 2957 2963 2969 2971 2999
+ 3001 3011 3019 3023 3037 3041 3049 3061 3067 3079
+ 3083 3089 3109 3119 3121 3137 3163 3167 3169 3181
+ 3187 3191 3203 3209 3217 3221 3229 3251 3253 3257
+ 3259 3271 3299 3301 3307 3313 3319 3323 3329 3331
+ 3343 3347 3359 3361 3371 3373 3389 3391 3407 3413
+ 3433 3449 3457 3461 3463 3467 3469 3491 3499 3511
+ 3517 3527 3529 3533 3539 3541 3547 3557 3559 3571
+ 3581 3583 3593 3607 3613 3617 3623 3631 3637 3643
+ 3659 3671 3673 3677 3691 3697 3701 3709 3719 3727
+ 3733 3739 3761 3767 3769 3779 3793 3797 3803 3821
+ 3823 3833 3847 3851 3853 3863 3877 3881 3889 3907
+ 3911 3917 3919 3923 3929 3931 3943 3947 3967 3989
+ 4001 4003 4007 4013 4019 4021 4027 4049 4051 4057
+ 4073 4079 4091 4093 4099 4111 4127 4129 4133 4139
+ 4153 4157 4159 4177 4201 4211 4217 4219 4229 4231
+ 4241 4243 4253 4259 4261 4271 4273 4283 4289 4297
+ 4327 4337 4339 4349 4357 4363 4373 4391 4397 4409
+ 4421 4423 4441 4447 4451 4457 4463 4481 4483 4493
+ 4507 4513 4517 4519 4523 4547 4549 4561 4567 4583
+ 4591 4597 4603 4621 4637 4639 4643 4649 4651 4657
+ 4663 4673 4679 4691 4703 4721 4723 4729 4733 4751
+ 4759 4783 4787 4789 4793 4799 4801 4813 4817 4831
+ 4861 4871 4877 4889 4903 4909 4919 4931 4933 4937
+ 4943 4951 4957 4967 4969 4973 4987 4993 4999 5003
+ 5009 5011 5021 5023 5039 5051 5059 5077 5081 5087
+ 5099 5101 5107 5113 5119 5147 5153 5167 5171 5179
+ 5189 5197 5209 5227 5231 5233 5237 5261 5273 5279
+ 5281 5297 5303 5309 5323 5333 5347 5351 5381 5387
+ 5393 5399 5407 5413 5417 5419 5431 5437 5441 5443
+ 5449 5471 5477 5479 5483 5501 5503 5507 5519 5521
+ 5527 5531 5557 5563 5569 5573 5581 5591 5623 5639
+ 5641 5647 5651 5653 5657 5659 5669 5683 5689 5693
+ 5701 5711 5717 5737 5741 5743 5749 5779 5783 5791
+ 5801 5807 5813 5821 5827 5839 5843 5849 5851 5857
+ 5861 5867 5869 5879 5881 5897 5903 5923 5927 5939
+ 5953 5981 5987 6007 6011 6029 6037 6043 6047 6053
+ 6067 6073 6079 6089 6091 6101 6113 6121 6131 6133
+ 6143 6151 6163 6173 6197 6199 6203 6211 6217 6221
+ 6229 6247 6257 6263 6269 6271 6277 6287 6299 6301
+ 6311 6317 6323 6329 6337 6343 6353 6359 6361 6367
+ 6373 6379 6389 6397 6421 6427 6449 6451 6469 6473
+ 6481 6491 6521 6529 6547 6551 6553 6563 6569 6571
+ 6577 6581 6599 6607 6619 6637 6653 6659 6661 6673
+ 6679 6689 6691 6701 6703 6709 6719 6733 6737 6761
+ 6763 6779 6781 6791 6793 6803 6823 6827 6829 6833
+ 6841 6857 6863 6869 6871 6883 6899 6907 6911 6917
+ 6947 6949 6959 6961 6967 6971 6977 6983 6991 6997
+ 7001 7013 7019 7027 7039 7043 7057 7069 7079 7103
+ 7109 7121 7127 7129 7151 7159 7177 7187 7193 7207
+ 7211 7213 7219 7229 7237 7243 7247 7253 7283 7297
+ 7307 7309 7321 7331 7333 7349 7351 7369 7393 7411
+ 7417 7433 7451 7457 7459 7477 7481 7487 7489 7499
+ 7507 7517 7523 7529 7537 7541 7547 7549 7559 7561
+ 7573 7577 7583 7589 7591 7603 7607 7621 7639 7643
+ 7649 7669 7673 7681 7687 7691 7699 7703 7717 7723
+ 7727 7741 7753 7757 7759 7789 7793 7817 7823 7829
+ 7841 7853 7867 7873 7877 7879 7883 7901 7907 7919
+ 7927 7933 7937 7949 7951 7963 7993 8009 8011 8017
+ 8039 8053 8059 8069 8081 8087 8089 8093 8101 8111
+ 8117 8123 8147 8161 8167 8171 8179 8191 8209 8219
+ 8221 8231 8233 8237 8243 8263 8269 8273 8287 8291
+ 8293 8297 8311 8317 8329 8353 8363 8369 8377 8387
+ 8389 8419 8423 8429 8431 8443 8447 8461 8467 8501
+ 8513 8521 8527 8537 8539 8543 8563 8573 8581 8597
+ 8599 8609 8623 8627 8629 8641 8647 8663 8669 8677
+ 8681 8689 8693 8699 8707 8713 8719 8731 8737 8741
+ 8747 8753 8761 8779 8783 8803 8807 8819 8821 8831
+ 8837 8839 8849 8861 8863 8867 8887 8893 8923 8929
+ 8933 8941 8951 8963 8969 8971 8999 9001 9007 9011
+ 9013 9029 9041 9043 9049 9059 9067 9091 9103 9109
+ 9127 9133 9137 9151 9157 9161 9173 9181 9187 9199
+ 9203 9209 9221 9227 9239 9241 9257 9277 9281 9283
+ 9293 9311 9319 9323 9337 9341 9343 9349 9371 9377
+ 9391 9397 9403 9413 9419 9421 9431 9433 9437 9439
+ 9461 9463 9467 9473 9479 9491 9497 9511 9521 9533
+ 9539 9547 9551 9587 9601 9613 9619 9623 9629 9631
+ 9643 9649 9661 9677 9679 9689 9697 9719 9721 9733
+ 9739 9743 9749 9767 9769 9781 9787 9791 9803 9811
+ 9817 9829 9833 9839 9851 9857 9859 9871 9883 9887
+ 9901 9907 9923 9929 9931 9941 9949 9967 9973 10007
+ 10009 10037 10039 10061 10067 10069 10079 10091 10093 10099
+ 10103 10111 10133 10139 10141 10151 10159 10163 10169 10177
+ 10181 10193 10211 10223 10243 10247 10253 10259 10267 10271
+ 10273 10289 10301 10303 10313 10321 10331 10333 10337 10343
+ 10357 10369 10391 10399 10427 10429 10433 10453 10457 10459
+ 10463 10477 10487 10499 10501 10513 10529 10531 10559 10567
+ 10589 10597 10601 10607 10613 10627 10631 10639 10651 10657
+ 10663 10667 10687 10691 10709 10711 10723 10729 10733 10739
+ 10753 10771 10781 10789 10799 10831 10837 10847 10853 10859
+ 10861 10867 10883 10889 10891 10903 10909 10937 10939 10949
+ 10957 10973 10979 10987 10993 11003 11027 11047 11057 11059
+ 11069 11071 11083 11087 11093 11113 11117 11119 11131 11149
+ 11159 11161 11171 11173 11177 11197 11213 11239 11243 11251
+ 11257 11261 11273 11279 11287 11299 11311 11317 11321 11329
+ 11351 11353 11369 11383 11393 11399 11411 11423 11437 11443
+ 11447 11467 11471 11483 11489 11491 11497 11503 11519 11527
+ 11549 11551 11579 11587 11593 11597 11617 11621 11633 11657
+ 11677 11681 11689 11699 11701 11717 11719 11731 11743 11777
+ 11779 11783 11789 11801 11807 11813 11821 11827 11831 11833
+ 11839 11863 11867 11887 11897 11903 11909 11923 11927 11933
+ 11939 11941 11953 11959 11969 11971 11981 11987 12007 12011
+ 12037 12041 12043 12049 12071 12073 12097 12101 12107 12109
+ 12113 12119 12143 12149 12157 12161 12163 12197 12203 12211
+ 12227 12239 12241 12251 12253 12263 12269 12277 12281 12289
+ 12301 12323 12329 12343 12347 12373 12377 12379 12391 12401
+ 12409 12413 12421 12433 12437 12451 12457 12473 12479 12487
+ 12491 12497 12503 12511 12517 12527 12539 12541 12547 12553
+ 12569 12577 12583 12589 12601 12611 12613 12619 12637 12641
+ 12647 12653 12659 12671 12689 12697 12703 12713 12721 12739
+ 12743 12757 12763 12781 12791 12799 12809 12821 12823 12829
+ 12841 12853 12889 12893 12899 12907 12911 12917 12919 12923
+ 12941 12953 12959 12967 12973 12979 12983 13001 13003 13007
+ 13009 13033 13037 13043 13049 13063 13093 13099 13103 13109
+ 13121 13127 13147 13151 13159 13163 13171 13177 13183 13187
+ 13217 13219 13229 13241 13249 13259 13267 13291 13297 13309
+ 13313 13327 13331 13337 13339 13367 13381 13397 13399 13411
+ 13417 13421 13441 13451 13457 13463 13469 13477 13487 13499
+ 13513 13523 13537 13553 13567 13577 13591 13597 13613 13619
+ 13627 13633 13649 13669 13679 13681 13687 13691 13693 13697
+ 13709 13711 13721 13723 13729 13751 13757 13759 13763 13781
+ 13789 13799 13807 13829 13831 13841 13859 13873 13877 13879
+ 13883 13901 13903 13907 13913 13921 13931 13933 13963 13967
+ 13997 13999 14009 14011 14029 14033 14051 14057 14071 14081
+ 14083 14087 14107 14143 14149 14153 14159 14173 14177 14197
+ 14207 14221 14243 14249 14251 14281 14293 14303 14321 14323
+ 14327 14341 14347 14369 14387 14389 14401 14407 14411 14419
+ 14423 14431 14437 14447 14449 14461 14479 14489 14503 14519
+ 14533 14537 14543 14549 14551 14557 14561 14563 14591 14593
+ 14621 14627 14629 14633 14639 14653 14657 14669 14683 14699
+ 14713 14717 14723 14731 14737 14741 14747 14753 14759 14767
+ 14771 14779 14783 14797 14813 14821 14827 14831 14843 14851
+ 14867 14869 14879 14887 14891 14897 14923 14929 14939 14947
+ 14951 14957 14969 14983 15013 15017 15031 15053 15061 15073
+ 15077 15083 15091 15101 15107 15121 15131 15137 15139 15149
+ 15161 15173 15187 15193 15199 15217 15227 15233 15241 15259
+ 15263 15269 15271 15277 15287 15289 15299 15307 15313 15319
+ 15329 15331 15349 15359 15361 15373 15377 15383 15391 15401
+ 15413 15427 15439 15443 15451 15461 15467 15473 15493 15497
+ 15511 15527 15541 15551 15559 15569 15581 15583 15601 15607
+ 15619 15629 15641 15643 15647 15649 15661 15667 15671 15679
+ 15683 15727 15731 15733 15737 15739 15749 15761 15767 15773
+ 15787 15791 15797 15803 15809 15817 15823 15859 15877 15881
+ 15887 15889 15901 15907 15913 15919 15923 15937 15959 15971
+ 15973 15991 16001 16007 16033 16057 16061 16063 16067 16069
+ 16073 16087 16091 16097 16103 16111 16127 16139 16141 16183
+ 16187 16189 16193 16217 16223 16229 16231 16249 16253 16267
+ 16273 16301 16319 16333 16339 16349 16361 16363 16369 16381
+ 16411 16417 16421 16427 16433 16447 16451 16453 16477 16481
+ 16487 16493 16519 16529 16547 16553 16561 16567 16573 16603
+ 16607 16619 16631 16633 16649 16651 16657 16661 16673 16691
+ 16693 16699 16703 16729 16741 16747 16759 16763 16787 16811
+ 16823 16829 16831 16843 16871 16879 16883 16889 16901 16903
+ 16921 16927 16931 16937 16943 16963 16979 16981 16987 16993
+ 17011 17021 17027 17029 17033 17041 17047 17053 17077 17093
+ 17099 17107 17117 17123 17137 17159 17167 17183 17189 17191
+ 17203 17207 17209 17231 17239 17257 17291 17293 17299 17317
+ 17321 17327 17333 17341 17351 17359 17377 17383 17387 17389
+ 17393 17401 17417 17419 17431 17443 17449 17467 17471 17477
+ 17483 17489 17491 17497 17509 17519 17539 17551 17569 17573
+ 17579 17581 17597 17599 17609 17623 17627 17657 17659 17669
+ 17681 17683 17707 17713 17729 17737 17747 17749 17761 17783
+ 17789 17791 17807 17827 17837 17839 17851 17863 17881 17891
+ 17903 17909 17911 17921 17923 17929 17939 17957 17959 17971
+ 17977 17981 17987 17989 18013 18041 18043 18047 18049 18059
+ 18061 18077 18089 18097 18119 18121 18127 18131 18133 18143
+ 18149 18169 18181 18191 18199 18211 18217 18223 18229 18233
+ 18251 18253 18257 18269 18287 18289 18301 18307 18311 18313
+ 18329 18341 18353 18367 18371 18379 18397 18401 18413 18427
+ 18433 18439 18443 18451 18457 18461 18481 18493 18503 18517
+ 18521 18523 18539 18541 18553 18583 18587 18593 18617 18637
+ 18661 18671 18679 18691 18701 18713 18719 18731 18743 18749
+ 18757 18773 18787 18793 18797 18803 18839 18859 18869 18899
+ 18911 18913 18917 18919 18947 18959 18973 18979 19001 19009
+ 19013 19031 19037 19051 19069 19073 19079 19081 19087 19121
+ 19139 19141 19157 19163 19181 19183 19207 19211 19213 19219
+ 19231 19237 19249 19259 19267 19273 19289 19301 19309 19319
+ 19333 19373 19379 19381 19387 19391 19403 19417 19421 19423
+ 19427 19429 19433 19441 19447 19457 19463 19469 19471 19477
+ 19483 19489 19501 19507 19531 19541 19543 19553 19559 19571
+ 19577 19583 19597 19603 19609 19661 19681 19687 19697 19699
+ 19709 19717 19727 19739 19751 19753 19759 19763 19777 19793
+ 19801 19813 19819 19841 19843 19853 19861 19867 19889 19891
+ 19913 19919 19927 19937 19949 19961 19963 19973 19979 19991
+ 19993 19997 20011 20021 20023 20029 20047 20051 20063 20071
+ 20089 20101 20107 20113 20117 20123 20129 20143 20147 20149
+ 20161 20173 20177 20183 20201 20219 20231 20233 20249 20261
+ 20269 20287 20297 20323 20327 20333 20341 20347 20353 20357
+ 20359 20369 20389 20393 20399 20407 20411 20431 20441 20443
+ 20477 20479 20483 20507 20509 20521 20533 20543 20549 20551
+ 20563 20593 20599 20611 20627 20639 20641 20663 20681 20693
+ 20707 20717 20719 20731 20743 20747 20749 20753 20759 20771
+ 20773 20789 20807 20809 20849 20857 20873 20879 20887 20897
+ 20899 20903 20921 20929 20939 20947 20959 20963 20981 20983
+ 21001 21011 21013 21017 21019 21023 21031 21059 21061 21067
+ 21089 21101 21107 21121 21139 21143 21149 21157 21163 21169
+ 21179 21187 21191 21193 21211 21221 21227 21247 21269 21277
+ 21283 21313 21317 21319 21323 21341 21347 21377 21379 21383
+ 21391 21397 21401 21407 21419 21433 21467 21481 21487 21491
+ 21493 21499 21503 21517 21521 21523 21529 21557 21559 21563
+ 21569 21577 21587 21589 21599 21601 21611 21613 21617 21647
+ 21649 21661 21673 21683 21701 21713 21727 21737 21739 21751
+ 21757 21767 21773 21787 21799 21803 21817 21821 21839 21841
+ 21851 21859 21863 21871 21881 21893 21911 21929 21937 21943
+ 21961 21977 21991 21997 22003 22013 22027 22031 22037 22039
+ 22051 22063 22067 22073 22079 22091 22093 22109 22111 22123
+ 22129 22133 22147 22153 22157 22159 22171 22189 22193 22229
+ 22247 22259 22271 22273 22277 22279 22283 22291 22303 22307
+ 22343 22349 22367 22369 22381 22391 22397 22409 22433 22441
+ 22447 22453 22469 22481 22483 22501 22511 22531 22541 22543
+ 22549 22567 22571 22573 22613 22619 22621 22637 22639 22643
+ 22651 22669 22679 22691 22697 22699 22709 22717 22721 22727
+ 22739 22741 22751 22769 22777 22783 22787 22807 22811 22817
+ 22853 22859 22861 22871 22877 22901 22907 22921 22937 22943
+ 22961 22963 22973 22993 23003 23011 23017 23021 23027 23029
+ 23039 23041 23053 23057 23059 23063 23071 23081 23087 23099
+ 23117 23131 23143 23159 23167 23173 23189 23197 23201 23203
+ 23209 23227 23251 23269 23279 23291 23293 23297 23311 23321
+ 23327 23333 23339 23357 23369 23371 23399 23417 23431 23447
+ 23459 23473 23497 23509 23531 23537 23539 23549 23557 23561
+ 23563 23567 23581 23593 23599 23603 23609 23623 23627 23629
+ 23633 23663 23669 23671 23677 23687 23689 23719 23741 23743
+ 23747 23753 23761 23767 23773 23789 23801 23813 23819 23827
+ 23831 23833 23857 23869 23873 23879 23887 23893 23899 23909
+ 23911 23917 23929 23957 23971 23977 23981 23993 24001 24007
+ 24019 24023 24029 24043 24049 24061 24071 24077 24083 24091
+ 24097 24103 24107 24109 24113 24121 24133 24137 24151 24169
+ 24179 24181 24197 24203 24223 24229 24239 24247 24251 24281
+ 24317 24329 24337 24359 24371 24373 24379 24391 24407 24413
+ 24419 24421 24439 24443 24469 24473 24481 24499 24509 24517
+ 24527 24533 24547 24551 24571 24593 24611 24623 24631 24659
+ 24671 24677 24683 24691 24697 24709 24733 24749 24763 24767
+ 24781 24793 24799 24809 24821 24841 24847 24851 24859 24877
+ 24889 24907 24917 24919 24923 24943 24953 24967 24971 24977
+ 24979 24989 25013 25031 25033 25037 25057 25073 25087 25097
+ 25111 25117 25121 25127 25147 25153 25163 25169 25171 25183
+ 25189 25219 25229 25237 25243 25247 25253 25261 25301 25303
+ 25307 25309 25321 25339 25343 25349 25357 25367 25373 25391
+ 25409 25411 25423 25439 25447 25453 25457 25463 25469 25471
+ 25523 25537 25541 25561 25577 25579 25583 25589 25601 25603
+ 25609 25621 25633 25639 25643 25657 25667 25673 25679 25693
+ 25703 25717 25733 25741 25747 25759 25763 25771 25793 25799
+ 25801 25819 25841 25847 25849 25867 25873 25889 25903 25913
+ 25919 25931 25933 25939 25943 25951 25969 25981 25997 25999
+ 26003 26017 26021 26029 26041 26053 26083 26099 26107 26111
+ 26113 26119 26141 26153 26161 26171 26177 26183 26189 26203
+ 26209 26227 26237 26249 26251 26261 26263 26267 26293 26297
+ 26309 26317 26321 26339 26347 26357 26371 26387 26393 26399
+ 26407 26417 26423 26431 26437 26449 26459 26479 26489 26497
+ 26501 26513 26539 26557 26561 26573 26591 26597 26627 26633
+ 26641 26647 26669 26681 26683 26687 26693 26699 26701 26711
+ 26713 26717 26723 26729 26731 26737 26759 26777 26783 26801
+ 26813 26821 26833 26839 26849 26861 26863 26879 26881 26891
+ 26893 26903 26921 26927 26947 26951 26953 26959 26981 26987
+ 26993 27011 27017 27031 27043 27059 27061 27067 27073 27077
+ 27091 27103 27107 27109 27127 27143 27179 27191 27197 27211
+ 27239 27241 27253 27259 27271 27277 27281 27283 27299 27329
+ 27337 27361 27367 27397 27407 27409 27427 27431 27437 27449
+ 27457 27479 27481 27487 27509 27527 27529 27539 27541 27551
+ 27581 27583 27611 27617 27631 27647 27653 27673 27689 27691
+ 27697 27701 27733 27737 27739 27743 27749 27751 27763 27767
+ 27773 27779 27791 27793 27799 27803 27809 27817 27823 27827
+ 27847 27851 27883 27893 27901 27917 27919 27941 27943 27947
+ 27953 27961 27967 27983 27997 28001 28019 28027 28031 28051
+ 28057 28069 28081 28087 28097 28099 28109 28111 28123 28151
+ 28163 28181 28183 28201 28211 28219 28229 28277 28279 28283
+ 28289 28297 28307 28309 28319 28349 28351 28387 28393 28403
+ 28409 28411 28429 28433 28439 28447 28463 28477 28493 28499
+ 28513 28517 28537 28541 28547 28549 28559 28571 28573 28579
+ 28591 28597 28603 28607 28619 28621 28627 28631 28643 28649
+ 28657 28661 28663 28669 28687 28697 28703 28711 28723 28729
+ 28751 28753 28759 28771 28789 28793 28807 28813 28817 28837
+ 28843 28859 28867 28871 28879 28901 28909 28921 28927 28933
+ 28949 28961 28979 29009 29017 29021 29023 29027 29033 29059
+ 29063 29077 29101 29123 29129 29131 29137 29147 29153 29167
+ 29173 29179 29191 29201 29207 29209 29221 29231 29243 29251
+ 29269 29287 29297 29303 29311 29327 29333 29339 29347 29363
+ 29383 29387 29389 29399 29401 29411 29423 29429 29437 29443
+ 29453 29473 29483 29501 29527 29531 29537 29567 29569 29573
+ 29581 29587 29599 29611 29629 29633 29641 29663 29669 29671
+ 29683 29717 29723 29741 29753 29759 29761 29789 29803 29819
+ 29833 29837 29851 29863 29867 29873 29879 29881 29917 29921
+ 29927 29947 29959 29983 29989 30011 30013 30029 30047 30059
+ 30071 30089 30091 30097 30103 30109 30113 30119 30133 30137
+ 30139 30161 30169 30181 30187 30197 30203 30211 30223 30241
+ 30253 30259 30269 30271 30293 30307 30313 30319 30323 30341
+ 30347 30367 30389 30391 30403 30427 30431 30449 30467 30469
+ 30491 30493 30497 30509 30517 30529 30539 30553 30557 30559
+ 30577 30593 30631 30637 30643 30649 30661 30671 30677 30689
+ 30697 30703 30707 30713 30727 30757 30763 30773 30781 30803
+ 30809 30817 30829 30839 30841 30851 30853 30859 30869 30871
+ 30881 30893 30911 30931 30937 30941 30949 30971 30977 30983
+ 31013 31019 31033 31039 31051 31063 31069 31079 31081 31091
+ 31121 31123 31139 31147 31151 31153 31159 31177 31181 31183
+ 31189 31193 31219 31223 31231 31237 31247 31249 31253 31259
+ 31267 31271 31277 31307 31319 31321 31327 31333 31337 31357
+ 31379 31387 31391 31393 31397 31469 31477 31481 31489 31511
+ 31513 31517 31531 31541 31543 31547 31567 31573 31583 31601
+ 31607 31627 31643 31649 31657 31663 31667 31687 31699 31721
+ 31723 31727 31729 31741 31751 31769 31771 31793 31799 31817
+ 31847 31849 31859 31873 31883 31891 31907 31957 31963 31973
+ 31981 31991 32003 32009 32027 32029 32051 32057 32059 32063
+ 32069 32077 32083 32089 32099 32117 32119 32141 32143 32159
+ 32173 32183 32189 32191 32203 32213 32233 32237 32251 32257
+ 32261 32297 32299 32303 32309 32321 32323 32327 32341 32353
+ 32359 32363 32369 32371 32377 32381 32401 32411 32413 32423
+ 32429 32441 32443 32467 32479 32491 32497 32503 32507 32531
+ 32533 32537 32561 32563 32569 32573 32579 32587 32603 32609
+ 32611 32621 32633 32647 32653 32687 32693 32707 32713 32717
+ 32719 32749 32771 32779 32783 32789 32797 32801 32803 32831
+ 32833 32839 32843 32869 32887 32909 32911 32917 32933 32939
+ 32941 32957 32969 32971 32983 32987 32993 32999 33013 33023
+ 33029 33037 33049 33053 33071 33073 33083 33091 33107 33113
+ 33119 33149 33151 33161 33179 33181 33191 33199 33203 33211
+ 33223 33247 33287 33289 33301 33311 33317 33329 33331 33343
+ 33347 33349 33353 33359 33377 33391 33403 33409 33413 33427
+ 33457 33461 33469 33479 33487 33493 33503 33521 33529 33533
+ 33547 33563 33569 33577 33581 33587 33589 33599 33601 33613
+ 33617 33619 33623 33629 33637 33641 33647 33679 33703 33713
+ 33721 33739 33749 33751 33757 33767 33769 33773 33791 33797
+ 33809 33811 33827 33829 33851 33857 33863 33871 33889 33893
+ 33911 33923 33931 33937 33941 33961 33967 33997 34019 34031
+ 34033 34039 34057 34061 34123 34127 34129 34141 34147 34157
+ 34159 34171 34183 34211 34213 34217 34231 34253 34259 34261
+ 34267 34273 34283 34297 34301 34303 34313 34319 34327 34337
+ 34351 34361 34367 34369 34381 34403 34421 34429 34439 34457
+ 34469 34471 34483 34487 34499 34501 34511 34513 34519 34537
+ 34543 34549 34583 34589 34591 34603 34607 34613 34631 34649
+ 34651 34667 34673 34679 34687 34693 34703 34721 34729 34739
+ 34747 34757 34759 34763 34781 34807 34819 34841 34843 34847
+ 34849 34871 34877 34883 34897 34913 34919 34939 34949 34961
+ 34963 34981 35023 35027 35051 35053 35059 35069 35081 35083
+ 35089 35099 35107 35111 35117 35129 35141 35149 35153 35159
+ 35171 35201 35221 35227 35251 35257 35267 35279 35281 35291
+ 35311 35317 35323 35327 35339 35353 35363 35381 35393 35401
+ 35407 35419 35423 35437 35447 35449 35461 35491 35507 35509
+ 35521 35527 35531 35533 35537 35543 35569 35573 35591 35593
+ 35597 35603 35617 35671 35677 35729 35731 35747 35753 35759
+ 35771 35797 35801 35803 35809 35831 35837 35839 35851 35863
+ 35869 35879 35897 35899 35911 35923 35933 35951 35963 35969
+ 35977 35983 35993 35999 36007 36011 36013 36017 36037 36061
+ 36067 36073 36083 36097 36107 36109 36131 36137 36151 36161
+ 36187 36191 36209 36217 36229 36241 36251 36263 36269 36277
+ 36293 36299 36307 36313 36319 36341 36343 36353 36373 36383
+ 36389 36433 36451 36457 36467 36469 36473 36479 36493 36497
+ 36523 36527 36529 36541 36551 36559 36563 36571 36583 36587
+ 36599 36607 36629 36637 36643 36653 36671 36677 36683 36691
+ 36697 36709 36713 36721 36739 36749 36761 36767 36779 36781
+ 36787 36791 36793 36809 36821 36833 36847 36857 36871 36877
+ 36887 36899 36901 36913 36919 36923 36929 36931 36943 36947
+ 36973 36979 36997 37003 37013 37019 37021 37039 37049 37057
+ 37061 37087 37097 37117 37123 37139 37159 37171 37181 37189
+ 37199 37201 37217 37223 37243 37253 37273 37277 37307 37309
+ 37313 37321 37337 37339 37357 37361 37363 37369 37379 37397
+ 37409 37423 37441 37447 37463 37483 37489 37493 37501 37507
+ 37511 37517 37529 37537 37547 37549 37561 37567 37571 37573
+ 37579 37589 37591 37607 37619 37633 37643 37649 37657 37663
+ 37691 37693 37699 37717 37747 37781 37783 37799 37811 37813
+ 37831 37847 37853 37861 37871 37879 37889 37897 37907 37951
+ 37957 37963 37967 37987 37991 37993 37997 38011 38039 38047
+ 38053 38069 38083 38113 38119 38149 38153 38167 38177 38183
+ 38189 38197 38201 38219 38231 38237 38239 38261 38273 38281
+ 38287 38299 38303 38317 38321 38327 38329 38333 38351 38371
+ 38377 38393 38431 38447 38449 38453 38459 38461 38501 38543
+ 38557 38561 38567 38569 38593 38603 38609 38611 38629 38639
+ 38651 38653 38669 38671 38677 38693 38699 38707 38711 38713
+ 38723 38729 38737 38747 38749 38767 38783 38791 38803 38821
+ 38833 38839 38851 38861 38867 38873 38891 38903 38917 38921
+ 38923 38933 38953 38959 38971 38977 38993 39019 39023 39041
+ 39043 39047 39079 39089 39097 39103 39107 39113 39119 39133
+ 39139 39157 39161 39163 39181 39191 39199 39209 39217 39227
+ 39229 39233 39239 39241 39251 39293 39301 39313 39317 39323
+ 39341 39343 39359 39367 39371 39373 39383 39397 39409 39419
+ 39439 39443 39451 39461 39499 39503 39509 39511 39521 39541
+ 39551 39563 39569 39581 39607 39619 39623 39631 39659 39667
+ 39671 39679 39703 39709 39719 39727 39733 39749 39761 39769
+ 39779 39791 39799 39821 39827 39829 39839 39841 39847 39857
+ 39863 39869 39877 39883 39887 39901 39929 39937 39953 39971
+ 39979 39983 39989 40009 40013 40031 40037 40039 40063 40087
+ 40093 40099 40111 40123 40127 40129 40151 40153 40163 40169
+ 40177 40189 40193 40213 40231 40237 40241 40253 40277 40283
+ 40289 40343 40351 40357 40361 40387 40423 40427 40429 40433
+ 40459 40471 40483 40487 40493 40499 40507 40519 40529 40531
+ 40543 40559 40577 40583 40591 40597 40609 40627 40637 40639
+ 40693 40697 40699 40709 40739 40751 40759 40763 40771 40787
+ 40801 40813 40819 40823 40829 40841 40847 40849 40853 40867
+ 40879 40883 40897 40903 40927 40933 40939 40949 40961 40973
+ 40993 41011 41017 41023 41039 41047 41051 41057 41077 41081
+ 41113 41117 41131 41141 41143 41149 41161 41177 41179 41183
+ 41189 41201 41203 41213 41221 41227 41231 41233 41243 41257
+ 41263 41269 41281 41299 41333 41341 41351 41357 41381 41387
+ 41389 41399 41411 41413 41443 41453 41467 41479 41491 41507
+ 41513 41519 41521 41539 41543 41549 41579 41593 41597 41603
+ 41609 41611 41617 41621 41627 41641 41647 41651 41659 41669
+ 41681 41687 41719 41729 41737 41759 41761 41771 41777 41801
+ 41809 41813 41843 41849 41851 41863 41879 41887 41893 41897
+ 41903 41911 41927 41941 41947 41953 41957 41959 41969 41981
+ 41983 41999 42013 42017 42019 42023 42043 42061 42071 42073
+ 42083 42089 42101 42131 42139 42157 42169 42179 42181 42187
+ 42193 42197 42209 42221 42223 42227 42239 42257 42281 42283
+ 42293 42299 42307 42323 42331 42337 42349 42359 42373 42379
+ 42391 42397 42403 42407 42409 42433 42437 42443 42451 42457
+ 42461 42463 42467 42473 42487 42491 42499 42509 42533 42557
+ 42569 42571 42577 42589 42611 42641 42643 42649 42667 42677
+ 42683 42689 42697 42701 42703 42709 42719 42727 42737 42743
+ 42751 42767 42773 42787 42793 42797 42821 42829 42839 42841
+ 42853 42859 42863 42899 42901 42923 42929 42937 42943 42953
+ 42961 42967 42979 42989 43003 43013 43019 43037 43049 43051
+ 43063 43067 43093 43103 43117 43133 43151 43159 43177 43189
+ 43201 43207 43223 43237 43261 43271 43283 43291 43313 43319
+ 43321 43331 43391 43397 43399 43403 43411 43427 43441 43451
+ 43457 43481 43487 43499 43517 43541 43543 43573 43577 43579
+ 43591 43597 43607 43609 43613 43627 43633 43649 43651 43661
+ 43669 43691 43711 43717 43721 43753 43759 43777 43781 43783
+ 43787 43789 43793 43801 43853 43867 43889 43891 43913 43933
+ 43943 43951 43961 43963 43969 43973 43987 43991 43997 44017
+ 44021 44027 44029 44041 44053 44059 44071 44087 44089 44101
+ 44111 44119 44123 44129 44131 44159 44171 44179 44189 44201
+ 44203 44207 44221 44249 44257 44263 44267 44269 44273 44279
+ 44281 44293 44351 44357 44371 44381 44383 44389 44417 44449
+ 44453 44483 44491 44497 44501 44507 44519 44531 44533 44537
+ 44543 44549 44563 44579 44587 44617 44621 44623 44633 44641
+ 44647 44651 44657 44683 44687 44699 44701 44711 44729 44741
+ 44753 44771 44773 44777 44789 44797 44809 44819 44839 44843
+ 44851 44867 44879 44887 44893 44909 44917 44927 44939 44953
+ 44959 44963 44971 44983 44987 45007 45013 45053 45061 45077
+ 45083 45119 45121 45127 45131 45137 45139 45161 45179 45181
+ 45191 45197 45233 45247 45259 45263 45281 45289 45293 45307
+ 45317 45319 45329 45337 45341 45343 45361 45377 45389 45403
+ 45413 45427 45433 45439 45481 45491 45497 45503 45523 45533
+ 45541 45553 45557 45569 45587 45589 45599 45613 45631 45641
+ 45659 45667 45673 45677 45691 45697 45707 45737 45751 45757
+ 45763 45767 45779 45817 45821 45823 45827 45833 45841 45853
+ 45863 45869 45887 45893 45943 45949 45953 45959 45971 45979
+ 45989 46021 46027 46049 46051 46061 46073 46091 46093 46099
+ 46103 46133 46141 46147 46153 46171 46181 46183 46187 46199
+ 46219 46229 46237 46261 46271 46273 46279 46301 46307 46309
+ 46327 46337 46349 46351 46381 46399 46411 46439 46441 46447
+ 46451 46457 46471 46477 46489 46499 46507 46511 46523 46549
+ 46559 46567 46573 46589 46591 46601 46619 46633 46639 46643
+ 46649 46663 46679 46681 46687 46691 46703 46723 46727 46747
+ 46751 46757 46769 46771 46807 46811 46817 46819 46829 46831
+ 46853 46861 46867 46877 46889 46901 46919 46933 46957 46993
+ 46997 47017 47041 47051 47057 47059 47087 47093 47111 47119
+ 47123 47129 47137 47143 47147 47149 47161 47189 47207 47221
+ 47237 47251 47269 47279 47287 47293 47297 47303 47309 47317
+ 47339 47351 47353 47363 47381 47387 47389 47407 47417 47419
+ 47431 47441 47459 47491 47497 47501 47507 47513 47521 47527
+ 47533 47543 47563 47569 47581 47591 47599 47609 47623 47629
+ 47639 47653 47657 47659 47681 47699 47701 47711 47713 47717
+ 47737 47741 47743 47777 47779 47791 47797 47807 47809 47819
+ 47837 47843 47857 47869 47881 47903 47911 47917 47933 47939
+ 47947 47951 47963 47969 47977 47981 48017 48023 48029 48049
+ 48073 48079 48091 48109 48119 48121 48131 48157 48163 48179
+ 48187 48193 48197 48221 48239 48247 48259 48271 48281 48299
+ 48311 48313 48337 48341 48353 48371 48383 48397 48407 48409
+ 48413 48437 48449 48463 48473 48479 48481 48487 48491 48497
+ 48523 48527 48533 48539 48541 48563 48571 48589 48593 48611
+ 48619 48623 48647 48649 48661 48673 48677 48679 48731 48733
+ 48751 48757 48761 48767 48779 48781 48787 48799 48809 48817
+ 48821 48823 48847 48857 48859 48869 48871 48883 48889 48907
+ 48947 48953 48973 48989 48991 49003 49009 49019 49031 49033
+ 49037 49043 49057 49069 49081 49103 49109 49117 49121 49123
+ 49139 49157 49169 49171 49177 49193 49199 49201 49207 49211
+ 49223 49253 49261 49277 49279 49297 49307 49331 49333 49339
+ 49363 49367 49369 49391 49393 49409 49411 49417 49429 49433
+ 49451 49459 49463 49477 49481 49499 49523 49529 49531 49537
+ 49547 49549 49559 49597 49603 49613 49627 49633 49639 49663
+ 49667 49669 49681 49697 49711 49727 49739 49741 49747 49757
+ 49783 49787 49789 49801 49807 49811 49823 49831 49843 49853
+ 49871 49877 49891 49919 49921 49927 49937 49939 49943 49957
+ 49991 49993 49999 50021 50023 50033 50047 50051 50053 50069
+ 50077 50087 50093 50101 50111 50119 50123 50129 50131 50147
+ 50153 50159 50177 50207 50221 50227 50231 50261 50263 50273
+ 50287 50291 50311 50321 50329 50333 50341 50359 50363 50377
+ 50383 50387 50411 50417 50423 50441 50459 50461 50497 50503
+ 50513 50527 50539 50543 50549 50551 50581 50587 50591 50593
+ 50599 50627 50647 50651 50671 50683 50707 50723 50741 50753
+ 50767 50773 50777 50789 50821 50833 50839 50849 50857 50867
+ 50873 50891 50893 50909 50923 50929 50951 50957 50969 50971
+ 50989 50993 51001 51031 51043 51047 51059 51061 51071 51109
+ 51131 51133 51137 51151 51157 51169 51193 51197 51199 51203
+ 51217 51229 51239 51241 51257 51263 51283 51287 51307 51329
+ 51341 51343 51347 51349 51361 51383 51407 51413 51419 51421
+ 51427 51431 51437 51439 51449 51461 51473 51479 51481 51487
+ 51503 51511 51517 51521 51539 51551 51563 51577 51581 51593
+ 51599 51607 51613 51631 51637 51647 51659 51673 51679 51683
+ 51691 51713 51719 51721 51749 51767 51769 51787 51797 51803
+ 51817 51827 51829 51839 51853 51859 51869 51871 51893 51899
+ 51907 51913 51929 51941 51949 51971 51973 51977 51991 52009
+ 52021 52027 52051 52057 52067 52069 52081 52103 52121 52127
+ 52147 52153 52163 52177 52181 52183 52189 52201 52223 52237
+ 52249 52253 52259 52267 52289 52291 52301 52313 52321 52361
+ 52363 52369 52379 52387 52391 52433 52453 52457 52489 52501
+ 52511 52517 52529 52541 52543 52553 52561 52567 52571 52579
+ 52583 52609 52627 52631 52639 52667 52673 52691 52697 52709
+ 52711 52721 52727 52733 52747 52757 52769 52783 52807 52813
+ 52817 52837 52859 52861 52879 52883 52889 52901 52903 52919
+ 52937 52951 52957 52963 52967 52973 52981 52999 53003 53017
+ 53047 53051 53069 53077 53087 53089 53093 53101 53113 53117
+ 53129 53147 53149 53161 53171 53173 53189 53197 53201 53231
+ 53233 53239 53267 53269 53279 53281 53299 53309 53323 53327
+ 53353 53359 53377 53381 53401 53407 53411 53419 53437 53441
+ 53453 53479 53503 53507 53527 53549 53551 53569 53591 53593
+ 53597 53609 53611 53617 53623 53629 53633 53639 53653 53657
+ 53681 53693 53699 53717 53719 53731 53759 53773 53777 53783
+ 53791 53813 53819 53831 53849 53857 53861 53881 53887 53891
+ 53897 53899 53917 53923 53927 53939 53951 53959 53987 53993
+ 54001 54011 54013 54037 54049 54059 54083 54091 54101 54121
+ 54133 54139 54151 54163 54167 54181 54193 54217 54251 54269
+ 54277 54287 54293 54311 54319 54323 54331 54347 54361 54367
+ 54371 54377 54401 54403 54409 54413 54419 54421 54437 54443
+ 54449 54469 54493 54497 54499 54503 54517 54521 54539 54541
+ 54547 54559 54563 54577 54581 54583 54601 54617 54623 54629
+ 54631 54647 54667 54673 54679 54709 54713 54721 54727 54751
+ 54767 54773 54779 54787 54799 54829 54833 54851 54869 54877
+ 54881 54907 54917 54919 54941 54949 54959 54973 54979 54983
+ 55001 55009 55021 55049 55051 55057 55061 55073 55079 55103
+ 55109 55117 55127 55147 55163 55171 55201 55207 55213 55217
+ 55219 55229 55243 55249 55259 55291 55313 55331 55333 55337
+ 55339 55343 55351 55373 55381 55399 55411 55439 55441 55457
+ 55469 55487 55501 55511 55529 55541 55547 55579 55589 55603
+ 55609 55619 55621 55631 55633 55639 55661 55663 55667 55673
+ 55681 55691 55697 55711 55717 55721 55733 55763 55787 55793
+ 55799 55807 55813 55817 55819 55823 55829 55837 55843 55849
+ 55871 55889 55897 55901 55903 55921 55927 55931 55933 55949
+ 55967 55987 55997 56003 56009 56039 56041 56053 56081 56087
+ 56093 56099 56101 56113 56123 56131 56149 56167 56171 56179
+ 56197 56207 56209 56237 56239 56249 56263 56267 56269 56299
+ 56311 56333 56359 56369 56377 56383 56393 56401 56417 56431
+ 56437 56443 56453 56467 56473 56477 56479 56489 56501 56503
+ 56509 56519 56527 56531 56533 56543 56569 56591 56597 56599
+ 56611 56629 56633 56659 56663 56671 56681 56687 56701 56711
+ 56713 56731 56737 56747 56767 56773 56779 56783 56807 56809
+ 56813 56821 56827 56843 56857 56873 56891 56893 56897 56909
+ 56911 56921 56923 56929 56941 56951 56957 56963 56983 56989
+ 56993 56999 57037 57041 57047 57059 57073 57077 57089 57097
+ 57107 57119 57131 57139 57143 57149 57163 57173 57179 57191
+ 57193 57203 57221 57223 57241 57251 57259 57269 57271 57283
+ 57287 57301 57329 57331 57347 57349 57367 57373 57383 57389
+ 57397 57413 57427 57457 57467 57487 57493 57503 57527 57529
+ 57557 57559 57571 57587 57593 57601 57637 57641 57649 57653
+ 57667 57679 57689 57697 57709 57713 57719 57727 57731 57737
+ 57751 57773 57781 57787 57791 57793 57803 57809 57829 57839
+ 57847 57853 57859 57881 57899 57901 57917 57923 57943 57947
+ 57973 57977 57991 58013 58027 58031 58043 58049 58057 58061
+ 58067 58073 58099 58109 58111 58129 58147 58151 58153 58169
+ 58171 58189 58193 58199 58207 58211 58217 58229 58231 58237
+ 58243 58271 58309 58313 58321 58337 58363 58367 58369 58379
+ 58391 58393 58403 58411 58417 58427 58439 58441 58451 58453
+ 58477 58481 58511 58537 58543 58549 58567 58573 58579 58601
+ 58603 58613 58631 58657 58661 58679 58687 58693 58699 58711
+ 58727 58733 58741 58757 58763 58771 58787 58789 58831 58889
+ 58897 58901 58907 58909 58913 58921 58937 58943 58963 58967
+ 58979 58991 58997 59009 59011 59021 59023 59029 59051 59053
+ 59063 59069 59077 59083 59093 59107 59113 59119 59123 59141
+ 59149 59159 59167 59183 59197 59207 59209 59219 59221 59233
+ 59239 59243 59263 59273 59281 59333 59341 59351 59357 59359
+ 59369 59377 59387 59393 59399 59407 59417 59419 59441 59443
+ 59447 59453 59467 59471 59473 59497 59509 59513 59539 59557
+ 59561 59567 59581 59611 59617 59621 59627 59629 59651 59659
+ 59663 59669 59671 59693 59699 59707 59723 59729 59743 59747
+ 59753 59771 59779 59791 59797 59809 59833 59863 59879 59887
+ 59921 59929 59951 59957 59971 59981 59999 60013 60017 60029
+ 60037 60041 60077 60083 60089 60091 60101 60103 60107 60127
+ 60133 60139 60149 60161 60167 60169 60209 60217 60223 60251
+ 60257 60259 60271 60289 60293 60317 60331 60337 60343 60353
+ 60373 60383 60397 60413 60427 60443 60449 60457 60493 60497
+ 60509 60521 60527 60539 60589 60601 60607 60611 60617 60623
+ 60631 60637 60647 60649 60659 60661 60679 60689 60703 60719
+ 60727 60733 60737 60757 60761 60763 60773 60779 60793 60811
+ 60821 60859 60869 60887 60889 60899 60901 60913 60917 60919
+ 60923 60937 60943 60953 60961 61001 61007 61027 61031 61043
+ 61051 61057 61091 61099 61121 61129 61141 61151 61153 61169
+ 61211 61223 61231 61253 61261 61283 61291 61297 61331 61333
+ 61339 61343 61357 61363 61379 61381 61403 61409 61417 61441
+ 61463 61469 61471 61483 61487 61493 61507 61511 61519 61543
+ 61547 61553 61559 61561 61583 61603 61609 61613 61627 61631
+ 61637 61643 61651 61657 61667 61673 61681 61687 61703 61717
+ 61723 61729 61751 61757 61781 61813 61819 61837 61843 61861
+ 61871 61879 61909 61927 61933 61949 61961 61967 61979 61981
+ 61987 61991 62003 62011 62017 62039 62047 62053 62057 62071
+ 62081 62099 62119 62129 62131 62137 62141 62143 62171 62189
+ 62191 62201 62207 62213 62219 62233 62273 62297 62299 62303
+ 62311 62323 62327 62347 62351 62383 62401 62417 62423 62459
+ 62467 62473 62477 62483 62497 62501 62507 62533 62539 62549
+ 62563 62581 62591 62597 62603 62617 62627 62633 62639 62653
+ 62659 62683 62687 62701 62723 62731 62743 62753 62761 62773
+ 62791 62801 62819 62827 62851 62861 62869 62873 62897 62903
+ 62921 62927 62929 62939 62969 62971 62981 62983 62987 62989
+ 63029 63031 63059 63067 63073 63079 63097 63103 63113 63127
+ 63131 63149 63179 63197 63199 63211 63241 63247 63277 63281
+ 63299 63311 63313 63317 63331 63337 63347 63353 63361 63367
+ 63377 63389 63391 63397 63409 63419 63421 63439 63443 63463
+ 63467 63473 63487 63493 63499 63521 63527 63533 63541 63559
+ 63577 63587 63589 63599 63601 63607 63611 63617 63629 63647
+ 63649 63659 63667 63671 63689 63691 63697 63703 63709 63719
+ 63727 63737 63743 63761 63773 63781 63793 63799 63803 63809
+ 63823 63839 63841 63853 63857 63863 63901 63907 63913 63929
+ 63949 63977 63997 64007 64013 64019 64033 64037 64063 64067
+ 64081 64091 64109 64123 64151 64153 64157 64171 64187 64189
+ 64217 64223 64231 64237 64271 64279 64283 64301 64303 64319
+ 64327 64333 64373 64381 64399 64403 64433 64439 64451 64453
+ 64483 64489 64499 64513 64553 64567 64577 64579 64591 64601
+ 64609 64613 64621 64627 64633 64661 64663 64667 64679 64693
+ 64709 64717 64747 64763 64781 64783 64793 64811 64817 64849
+ 64853 64871 64877 64879 64891 64901 64919 64921 64927 64937
+ 64951 64969 64997 65003 65011 65027 65029 65033 65053 65063
+ 65071 65089 65099 65101 65111 65119 65123 65129 65141 65147
+ 65167 65171 65173 65179 65183 65203 65213 65239 65257 65267
+ 65269 65287 65293 65309 65323 65327 65353 65357 65371 65381
+ 65393 65407 65413 65419 65423 65437 65447 65449 65479 65497
+ 65519 65521 65537 65539 65543 65551 65557 65563 65579 65581
+ 65587 65599 65609 65617 65629 65633 65647 65651 65657 65677
+ 65687 65699 65701 65707 65713 65717 65719 65729 65731 65761
+ 65777 65789 65809 65827 65831 65837 65839 65843 65851 65867
+ 65881 65899 65921 65927 65929 65951 65957 65963 65981 65983
+ 65993 66029 66037 66041 66047 66067 66071 66083 66089 66103
+ 66107 66109 66137 66161 66169 66173 66179 66191 66221 66239
+ 66271 66293 66301 66337 66343 66347 66359 66361 66373 66377
+ 66383 66403 66413 66431 66449 66457 66463 66467 66491 66499
+ 66509 66523 66529 66533 66541 66553 66569 66571 66587 66593
+ 66601 66617 66629 66643 66653 66683 66697 66701 66713 66721
+ 66733 66739 66749 66751 66763 66791 66797 66809 66821 66841
+ 66851 66853 66863 66877 66883 66889 66919 66923 66931 66943
+ 66947 66949 66959 66973 66977 67003 67021 67033 67043 67049
+ 67057 67061 67073 67079 67103 67121 67129 67139 67141 67153
+ 67157 67169 67181 67187 67189 67211 67213 67217 67219 67231
+ 67247 67261 67271 67273 67289 67307 67339 67343 67349 67369
+ 67391 67399 67409 67411 67421 67427 67429 67433 67447 67453
+ 67477 67481 67489 67493 67499 67511 67523 67531 67537 67547
+ 67559 67567 67577 67579 67589 67601 67607 67619 67631 67651
+ 67679 67699 67709 67723 67733 67741 67751 67757 67759 67763
+ 67777 67783 67789 67801 67807 67819 67829 67843 67853 67867
+ 67883 67891 67901 67927 67931 67933 67939 67943 67957 67961
+ 67967 67979 67987 67993 68023 68041 68053 68059 68071 68087
+ 68099 68111 68113 68141 68147 68161 68171 68207 68209 68213
+ 68219 68227 68239 68261 68279 68281 68311 68329 68351 68371
+ 68389 68399 68437 68443 68447 68449 68473 68477 68483 68489
+ 68491 68501 68507 68521 68531 68539 68543 68567 68581 68597
+ 68611 68633 68639 68659 68669 68683 68687 68699 68711 68713
+ 68729 68737 68743 68749 68767 68771 68777 68791 68813 68819
+ 68821 68863 68879 68881 68891 68897 68899 68903 68909 68917
+ 68927 68947 68963 68993 69001 69011 69019 69029 69031 69061
+ 69067 69073 69109 69119 69127 69143 69149 69151 69163 69191
+ 69193 69197 69203 69221 69233 69239 69247 69257 69259 69263
+ 69313 69317 69337 69341 69371 69379 69383 69389 69401 69403
+ 69427 69431 69439 69457 69463 69467 69473 69481 69491 69493
+ 69497 69499 69539 69557 69593 69623 69653 69661 69677 69691
+ 69697 69709 69737 69739 69761 69763 69767 69779 69809 69821
+ 69827 69829 69833 69847 69857 69859 69877 69899 69911 69929
+ 69931 69941 69959 69991 69997 70001 70003 70009 70019 70039
+ 70051 70061 70067 70079 70099 70111 70117 70121 70123 70139
+ 70141 70157 70163 70177 70181 70183 70199 70201 70207 70223
+ 70229 70237 70241 70249 70271 70289 70297 70309 70313 70321
+ 70327 70351 70373 70379 70381 70393 70423 70429 70439 70451
+ 70457 70459 70481 70487 70489 70501 70507 70529 70537 70549
+ 70571 70573 70583 70589 70607 70619 70621 70627 70639 70657
+ 70663 70667 70687 70709 70717 70729 70753 70769 70783 70793
+ 70823 70841 70843 70849 70853 70867 70877 70879 70891 70901
+ 70913 70919 70921 70937 70949 70951 70957 70969 70979 70981
+ 70991 70997 70999 71011 71023 71039 71059 71069 71081 71089
+ 71119 71129 71143 71147 71153 71161 71167 71171 71191 71209
+ 71233 71237 71249 71257 71261 71263 71287 71293 71317 71327
+ 71329 71333 71339 71341 71347 71353 71359 71363 71387 71389
+ 71399 71411 71413 71419 71429 71437 71443 71453 71471 71473
+ 71479 71483 71503 71527 71537 71549 71551 71563 71569 71593
+ 71597 71633 71647 71663 71671 71693 71699 71707 71711 71713
+ 71719 71741 71761 71777 71789 71807 71809 71821 71837 71843
+ 71849 71861 71867 71879 71881 71887 71899 71909 71917 71933
+ 71941 71947 71963 71971 71983 71987 71993 71999 72019 72031
+ 72043 72047 72053 72073 72077 72089 72091 72101 72103 72109
+ 72139 72161 72167 72169 72173 72211 72221 72223 72227 72229
+ 72251 72253 72269 72271 72277 72287 72307 72313 72337 72341
+ 72353 72367 72379 72383 72421 72431 72461 72467 72469 72481
+ 72493 72497 72503 72533 72547 72551 72559 72577 72613 72617
+ 72623 72643 72647 72649 72661 72671 72673 72679 72689 72701
+ 72707 72719 72727 72733 72739 72763 72767 72797 72817 72823
+ 72859 72869 72871 72883 72889 72893 72901 72907 72911 72923
+ 72931 72937 72949 72953 72959 72973 72977 72997 73009 73013
+ 73019 73037 73039 73043 73061 73063 73079 73091 73121 73127
+ 73133 73141 73181 73189 73237 73243 73259 73277 73291 73303
+ 73309 73327 73331 73351 73361 73363 73369 73379 73387 73417
+ 73421 73433 73453 73459 73471 73477 73483 73517 73523 73529
+ 73547 73553 73561 73571 73583 73589 73597 73607 73609 73613
+ 73637 73643 73651 73673 73679 73681 73693 73699 73709 73721
+ 73727 73751 73757 73771 73783 73819 73823 73847 73849 73859
+ 73867 73877 73883 73897 73907 73939 73943 73951 73961 73973
+ 73999 74017 74021 74027 74047 74051 74071 74077 74093 74099
+ 74101 74131 74143 74149 74159 74161 74167 74177 74189 74197
+ 74201 74203 74209 74219 74231 74257 74279 74287 74293 74297
+ 74311 74317 74323 74353 74357 74363 74377 74381 74383 74411
+ 74413 74419 74441 74449 74453 74471 74489 74507 74509 74521
+ 74527 74531 74551 74561 74567 74573 74587 74597 74609 74611
+ 74623 74653 74687 74699 74707 74713 74717 74719 74729 74731
+ 74747 74759 74761 74771 74779 74797 74821 74827 74831 74843
+ 74857 74861 74869 74873 74887 74891 74897 74903 74923 74929
+ 74933 74941 74959 75011 75013 75017 75029 75037 75041 75079
+ 75083 75109 75133 75149 75161 75167 75169 75181 75193 75209
+ 75211 75217 75223 75227 75239 75253 75269 75277 75289 75307
+ 75323 75329 75337 75347 75353 75367 75377 75389 75391 75401
+ 75403 75407 75431 75437 75479 75503 75511 75521 75527 75533
+ 75539 75541 75553 75557 75571 75577 75583 75611 75617 75619
+ 75629 75641 75653 75659 75679 75683 75689 75703 75707 75709
+ 75721 75731 75743 75767 75773 75781 75787 75793 75797 75821
+ 75833 75853 75869 75883 75913 75931 75937 75941 75967 75979
+ 75983 75989 75991 75997 76001 76003 76031 76039 76079 76081
+ 76091 76099 76103 76123 76129 76147 76157 76159 76163 76207
+ 76213 76231 76243 76249 76253 76259 76261 76283 76289 76303
+ 76333 76343 76367 76369 76379 76387 76403 76421 76423 76441
+ 76463 76471 76481 76487 76493 76507 76511 76519 76537 76541
+ 76543 76561 76579 76597 76603 76607 76631 76649 76651 76667
+ 76673 76679 76697 76717 76733 76753 76757 76771 76777 76781
+ 76801 76819 76829 76831 76837 76847 76871 76873 76883 76907
+ 76913 76919 76943 76949 76961 76963 76991 77003 77017 77023
+ 77029 77041 77047 77069 77081 77093 77101 77137 77141 77153
+ 77167 77171 77191 77201 77213 77237 77239 77243 77249 77261
+ 77263 77267 77269 77279 77291 77317 77323 77339 77347 77351
+ 77359 77369 77377 77383 77417 77419 77431 77447 77471 77477
+ 77479 77489 77491 77509 77513 77521 77527 77543 77549 77551
+ 77557 77563 77569 77573 77587 77591 77611 77617 77621 77641
+ 77647 77659 77681 77687 77689 77699 77711 77713 77719 77723
+ 77731 77743 77747 77761 77773 77783 77797 77801 77813 77839
+ 77849 77863 77867 77893 77899 77929 77933 77951 77969 77977
+ 77983 77999 78007 78017 78031 78041 78049 78059 78079 78101
+ 78121 78137 78139 78157 78163 78167 78173 78179 78191 78193
+ 78203 78229 78233 78241 78259 78277 78283 78301 78307 78311
+ 78317 78341 78347 78367 78401 78427 78437 78439 78467 78479
+ 78487 78497 78509 78511 78517 78539 78541 78553 78569 78571
+ 78577 78583 78593 78607 78623 78643 78649 78653 78691 78697
+ 78707 78713 78721 78737 78779 78781 78787 78791 78797 78803
+ 78809 78823 78839 78853 78857 78877 78887 78889 78893 78901
+ 78919 78929 78941 78977 78979 78989 79031 79039 79043 79063
+ 79087 79103 79111 79133 79139 79147 79151 79153 79159 79181
+ 79187 79193 79201 79229 79231 79241 79259 79273 79279 79283
+ 79301 79309 79319 79333 79337 79349 79357 79367 79379 79393
+ 79397 79399 79411 79423 79427 79433 79451 79481 79493 79531
+ 79537 79549 79559 79561 79579 79589 79601 79609 79613 79621
+ 79627 79631 79633 79657 79669 79687 79691 79693 79697 79699
+ 79757 79769 79777 79801 79811 79813 79817 79823 79829 79841
+ 79843 79847 79861 79867 79873 79889 79901 79903 79907 79939
+ 79943 79967 79973 79979 79987 79997 79999 80021 80039 80051
+ 80071 80077 80107 80111 80141 80147 80149 80153 80167 80173
+ 80177 80191 80207 80209 80221 80231 80233 80239 80251 80263
+ 80273 80279 80287 80309 80317 80329 80341 80347 80363 80369
+ 80387 80407 80429 80447 80449 80471 80473 80489 80491 80513
+ 80527 80537 80557 80567 80599 80603 80611 80621 80627 80629
+ 80651 80657 80669 80671 80677 80681 80683 80687 80701 80713
+ 80737 80747 80749 80761 80777 80779 80783 80789 80803 80809
+ 80819 80831 80833 80849 80863 80897 80909 80911 80917 80923
+ 80929 80933 80953 80963 80989 81001 81013 81017 81019 81023
+ 81031 81041 81043 81047 81049 81071 81077 81083 81097 81101
+ 81119 81131 81157 81163 81173 81181 81197 81199 81203 81223
+ 81233 81239 81281 81283 81293 81299 81307 81331 81343 81349
+ 81353 81359 81371 81373 81401 81409 81421 81439 81457 81463
+ 81509 81517 81527 81533 81547 81551 81553 81559 81563 81569
+ 81611 81619 81629 81637 81647 81649 81667 81671 81677 81689
+ 81701 81703 81707 81727 81737 81749 81761 81769 81773 81799
+ 81817 81839 81847 81853 81869 81883 81899 81901 81919 81929
+ 81931 81937 81943 81953 81967 81971 81973 82003 82007 82009
+ 82013 82021 82031 82037 82039 82051 82067 82073 82129 82139
+ 82141 82153 82163 82171 82183 82189 82193 82207 82217 82219
+ 82223 82231 82237 82241 82261 82267 82279 82301 82307 82339
+ 82349 82351 82361 82373 82387 82393 82421 82457 82463 82469
+ 82471 82483 82487 82493 82499 82507 82529 82531 82549 82559
+ 82561 82567 82571 82591 82601 82609 82613 82619 82633 82651
+ 82657 82699 82721 82723 82727 82729 82757 82759 82763 82781
+ 82787 82793 82799 82811 82813 82837 82847 82883 82889 82891
+ 82903 82913 82939 82963 82981 82997 83003 83009 83023 83047
+ 83059 83063 83071 83077 83089 83093 83101 83117 83137 83177
+ 83203 83207 83219 83221 83227 83231 83233 83243 83257 83267
+ 83269 83273 83299 83311 83339 83341 83357 83383 83389 83399
+ 83401 83407 83417 83423 83431 83437 83443 83449 83459 83471
+ 83477 83497 83537 83557 83561 83563 83579 83591 83597 83609
+ 83617 83621 83639 83641 83653 83663 83689 83701 83717 83719
+ 83737 83761 83773 83777 83791 83813 83833 83843 83857 83869
+ 83873 83891 83903 83911 83921 83933 83939 83969 83983 83987
+ 84011 84017 84047 84053 84059 84061 84067 84089 84121 84127
+ 84131 84137 84143 84163 84179 84181 84191 84199 84211 84221
+ 84223 84229 84239 84247 84263 84299 84307 84313 84317 84319
+ 84347 84349 84377 84389 84391 84401 84407 84421 84431 84437
+ 84443 84449 84457 84463 84467 84481 84499 84503 84509 84521
+ 84523 84533 84551 84559 84589 84629 84631 84649 84653 84659
+ 84673 84691 84697 84701 84713 84719 84731 84737 84751 84761
+ 84787 84793 84809 84811 84827 84857 84859 84869 84871 84913
+ 84919 84947 84961 84967 84977 84979 84991 85009 85021 85027
+ 85037 85049 85061 85081 85087 85091 85093 85103 85109 85121
+ 85133 85147 85159 85193 85199 85201 85213 85223 85229 85237
+ 85243 85247 85259 85297 85303 85313 85331 85333 85361 85363
+ 85369 85381 85411 85427 85429 85439 85447 85451 85453 85469
+ 85487 85513 85517 85523 85531 85549 85571 85577 85597 85601
+ 85607 85619 85621 85627 85639 85643 85661 85667 85669 85691
+ 85703 85711 85717 85733 85751 85781 85793 85817 85819 85829
+ 85831 85837 85843 85847 85853 85889 85903 85909 85931 85933
+ 85991 85999 86011 86017 86027 86029 86069 86077 86083 86111
+ 86113 86117 86131 86137 86143 86161 86171 86179 86183 86197
+ 86201 86209 86239 86243 86249 86257 86263 86269 86287 86291
+ 86293 86297 86311 86323 86341 86351 86353 86357 86369 86371
+ 86381 86389 86399 86413 86423 86441 86453 86461 86467 86477
+ 86491 86501 86509 86531 86533 86539 86561 86573 86579 86587
+ 86599 86627 86629 86677 86689 86693 86711 86719 86729 86743
+ 86753 86767 86771 86783 86813 86837 86843 86851 86857 86861
+ 86869 86923 86927 86929 86939 86951 86959 86969 86981 86993
+ 87011 87013 87037 87041 87049 87071 87083 87103 87107 87119
+ 87121 87133 87149 87151 87179 87181 87187 87211 87221 87223
+ 87251 87253 87257 87277 87281 87293 87299 87313 87317 87323
+ 87337 87359 87383 87403 87407 87421 87427 87433 87443 87473
+ 87481 87491 87509 87511 87517 87523 87539 87541 87547 87553
+ 87557 87559 87583 87587 87589 87613 87623 87629 87631 87641
+ 87643 87649 87671 87679 87683 87691 87697 87701 87719 87721
+ 87739 87743 87751 87767 87793 87797 87803 87811 87833 87853
+ 87869 87877 87881 87887 87911 87917 87931 87943 87959 87961
+ 87973 87977 87991 88001 88003 88007 88019 88037 88069 88079
+ 88093 88117 88129 88169 88177 88211 88223 88237 88241 88259
+ 88261 88289 88301 88321 88327 88337 88339 88379 88397 88411
+ 88423 88427 88463 88469 88471 88493 88499 88513 88523 88547
+ 88589 88591 88607 88609 88643 88651 88657 88661 88663 88667
+ 88681 88721 88729 88741 88747 88771 88789 88793 88799 88801
+ 88807 88811 88813 88817 88819 88843 88853 88861 88867 88873
+ 88883 88897 88903 88919 88937 88951 88969 88993 88997 89003
+ 89009 89017 89021 89041 89051 89057 89069 89071 89083 89087
+ 89101 89107 89113 89119 89123 89137 89153 89189 89203 89209
+ 89213 89227 89231 89237 89261 89269 89273 89293 89303 89317
+ 89329 89363 89371 89381 89387 89393 89399 89413 89417 89431
+ 89443 89449 89459 89477 89491 89501 89513 89519 89521 89527
+ 89533 89561 89563 89567 89591 89597 89599 89603 89611 89627
+ 89633 89653 89657 89659 89669 89671 89681 89689 89753 89759
+ 89767 89779 89783 89797 89809 89819 89821 89833 89839 89849
+ 89867 89891 89897 89899 89909 89917 89923 89939 89959 89963
+ 89977 89983 89989 90001 90007 90011 90017 90019 90023 90031
+ 90053 90059 90067 90071 90073 90089 90107 90121 90127 90149
+ 90163 90173 90187 90191 90197 90199 90203 90217 90227 90239
+ 90247 90263 90271 90281 90289 90313 90353 90359 90371 90373
+ 90379 90397 90401 90403 90407 90437 90439 90469 90473 90481
+ 90499 90511 90523 90527 90529 90533 90547 90583 90599 90617
+ 90619 90631 90641 90647 90659 90677 90679 90697 90703 90709
+ 90731 90749 90787 90793 90803 90821 90823 90833 90841 90847
+ 90863 90887 90901 90907 90911 90917 90931 90947 90971 90977
+ 90989 90997 91009 91019 91033 91079 91081 91097 91099 91121
+ 91127 91129 91139 91141 91151 91153 91159 91163 91183 91193
+ 91199 91229 91237 91243 91249 91253 91283 91291 91297 91303
+ 91309 91331 91367 91369 91373 91381 91387 91393 91397 91411
+ 91423 91433 91453 91457 91459 91463 91493 91499 91513 91529
+ 91541 91571 91573 91577 91583 91591 91621 91631 91639 91673
+ 91691 91703 91711 91733 91753 91757 91771 91781 91801 91807
+ 91811 91813 91823 91837 91841 91867 91873 91909 91921 91939
+ 91943 91951 91957 91961 91967 91969 91997 92003 92009 92033
+ 92041 92051 92077 92083 92107 92111 92119 92143 92153 92173
+ 92177 92179 92189 92203 92219 92221 92227 92233 92237 92243
+ 92251 92269 92297 92311 92317 92333 92347 92353 92357 92363
+ 92369 92377 92381 92383 92387 92399 92401 92413 92419 92431
+ 92459 92461 92467 92479 92489 92503 92507 92551 92557 92567
+ 92569 92581 92593 92623 92627 92639 92641 92647 92657 92669
+ 92671 92681 92683 92693 92699 92707 92717 92723 92737 92753
+ 92761 92767 92779 92789 92791 92801 92809 92821 92831 92849
+ 92857 92861 92863 92867 92893 92899 92921 92927 92941 92951
+ 92957 92959 92987 92993 93001 93047 93053 93059 93077 93083
+ 93089 93097 93103 93113 93131 93133 93139 93151 93169 93179
+ 93187 93199 93229 93239 93241 93251 93253 93257 93263 93281
+ 93283 93287 93307 93319 93323 93329 93337 93371 93377 93383
+ 93407 93419 93427 93463 93479 93481 93487 93491 93493 93497
+ 93503 93523 93529 93553 93557 93559 93563 93581 93601 93607
+ 93629 93637 93683 93701 93703 93719 93739 93761 93763 93787
+ 93809 93811 93827 93851 93871 93887 93889 93893 93901 93911
+ 93913 93923 93937 93941 93949 93967 93971 93979 93983 93997
+ 94007 94009 94033 94049 94057 94063 94079 94099 94109 94111
+ 94117 94121 94151 94153 94169 94201 94207 94219 94229 94253
+ 94261 94273 94291 94307 94309 94321 94327 94331 94343 94349
+ 94351 94379 94397 94399 94421 94427 94433 94439 94441 94447
+ 94463 94477 94483 94513 94529 94531 94541 94543 94547 94559
+ 94561 94573 94583 94597 94603 94613 94621 94649 94651 94687
+ 94693 94709 94723 94727 94747 94771 94777 94781 94789 94793
+ 94811 94819 94823 94837 94841 94847 94849 94873 94889 94903
+ 94907 94933 94949 94951 94961 94993 94999 95003 95009 95021
+ 95027 95063 95071 95083 95087 95089 95093 95101 95107 95111
+ 95131 95143 95153 95177 95189 95191 95203 95213 95219 95231
+ 95233 95239 95257 95261 95267 95273 95279 95287 95311 95317
+ 95327 95339 95369 95383 95393 95401 95413 95419 95429 95441
+ 95443 95461 95467 95471 95479 95483 95507 95527 95531 95539
+ 95549 95561 95569 95581 95597 95603 95617 95621 95629 95633
+ 95651 95701 95707 95713 95717 95723 95731 95737 95747 95773
+ 95783 95789 95791 95801 95803 95813 95819 95857 95869 95873
+ 95881 95891 95911 95917 95923 95929 95947 95957 95959 95971
+ 95987 95989 96001 96013 96017 96043 96053 96059 96079 96097
+ 96137 96149 96157 96167 96179 96181 96199 96211 96221 96223
+ 96233 96259 96263 96269 96281 96289 96293 96323 96329 96331
+ 96337 96353 96377 96401 96419 96431 96443 96451 96457 96461
+ 96469 96479 96487 96493 96497 96517 96527 96553 96557 96581
+ 96587 96589 96601 96643 96661 96667 96671 96697 96703 96731
+ 96737 96739 96749 96757 96763 96769 96779 96787 96797 96799
+ 96821 96823 96827 96847 96851 96857 96893 96907 96911 96931
+ 96953 96959 96973 96979 96989 96997 97001 97003 97007 97021
+ 97039 97073 97081 97103 97117 97127 97151 97157 97159 97169
+ 97171 97177 97187 97213 97231 97241 97259 97283 97301 97303
+ 97327 97367 97369 97373 97379 97381 97387 97397 97423 97429
+ 97441 97453 97459 97463 97499 97501 97511 97523 97547 97549
+ 97553 97561 97571 97577 97579 97583 97607 97609 97613 97649
+ 97651 97673 97687 97711 97729 97771 97777 97787 97789 97813
+ 97829 97841 97843 97847 97849 97859 97861 97871 97879 97883
+ 97919 97927 97931 97943 97961 97967 97973 97987 98009 98011
+ 98017 98041 98047 98057 98081 98101 98123 98129 98143 98179
+ 98207 98213 98221 98227 98251 98257 98269 98297 98299 98317
+ 98321 98323 98327 98347 98369 98377 98387 98389 98407 98411
+ 98419 98429 98443 98453 98459 98467 98473 98479 98491 98507
+ 98519 98533 98543 98561 98563 98573 98597 98621 98627 98639
+ 98641 98663 98669 98689 98711 98713 98717 98729 98731 98737
+ 98773 98779 98801 98807 98809 98837 98849 98867 98869 98873
+ 98887 98893 98897 98899 98909 98911 98927 98929 98939 98947
+ 98953 98963 98981 98993 98999 99013 99017 99023 99041 99053
+ 99079 99083 99089 99103 99109 99119 99131 99133 99137 99139
+ 99149 99173 99181 99191 99223 99233 99241 99251 99257 99259
+ 99277 99289 99317 99347 99349 99367 99371 99377 99391 99397
+ 99401 99409 99431 99439 99469 99487 99497 99523 99527 99529
+ 99551 99559 99563 99571 99577 99581 99607 99611 99623 99643
+ 99661 99667 99679 99689 99707 99709 99713 99719 99721 99733
+ 99761 99767 99787 99793 99809 99817 99823 99829 99833 99839
+ 99859 99871 99877 99881 99901 99907 99923 99929 99961 99971
+ 99989 99991 100003 100019 100043 100049 100057 100069 100103 100109
+ 100129 100151 100153 100169 100183 100189 100193 100207 100213 100237
+ 100267 100271 100279 100291 100297 100313 100333 100343 100357 100361
+ 100363 100379 100391 100393 100403 100411 100417 100447 100459 100469
+ 100483 100493 100501 100511 100517 100519 100523 100537 100547 100549
+ 100559 100591 100609 100613 100621 100649 100669 100673 100693 100699
+ 100703 100733 100741 100747 100769 100787 100799 100801 100811 100823
+ 100829 100847 100853 100907 100913 100927 100931 100937 100943 100957
+ 100981 100987 100999 101009 101021 101027 101051 101063 101081 101089
+ 101107 101111 101113 101117 101119 101141 101149 101159 101161 101173
+ 101183 101197 101203 101207 101209 101221 101267 101273 101279 101281
+ 101287 101293 101323 101333 101341 101347 101359 101363 101377 101383
+ 101399 101411 101419 101429 101449 101467 101477 101483 101489 101501
+ 101503 101513 101527 101531 101533 101537 101561 101573 101581 101599
+ 101603 101611 101627 101641 101653 101663 101681 101693 101701 101719
+ 101723 101737 101741 101747 101749 101771 101789 101797 101807 101833
+ 101837 101839 101863 101869 101873 101879 101891 101917 101921 101929
+ 101939 101957 101963 101977 101987 101999 102001 102013 102019 102023
+ 102031 102043 102059 102061 102071 102077 102079 102101 102103 102107
+ 102121 102139 102149 102161 102181 102191 102197 102199 102203 102217
+ 102229 102233 102241 102251 102253 102259 102293 102299 102301 102317
+ 102329 102337 102359 102367 102397 102407 102409 102433 102437 102451
+ 102461 102481 102497 102499 102503 102523 102533 102539 102547 102551
+ 102559 102563 102587 102593 102607 102611 102643 102647 102653 102667
+ 102673 102677 102679 102701 102761 102763 102769 102793 102797 102811
+ 102829 102841 102859 102871 102877 102881 102911 102913 102929 102931
+ 102953 102967 102983 103001 103007 103043 103049 103067 103069 103079
+ 103087 103091 103093 103099 103123 103141 103171 103177 103183 103217
+ 103231 103237 103289 103291 103307 103319 103333 103349 103357 103387
+ 103391 103393 103399 103409 103421 103423 103451 103457 103471 103483
+ 103511 103529 103549 103553 103561 103567 103573 103577 103583 103591
+ 103613 103619 103643 103651 103657 103669 103681 103687 103699 103703
+ 103723 103769 103787 103801 103811 103813 103837 103841 103843 103867
+ 103889 103903 103913 103919 103951 103963 103967 103969 103979 103981
+ 103991 103993 103997 104003 104009 104021 104033 104047 104053 104059
+ 104087 104089 104107 104113 104119 104123 104147 104149 104161 104173
+ 104179 104183 104207 104231 104233 104239 104243 104281 104287 104297
+ 104309 104311 104323 104327 104347 104369 104381 104383 104393 104399
+ 104417 104459 104471 104473 104479 104491 104513 104527 104537 104543
+ 104549 104551 104561 104579 104593 104597 104623 104639 104651 104659
+ 104677 104681 104683 104693 104701 104707 104711 104717 104723 104729
diff --git a/src/utils/__tests__/memory/meminfo.ubuntu14.txt b/src/utils/__tests__/memory/meminfo.ubuntu14.txt
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/memory/meminfo.ubuntu14.txt
@@ -0,0 +1,42 @@
+MemTotal: 7659508 kB
+MemFree: 246684 kB
+Buffers: 126580 kB
+Cached: 3296948 kB
+SwapCached: 0 kB
+Active: 4916076 kB
+Inactive: 1732880 kB
+Active(anon): 3225504 kB
+Inactive(anon): 20576 kB
+Active(file): 1690572 kB
+Inactive(file): 1712304 kB
+Unevictable: 0 kB
+Mlocked: 0 kB
+SwapTotal: 0 kB
+SwapFree: 0 kB
+Dirty: 32 kB
+Writeback: 0 kB
+AnonPages: 3225428 kB
+Mapped: 37500 kB
+Shmem: 20652 kB
+Slab: 633908 kB
+SReclaimable: 467472 kB
+SUnreclaim: 166436 kB
+KernelStack: 2416 kB
+PageTables: 64744 kB
+NFS_Unstable: 0 kB
+Bounce: 0 kB
+WritebackTmp: 0 kB
+CommitLimit: 3829752 kB
+Committed_AS: 4935116 kB
+VmallocTotal: 34359738367 kB
+VmallocUsed: 17244 kB
+VmallocChunk: 34359712740 kB
+HardwareCorrupted: 0 kB
+AnonHugePages: 954368 kB
+HugePages_Total: 0
+HugePages_Free: 0
+HugePages_Rsvd: 0
+HugePages_Surp: 0
+Hugepagesize: 2048 kB
+DirectMap4k: 45056 kB
+DirectMap2M: 7950336 kB
diff --git a/src/utils/__tests__/memory/vmstat.yosemite.txt b/src/utils/__tests__/memory/vmstat.yosemite.txt
new file mode 100644
--- /dev/null
+++ b/src/utils/__tests__/memory/vmstat.yosemite.txt
@@ -0,0 +1,23 @@
+Mach Virtual Memory Statistics: (page size of 4096 bytes)
+Pages free: 422941.
+Pages active: 2348641.
+Pages inactive: 830440.
+Pages speculative: 110635.
+Pages throttled: 0.
+Pages wired down: 427172.
+Pages purgeable: 33368.
+"Translation faults": 931955891.
+Pages copy-on-write: 59498342.
+Pages zero filled: 411628732.
+Pages reactivated: 175636.
+Pages purged: 569552.
+File-backed pages: 926777.
+Anonymous pages: 2362939.
+Pages stored in compressor: 125673.
+Pages occupied by compressor: 51938.
+Decompressions: 32945.
+Compressions: 197789.
+Pageins: 13750115.
+Pageouts: 39562.
+Swapins: 0.
+Swapouts: 2290.
diff --git a/src/utils/utf8.php b/src/utils/utf8.php
new file mode 100644
--- /dev/null
+++ b/src/utils/utf8.php
@@ -0,0 +1,950 @@
+= 0xD800 && $codepoint <= 0xDFFF) {
+ $result[] = str_repeat($replacement, strlen($match));
+ $offset += strlen($matches[0]);
+ continue;
+ }
+ }
+
+ $result[] = $match;
+ } else {
+ // Unicode replacement character, U+FFFD.
+ $result[] = $replacement;
+ }
+
+ $offset += strlen($matches[0]);
+ }
+
+ return implode('', $result);
+}
+
+
+/**
+ * Determine if a string is valid UTF-8, with only basic multilingual plane
+ * characters. This is particularly important because MySQL's `utf8` column
+ * types silently truncate strings which contain characters outside of this
+ * set.
+ *
+ * @param string String to test for being valid UTF-8 with only characters in
+ * the basic multilingual plane.
+ * @return bool True if the string is valid UTF-8 with only BMP characters.
+ */
+function phutil_is_utf8_with_only_bmp_characters($string) {
+ return phutil_is_utf8_slowly($string, $only_bmp = true);
+}
+
+
+/**
+ * Determine if a string is valid UTF-8.
+ *
+ * @param string Some string which may or may not be valid UTF-8.
+ * @return bool True if the string is valid UTF-8.
+ */
+function phutil_is_utf8($string) {
+ if (function_exists('mb_check_encoding')) {
+ // If mbstring is available, this is significantly faster than using PHP.
+ return mb_check_encoding($string, 'UTF-8');
+ }
+
+ return phutil_is_utf8_slowly($string);
+}
+
+
+/**
+ * Determine if a string is valid UTF-8, slowly.
+ *
+ * This works on any system, but has very poor performance.
+ *
+ * You should call @{function:phutil_is_utf8} instead of this function, as
+ * that function can use more performant mechanisms if they are available on
+ * the system.
+ *
+ * @param string Some string which may or may not be valid UTF-8.
+ * @param bool True to require all characters be part of the basic
+ * multilingual plane (no more than 3-bytes long).
+ * @return bool True if the string is valid UTF-8.
+ */
+function phutil_is_utf8_slowly($string, $only_bmp = false) {
+ // First, check the common case of normal ASCII strings. We're fine if
+ // the string contains no bytes larger than 127.
+ if (preg_match('/^[\x01-\x7F]+\z/', $string)) {
+ return true;
+ }
+
+ // NOTE: In the past, we used a large regular expression in the form of
+ // '(x|y|z)+' to match UTF8 strings. However, PCRE can segfaults on patterns
+ // like this at relatively small input sizes, at least on some systems
+ // (observed on OSX and Windows). This is apparently because the internal
+ // implementation is recursive and it blows the stack.
+
+ // See for some discussion. Since the
+ // input limit is extremely low (less than 50KB on my system), do this check
+ // very very slowly in PHP instead. See also T5316.
+
+ $len = strlen($string);
+ for ($ii = 0; $ii < $len; $ii++) {
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x01 && $chr <= 0x7F) {
+ continue;
+ } else if ($chr >= 0xC2 && $chr <= 0xDF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ continue;
+ }
+ return false;
+ } else if ($chr > 0xE0 && $chr <= 0xEF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ continue;
+ }
+ }
+ return false;
+ } else if ($chr == 0xE0) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+
+ // NOTE: This range starts at 0xA0, not 0x80. The values 0x80-0xA0 are
+ // "valid", but not minimal representations, and MySQL rejects them. We're
+ // special casing this part of the range.
+
+ if ($chr >= 0xA0 && $chr <= 0xBF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ continue;
+ }
+ }
+ return false;
+ } else if (!$only_bmp) {
+ if ($chr > 0xF0 && $chr <= 0xF4) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ continue;
+ }
+ }
+ }
+ } else if ($chr == 0xF0) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+
+ // NOTE: As above, this range starts at 0x90, not 0x80. The values
+ // 0x80-0x90 are not minimal representations.
+
+ if ($chr >= 0x90 && $chr <= 0xBF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ ++$ii;
+ if ($ii >= $len) {
+ return false;
+ }
+ $chr = ord($string[$ii]);
+ if ($chr >= 0x80 && $chr <= 0xBF) {
+ continue;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+ }
+
+ return true;
+}
+
+
+/**
+ * Find the character length of a UTF-8 string.
+ *
+ * @param string A valid utf-8 string.
+ * @return int The character length of the string.
+ */
+function phutil_utf8_strlen($string) {
+ if (function_exists('utf8_decode')) {
+ return strlen(utf8_decode($string));
+ }
+ return count(phutil_utf8v($string));
+}
+
+
+/**
+ * Find the console display length of a UTF-8 string. This may differ from the
+ * character length of the string if it contains double-width characters, like
+ * many Chinese characters.
+ *
+ * This method is based on a C implementation here, which is based on the IEEE
+ * standards. The source has more discussion and addresses more considerations
+ * than this implementation does.
+ *
+ * http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ *
+ * NOTE: We currently assume width 1 for East-Asian ambiguous characters.
+ *
+ * NOTE: This function is VERY slow.
+ *
+ * @param string A valid UTF-8 string.
+ * @return int The console display length of the string.
+ */
+function phutil_utf8_console_strlen($string) {
+ // Formatting and colors don't contribute any width in the console.
+ $string = preg_replace("/\x1B\[\d*m/", '', $string);
+
+ // In the common case of an ASCII string, just return the string length.
+ if (preg_match('/^[\x01-\x7F]*\z/', $string)) {
+ return strlen($string);
+ }
+
+ $len = 0;
+
+ // NOTE: To deal with combining characters, we're splitting the string into
+ // glyphs first (characters with combiners) and then counting just the width
+ // of the first character in each glyph.
+
+ $display_glyphs = phutil_utf8v_combined($string);
+ foreach ($display_glyphs as $display_glyph) {
+ $glyph_codepoints = phutil_utf8v_codepoints($display_glyph);
+ foreach ($glyph_codepoints as $c) {
+ if ($c == 0) {
+ break;
+ }
+
+ $len += 1 +
+ ($c >= 0x1100 &&
+ ($c <= 0x115F || /* Hangul Jamo init. consonants */
+ $c == 0x2329 || $c == 0x232A ||
+ ($c >= 0x2E80 && $c <= 0xA4CF &&
+ $c != 0x303F) || /* CJK ... Yi */
+ ($c >= 0xAC00 && $c <= 0xD7A3) || /* Hangul Syllables */
+ ($c >= 0xF900 && $c <= 0xFAFF) || /* CJK Compatibility Ideographs */
+ ($c >= 0xFE10 && $c <= 0xFE19) || /* Vertical forms */
+ ($c >= 0xFE30 && $c <= 0xFE6F) || /* CJK Compatibility Forms */
+ ($c >= 0xFF00 && $c <= 0xFF60) || /* Fullwidth Forms */
+ ($c >= 0xFFE0 && $c <= 0xFFE6) ||
+ ($c >= 0x20000 && $c <= 0x2FFFD) ||
+ ($c >= 0x30000 && $c <= 0x3FFFD)));
+
+ break;
+ }
+ }
+
+ return $len;
+}
+
+
+/**
+ * Test if a string contains Chinese, Japanese, or Korean characters.
+ *
+ * Most languages use spaces to separate words, but these languages do not.
+ *
+ * @param string String to examine, in UTF8.
+ * @return bool True if the string contains Chinese, Japanese, or Korean
+ * characters.
+ */
+function phutil_utf8_is_cjk($string) {
+ $codepoints = phutil_utf8v_codepoints($string);
+
+ foreach ($codepoints as $codepoint) {
+ // CJK Unified Ideographs
+ if ($codepoint >= 0x4E00 && $codepoint <= 0x9FFF) {
+ return true;
+ }
+
+ // CJK Unified Ideographs Extension A
+ if ($codepoint >= 0x3400 && $codepoint <= 0x4DBF) {
+ return true;
+ }
+
+ // CJK Unified Ideographs Extension B
+ if ($codepoint >= 0x20000 && $codepoint <= 0x2A6DF) {
+ return true;
+ }
+
+ // CJK Unified Ideographs Extension C
+ if ($codepoint >= 0x2A700 && $codepoint <= 0x2B73F) {
+ return true;
+ }
+
+ // CJK Unified Ideographs Extension D
+ if ($codepoint >= 0x2B740 && $codepoint <= 0x2B81F) {
+ return true;
+ }
+
+ // CJK Unified Ideographs Extension E
+ if ($codepoint >= 0x2B820 && $codepoint <= 0x2CEAF) {
+ return true;
+ }
+
+ // CJK Unified Ideographs Extension F
+ if ($codepoint >= 0x2CEB0 && $codepoint <= 0x2EBEF) {
+ return true;
+ }
+
+ // CJK Compatibility Ideographs
+ if ($codepoint >= 0xF900 && $codepoint <= 0xFAFF) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+/**
+ * Split a UTF-8 string into an array of characters. Combining characters are
+ * also split.
+ *
+ * @param string A valid utf-8 string.
+ * @param int|null Stop processing after examining this many bytes.
+ * @return list A list of characters in the string.
+ */
+function phutil_utf8v($string, $byte_limit = null) {
+ $res = array();
+ $len = strlen($string);
+
+ $ii = 0;
+ while ($ii < $len) {
+ $byte = $string[$ii];
+ if ($byte <= "\x7F") {
+ $res[] = $byte;
+ $ii += 1;
+
+ if ($byte_limit && ($ii >= $byte_limit)) {
+ break;
+ }
+
+ continue;
+ } else if ($byte < "\xC0") {
+ throw new Exception(
+ pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
+ } else if ($byte <= "\xDF") {
+ $seq_len = 2;
+ } else if ($byte <= "\xEF") {
+ $seq_len = 3;
+ } else if ($byte <= "\xF7") {
+ $seq_len = 4;
+ } else if ($byte <= "\xFB") {
+ $seq_len = 5;
+ } else if ($byte <= "\xFD") {
+ $seq_len = 6;
+ } else {
+ throw new Exception(
+ pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
+ }
+
+ if ($ii + $seq_len > $len) {
+ throw new Exception(
+ pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
+ }
+ for ($jj = 1; $jj < $seq_len; ++$jj) {
+ if ($string[$ii + $jj] >= "\xC0") {
+ throw new Exception(
+ pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
+ }
+ }
+ $res[] = substr($string, $ii, $seq_len);
+ $ii += $seq_len;
+
+ if ($byte_limit && ($ii >= $byte_limit)) {
+ break;
+ }
+ }
+
+ return $res;
+}
+
+
+/**
+ * Split a UTF-8 string into an array of codepoints (as integers).
+ *
+ * @param string A valid UTF-8 string.
+ * @return list A list of codepoints, as integers.
+ */
+function phutil_utf8v_codepoints($string) {
+ $str_v = phutil_utf8v($string);
+
+ foreach ($str_v as $key => $char) {
+ $c = ord($char[0]);
+ $v = 0;
+
+ if (($c & 0x80) == 0) {
+ $v = $c;
+ } else if (($c & 0xE0) == 0xC0) {
+ $v = (($c & 0x1F) << 6)
+ + ((ord($char[1]) & 0x3F));
+ } else if (($c & 0xF0) == 0xE0) {
+ $v = (($c & 0x0F) << 12)
+ + ((ord($char[1]) & 0x3F) << 6)
+ + ((ord($char[2]) & 0x3F));
+ } else if (($c & 0xF8) == 0xF0) {
+ $v = (($c & 0x07) << 18)
+ + ((ord($char[1]) & 0x3F) << 12)
+ + ((ord($char[2]) & 0x3F) << 6)
+ + ((ord($char[3]) & 0x3F));
+ } else if (($c & 0xFC) == 0xF8) {
+ $v = (($c & 0x03) << 24)
+ + ((ord($char[1]) & 0x3F) << 18)
+ + ((ord($char[2]) & 0x3F) << 12)
+ + ((ord($char[3]) & 0x3F) << 6)
+ + ((ord($char[4]) & 0x3F));
+ } else if (($c & 0xFE) == 0xFC) {
+ $v = (($c & 0x01) << 30)
+ + ((ord($char[1]) & 0x3F) << 24)
+ + ((ord($char[2]) & 0x3F) << 18)
+ + ((ord($char[3]) & 0x3F) << 12)
+ + ((ord($char[4]) & 0x3F) << 6)
+ + ((ord($char[5]) & 0x3F));
+ }
+
+ $str_v[$key] = $v;
+ }
+
+ return $str_v;
+}
+
+
+/**
+ * Convert a Unicode codepoint into a UTF8-encoded string.
+ *
+ * @param int Unicode codepoint.
+ * @return string UTF8 encoding.
+ */
+function phutil_utf8_encode_codepoint($codepoint) {
+ if ($codepoint < 0x80) {
+ $r = chr($codepoint);
+ } else if ($codepoint < 0x800) {
+ $r = chr(0xC0 | (($codepoint >> 6) & 0x1F)).
+ chr(0x80 | (($codepoint) & 0x3F));
+ } else if ($codepoint < 0x10000) {
+ $r = chr(0xE0 | (($codepoint >> 12) & 0x0F)).
+ chr(0x80 | (($codepoint >> 6) & 0x3F)).
+ chr(0x80 | (($codepoint) & 0x3F));
+ } else if ($codepoint < 0x110000) {
+ $r = chr(0xF0 | (($codepoint >> 18) & 0x07)).
+ chr(0x80 | (($codepoint >> 12) & 0x3F)).
+ chr(0x80 | (($codepoint >> 6) & 0x3F)).
+ chr(0x80 | (($codepoint) & 0x3F));
+ } else {
+ throw new Exception(
+ pht(
+ 'Encoding UTF8 codepoint "%s" is not supported.',
+ $codepoint));
+ }
+
+ return $r;
+}
+
+
+/**
+ * Hard-wrap a block of UTF-8 text with embedded HTML tags and entities.
+ *
+ * @param string An HTML string with tags and entities.
+ * @return list List of hard-wrapped lines.
+ */
+function phutil_utf8_hard_wrap_html($string, $width) {
+ $break_here = array();
+
+ // Convert the UTF-8 string into a list of UTF-8 characters.
+ $vector = phutil_utf8v($string);
+ $len = count($vector);
+ $char_pos = 0;
+ for ($ii = 0; $ii < $len; ++$ii) {
+ // An ampersand indicates an HTML entity; consume the whole thing (until
+ // ";") but treat it all as one character.
+ if ($vector[$ii] == '&') {
+ do {
+ ++$ii;
+ } while ($vector[$ii] != ';');
+ ++$char_pos;
+ // An "<" indicates an HTML tag, consume the whole thing but don't treat
+ // it as a character.
+ } else if ($vector[$ii] == '<') {
+ do {
+ ++$ii;
+ } while ($vector[$ii] != '>');
+ } else {
+ ++$char_pos;
+ }
+
+ // Keep track of where we need to break the string later.
+ if ($char_pos == $width) {
+ $break_here[$ii] = true;
+ $char_pos = 0;
+ }
+ }
+
+ $result = array();
+ $string = '';
+ foreach ($vector as $ii => $char) {
+ $string .= $char;
+ if (isset($break_here[$ii])) {
+ $result[] = $string;
+ $string = '';
+ }
+ }
+
+ if (strlen($string)) {
+ $result[] = $string;
+ }
+
+ return $result;
+}
+
+/**
+ * Hard-wrap a block of UTF-8 text with no embedded HTML tags and entities.
+ *
+ * @param string A non HTML string
+ * @param int Width of the hard-wrapped lines
+ * @return list List of hard-wrapped lines.
+ */
+function phutil_utf8_hard_wrap($string, $width) {
+ $result = array();
+
+ $lines = phutil_split_lines($string, $retain_endings = false);
+ foreach ($lines as $line) {
+
+ // Convert the UTF-8 string into a list of UTF-8 characters.
+ $vector = phutil_utf8v($line);
+
+ $len = count($vector);
+ $buffer = '';
+
+ for ($ii = 1; $ii <= $len; ++$ii) {
+ $buffer .= $vector[$ii - 1];
+ if (($ii % $width) === 0) {
+ $result[] = $buffer;
+ $buffer = '';
+ }
+ }
+
+ if (strlen($buffer)) {
+ $result[] = $buffer;
+ }
+ }
+
+ return $result;
+}
+
+/**
+ * Convert a string from one encoding (like ISO-8859-1) to another encoding
+ * (like UTF-8).
+ *
+ * This is primarily a thin wrapper around `mb_convert_encoding()` which checks
+ * you have the extension installed, since we try to require the extension
+ * only if you actually need it (i.e., you want to work with encodings other
+ * than UTF-8).
+ *
+ * NOTE: This function assumes that the input is in the given source encoding.
+ * If it is not, it may not output in the specified target encoding. If you
+ * need to perform a hard conversion to UTF-8, use this function in conjunction
+ * with @{function:phutil_utf8ize}. We can detect failures caused by invalid
+ * encoding names, but `mb_convert_encoding()` fails silently if the
+ * encoding name identifies a real encoding but the string is not actually
+ * encoded with that encoding.
+ *
+ * @param string String to re-encode.
+ * @param string Target encoding name, like "UTF-8".
+ * @param string Source encoding name, like "ISO-8859-1".
+ * @return string Input string, with converted character encoding.
+ *
+ * @phutil-external-symbol function mb_convert_encoding
+ */
+function phutil_utf8_convert($string, $to_encoding, $from_encoding) {
+ if (!$from_encoding) {
+ throw new InvalidArgumentException(
+ pht(
+ 'Attempting to convert a string encoding, but no source encoding '.
+ 'was provided. Explicitly provide the source encoding.'));
+ }
+ if (!$to_encoding) {
+ throw new InvalidArgumentException(
+ pht(
+ 'Attempting to convert a string encoding, but no target encoding '.
+ 'was provided. Explicitly provide the target encoding.'));
+ }
+
+ // Normalize encoding names so we can no-op the very common case of UTF8
+ // to UTF8 (or any other conversion where both encodings are identical).
+ $to_upper = strtoupper(str_replace('-', '', $to_encoding));
+ $from_upper = strtoupper(str_replace('-', '', $from_encoding));
+ if ($from_upper == $to_upper) {
+ return $string;
+ }
+
+ if (!function_exists('mb_convert_encoding')) {
+ throw new Exception(
+ pht(
+ "Attempting to convert a string encoding from '%s' to '%s', ".
+ "but the '%s' PHP extension is not available. Install %s to ".
+ "work with encodings other than UTF-8.",
+ $from_encoding,
+ $to_encoding,
+ 'mbstring',
+ 'mbstring'));
+ }
+
+ $result = @mb_convert_encoding($string, $to_encoding, $from_encoding);
+
+ if ($result === false) {
+ $message = error_get_last();
+ if ($message) {
+ $message = idx($message, 'message', pht('Unknown error.'));
+ }
+ throw new Exception(
+ pht(
+ "String conversion from encoding '%s' to encoding '%s' failed: %s",
+ $from_encoding,
+ $to_encoding,
+ $message));
+ }
+
+ return $result;
+}
+
+
+/**
+ * Convert a string to title case in a UTF8-aware way. This function doesn't
+ * necessarily do a great job, but the builtin implementation of `ucwords()` can
+ * completely destroy inputs, so it just has to be better than that. Similar to
+ * @{function:ucwords}.
+ *
+ * @param string UTF-8 input string.
+ * @return string Input, in some semblance of title case.
+ */
+function phutil_utf8_ucwords($str) {
+ // NOTE: mb_convert_case() discards uppercase letters in words when converting
+ // to title case. For example, it will convert "AAA" into "Aaa", which is
+ // undesirable.
+
+ $v = phutil_utf8v($str);
+ $result = '';
+ $last = null;
+
+ $ord_a = ord('a');
+ $ord_z = ord('z');
+ foreach ($v as $c) {
+ $convert = false;
+ if ($last === null || $last === ' ') {
+ $o = ord($c[0]);
+ if ($o >= $ord_a && $o <= $ord_z) {
+ $convert = true;
+ }
+ }
+
+ if ($convert) {
+ $result .= phutil_utf8_strtoupper($c);
+ } else {
+ $result .= $c;
+ }
+
+ $last = $c;
+ }
+
+ return $result;
+}
+
+
+/**
+ * Convert a string to lower case in a UTF8-aware way. Similar to
+ * @{function:strtolower}.
+ *
+ * @param string UTF-8 input string.
+ * @return string Input, in some semblance of lower case.
+ *
+ * @phutil-external-symbol function mb_convert_case
+ */
+function phutil_utf8_strtolower($str) {
+ if (function_exists('mb_convert_case')) {
+ return mb_convert_case($str, MB_CASE_LOWER, 'UTF-8');
+ }
+
+ static $map;
+ if ($map === null) {
+ $map = array_combine(
+ range('A', 'Z'),
+ range('a', 'z'));
+ }
+
+ return phutil_utf8_strtr($str, $map);
+}
+
+
+/**
+ * Convert a string to upper case in a UTF8-aware way. Similar to
+ * @{function:strtoupper}.
+ *
+ * @param string UTF-8 input string.
+ * @return string Input, in some semblance of upper case.
+ *
+ * @phutil-external-symbol function mb_convert_case
+ */
+function phutil_utf8_strtoupper($str) {
+ if (function_exists('mb_convert_case')) {
+ return mb_convert_case($str, MB_CASE_UPPER, 'UTF-8');
+ }
+
+ static $map;
+ if ($map === null) {
+ $map = array_combine(
+ range('a', 'z'),
+ range('A', 'Z'));
+ }
+
+ return phutil_utf8_strtr($str, $map);
+}
+
+
+/**
+ * Replace characters in a string in a UTF-aware way. Similar to
+ * @{function:strtr}.
+ *
+ * @param string UTF-8 input string.
+ * @param map Map of characters to replace.
+ * @return string Input with translated characters.
+ */
+function phutil_utf8_strtr($str, array $map) {
+ $v = phutil_utf8v($str);
+ $result = '';
+ foreach ($v as $c) {
+ if (isset($map[$c])) {
+ $result .= $map[$c];
+ } else {
+ $result .= $c;
+ }
+ }
+
+ return $result;
+}
+
+/**
+ * Determine if a given unicode character is a combining character or not.
+ *
+ * @param string A single unicode character.
+ * @return boolean True or false.
+ */
+function phutil_utf8_is_combining_character($character) {
+ $components = phutil_utf8v_codepoints($character);
+
+ // Combining Diacritical Marks (0300 - 036F).
+ // Combining Diacritical Marks Supplement (1DC0 - 1DFF).
+ // Combining Diacritical Marks for Symbols (20D0 - 20FF).
+ // Combining Half Marks (FE20 - FE2F).
+
+ foreach ($components as $codepoint) {
+ if ($codepoint >= 0x0300 && $codepoint <= 0x036F ||
+ $codepoint >= 0x1DC0 && $codepoint <= 0x1DFF ||
+ $codepoint >= 0x20D0 && $codepoint <= 0x20FF ||
+ $codepoint >= 0xFE20 && $codepoint <= 0xFE2F) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+/**
+ * Split a UTF-8 string into an array of characters. Combining characters
+ * are not split.
+ *
+ * @param string A valid utf-8 string.
+ * @return list A list of characters in the string.
+ */
+function phutil_utf8v_combined($string) {
+ $components = phutil_utf8v($string);
+ return phutil_utf8v_combine_characters($components);
+}
+
+
+/**
+ * Merge combining characters in a UTF-8 string.
+ *
+ * This is a low-level method which can allow other operations to do less work.
+ * If you have a string, call @{method:phutil_utf8v_combined} instead.
+ *
+ * @param list List of UTF-8 characters.
+ * @return list List of UTF-8 strings with combining characters merged.
+ */
+function phutil_utf8v_combine_characters(array $characters) {
+ if (!$characters) {
+ return array();
+ }
+
+ // If the first character in the string is a combining character,
+ // start with a space.
+ if (phutil_utf8_is_combining_character($characters[0])) {
+ $buf = ' ';
+ } else {
+ $buf = null;
+ }
+
+ $parts = array();
+ foreach ($characters as $character) {
+ if (!isset($character[1])) {
+ // This an optimization: there are no one-byte combining characters,
+ // so we can just pass these through unmodified.
+ $is_combining = false;
+ } else {
+ $is_combining = phutil_utf8_is_combining_character($character);
+ }
+
+ if ($is_combining) {
+ $buf .= $character;
+ } else {
+ if ($buf !== null) {
+ $parts[] = $buf;
+ }
+ $buf = $character;
+ }
+ }
+
+ $parts[] = $buf;
+
+ return $parts;
+}
+
+
+/**
+ * Return the current system locale setting (LC_ALL).
+ *
+ * @return string Current system locale setting.
+ */
+function phutil_get_system_locale() {
+ $locale = setlocale(LC_ALL, 0);
+
+ if ($locale === false) {
+ throw new Exception(
+ pht(
+ 'Unable to determine current system locale (call to '.
+ '"setlocale(LC_ALL, 0)" failed).'));
+ }
+
+ return $locale;
+}
+
+
+/**
+ * Test if a system locale (LC_ALL) is available on the system.
+ *
+ * @param string Locale name like "en_US.UTF-8".
+ * @return bool True if the locale is available.
+ */
+function phutil_is_system_locale_available($locale) {
+ $old_locale = phutil_get_system_locale();
+ $is_available = @setlocale(LC_ALL, $locale);
+ setlocale(LC_ALL, $old_locale);
+
+ return ($is_available !== false);
+}
+
+
+/**
+ * Set the system locale (LC_ALL) to a particular value.
+ *
+ * @param string New locale setting.
+ * @return void
+ */
+function phutil_set_system_locale($locale) {
+ $ok = @setlocale(LC_ALL, $locale);
+ if (!$ok) {
+ throw new Exception(
+ pht(
+ 'Failed to set system locale (to "%s").',
+ $locale));
+ }
+}
diff --git a/src/utils/utils.php b/src/utils/utils.php
new file mode 100644
--- /dev/null
+++ b/src/utils/utils.php
@@ -0,0 +1,1516 @@
+doStuff();
+ *
+ * ...but this works fine:
+ *
+ * id(new Thing())->doStuff();
+ *
+ * @param wild Anything.
+ * @return wild Unmodified argument.
+ */
+function id($x) {
+ return $x;
+}
+
+
+/**
+ * Access an array index, retrieving the value stored there if it exists or
+ * a default if it does not. This function allows you to concisely access an
+ * index which may or may not exist without raising a warning.
+ *
+ * @param array Array to access.
+ * @param scalar Index to access in the array.
+ * @param wild Default value to return if the key is not present in the
+ * array.
+ * @return wild If `$array[$key]` exists, that value is returned. If not,
+ * $default is returned without raising a warning.
+ */
+function idx(array $array, $key, $default = null) {
+ // isset() is a micro-optimization - it is fast but fails for null values.
+ if (isset($array[$key])) {
+ return $array[$key];
+ }
+
+ // Comparing $default is also a micro-optimization.
+ if ($default === null || array_key_exists($key, $array)) {
+ return null;
+ }
+
+ return $default;
+}
+
+
+/**
+ * Access a sequence of array indexes, retrieving a deeply nested value if
+ * it exists or a default if it does not.
+ *
+ * For example, `idxv($dict, array('a', 'b', 'c'))` accesses the key at
+ * `$dict['a']['b']['c']`, if it exists. If it does not, or any intermediate
+ * value is not itself an array, it returns the defualt value.
+ *
+ * @param array Array to access.
+ * @param list List of keys to access, in sequence.
+ * @param wild Default value to return.
+ * @return wild Accessed value, or default if the value is not accessible.
+ */
+function idxv(array $map, array $path, $default = null) {
+ if (!$path) {
+ return $default;
+ }
+
+ $last = last($path);
+ $path = array_slice($path, 0, -1);
+
+ $cursor = $map;
+ foreach ($path as $key) {
+ $cursor = idx($cursor, $key);
+ if (!is_array($cursor)) {
+ return $default;
+ }
+ }
+
+ return idx($cursor, $last, $default);
+}
+
+
+/**
+ * Call a method on a list of objects. Short for "method pull", this function
+ * works just like @{function:ipull}, except that it operates on a list of
+ * objects instead of a list of arrays. This function simplifies a common type
+ * of mapping operation:
+ *
+ * COUNTEREXAMPLE
+ * $names = array();
+ * foreach ($objects as $key => $object) {
+ * $names[$key] = $object->getName();
+ * }
+ *
+ * You can express this more concisely with mpull():
+ *
+ * $names = mpull($objects, 'getName');
+ *
+ * mpull() takes a third argument, which allows you to do the same but for
+ * the array's keys:
+ *
+ * COUNTEREXAMPLE
+ * $names = array();
+ * foreach ($objects as $object) {
+ * $names[$object->getID()] = $object->getName();
+ * }
+ *
+ * This is the mpull version():
+ *
+ * $names = mpull($objects, 'getName', 'getID');
+ *
+ * If you pass ##null## as the second argument, the objects will be preserved:
+ *
+ * COUNTEREXAMPLE
+ * $id_map = array();
+ * foreach ($objects as $object) {
+ * $id_map[$object->getID()] = $object;
+ * }
+ *
+ * With mpull():
+ *
+ * $id_map = mpull($objects, null, 'getID');
+ *
+ * See also @{function:ipull}, which works similarly but accesses array indexes
+ * instead of calling methods.
+ *
+ * @param list Some list of objects.
+ * @param string|null Determines which **values** will appear in the result
+ * array. Use a string like 'getName' to store the
+ * value of calling the named method in each value, or
+ * ##null## to preserve the original objects.
+ * @param string|null Determines how **keys** will be assigned in the result
+ * array. Use a string like 'getID' to use the result
+ * of calling the named method as each object's key, or
+ * `null` to preserve the original keys.
+ * @return dict A dictionary with keys and values derived according
+ * to whatever you passed as `$method` and `$key_method`.
+ */
+function mpull(array $list, $method, $key_method = null) {
+ $result = array();
+ foreach ($list as $key => $object) {
+ if ($key_method !== null) {
+ $key = $object->$key_method();
+ }
+ if ($method !== null) {
+ $value = $object->$method();
+ } else {
+ $value = $object;
+ }
+ $result[$key] = $value;
+ }
+ return $result;
+}
+
+
+/**
+ * Access a property on a list of objects. Short for "property pull", this
+ * function works just like @{function:mpull}, except that it accesses object
+ * properties instead of methods. This function simplifies a common type of
+ * mapping operation:
+ *
+ * COUNTEREXAMPLE
+ * $names = array();
+ * foreach ($objects as $key => $object) {
+ * $names[$key] = $object->name;
+ * }
+ *
+ * You can express this more concisely with ppull():
+ *
+ * $names = ppull($objects, 'name');
+ *
+ * ppull() takes a third argument, which allows you to do the same but for
+ * the array's keys:
+ *
+ * COUNTEREXAMPLE
+ * $names = array();
+ * foreach ($objects as $object) {
+ * $names[$object->id] = $object->name;
+ * }
+ *
+ * This is the ppull version():
+ *
+ * $names = ppull($objects, 'name', 'id');
+ *
+ * If you pass ##null## as the second argument, the objects will be preserved:
+ *
+ * COUNTEREXAMPLE
+ * $id_map = array();
+ * foreach ($objects as $object) {
+ * $id_map[$object->id] = $object;
+ * }
+ *
+ * With ppull():
+ *
+ * $id_map = ppull($objects, null, 'id');
+ *
+ * See also @{function:mpull}, which works similarly but calls object methods
+ * instead of accessing object properties.
+ *
+ * @param list Some list of objects.
+ * @param string|null Determines which **values** will appear in the result
+ * array. Use a string like 'name' to store the value of
+ * accessing the named property in each value, or
+ * `null` to preserve the original objects.
+ * @param string|null Determines how **keys** will be assigned in the result
+ * array. Use a string like 'id' to use the result of
+ * accessing the named property as each object's key, or
+ * `null` to preserve the original keys.
+ * @return dict A dictionary with keys and values derived according
+ * to whatever you passed as `$property` and
+ * `$key_property`.
+ */
+function ppull(array $list, $property, $key_property = null) {
+ $result = array();
+ foreach ($list as $key => $object) {
+ if ($key_property !== null) {
+ $key = $object->$key_property;
+ }
+ if ($property !== null) {
+ $value = $object->$property;
+ } else {
+ $value = $object;
+ }
+ $result[$key] = $value;
+ }
+ return $result;
+}
+
+
+/**
+ * Choose an index from a list of arrays. Short for "index pull", this function
+ * works just like @{function:mpull}, except that it operates on a list of
+ * arrays and selects an index from them instead of operating on a list of
+ * objects and calling a method on them.
+ *
+ * This function simplifies a common type of mapping operation:
+ *
+ * COUNTEREXAMPLE
+ * $names = array();
+ * foreach ($list as $key => $dict) {
+ * $names[$key] = $dict['name'];
+ * }
+ *
+ * With ipull():
+ *
+ * $names = ipull($list, 'name');
+ *
+ * See @{function:mpull} for more usage examples.
+ *
+ * @param list Some list of arrays.
+ * @param scalar|null Determines which **values** will appear in the result
+ * array. Use a scalar to select that index from each
+ * array, or null to preserve the arrays unmodified as
+ * values.
+ * @param scalar|null Determines which **keys** will appear in the result
+ * array. Use a scalar to select that index from each
+ * array, or null to preserve the array keys.
+ * @return dict A dictionary with keys and values derived according
+ * to whatever you passed for `$index` and `$key_index`.
+ */
+function ipull(array $list, $index, $key_index = null) {
+ $result = array();
+ foreach ($list as $key => $array) {
+ if ($key_index !== null) {
+ $key = $array[$key_index];
+ }
+ if ($index !== null) {
+ $value = $array[$index];
+ } else {
+ $value = $array;
+ }
+ $result[$key] = $value;
+ }
+ return $result;
+}
+
+
+/**
+ * Group a list of objects by the result of some method, similar to how
+ * GROUP BY works in an SQL query. This function simplifies grouping objects
+ * by some property:
+ *
+ * COUNTEREXAMPLE
+ * $animals_by_species = array();
+ * foreach ($animals as $animal) {
+ * $animals_by_species[$animal->getSpecies()][] = $animal;
+ * }
+ *
+ * This can be expressed more tersely with mgroup():
+ *
+ * $animals_by_species = mgroup($animals, 'getSpecies');
+ *
+ * In either case, the result is a dictionary which maps species (e.g., like
+ * "dog") to lists of animals with that property, so all the dogs are grouped
+ * together and all the cats are grouped together, or whatever super
+ * businessesey thing is actually happening in your problem domain.
+ *
+ * See also @{function:igroup}, which works the same way but operates on
+ * array indexes.
+ *
+ * @param list List of objects to group by some property.
+ * @param string Name of a method, like 'getType', to call on each object
+ * in order to determine which group it should be placed into.
+ * @param ... Zero or more additional method names, to subgroup the
+ * groups.
+ * @return dict Dictionary mapping distinct method returns to lists of
+ * all objects which returned that value.
+ */
+function mgroup(array $list, $by /* , ... */) {
+ $map = mpull($list, $by);
+
+ $groups = array();
+ foreach ($map as $group) {
+ // Can't array_fill_keys() here because 'false' gets encoded wrong.
+ $groups[$group] = array();
+ }
+
+ foreach ($map as $key => $group) {
+ $groups[$group][$key] = $list[$key];
+ }
+
+ $args = func_get_args();
+ $args = array_slice($args, 2);
+ if ($args) {
+ array_unshift($args, null);
+ foreach ($groups as $group_key => $grouped) {
+ $args[0] = $grouped;
+ $groups[$group_key] = call_user_func_array('mgroup', $args);
+ }
+ }
+
+ return $groups;
+}
+
+
+/**
+ * Group a list of arrays by the value of some index. This function is the same
+ * as @{function:mgroup}, except it operates on the values of array indexes
+ * rather than the return values of method calls.
+ *
+ * @param list List of arrays to group by some index value.
+ * @param string Name of an index to select from each array in order to
+ * determine which group it should be placed into.
+ * @param ... Zero or more additional indexes names, to subgroup the
+ * groups.
+ * @return dict Dictionary mapping distinct index values to lists of
+ * all objects which had that value at the index.
+ */
+function igroup(array $list, $by /* , ... */) {
+ $map = ipull($list, $by);
+
+ $groups = array();
+ foreach ($map as $group) {
+ $groups[$group] = array();
+ }
+
+ foreach ($map as $key => $group) {
+ $groups[$group][$key] = $list[$key];
+ }
+
+ $args = func_get_args();
+ $args = array_slice($args, 2);
+ if ($args) {
+ array_unshift($args, null);
+ foreach ($groups as $group_key => $grouped) {
+ $args[0] = $grouped;
+ $groups[$group_key] = call_user_func_array('igroup', $args);
+ }
+ }
+
+ return $groups;
+}
+
+
+/**
+ * Sort a list of objects by the return value of some method. In PHP, this is
+ * often vastly more efficient than `usort()` and similar.
+ *
+ * // Sort a list of Duck objects by name.
+ * $sorted = msort($ducks, 'getName');
+ *
+ * It is usually significantly more efficient to define an ordering method
+ * on objects and call `msort()` than to write a comparator. It is often more
+ * convenient, as well.
+ *
+ * NOTE: This method does not take the list by reference; it returns a new list.
+ *
+ * @param list List of objects to sort by some property.
+ * @param string Name of a method to call on each object; the return values
+ * will be used to sort the list.
+ * @return list Objects ordered by the return values of the method calls.
+ */
+function msort(array $list, $method) {
+ $surrogate = mpull($list, $method);
+
+ asort($surrogate);
+
+ $result = array();
+ foreach ($surrogate as $key => $value) {
+ $result[$key] = $list[$key];
+ }
+
+ return $result;
+}
+
+
+/**
+ * Sort a list of objects by a sort vector.
+ *
+ * This sort is stable, well-behaved, and more efficient than `usort()`.
+ *
+ * @param list List of objects to sort.
+ * @param string Name of a method to call on each object. The method must
+ * return a @{class:PhutilSortVector}.
+ * @return list Objects ordered by the vectors.
+ */
+function msortv(array $list, $method) {
+ $surrogate = mpull($list, $method);
+
+ $index = 0;
+ foreach ($surrogate as $key => $value) {
+ if (!($value instanceof PhutilSortVector)) {
+ throw new Exception(
+ pht(
+ 'Objects passed to "%s" must return sort vectors (objects of '.
+ 'class "%s") from the specified method ("%s"). One object (with '.
+ 'key "%s") did not.',
+ 'msortv()',
+ 'PhutilSortVector',
+ $method,
+ $key));
+ }
+
+ // Add the original index to keep the sort stable.
+ $value->addInt($index++);
+
+ $surrogate[$key] = (string)$value;
+ }
+
+ asort($surrogate, SORT_STRING);
+
+ $result = array();
+ foreach ($surrogate as $key => $value) {
+ $result[$key] = $list[$key];
+ }
+
+ return $result;
+}
+
+
+/**
+ * Sort a list of arrays by the value of some index. This method is identical to
+ * @{function:msort}, but operates on a list of arrays instead of a list of
+ * objects.
+ *
+ * @param list List of arrays to sort by some index value.
+ * @param string Index to access on each object; the return values
+ * will be used to sort the list.
+ * @return list Arrays ordered by the index values.
+ */
+function isort(array $list, $index) {
+ $surrogate = ipull($list, $index);
+
+ asort($surrogate);
+
+ $result = array();
+ foreach ($surrogate as $key => $value) {
+ $result[$key] = $list[$key];
+ }
+
+ return $result;
+}
+
+
+/**
+ * Filter a list of objects by executing a method across all the objects and
+ * filter out the ones with empty() results. this function works just like
+ * @{function:ifilter}, except that it operates on a list of objects instead
+ * of a list of arrays.
+ *
+ * For example, to remove all objects with no children from a list, where
+ * 'hasChildren' is a method name, do this:
+ *
+ * mfilter($list, 'hasChildren');
+ *
+ * The optional third parameter allows you to negate the operation and filter
+ * out nonempty objects. To remove all objects that DO have children, do this:
+ *
+ * mfilter($list, 'hasChildren', true);
+ *
+ * @param array List of objects to filter.
+ * @param string A method name.
+ * @param bool Optionally, pass true to drop objects which pass the
+ * filter instead of keeping them.
+ * @return array List of objects which pass the filter.
+ */
+function mfilter(array $list, $method, $negate = false) {
+ if (!is_string($method)) {
+ throw new InvalidArgumentException(pht('Argument method is not a string.'));
+ }
+
+ $result = array();
+ foreach ($list as $key => $object) {
+ $value = $object->$method();
+
+ if (!$negate) {
+ if (!empty($value)) {
+ $result[$key] = $object;
+ }
+ } else {
+ if (empty($value)) {
+ $result[$key] = $object;
+ }
+ }
+ }
+
+ return $result;
+}
+
+
+/**
+ * Filter a list of arrays by removing the ones with an empty() value for some
+ * index. This function works just like @{function:mfilter}, except that it
+ * operates on a list of arrays instead of a list of objects.
+ *
+ * For example, to remove all arrays without value for key 'username', do this:
+ *
+ * ifilter($list, 'username');
+ *
+ * The optional third parameter allows you to negate the operation and filter
+ * out nonempty arrays. To remove all arrays that DO have value for key
+ * 'username', do this:
+ *
+ * ifilter($list, 'username', true);
+ *
+ * @param array List of arrays to filter.
+ * @param scalar The index.
+ * @param bool Optionally, pass true to drop arrays which pass the
+ * filter instead of keeping them.
+ * @return array List of arrays which pass the filter.
+ */
+function ifilter(array $list, $index, $negate = false) {
+ if (!is_scalar($index)) {
+ throw new InvalidArgumentException(pht('Argument index is not a scalar.'));
+ }
+
+ $result = array();
+ if (!$negate) {
+ foreach ($list as $key => $array) {
+ if (!empty($array[$index])) {
+ $result[$key] = $array;
+ }
+ }
+ } else {
+ foreach ($list as $key => $array) {
+ if (empty($array[$index])) {
+ $result[$key] = $array;
+ }
+ }
+ }
+
+ return $result;
+}
+
+
+/**
+ * Selects a list of keys from an array, returning a new array with only the
+ * key-value pairs identified by the selected keys, in the specified order.
+ *
+ * Note that since this function orders keys in the result according to the
+ * order they appear in the list of keys, there are effectively two common
+ * uses: either reducing a large dictionary to a smaller one, or changing the
+ * key order on an existing dictionary.
+ *
+ * @param dict Dictionary of key-value pairs to select from.
+ * @param list List of keys to select.
+ * @return dict Dictionary of only those key-value pairs where the key was
+ * present in the list of keys to select. Ordering is
+ * determined by the list order.
+ */
+function array_select_keys(array $dict, array $keys) {
+ $result = array();
+ foreach ($keys as $key) {
+ if (array_key_exists($key, $dict)) {
+ $result[$key] = $dict[$key];
+ }
+ }
+ return $result;
+}
+
+
+/**
+ * Checks if all values of array are instances of the passed class. Throws
+ * `InvalidArgumentException` if it isn't true for any value.
+ *
+ * @param array
+ * @param string Name of the class or 'array' to check arrays.
+ * @return array Returns passed array.
+ */
+function assert_instances_of(array $arr, $class) {
+ $is_array = !strcasecmp($class, 'array');
+
+ foreach ($arr as $key => $object) {
+ if ($is_array) {
+ if (!is_array($object)) {
+ $given = gettype($object);
+ throw new InvalidArgumentException(
+ pht(
+ "Array item with key '%s' must be of type array, %s given.",
+ $key,
+ $given));
+ }
+
+ } else if (!($object instanceof $class)) {
+ $given = gettype($object);
+ if (is_object($object)) {
+ $given = pht('instance of %s', get_class($object));
+ }
+ throw new InvalidArgumentException(
+ pht(
+ "Array item with key '%s' must be an instance of %s, %s given.",
+ $key,
+ $class,
+ $given));
+ }
+ }
+
+ return $arr;
+}
+
+/**
+ * Assert that passed data can be converted to string.
+ *
+ * @param string Assert that this data is valid.
+ * @return void
+ *
+ * @task assert
+ */
+function assert_stringlike($parameter) {
+ switch (gettype($parameter)) {
+ case 'string':
+ case 'NULL':
+ case 'boolean':
+ case 'double':
+ case 'integer':
+ return;
+ case 'object':
+ if (method_exists($parameter, '__toString')) {
+ return;
+ }
+ break;
+ case 'array':
+ case 'resource':
+ case 'unknown type':
+ default:
+ break;
+ }
+
+ throw new InvalidArgumentException(
+ pht(
+ 'Argument must be scalar or object which implements %s!',
+ '__toString()'));
+}
+
+/**
+ * Returns the first argument which is not strictly null, or `null` if there
+ * are no such arguments. Identical to the MySQL function of the same name.
+ *
+ * @param ... Zero or more arguments of any type.
+ * @return mixed First non-`null` arg, or null if no such arg exists.
+ */
+function coalesce(/* ... */) {
+ $args = func_get_args();
+ foreach ($args as $arg) {
+ if ($arg !== null) {
+ return $arg;
+ }
+ }
+ return null;
+}
+
+
+/**
+ * Similar to @{function:coalesce}, but less strict: returns the first
+ * non-`empty()` argument, instead of the first argument that is strictly
+ * non-`null`. If no argument is nonempty, it returns the last argument. This
+ * is useful idiomatically for setting defaults:
+ *
+ * $display_name = nonempty($user_name, $full_name, "Anonymous");
+ *
+ * @param ... Zero or more arguments of any type.
+ * @return mixed First non-`empty()` arg, or last arg if no such arg
+ * exists, or null if you passed in zero args.
+ */
+function nonempty(/* ... */) {
+ $args = func_get_args();
+ $result = null;
+ foreach ($args as $arg) {
+ $result = $arg;
+ if ($arg) {
+ break;
+ }
+ }
+ return $result;
+}
+
+
+/**
+ * Invokes the "new" operator with a vector of arguments. There is no way to
+ * `call_user_func_array()` on a class constructor, so you can instead use this
+ * function:
+ *
+ * $obj = newv($class_name, $argv);
+ *
+ * That is, these two statements are equivalent:
+ *
+ * $pancake = new Pancake('Blueberry', 'Maple Syrup', true);
+ * $pancake = newv('Pancake', array('Blueberry', 'Maple Syrup', true));
+ *
+ * DO NOT solve this problem in other, more creative ways! Three popular
+ * alternatives are:
+ *
+ * - Build a fake serialized object and unserialize it.
+ * - Invoke the constructor twice.
+ * - just use `eval()` lol
+ *
+ * These are really bad solutions to the problem because they can have side
+ * effects (e.g., __wakeup()) and give you an object in an otherwise impossible
+ * state. Please endeavor to keep your objects in possible states.
+ *
+ * If you own the classes you're doing this for, you should consider whether
+ * or not restructuring your code (for instance, by creating static
+ * construction methods) might make it cleaner before using `newv()`. Static
+ * constructors can be invoked with `call_user_func_array()`, and may give your
+ * class a cleaner and more descriptive API.
+ *
+ * @param string The name of a class.
+ * @param list Array of arguments to pass to its constructor.
+ * @return obj A new object of the specified class, constructed by passing
+ * the argument vector to its constructor.
+ */
+function newv($class_name, array $argv) {
+ $reflector = new ReflectionClass($class_name);
+ if ($argv) {
+ return $reflector->newInstanceArgs($argv);
+ } else {
+ return $reflector->newInstance();
+ }
+}
+
+
+/**
+ * Returns the first element of an array. Exactly like reset(), but doesn't
+ * choke if you pass it some non-referenceable value like the return value of
+ * a function.
+ *
+ * @param array Array to retrieve the first element from.
+ * @return wild The first value of the array.
+ */
+function head(array $arr) {
+ return reset($arr);
+}
+
+/**
+ * Returns the last element of an array. This is exactly like `end()` except
+ * that it won't warn you if you pass some non-referencable array to
+ * it -- e.g., the result of some other array operation.
+ *
+ * @param array Array to retrieve the last element from.
+ * @return wild The last value of the array.
+ */
+function last(array $arr) {
+ return end($arr);
+}
+
+/**
+ * Returns the first key of an array.
+ *
+ * @param array Array to retrieve the first key from.
+ * @return int|string The first key of the array.
+ */
+function head_key(array $arr) {
+ reset($arr);
+ return key($arr);
+}
+
+/**
+ * Returns the last key of an array.
+ *
+ * @param array Array to retrieve the last key from.
+ * @return int|string The last key of the array.
+ */
+function last_key(array $arr) {
+ end($arr);
+ return key($arr);
+}
+
+/**
+ * Merge a vector of arrays performantly. This has the same semantics as
+ * array_merge(), so these calls are equivalent:
+ *
+ * array_merge($a, $b, $c);
+ * array_mergev(array($a, $b, $c));
+ *
+ * However, when you have a vector of arrays, it is vastly more performant to
+ * merge them with this function than by calling array_merge() in a loop,
+ * because using a loop generates an intermediary array on each iteration.
+ *
+ * @param list Vector of arrays to merge.
+ * @return list Arrays, merged with array_merge() semantics.
+ */
+function array_mergev(array $arrayv) {
+ if (!$arrayv) {
+ return array();
+ }
+
+ foreach ($arrayv as $key => $item) {
+ if (!is_array($item)) {
+ throw new InvalidArgumentException(
+ pht(
+ 'Expected all items passed to `%s` to be arrays, but '.
+ 'argument with key "%s" has type "%s".',
+ __FUNCTION__.'()',
+ $key,
+ gettype($item)));
+ }
+ }
+
+ return call_user_func_array('array_merge', $arrayv);
+}
+
+
+/**
+ * Split a corpus of text into lines. This function splits on "\n", "\r\n", or
+ * a mixture of any of them.
+ *
+ * NOTE: This function does not treat "\r" on its own as a newline because none
+ * of SVN, Git or Mercurial do on any OS.
+ *
+ * @param string Block of text to be split into lines.
+ * @param bool If true, retain line endings in result strings.
+ * @return list List of lines.
+ */
+function phutil_split_lines($corpus, $retain_endings = true) {
+ if (!strlen($corpus)) {
+ return array('');
+ }
+
+ // Split on "\r\n" or "\n".
+ if ($retain_endings) {
+ $lines = preg_split('/(?<=\n)/', $corpus);
+ } else {
+ $lines = preg_split('/\r?\n/', $corpus);
+ }
+
+ // If the text ends with "\n" or similar, we'll end up with an empty string
+ // at the end; discard it.
+ if (end($lines) == '') {
+ array_pop($lines);
+ }
+
+ if ($corpus instanceof PhutilSafeHTML) {
+ return array_map('phutil_safe_html', $lines);
+ }
+
+ return $lines;
+}
+
+
+/**
+ * Simplifies a common use of `array_combine()`. Specifically, this:
+ *
+ * COUNTEREXAMPLE:
+ * if ($list) {
+ * $result = array_combine($list, $list);
+ * } else {
+ * // Prior to PHP 5.4, array_combine() failed if given empty arrays.
+ * $result = array();
+ * }
+ *
+ * ...is equivalent to this:
+ *
+ * $result = array_fuse($list);
+ *
+ * @param list List of scalars.
+ * @return dict Dictionary with inputs mapped to themselves.
+ */
+function array_fuse(array $list) {
+ if ($list) {
+ return array_combine($list, $list);
+ }
+ return array();
+}
+
+
+/**
+ * Add an element between every two elements of some array. That is, given a
+ * list `A, B, C, D`, and some element to interleave, `x`, this function returns
+ * `A, x, B, x, C, x, D`. This works like `implode()`, but does not concatenate
+ * the list into a string. In particular:
+ *
+ * implode('', array_interleave($x, $list));
+ *
+ * ...is equivalent to:
+ *
+ * implode($x, $list);
+ *
+ * This function does not preserve keys.
+ *
+ * @param wild Element to interleave.
+ * @param list List of elements to be interleaved.
+ * @return list Original list with the new element interleaved.
+ */
+function array_interleave($interleave, array $array) {
+ $result = array();
+ foreach ($array as $item) {
+ $result[] = $item;
+ $result[] = $interleave;
+ }
+ array_pop($result);
+ return $result;
+}
+
+function phutil_is_windows() {
+ // We can also use PHP_OS, but that's kind of sketchy because it returns
+ // "WINNT" for Windows 7 and "Darwin" for Mac OS X. Practically, testing for
+ // DIRECTORY_SEPARATOR is more straightforward.
+ return (DIRECTORY_SEPARATOR != '/');
+}
+
+function phutil_is_hiphop_runtime() {
+ return (array_key_exists('HPHP', $_ENV) && $_ENV['HPHP'] === 1);
+}
+
+/**
+ * Converts a string to a loggable one, with unprintables and newlines escaped.
+ *
+ * @param string Any string.
+ * @return string String with control and newline characters escaped, suitable
+ * for printing on a single log line.
+ */
+function phutil_loggable_string($string) {
+ if (preg_match('/^[\x20-\x7E]+$/', $string)) {
+ return $string;
+ }
+
+ $result = '';
+
+ static $c_map = array(
+ '\\' => '\\\\',
+ "\n" => '\\n',
+ "\r" => '\\r',
+ "\t" => '\\t',
+ );
+
+ $len = strlen($string);
+ for ($ii = 0; $ii < $len; $ii++) {
+ $c = $string[$ii];
+ if (isset($c_map[$c])) {
+ $result .= $c_map[$c];
+ } else {
+ $o = ord($c);
+ if ($o < 0x20 || $o == 0x7F) {
+ $result .= '\\x'.sprintf('%02X', $o);
+ } else {
+ $result .= $c;
+ }
+ }
+ }
+
+ return $result;
+}
+
+
+/**
+ * Perform an `fwrite()` which distinguishes between EAGAIN and EPIPE.
+ *
+ * PHP's `fwrite()` is broken, and never returns `false` for writes to broken
+ * nonblocking pipes: it always returns 0, and provides no straightforward
+ * mechanism for distinguishing between EAGAIN (buffer is full, can't write any
+ * more right now) and EPIPE or similar (no write will ever succeed).
+ *
+ * See: https://bugs.php.net/bug.php?id=39598
+ *
+ * If you call this method instead of `fwrite()`, it will attempt to detect
+ * when a zero-length write is caused by EAGAIN and return `0` only if the
+ * write really should be retried.
+ *
+ * @param resource Socket or pipe stream.
+ * @param string Bytes to write.
+ * @return bool|int Number of bytes written, or `false` on any error (including
+ * errors which `fwrite()` can not detect, like a broken pipe).
+ */
+function phutil_fwrite_nonblocking_stream($stream, $bytes) {
+ if (!strlen($bytes)) {
+ return 0;
+ }
+
+ $result = @fwrite($stream, $bytes);
+ if ($result !== 0) {
+ // In cases where some bytes are witten (`$result > 0`) or
+ // an error occurs (`$result === false`), the behavior of fwrite() is
+ // correct. We can return the value as-is.
+ return $result;
+ }
+
+ // If we make it here, we performed a 0-length write. Try to distinguish
+ // between EAGAIN and EPIPE. To do this, we're going to `stream_select()`
+ // the stream, write to it again if PHP claims that it's writable, and
+ // consider the pipe broken if the write fails.
+
+ $read = array();
+ $write = array($stream);
+ $except = array();
+
+ @stream_select($read, $write, $except, 0);
+
+ if (!$write) {
+ // The stream isn't writable, so we conclude that it probably really is
+ // blocked and the underlying error was EAGAIN. Return 0 to indicate that
+ // no data could be written yet.
+ return 0;
+ }
+
+ // If we make it here, PHP **just** claimed that this stream is writable, so
+ // perform a write. If the write also fails, conclude that these failures are
+ // EPIPE or some other permanent failure.
+ $result = @fwrite($stream, $bytes);
+ if ($result !== 0) {
+ // The write worked or failed explicitly. This value is fine to return.
+ return $result;
+ }
+
+ // We performed a 0-length write, were told that the stream was writable, and
+ // then immediately performed another 0-length write. Conclude that the pipe
+ // is broken and return `false`.
+ return false;
+}
+
+
+/**
+ * Convert a human-readable unit description into a numeric one. This function
+ * allows you to replace this:
+ *
+ * COUNTEREXAMPLE
+ * $ttl = (60 * 60 * 24 * 30); // 30 days
+ *
+ * ...with this:
+ *
+ * $ttl = phutil_units('30 days in seconds');
+ *
+ * ...which is self-documenting and difficult to make a mistake with.
+ *
+ * @param string Human readable description of a unit quantity.
+ * @return int Quantity of specified unit.
+ */
+function phutil_units($description) {
+ $matches = null;
+ if (!preg_match('/^(\d+) (\w+) in (\w+)$/', $description, $matches)) {
+ throw new InvalidArgumentException(
+ pht(
+ 'Unable to parse unit specification (expected a specification in the '.
+ 'form "%s"): %s',
+ '5 days in seconds',
+ $description));
+ }
+
+ $quantity = (int)$matches[1];
+ $src_unit = $matches[2];
+ $dst_unit = $matches[3];
+
+ $is_divisor = false;
+
+ switch ($dst_unit) {
+ case 'seconds':
+ switch ($src_unit) {
+ case 'second':
+ case 'seconds':
+ $factor = 1;
+ break;
+ case 'minute':
+ case 'minutes':
+ $factor = 60;
+ break;
+ case 'hour':
+ case 'hours':
+ $factor = 60 * 60;
+ break;
+ case 'day':
+ case 'days':
+ $factor = 60 * 60 * 24;
+ break;
+ default:
+ throw new InvalidArgumentException(
+ pht(
+ 'This function can not convert from the unit "%s".',
+ $src_unit));
+ }
+ break;
+ case 'bytes':
+ switch ($src_unit) {
+ case 'byte':
+ case 'bytes':
+ $factor = 1;
+ break;
+ case 'bit':
+ case 'bits':
+ $factor = 8;
+ $is_divisor = true;
+ break;
+ default:
+ throw new InvalidArgumentException(
+ pht(
+ 'This function can not convert from the unit "%s".',
+ $src_unit));
+ }
+ break;
+ default:
+ throw new InvalidArgumentException(
+ pht(
+ 'This function can not convert into the unit "%s".',
+ $dst_unit));
+ }
+
+ if ($is_divisor) {
+ if ($quantity % $factor) {
+ throw new InvalidArgumentException(
+ pht(
+ '"%s" is not an exact quantity.',
+ $description));
+ }
+ return (int)($quantity / $factor);
+ } else {
+ return $quantity * $factor;
+ }
+}
+
+
+/**
+ * Decode a JSON dictionary.
+ *
+ * @param string A string which ostensibly contains a JSON-encoded list or
+ * dictionary.
+ * @return mixed Decoded list/dictionary.
+ */
+function phutil_json_decode($string) {
+ $result = @json_decode($string, true);
+
+ if (!is_array($result)) {
+ // Failed to decode the JSON. Try to use @{class:PhutilJSONParser} instead.
+ // This will probably fail, but will throw a useful exception.
+ $parser = new PhutilJSONParser();
+ $result = $parser->parse($string);
+ }
+
+ return $result;
+}
+
+
+/**
+ * Encode a value in JSON, raising an exception if it can not be encoded.
+ *
+ * @param wild A value to encode.
+ * @return string JSON representation of the value.
+ */
+function phutil_json_encode($value) {
+ $result = @json_encode($value);
+ if ($result === false) {
+ $reason = phutil_validate_json($value);
+ if (function_exists('json_last_error')) {
+ $err = json_last_error();
+ if (function_exists('json_last_error_msg')) {
+ $msg = json_last_error_msg();
+ $extra = pht('#%d: %s', $err, $msg);
+ } else {
+ $extra = pht('#%d', $err);
+ }
+ } else {
+ $extra = null;
+ }
+
+ if ($extra) {
+ $message = pht(
+ 'Failed to JSON encode value (%s): %s.',
+ $extra,
+ $reason);
+ } else {
+ $message = pht(
+ 'Failed to JSON encode value: %s.',
+ $reason);
+ }
+
+ throw new Exception($message);
+ }
+
+ return $result;
+}
+
+
+/**
+ * Produce a human-readable explanation why a value can not be JSON-encoded.
+ *
+ * @param wild Value to validate.
+ * @param string Path within the object to provide context.
+ * @return string|null Explanation of why it can't be encoded, or null.
+ */
+function phutil_validate_json($value, $path = '') {
+ if ($value === null) {
+ return;
+ }
+
+ if ($value === true) {
+ return;
+ }
+
+ if ($value === false) {
+ return;
+ }
+
+ if (is_int($value)) {
+ return;
+ }
+
+ if (is_float($value)) {
+ return;
+ }
+
+ if (is_array($value)) {
+ foreach ($value as $key => $subvalue) {
+ if (strlen($path)) {
+ $full_key = $path.' > ';
+ } else {
+ $full_key = '';
+ }
+
+ if (!phutil_is_utf8($key)) {
+ $full_key = $full_key.phutil_utf8ize($key);
+ return pht(
+ 'Dictionary key "%s" is not valid UTF8, and cannot be JSON encoded.',
+ $full_key);
+ }
+
+ $full_key .= $key;
+ $result = phutil_validate_json($subvalue, $full_key);
+ if ($result !== null) {
+ return $result;
+ }
+ }
+ }
+
+ if (is_string($value)) {
+ if (!phutil_is_utf8($value)) {
+ $display = substr($value, 0, 256);
+ $display = phutil_utf8ize($display);
+ if (!strlen($path)) {
+ return pht(
+ 'String value is not valid UTF8, and can not be JSON encoded: %s',
+ $display);
+ } else {
+ return pht(
+ 'Dictionary value at key "%s" is not valid UTF8, and cannot be '.
+ 'JSON encoded: %s',
+ $path,
+ $display);
+ }
+ }
+ }
+
+ return;
+}
+
+
+/**
+ * Decode an INI string.
+ *
+ * @param string
+ * @return mixed
+ */
+function phutil_ini_decode($string) {
+ $results = null;
+ $trap = new PhutilErrorTrap();
+
+ try {
+ if (!function_exists('parse_ini_string')) {
+ throw new PhutilMethodNotImplementedException(
+ pht(
+ '%s is not compatible with your version of PHP (%s). This function '.
+ 'is only supported on PHP versions newer than 5.3.0.',
+ __FUNCTION__,
+ phpversion()));
+ }
+
+ $results = @parse_ini_string($string, true, INI_SCANNER_RAW);
+
+ if ($results === false) {
+ throw new PhutilINIParserException(trim($trap->getErrorsAsString()));
+ }
+
+ foreach ($results as $section => $result) {
+ if (!is_array($result)) {
+ // We JSON decode the value in ordering to perform the following
+ // conversions:
+ //
+ // - `'true'` => `true`
+ // - `'false'` => `false`
+ // - `'123'` => `123`
+ // - `'1.234'` => `1.234`
+ //
+ $result = json_decode($result, true);
+
+ if ($result !== null && !is_array($result)) {
+ $results[$section] = $result;
+ }
+
+ continue;
+ }
+
+ foreach ($result as $key => $value) {
+ $value = json_decode($value, true);
+
+ if ($value !== null && !is_array($value)) {
+ $results[$section][$key] = $value;
+ }
+ }
+ }
+ } catch (Exception $ex) {
+ $trap->destroy();
+ throw $ex;
+ }
+
+ $trap->destroy();
+ return $results;
+}
+
+
+/**
+ * Attempt to censor any plaintext credentials from a string.
+ *
+ * The major use case here is to censor usernames and passwords from command
+ * output. For example, when `git fetch` fails, the output includes credentials
+ * for authenticated HTTP remotes.
+ *
+ * @param string Some block of text.
+ * @return string A similar block of text, but with credentials that could
+ * be identified censored.
+ */
+function phutil_censor_credentials($string) {
+ return preg_replace(',(?<=://)([^/@\s]+)(?=@|$),', '********', $string);
+}
+
+
+/**
+ * Returns a parsable string representation of a variable.
+ *
+ * This function is intended to behave similarly to PHP's `var_export` function,
+ * but the output is intended to follow our style conventions.
+ *
+ * @param wild The variable you want to export.
+ * @return string
+ */
+function phutil_var_export($var) {
+ // `var_export(null, true)` returns `"NULL"` (in uppercase).
+ if ($var === null) {
+ return 'null';
+ }
+
+ // PHP's `var_export` doesn't format arrays very nicely. In particular:
+ //
+ // - An empty array is split over two lines (`"array (\n)"`).
+ // - A space separates "array" and the first opening brace.
+ // - Non-associative arrays are returned as associative arrays with an
+ // integer key.
+ //
+ if (is_array($var)) {
+ if (count($var) === 0) {
+ return 'array()';
+ }
+
+ // Don't show keys for non-associative arrays.
+ $show_keys = (array_keys($var) !== range(0, count($var) - 1));
+
+ $output = array();
+ $output[] = 'array(';
+
+ foreach ($var as $key => $value) {
+ // Adjust the indentation of the value.
+ $value = str_replace("\n", "\n ", phutil_var_export($value));
+ $output[] = ' '.
+ ($show_keys ? var_export($key, true).' => ' : '').
+ $value.',';
+ }
+
+ $output[] = ')';
+ return implode("\n", $output);
+ }
+
+ // Let PHP handle everything else.
+ return var_export($var, true);
+}
+
+
+/**
+ * An improved version of `fnmatch`.
+ *
+ * @param string A glob pattern.
+ * @param string A path.
+ * @return bool
+ */
+function phutil_fnmatch($glob, $path) {
+ // Modify the glob to allow `**/` to match files in the root directory.
+ $glob = preg_replace('@(?:(? $now - $shift) {
+ $format = pht('D, M j');
+ } else {
+ $format = pht('M j Y');
+ }
+ return $format;
+}
+
+function phutil_format_relative_time($duration) {
+ return phutil_format_units_generic(
+ $duration,
+ array(60, 60, 24, 7),
+ array('s', 'm', 'h', 'd', 'w'),
+ $precision = 0);
+}
+
+/**
+ * Format a relative time (duration) into weeks, days, hours, minutes,
+ * seconds, but unlike phabricator_format_relative_time, does so for more than
+ * just the largest unit.
+ *
+ * @param int Duration in seconds.
+ * @param int Levels to render - will render the three highest levels, ie:
+ * 5 h, 37 m, 1 s
+ * @return string Human-readable description.
+ */
+function phutil_format_relative_time_detailed($duration, $levels = 2) {
+ if ($duration == 0) {
+ return 'now';
+ }
+ $levels = max(1, min($levels, 5));
+ $remainder = 0;
+
+ $is_negative = false;
+ if ($duration < 0) {
+ $is_negative = true;
+ $duration = abs($duration);
+ }
+
+ $this_level = 1;
+ $detailed_relative_time = phutil_format_units_generic(
+ $duration,
+ array(60, 60, 24, 7),
+ array('s', 'm', 'h', 'd', 'w'),
+ $precision = 0,
+ $remainder);
+ $duration = $remainder;
+
+ while ($remainder > 0 && $this_level < $levels) {
+ $detailed_relative_time .= ', '.phutil_format_units_generic(
+ $duration,
+ array(60, 60, 24, 7),
+ array('s', 'm', 'h', 'd', 'w'),
+ $precision = 0,
+ $remainder);
+ $duration = $remainder;
+ $this_level++;
+ }
+
+ if ($is_negative) {
+ $detailed_relative_time .= ' ago';
+ }
+
+ return $detailed_relative_time;
+}
+
+/**
+ * Format a byte count for human consumption, e.g. "10MB" instead of
+ * "10485760".
+ *
+ * @param int Number of bytes.
+ * @return string Human-readable description.
+ */
+function phutil_format_bytes($bytes) {
+ return phutil_format_units_generic(
+ $bytes,
+ array(1024, 1024, 1024, 1024, 1024),
+ array('B', 'KB', 'MB', 'GB', 'TB', 'PB'),
+ $precision = 0);
+}
+
+
+/**
+ * Parse a human-readable byte description (like "6MB") into an integer.
+ *
+ * @param string Human-readable description.
+ * @return int Number of represented bytes.
+ */
+function phutil_parse_bytes($input) {
+ $bytes = trim($input);
+ if (!strlen($bytes)) {
+ return null;
+ }
+
+ // NOTE: Assumes US-centric numeral notation.
+ $bytes = preg_replace('/[ ,]/', '', $bytes);
+
+ $matches = null;
+ if (!preg_match('/^(?:\d+(?:[.]\d+)?)([kmgtp]?)b?$/i', $bytes, $matches)) {
+ throw new Exception(pht("Unable to parse byte size '%s'!", $input));
+ }
+
+ $scale = array(
+ 'k' => 1024,
+ 'm' => 1024 * 1024,
+ 'g' => 1024 * 1024 * 1024,
+ 't' => 1024 * 1024 * 1024 * 1024,
+ 'p' => 1024 * 1024 * 1024 * 1024 * 1024,
+ );
+
+ $bytes = (float)$bytes;
+ if ($matches[1]) {
+ $bytes *= $scale[strtolower($matches[1])];
+ }
+
+ return (int)$bytes;
+}
+
+
+function phutil_format_units_generic(
+ $n,
+ array $scales,
+ array $labels,
+ $precision = 0,
+ &$remainder = null) {
+
+ $is_negative = false;
+ if ($n < 0) {
+ $is_negative = true;
+ $n = abs($n);
+ }
+
+ $remainder = 0;
+ $accum = 1;
+
+ $scale = array_shift($scales);
+ $label = array_shift($labels);
+ while ($n >= $scale && count($labels)) {
+ $remainder += ($n % $scale) * $accum;
+ $n /= $scale;
+ $accum *= $scale;
+ $label = array_shift($labels);
+ if (!count($scales)) {
+ break;
+ }
+ $scale = array_shift($scales);
+ }
+
+ if ($is_negative) {
+ $n = -$n;
+ $remainder = -$remainder;
+ }
+
+ if ($precision) {
+ $num_string = number_format($n, $precision);
+ } else {
+ $num_string = (int)floor($n);
+ }
+
+ if ($label) {
+ $num_string .= ' '.$label;
+ }
+
+ return $num_string;
+}
diff --git a/src/xsprintf/PhutilCommandString.php b/src/xsprintf/PhutilCommandString.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/PhutilCommandString.php
@@ -0,0 +1,85 @@
+argv = $argv;
+
+ $this->escapingMode = self::MODE_DEFAULT;
+
+ // This makes sure we throw immediately if there are errors in the
+ // parameters.
+ $this->getMaskedString();
+ }
+
+ public function __toString() {
+ return $this->getMaskedString();
+ }
+
+ public function getUnmaskedString() {
+ return $this->renderString(true);
+ }
+
+ public function getMaskedString() {
+ return $this->renderString(false);
+ }
+
+ public function setEscapingMode($escaping_mode) {
+ $this->escapingMode = $escaping_mode;
+ return $this;
+ }
+
+ private function renderString($unmasked) {
+ return xsprintf(
+ 'xsprintf_command',
+ array(
+ 'unmasked' => $unmasked,
+ 'mode' => $this->escapingMode,
+ ),
+ $this->argv);
+ }
+
+ public static function escapeArgument($value, $mode) {
+ switch ($mode) {
+ case self::MODE_DEFAULT:
+ return escapeshellarg($value);
+ case self::MODE_POWERSHELL:
+ return self::escapePowershell($value);
+ default:
+ throw new Exception(pht('Unknown escaping mode!'));
+ }
+ }
+
+ private static function escapePowershell($value) {
+ // These escape sequences are from http://ss64.com/ps/syntax-esc.html
+
+ // Replace backticks first.
+ $value = str_replace('`', '``', $value);
+
+ // Now replace other required notations.
+ $value = str_replace("\0", '`0', $value);
+ $value = str_replace(chr(7), '`a', $value);
+ $value = str_replace(chr(8), '`b', $value);
+ $value = str_replace("\f", '`f', $value);
+ $value = str_replace("\n", '`n', $value);
+ $value = str_replace("\r", '`r', $value);
+ $value = str_replace("\t", '`t', $value);
+ $value = str_replace("\v", '`v', $value);
+ $value = str_replace('#', '`#', $value);
+ $value = str_replace("'", '`\'', $value);
+ $value = str_replace('"', '`"', $value);
+
+ // The rule on dollar signs is mentioned further down the page, and
+ // they only need to be escaped when using double quotes (which we are).
+ $value = str_replace('$', '`$', $value);
+
+ return '"'.$value.'"';
+ }
+
+}
diff --git a/src/xsprintf/PhutilQsprintfInterface.php b/src/xsprintf/PhutilQsprintfInterface.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/PhutilQsprintfInterface.php
@@ -0,0 +1,9 @@
+string = $string;
+ }
+
+ public function __toString() {
+ return $this->string;
+ }
+
+ public function applyWrap() {
+ $string = (string)$this;
+ $string = phutil_console_wrap($string);
+ return new self($string);
+ }
+
+ public function applyIndent($depth, $with_prefix = true) {
+ $string = (string)$this;
+ $string = phutil_console_wrap($string, $depth, $with_prefix);
+ return new self($string);
+ }
+
+ public static function escapeStringValue($value, $allow_whitespace) {
+ if ($value instanceof PhutilTerminalString) {
+ return (string)$value;
+ }
+
+ $value = (string)$value;
+
+ static $escape_map;
+ if ($escape_map === null) {
+ $escape_map = array(
+ chr(0x00) => '',
+ chr(0x07) => '',
+ chr(0x08) => '',
+ chr(0x09) => '',
+ chr(0x0A) => '',
+ chr(0x0D) => '',
+ chr(0x1B) => '',
+ chr(0x7F) => '',
+ );
+
+ for ($ii = 0; $ii < 32; $ii++) {
+ $c = chr($ii);
+ if (empty($escape_map[$c])) {
+ $escape_map[$c] = sprintf('<0x%02X>', $ii);
+ }
+ }
+ }
+
+ $map = $escape_map;
+ if ($allow_whitespace) {
+ unset($map["\r"]);
+ unset($map["\n"]);
+ unset($map["\t"]);
+ }
+
+ $value = str_replace(array_keys($map), array_values($map), $value);
+
+ // In this mode, we additionally escape any which is not immediately
+ // followed by .
+ if ($allow_whitespace) {
+ $value = preg_replace('/\r(?!\n)/', '', $value);
+ }
+
+ return $value;
+ }
+}
diff --git a/src/xsprintf/__tests__/PhutilCsprintfTestCase.php b/src/xsprintf/__tests__/PhutilCsprintfTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/__tests__/PhutilCsprintfTestCase.php
@@ -0,0 +1,96 @@
+ true,
+
+ // For arguments which have any characters which are not safe in some
+ // context, %R should apply standard escaping.
+ 'a b' => false,
+
+
+ 'http://domain.com/path/' => true,
+ 'svn+ssh://domain.com/path/' => true,
+ '`rm -rf`' => false,
+ '$VALUE' => false,
+ );
+
+ foreach ($inputs as $input => $expect_same) {
+ $actual = (string)csprintf('%R', $input);
+ if ($expect_same) {
+ $this->assertEqual($input, $actual);
+ } else {
+ $this->assertFalse($input === $actual);
+ }
+ }
+ }
+
+ public function testPowershell() {
+ $cmd = csprintf('%s', "\n");
+ $cmd->setEscapingMode(PhutilCommandString::MODE_POWERSHELL);
+
+ $this->assertEqual(
+ '"`n"',
+ (string)$cmd);
+ }
+
+ public function testNoPowershell() {
+ if (!phutil_is_windows()) {
+ $cmd = csprintf('%s', '#');
+ $cmd->setEscapingMode(PhutilCommandString::MODE_DEFAULT);
+
+ $this->assertEqual(
+ '\'#\'',
+ (string)$cmd);
+ }
+ }
+
+ public function testPasswords() {
+ // Normal "%s" doesn't do anything special.
+ $command = csprintf('echo %s', 'hunter2trustno1');
+ $this->assertTrue(strpos($command, 'hunter2trustno1') !== false);
+
+ // "%P" takes a PhutilOpaqueEnvelope.
+ $caught = null;
+ try {
+ csprintf('echo %P', 'hunter2trustno1');
+ } catch (Exception $ex) {
+ $caught = $ex;
+ }
+ $this->assertTrue($caught instanceof InvalidArgumentException);
+
+
+ // "%P" masks the provided value.
+ $command = csprintf('echo %P', new PhutilOpaqueEnvelope('hunter2trustno1'));
+ $this->assertFalse(strpos($command, 'hunter2trustno1'));
+
+
+ // Executing the command works as expected.
+ list($out) = execx('%C', $command);
+ $this->assertTrue(strpos($out, 'hunter2trustno1') !== false);
+ }
+
+ public function testEscapingIsRobust() {
+ if (phutil_is_windows()) {
+ $this->assertSkipped(pht("This test doesn't work on Windows."));
+ }
+
+ // Escaping should be robust even when used to escape commands which take
+ // other commands.
+ list($out) = execx(
+ 'sh -c %s',
+ csprintf(
+ 'sh -c %s',
+ csprintf(
+ 'sh -c %s',
+ csprintf(
+ 'echo %P',
+ new PhutilOpaqueEnvelope('!@#$%^&*()')))));
+ $this->assertTrue(strpos($out, '!@#$%^&*()') !== false);
+ }
+
+}
diff --git a/src/xsprintf/__tests__/PhutilHgsprintfTestCase.php b/src/xsprintf/__tests__/PhutilHgsprintfTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/__tests__/PhutilHgsprintfTestCase.php
@@ -0,0 +1,23 @@
+assertEqual(
+ "'version-1'",
+ hgsprintf('%s', 'version-1'));
+
+ $this->assertEqual(
+ "'single\\'quote'",
+ hgsprintf('%s', "single'quote"));
+
+ $this->assertEqual(
+ "'back\\\\slash'",
+ hgsprintf('%s', 'back\\slash'));
+
+ $this->assertEqual(
+ "'33%'",
+ hgsprintf('%R', hgsprintf('%s', '33%')));
+ }
+
+}
diff --git a/src/xsprintf/__tests__/PhutilPregsprintfTestCase.php b/src/xsprintf/__tests__/PhutilPregsprintfTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/__tests__/PhutilPregsprintfTestCase.php
@@ -0,0 +1,23 @@
+assertEqual(
+ chr(7).'foobar'.chr(7),
+ pregsprintf('%s', '', 'foobar'));
+
+ $this->assertEqual(
+ chr(7).'\.\*\[a\-z\]'.chr(7),
+ pregsprintf('%s', '', '.*[a-z]'));
+
+ $this->assertEqual(
+ chr(7).'.*[a-z]'.chr(7),
+ pregsprintf('%R', '', '.*[a-z]'));
+
+ $this->assertEqual(
+ chr(7).'^abc\.\*xyz.*$'.chr(7).'siU',
+ pregsprintf('^abc%sxyz%R$', 'siU', '.*', '.*'));
+ }
+
+}
diff --git a/src/xsprintf/__tests__/PhutilTsprintfTestCase.php b/src/xsprintf/__tests__/PhutilTsprintfTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/__tests__/PhutilTsprintfTestCase.php
@@ -0,0 +1,24 @@
+assertEqual(
+ '',
+ (string)tsprintf('%s', "\0"));
+
+ $this->assertEqual(
+ '[31mred[39m',
+ (string)tsprintf('%s', "\x1B[31mred\x1B[39m"));
+
+ $block = "1\r\n2\r3\n4";
+
+ $this->assertEqual(
+ '1234',
+ (string)tsprintf('%s', $block));
+ $this->assertEqual(
+ "1\r\n23\n4",
+ (string)tsprintf('%B', $block));
+ }
+
+}
diff --git a/src/xsprintf/__tests__/PhutilUrisprintfTestCase.php b/src/xsprintf/__tests__/PhutilUrisprintfTestCase.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/__tests__/PhutilUrisprintfTestCase.php
@@ -0,0 +1,19 @@
+assertEqual(
+ 'x.com?a=huh%3F',
+ urisprintf('x.com?a=%s', 'huh?'));
+
+ $this->assertEqual(
+ '/a/origin%252Fmaster/z/',
+ urisprintf('/a/%p/z/', 'origin/master'));
+
+ $this->assertEqual(
+ 'y.com?%21&%23',
+ vurisprintf('y.com?%s&%s', array('!', '#')));
+ }
+
+}
diff --git a/src/xsprintf/csprintf.php b/src/xsprintf/csprintf.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/csprintf.php
@@ -0,0 +1,140 @@
+ $pos + 1) ? $pattern[$pos + 1] : null;
+
+ $is_unmasked = !empty($userdata['unmasked']);
+
+ if (empty($userdata['mode'])) {
+ $mode = PhutilCommandString::MODE_DEFAULT;
+ } else {
+ $mode = $userdata['mode'];
+ }
+
+ if ($value instanceof PhutilCommandString) {
+ if ($is_unmasked) {
+ $value = $value->getUnmaskedString();
+ } else {
+ $value = $value->getMaskedString();
+ }
+ }
+
+ switch ($type) {
+ case 'L':
+ // Remove the L.
+ $pattern = substr_replace($pattern, '', $pos, 1);
+ $length = strlen($pattern);
+ $type = 's';
+
+ // Check that the value is a non-empty array.
+ if (!is_array($value)) {
+ throw new InvalidArgumentException(
+ pht('Expected an array for %%L%s conversion.', $next));
+ }
+
+ switch ($next) {
+ case 's':
+ $values = array();
+ foreach ($value as $val) {
+ $values[] = csprintf('%s', $val);
+ }
+ $value = implode(' ', $values);
+ break;
+
+ case 'R':
+ $values = array();
+ foreach ($value as $val) {
+ $values[] = csprintf('%R', $val);
+ }
+ $value = implode(' ', $values);
+ break;
+
+ default:
+ throw new XsprintfUnknownConversionException("%L{$next}");
+ }
+ break;
+
+ case 'R':
+ if (!preg_match('(^[a-zA-Z0-9:/@._+-]+$)', $value)) {
+ $value = PhutilCommandString::escapeArgument($value, $mode);
+ }
+ $type = 's';
+ break;
+ case 's':
+ $value = PhutilCommandString::escapeArgument($value, $mode);
+ $type = 's';
+ break;
+ case 'P':
+ if (!($value instanceof PhutilOpaqueEnvelope)) {
+ throw new InvalidArgumentException(
+ pht('Expected %s for %%P conversion.', 'PhutilOpaqueEnvelope'));
+ }
+ if ($is_unmasked) {
+ $value = $value->openEnvelope();
+ } else {
+ $value = '********';
+ }
+ $value = PhutilCommandString::escapeArgument($value, $mode);
+ $type = 's';
+ break;
+ case 'C':
+ $type = 's';
+ break;
+ }
+
+ $pattern[$pos] = $type;
+}
diff --git a/src/xsprintf/exception/XsprintfUnknownConversionException.php b/src/xsprintf/exception/XsprintfUnknownConversionException.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/exception/XsprintfUnknownConversionException.php
@@ -0,0 +1,10 @@
+ 0x1FFFFFFFFFFFFF) {
+ throw new RangeException(
+ pht(
+ "You are passing an integer to %s which is so large it can ".
+ "not be represented without loss of precision by Javascript's ".
+ "native %s class. Use %%# instead.",
+ 'jsprintf()',
+ 'Number'));
+ }
+ break;
+ }
+
+ $pattern[$pos] = $type;
+}
diff --git a/src/xsprintf/ldapsprintf.php b/src/xsprintf/ldapsprintf.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/ldapsprintf.php
@@ -0,0 +1,48 @@
+;"= ');
+ $type = 's';
+ break;
+
+ case 'Q':
+ $type = 's';
+ break;
+ }
+
+ $pattern[$pos] = $type;
+}
diff --git a/src/xsprintf/pregsprintf.php b/src/xsprintf/pregsprintf.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/pregsprintf.php
@@ -0,0 +1,45 @@
+ $delim);
+
+ $pattern = xsprintf('xsprintf_regex', $userdata, $args);
+ return $delim.$pattern.$delim.$flags;
+}
+
+/**
+ * @{function:xsprintf} callback for regular expressions.
+ */
+function xsprintf_regex($userdata, &$pattern, &$pos, &$value, &$length) {
+ $delim = idx($userdata, 'delimiter');
+ $type = $pattern[$pos];
+
+ switch ($type) {
+ case 's':
+ $value = preg_quote($value, $delim);
+ break;
+ case 'R':
+ $type = 's';
+ break;
+ }
+
+ $pattern[$pos] = $type;
+}
diff --git a/src/xsprintf/qsprintf.php b/src/xsprintf/qsprintf.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/qsprintf.php
@@ -0,0 +1,318 @@
+ and %<.
+ *
+ * %> ("Prefix")
+ * Escapes a prefix query for a LIKE clause. For example:
+ *
+ * // Find all rows where `name` starts with $prefix.
+ * qsprintf($escaper, 'WHERE name LIKE %>', $prefix);
+ *
+ * %< ("Suffix")
+ * Escapes a suffix query for a LIKE clause. For example:
+ *
+ * // Find all rows where `name` ends with $suffix.
+ * qsprintf($escaper, 'WHERE name LIKE %<', $suffix);
+ */
+function qsprintf(PhutilQsprintfInterface $escaper, $pattern /* , ... */) {
+ $args = func_get_args();
+ array_shift($args);
+ return xsprintf('xsprintf_query', $escaper, $args);
+}
+
+function vqsprintf(PhutilQsprintfInterface $escaper, $pattern, array $argv) {
+ array_unshift($argv, $pattern);
+ return xsprintf('xsprintf_query', $escaper, $argv);
+}
+
+/**
+ * @{function:xsprintf} callback for encoding SQL queries. See
+ * @{function:qsprintf}.
+ */
+function xsprintf_query($userdata, &$pattern, &$pos, &$value, &$length) {
+ $type = $pattern[$pos];
+ $escaper = $userdata;
+ $next = (strlen($pattern) > $pos + 1) ? $pattern[$pos + 1] : null;
+
+ $nullable = false;
+ $done = false;
+
+ $prefix = '';
+
+ if (!($escaper instanceof PhutilQsprintfInterface)) {
+ throw new InvalidArgumentException(pht('Invalid database escaper.'));
+ }
+
+ switch ($type) {
+ case '=': // Nullable test
+ switch ($next) {
+ case 'd':
+ case 'f':
+ case 's':
+ $pattern = substr_replace($pattern, '', $pos, 1);
+ $length = strlen($pattern);
+ $type = 's';
+ if ($value === null) {
+ $value = 'IS NULL';
+ $done = true;
+ } else {
+ $prefix = '= ';
+ $type = $next;
+ }
+ break;
+ default:
+ throw new Exception(
+ pht(
+ 'Unknown conversion, try %s, %s, or %s.',
+ '%=d',
+ '%=s',
+ '%=f'));
+ }
+ break;
+
+ case 'n': // Nullable...
+ switch ($next) {
+ case 'd': // ...integer.
+ case 'f': // ...float.
+ case 's': // ...string.
+ case 'B': // ...binary string.
+ $pattern = substr_replace($pattern, '', $pos, 1);
+ $length = strlen($pattern);
+ $type = $next;
+ $nullable = true;
+ break;
+ default:
+ throw new XsprintfUnknownConversionException("%n{$next}");
+ }
+ break;
+
+ case 'L': // List of..
+ qsprintf_check_type($value, "L{$next}", $pattern);
+ $pattern = substr_replace($pattern, '', $pos, 1);
+ $length = strlen($pattern);
+ $type = 's';
+ $done = true;
+
+ switch ($next) {
+ case 'd': // ...integers.
+ $value = implode(', ', array_map('intval', $value));
+ break;
+ case 'f': // ...floats.
+ $value = implode(', ', array_map('floatval', $value));
+ break;
+ case 's': // ...strings.
+ foreach ($value as $k => $v) {
+ $value[$k] = "'".$escaper->escapeUTF8String((string)$v)."'";
+ }
+ $value = implode(', ', $value);
+ break;
+ case 'B': // ...binary strings.
+ foreach ($value as $k => $v) {
+ $value[$k] = "'".$escaper->escapeBinaryString((string)$v)."'";
+ }
+ $value = implode(', ', $value);
+ break;
+ case 'C': // ...columns.
+ foreach ($value as $k => $v) {
+ $value[$k] = $escaper->escapeColumnName($v);
+ }
+ $value = implode(', ', $value);
+ break;
+ default:
+ throw new XsprintfUnknownConversionException("%L{$next}");
+ }
+ break;
+ }
+
+ if (!$done) {
+ qsprintf_check_type($value, $type, $pattern);
+ switch ($type) {
+ case 's': // String
+ if ($nullable && $value === null) {
+ $value = 'NULL';
+ } else {
+ $value = "'".$escaper->escapeUTF8String((string)$value)."'";
+ }
+ $type = 's';
+ break;
+
+ case 'B': // Binary String
+ if ($nullable && $value === null) {
+ $value = 'NULL';
+ } else {
+ $value = "'".$escaper->escapeBinaryString((string)$value)."'";
+ }
+ $type = 's';
+ break;
+
+ case 'Q': // Query Fragment
+ $type = 's';
+ break;
+
+ case '~': // Like Substring
+ case '>': // Like Prefix
+ case '<': // Like Suffix
+ $value = $escaper->escapeStringForLikeClause($value);
+ switch ($type) {
+ case '~': $value = "'%".$value."%'"; break;
+ case '>': $value = "'".$value."%'"; break;
+ case '<': $value = "'%".$value."'"; break;
+ }
+ $type = 's';
+ break;
+
+ case 'f': // Float
+ if ($nullable && $value === null) {
+ $value = 'NULL';
+ } else {
+ $value = (float)$value;
+ }
+ $type = 's';
+ break;
+
+ case 'd': // Integer
+ if ($nullable && $value === null) {
+ $value = 'NULL';
+ } else {
+ $value = (int)$value;
+ }
+ $type = 's';
+ break;
+
+ case 'T': // Table
+ case 'C': // Column
+ $value = $escaper->escapeColumnName($value);
+ $type = 's';
+ break;
+
+ case 'K': // Komment
+ $value = $escaper->escapeMultilineComment($value);
+ $type = 's';
+ break;
+
+ default:
+ throw new XsprintfUnknownConversionException($type);
+ }
+ }
+
+ if ($prefix) {
+ $value = $prefix.$value;
+ }
+ $pattern[$pos] = $type;
+}
+
+function qsprintf_check_type($value, $type, $query) {
+ switch ($type) {
+ case 'Ld':
+ case 'Ls':
+ case 'LC':
+ case 'LB':
+ case 'Lf':
+ if (!is_array($value)) {
+ throw new AphrontParameterQueryException(
+ $query,
+ pht('Expected array argument for %%%s conversion.', $type));
+ }
+ if (empty($value)) {
+ throw new AphrontParameterQueryException(
+ $query,
+ pht('Array for %%%s conversion is empty.', $type));
+ }
+
+ foreach ($value as $scalar) {
+ qsprintf_check_scalar_type($scalar, $type, $query);
+ }
+ break;
+ default:
+ qsprintf_check_scalar_type($value, $type, $query);
+ break;
+ }
+}
+
+function qsprintf_check_scalar_type($value, $type, $query) {
+ switch ($type) {
+ case 'Q':
+ case 'LC':
+ case 'T':
+ case 'C':
+ if (!is_string($value)) {
+ throw new AphrontParameterQueryException(
+ $query,
+ pht('Expected a string for %%%s conversion.', $type));
+ }
+ break;
+
+ case 'Ld':
+ case 'Lf':
+ case 'd':
+ case 'f':
+ if (!is_null($value) && !is_numeric($value)) {
+ throw new AphrontParameterQueryException(
+ $query,
+ pht('Expected a numeric scalar or null for %%%s conversion.', $type));
+ }
+ break;
+
+ case 'Ls':
+ case 's':
+ case 'LB':
+ case 'B':
+ case '~':
+ case '>':
+ case '<':
+ case 'K':
+ if (!is_null($value) && !is_scalar($value)) {
+ throw new AphrontParameterQueryException(
+ $query,
+ pht('Expected a scalar or null for %%%s conversion.', $type));
+ }
+ break;
+
+ default:
+ throw new XsprintfUnknownConversionException($type);
+ }
+}
diff --git a/src/xsprintf/queryfx.php b/src/xsprintf/queryfx.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/queryfx.php
@@ -0,0 +1,27 @@
+setLastActiveEpoch(time());
+ $conn->executeRawQuery($query);
+}
+
+function queryfx_all(AphrontDatabaseConnection $conn, $sql /* , ... */) {
+ $argv = func_get_args();
+ call_user_func_array('queryfx', $argv);
+ return $conn->selectAllResults();
+}
+
+function queryfx_one(AphrontDatabaseConnection $conn, $sql /* , ... */) {
+ $argv = func_get_args();
+ $ret = call_user_func_array('queryfx_all', $argv);
+ if (count($ret) > 1) {
+ throw new AphrontCountQueryException(
+ pht('Query returned more than one row.'));
+ } else if (count($ret)) {
+ return reset($ret);
+ }
+ return null;
+}
diff --git a/src/xsprintf/tsprintf.php b/src/xsprintf/tsprintf.php
new file mode 100644
--- /dev/null
+++ b/src/xsprintf/tsprintf.php
@@ -0,0 +1,44 @@
+= $argc) {
+ throw new BadFunctionCallException(
+ pht(
+ 'Too few arguments to %s.',
+ 'xsprintf()'));
+ }
+
+ if ($callback !== null) {
+ $callback($userdata, $pattern, $pos, $argv[$arg], $len);
+ }
+ }
+ }
+
+ if ($c === '%') {
+ // If we have "%%", this encodes a literal percentage symbol, so we are
+ // no longer inside a conversion.
+ $conv = !$conv;
+ }
+ }
+
+ if ($arg !== ($argc - 1)) {
+ throw new BadFunctionCallException(
+ pht(
+ 'Too many arguments to %s.',
+ 'xsprintf()'));
+ }
+
+ $argv[0] = $pattern;
+ return call_user_func_array('sprintf', $argv);
+}
+
+/**
+ * Example @{function:xsprintf} callback. When you call `xsprintf`, you must
+ * pass a callback like this one. `xsprintf` will invoke the callback when it
+ * encounters a conversion (like "%Z") in the pattern string.
+ *
+ * Generally, this callback should examine `$pattern[$pos]` (which will contain
+ * the conversion character, like 'Z'), escape `$value` appropriately, and then
+ * replace `$pattern[$pos]` with an 's' so `sprintf` prints the escaped value
+ * as a string. However, more sophisticated behaviors are possible --
+ * particularly, consuming multiple characters to allow for conversions like
+ * "%Ld". In this case, the callback needs to `substr_replace` the entire
+ * conversion with 's' and then update `$length`.
+ *
+ * For example implementations, see @{function:xsprintf_command},
+ * @{function:xsprintf_javascript} and @{function:xsprintf_query}.
+ *
+ * @param wild Arbitrary, optional userdata. This is whatever userdata
+ * was passed to @{function:xsprintf}.
+ * @param string The pattern string being parsed.
+ * @param int The current character position in the string.
+ * @param wild The value to convert.
+ * @param int The string length.
+ */
+function xsprintf_callback_example(
+ $userdata,
+ &$pattern,
+ &$pos,
+ &$value,
+ &$length) {
+ throw new RuntimeException(
+ pht(
+ 'This function exists only to document the call signature '.
+ 'for %s callbacks.',
+ 'xsprintf()'));
+}
diff --git a/support/ArcanistRuntime.php b/support/ArcanistRuntime.php
--- a/support/ArcanistRuntime.php
+++ b/support/ArcanistRuntime.php
@@ -35,7 +35,7 @@
array(
'name' => 'library',
'param' => 'path',
- 'help' => pht('Load a libphutil library.'),
+ 'help' => pht('Load a library.'),
'repeat' => true,
),
array(
@@ -243,21 +243,6 @@
ini_set('include_path', $php_include_path);
- // Load libphutil. Note that this has some side effects, including
- // adjusting some PHP configuration values.
- @include_once 'libphutil/scripts/__init_script__.php';
-
- if (!@constant('__LIBPHUTIL__')) {
- return $this->fatalError(
- 'Unable to load libphutil. Put "libphutil/" next to "arcanist/"; '.
- 'or update your PHP "include_path" to include the parent directory '.
- 'of "libphutil/"; or symlink "libphutil" into '.
- '"arcanist/externals/includes/".');
- }
-
- // Load Arcanist.
- phutil_load_library($arcanist_dir.'/src/');
-
return 0;
}
diff --git a/support/parser/generate-type-parser.php b/support/parser/generate-type-parser.php
new file mode 100755
--- /dev/null
+++ b/support/parser/generate-type-parser.php
@@ -0,0 +1,69 @@
+#!/usr/bin/env php
+',
+ '(',
+ ')',
+ ',',
+ 'k',
+ 'map',
+ 'list',
+ '?',
+ 'opt',
+ 'cm',
+);
+
+$rules = array(
+ 'start' => 'maybe_optional',
+ 'maybe_optional' => array(
+ 'yes' => 'opt maybe_comment',
+ 'no' => 'maybe_comment',
+ ),
+ 'maybe_comment' => array(
+ 'yes' => 'type comment',
+ 'no' => 'type',
+ ),
+ 'comment' => '( comment_text )',
+ 'comment_text' => array(
+ 'comment_text cm',
+ 'cm',
+ ),
+ 'type' => array(
+ 'yes' => 'some_type ?',
+ 'no' => 'some_type',
+ ),
+ 'some_type' => array(
+ 'or_type',
+ 'not_or_type',
+ ),
+ 'or_type' => array(
+ 'or_type | not_or_type',
+ 'not_or_type | not_or_type',
+ ),
+ 'not_or_type' => array(
+ 'basic_type',
+ 'map_type',
+ 'list_type',
+ ),
+ 'basic_type' => array(
+ 'k',
+ ),
+ 'map_type' => array(
+ 'map < type , type >',
+ ),
+ 'list_type' => array(
+ 'list < type >',
+ ),
+);
+
+$parser = id(new PhutilParserGenerator())
+ ->setTerminals($terminals)
+ ->setRules($rules)
+ ->processGrammar();
+
+echo $parser->generateParserFunction('phutil_type_spec_parser')."\n";
diff --git a/support/xhpast/Makefile b/support/xhpast/Makefile
new file mode 100644
--- /dev/null
+++ b/support/xhpast/Makefile
@@ -0,0 +1,77 @@
+BISONFLAGS = --verbose -Wall
+CPPFLAGS = -fPIC -Wall
+FLEXFLAGS = -CFr
+
+ifdef DEBUG
+ BISONFLAGS += --debug
+ CPPFLAGS += -ggdb -DDEBUG
+ FLEXFLAGS += --debug
+else
+ CPPFLAGS += -O3 -minline-all-stringops
+endif
+
+ifdef PROFILE
+ CPPFLAGS += -pg
+endif
+
+ifdef STATIC
+ CPPFLAGS += -static
+endif
+
+ifdef MSYSTEM
+ CPPFLAGS += -static-libgcc -static-libstdc++
+endif
+
+ROOT = ../../src/parser/xhpast
+
+.PHONY: all
+all: xhpast
+
+clean:
+ rm -f xhpast parser.yacc.output libxhpast.a *.o
+
+cleanall: clean
+ rm -f scanner.lex.hpp scanner.lex.cpp parser.yacc.hpp parser.yacc.cpp
+ rm -f node_names.hpp parser_nodes.php
+
+.PHONY: install
+install: xhpast
+ cp xhpast $(ROOT)/bin/xhpast
+
+.PHONY: parser scanner
+
+parser: parser.yacc.hpp parser.yacc.cpp
+scanner: scanner.lex.hpp scanner.lex.cpp
+
+%.lex.hpp %.lex.cpp: %.l
+ifndef SKIP_SCANNER
+ flex $(FLEXFLAGS) --header-file=$*.lex.hpp --outfile=$*.lex.cpp $<
+ @echo '/* @gen''er''ated */' >> $*.lex.hpp
+ @echo '/* @gen''er''ated */' >> $*.lex.cpp
+else
+ touch $*.lex.hpp $*.lex.cpp
+endif
+
+%.yacc.hpp %.yacc.cpp: %.y
+ifndef SKIP_PARSER
+ bison $(BISONFLAGS) --defines=$*.yacc.hpp --output=$*.yacc.cpp $<
+ @echo '/* @gen''er''ated */' >> $*.yacc.hpp
+ @echo '/* @gen''er''ated */' >> $*.yacc.cpp
+else
+ touch $*.yacc.hpp $*.yacc.cpp
+endif
+
+%.o: %.cpp
+ $(CXX) -c $(CPPFLAGS) -o $@ $<
+
+node_names.hpp parser_nodes.php: generate_nodes.php
+ php -f $<
+
+parser.yacc.o: scanner.lex.hpp
+scanner.lex.o: parser.yacc.hpp node_names.hpp scanner.lex.hpp
+
+libxhpast.a: scanner.lex.o parser.yacc.o
+ $(AR) -crs $@ $^
+
+xhpast: xhpast.cpp libxhpast.a
+ $(CXX) $(CPPFLAGS) -o $@ $^
diff --git a/support/xhpast/README b/support/xhpast/README
new file mode 100644
--- /dev/null
+++ b/support/xhpast/README
@@ -0,0 +1,18 @@
+= Building =
+
+Normally, you can build `xhpast` by running `make`, which will create a binary
+in this directory:
+
+ xhpast/ $ make
+
+You can run `make install` to copy that binary to the right place in libphutil
+so that libphutil, Phabricator, Diviner, etc., can use xhpast.
+
+If you are developing `xhpast`, you need to `make parser scanner xhpast`
+instead to regenerate the parser and scanner:
+
+ xhpast/ $ make parser scanner xhpast
+
+We ship the generated parser and scanner and do not rebuild them by default to
+prevent users from needing to install flex and bison and fiddle around with
+flex versions.
diff --git a/support/xhpast/ast.hpp b/support/xhpast/ast.hpp
new file mode 100644
--- /dev/null
+++ b/support/xhpast/ast.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include
+#include
+
+#include "astnode.hpp"
+
+class yy_extra_type {
+ public:
+ yy_extra_type() {
+ first_lineno = 0;
+ lineno = 1;
+ terminated = false;
+ last_token = -1;
+ insert_token = -1;
+ heredoc_yyleng = -1;
+ list_size = 0;
+ pushStack();
+ }
+
+ size_t first_lineno; // line number before scanning the current token
+ size_t lineno; // current line number being scanned.
+ std::string error; // description of error (if terminated true)
+ bool terminated; // becomes true when the parser terminates with an error
+ int last_token; // the last token to be returned by the scanner
+ int insert_token; // insert this token without reading from buffer
+ size_t heredoc_yyleng; // last length of yytext while scanning
+ std::string heredoc_label; // heredoc sentinel label
+ unsigned int list_size;
+
+ xhpast::token_list_t token_list;
+
+ void pushStack() {
+ tag_stack.push_front(std::deque());
+ }
+
+ protected:
+ std::deque > tag_stack;
+};
+
+#define YYSTYPE xhpast::Node *
+#define YY_HEADER_EXPORT_START_CONDITIONS
+#define YY_EXTRA_TYPE yy_extra_type*
+
+#include "parser.yacc.hpp"
+#ifndef FLEX_SCANNER
+ #include "scanner.lex.hpp"
+#endif
+
+int xhpparse(void*, YYSTYPE *);
+void xhp_new_push_state(int s, struct yyguts_t* yyg);
+void xhp_new_pop_state(struct yyguts_t* yyg);
+void xhp_set_state(int s, struct yyguts_t* yyg);
diff --git a/support/xhpast/astnode.hpp b/support/xhpast/astnode.hpp
new file mode 100644
--- /dev/null
+++ b/support/xhpast/astnode.hpp
@@ -0,0 +1,106 @@
+#pragma once
+#include
+#include
+#include
+#include
+
+namespace xhpast {
+
+ class Token;
+ typedef std::list token_list_t;
+
+ class Token {
+
+ public:
+ unsigned int type;
+ std::string value;
+ unsigned int lineno;
+ unsigned int n;
+
+ Token(unsigned int type, char *value, unsigned int n) :
+ type(type),
+ value(value),
+ lineno(0),
+ n(n) {
+ }
+ };
+
+ class Node;
+ typedef std::list node_list_t;
+
+ class Node {
+ public:
+ unsigned int type;
+
+ int l_tok;
+ int r_tok;
+
+ node_list_t children;
+
+
+ Node() : type(0), l_tok(-1), r_tok(-1) {};
+
+ Node(unsigned int type) : type(type), l_tok(-1), r_tok(-1) {};
+
+ Node(unsigned int type, int end_tok) :
+ type(type) {
+ this->l_tok = end_tok;
+ this->r_tok = end_tok;
+ }
+
+ Node(unsigned int type, int l_tok, int r_tok) :
+ type(type),
+ l_tok(l_tok),
+ r_tok(r_tok) {
+
+ }
+
+ Node *appendChild(Node *node) {
+ this->children.push_back(node);
+ return this->expandRange(node);
+ }
+
+ Node *appendChildren(Node *node) {
+ for (node_list_t::iterator ii = node->children.begin();
+ ii != node->children.end();
+ ++ii) {
+
+ this->appendChild(*ii);
+ }
+ return this;
+ }
+
+ Node *firstChild() {
+ if (this->children.empty()) {
+ return NULL;
+ }
+ return *(this->children.begin());
+ }
+
+ Node *setType(unsigned int t) {
+ this->type = t;
+ return this;
+ }
+
+ Node *expandRange(Node *n) {
+ if (!n) {
+ fprintf(
+ stderr,
+ "Trying to expandRange() a null node to one of type %d\n",
+ this->type);
+ exit(1);
+ };
+
+ if (n->l_tok != -1 && (n->l_tok < this->l_tok || (this->l_tok == -1))) {
+ this->l_tok = n->l_tok;
+ }
+
+ if (n->r_tok != -1 && (n->r_tok > this->r_tok || (this->r_tok == -1))) {
+ this->r_tok = n->r_tok;
+ }
+
+ return this;
+ }
+
+ };
+}
diff --git a/support/xhpast/generate_nodes.php b/support/xhpast/generate_nodes.php
new file mode 100755
--- /dev/null
+++ b/support/xhpast/generate_nodes.php
@@ -0,0 +1,164 @@
+#!/usr/bin/env php
+ $value) {
+ $hpp .= "#define {$node} {$value}\n";
+}
+Filesystem::writeFile(
+ Filesystem::resolvePath('node_names.hpp', dirname(__FILE__)),
+ $hpp);
+echo pht('Wrote C++ definition.')."\n";
+
+$at = '@';
+$php = << $value) {
+ $php .= " {$value} => '{$node}',\n";
+}
+$php .= <<(xhpastget_extra(yyscanner))
+#undef yylineno
+#define yylineno yyextra->first_lineno
+#define push_state(s) xhp_new_push_state(s, (struct yyguts_t*) yyscanner)
+#define pop_state() xhp_new_pop_state((struct yyguts_t*) yyscanner)
+#define set_state(s) xhp_set_state(s, (struct yyguts_t*) yyscanner)
+
+#define NNEW(t) \
+ (new xhpast::Node(t))
+
+#define NTYPE(n, type) \
+ ((n)->setType(type))
+
+#define NMORE(n, end) \
+ ((n)->expandRange(end))
+
+#define NSPAN(n, type, end) \
+ (NMORE(NTYPE((n), type), end))
+
+#define NEXPAND(l, n, r) \
+ ((n)->expandRange(l)->expandRange(r))
+
+using namespace std;
+
+static void yyerror(void* yyscanner, void* _, const char* error) {
+ if (yyextra->terminated) {
+ return;
+ }
+ yyextra->terminated = true;
+ yyextra->error = error;
+}
+
+%}
+
+%expect 5
+// 2: PHP's if/else grammar
+// 7: expr '[' dim_offset ']' -- shift will default to first grammar
+%name-prefix "xhpast"
+%pure-parser
+%parse-param { void* yyscanner }
+%parse-param { xhpast::Node** root }
+%lex-param { void* yyscanner }
+%error-verbose
+
+%precedence T_INCLUDE T_INCLUDE_ONCE
+%token T_EVAL
+%precedence T_REQUIRE T_REQUIRE_ONCE
+%token ','
+%left T_LOGICAL_OR
+%left T_LOGICAL_XOR
+%left T_LOGICAL_AND
+%precedence T_PRINT
+%precedence '=' T_PLUS_EQUAL
+ T_MINUS_EQUAL
+ T_MUL_EQUAL
+ T_DIV_EQUAL
+ T_CONCAT_EQUAL
+ T_MOD_EQUAL
+ T_AND_EQUAL
+ T_OR_EQUAL
+ T_XOR_EQUAL
+ T_SL_EQUAL
+ T_SR_EQUAL
+%left '?' ':'
+%right T_COALESCE
+%left T_BOOLEAN_OR
+%left T_BOOLEAN_AND
+%left '|'
+%left '^'
+%left '&'
+%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL
+ T_SPACESHIP
+%nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
+%left T_SL T_SR
+%left '+' '-' '.'
+%left '*' '/' '%'
+%precedence '!'
+%precedence T_INSTANCEOF
+%precedence '~' T_INC
+%token T_DEC
+%precedence T_INT_CAST T_DOUBLE_CAST T_STRING_CAST
+%token T_UNICODE_CAST
+%token T_BINARY_CAST
+%precedence T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@'
+%token '['
+%token T_NEW
+%precedence T_CLONE
+%token T_EXIT
+%token T_IF
+%token T_ELSEIF
+%token T_ELSE
+%token T_ENDIF
+
+%token T_LNUMBER
+%token T_DNUMBER
+%token T_STRING
+%token T_STRING_VARNAME /* unused in XHP: `foo` in `"$foo"` */
+%token T_VARIABLE
+%token T_NUM_STRING /* unused in XHP: `0` in `"$foo[0]"` */
+%token T_INLINE_HTML
+%token T_CHARACTER /* unused in vanilla PHP */
+%token T_BAD_CHARACTER /* unused in vanilla PHP */
+%token T_ENCAPSED_AND_WHITESPACE /* unused in XHP: ` ` in `" "` */
+%token T_CONSTANT_ENCAPSED_STRING /* overloaded in XHP;
+ replaces '"' encaps_list '"' */
+%token T_BACKTICKS_EXPR /* new in XHP; replaces '`' backticks_expr '`' */
+%token T_ECHO
+%token T_DO
+%token T_WHILE
+%token T_ENDWHILE
+%token T_FOR
+%token T_ENDFOR
+%token T_FOREACH
+%token T_ENDFOREACH
+%token T_DECLARE
+%token T_ENDDECLARE
+%token T_AS
+%token T_SWITCH
+%token T_ENDSWITCH
+%token T_CASE
+%token T_DEFAULT
+%token T_BREAK
+%token T_CONTINUE
+%token T_GOTO
+%token T_FUNCTION
+%token T_CONST
+%token T_RETURN
+%token T_TRY
+%token T_CATCH
+%token T_THROW
+%token T_USE
+%token T_GLOBAL
+%token T_STATIC
+%token T_ABSTRACT
+%token T_FINAL
+%token T_PRIVATE
+%token T_PROTECTED
+%token T_PUBLIC
+%token T_VAR
+%token T_UNSET
+%token T_ISSET
+%token T_EMPTY
+%token T_HALT_COMPILER
+%token T_CLASS
+%token T_INTERFACE
+%token T_EXTENDS
+%token T_IMPLEMENTS
+%token T_OBJECT_OPERATOR
+%token T_DOUBLE_ARROW
+%token T_LIST
+%token T_ARRAY
+%token T_CLASS_C
+%token T_METHOD_C
+%token T_FUNC_C
+%token T_LINE
+%token T_FILE
+%token T_COMMENT
+%token T_DOC_COMMENT
+%token T_OPEN_TAG
+%token T_OPEN_TAG_WITH_ECHO
+%token T_OPEN_TAG_FAKE
+%token T_CLOSE_TAG
+%token T_WHITESPACE
+%token T_START_HEREDOC /* unused in XHP; replaced with T_HEREDOC */
+%token T_END_HEREDOC /* unused in XHP; replaced with T_HEREDOC */
+%token T_HEREDOC /* new in XHP;
+ replaces start_heredoc encaps_list T_END_HEREDOC */
+%token T_DOLLAR_OPEN_CURLY_BRACES /* unused in XHP: `${` in `"${foo}"` */
+%token T_CURLY_OPEN /* unused in XHP: `{$` in `"{$foo}"` */
+%token T_PAAMAYIM_NEKUDOTAYIM
+%token T_BINARY_DOUBLE /* unsused in XHP: `b"` in `b"foo"` */
+%token T_BINARY_HEREDOC /* unsused in XHP: `b<<<` in `b<<appendChild($1);
+ }
+;
+
+top_statement_list:
+ top_statement_list top_statement {
+ $$ = $1->appendChild($2);
+ }
+| %empty {
+ $$ = NNEW(n_STATEMENT_LIST);
+ }
+;
+
+namespace_name:
+ T_STRING {
+ $$ = NTYPE($1, n_SYMBOL_NAME);
+ }
+| namespace_name T_NS_SEPARATOR T_STRING {
+ $$ = NMORE($1, $3);
+ }
+;
+
+top_statement:
+ statement
+| function_declaration_statement
+| class_declaration_statement
+| T_HALT_COMPILER '(' ')' ';' {
+ $1 = NSPAN($1, n_HALT_COMPILER, $3);
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $4);
+ }
+| T_NAMESPACE namespace_name ';' {
+ NSPAN($1, n_NAMESPACE, $2);
+ $1->appendChild($2);
+ $1->appendChild(NNEW(n_EMPTY));
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+ }
+| T_NAMESPACE namespace_name '{' top_statement_list '}' {
+ NSPAN($1, n_NAMESPACE, $5);
+ $1->appendChild($2);
+ $1->appendChild(NEXPAND($3, $4, $5));
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_NAMESPACE '{' top_statement_list '}' {
+ NSPAN($1, n_NAMESPACE, $4);
+ $1->appendChild(NNEW(n_EMPTY));
+ NMORE($3, $4);
+ NMORE($3, $2);
+ $1->appendChild($3);
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_USE use_declarations ';' {
+ NMORE($2, $1);
+ $$ = NNEW(n_STATEMENT)->appendChild($2);
+ NMORE($$, $3);
+ }
+| constant_declaration ';' {
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+;
+
+use_declarations:
+ use_declarations ',' use_declaration {
+ $$ = $1->appendChild($3);
+ }
+| use_declaration {
+ $$ = NNEW(n_USE_LIST);
+ $$->appendChild($1);
+ }
+;
+
+use_declaration:
+ namespace_name {
+ $$ = NNEW(n_USE);
+ $$->appendChild($1);
+ $$->appendChild(NNEW(n_EMPTY));
+ }
+| namespace_name T_AS T_STRING {
+ $$ = NNEW(n_USE);
+ $$->appendChild($1);
+ NTYPE($3, n_STRING);
+ $$->appendChild($3);
+ }
+| T_NS_SEPARATOR namespace_name {
+ $$ = NNEW(n_USE);
+ NMORE($2, $1);
+ $$->appendChild($2);
+ $$->appendChild(NNEW(n_EMPTY));
+ }
+| T_NS_SEPARATOR namespace_name T_AS T_STRING {
+ $$ = NNEW(n_USE);
+ NMORE($2, $1);
+ $$->appendChild($2);
+ NTYPE($4, n_STRING);
+ $$->appendChild($4);
+ }
+;
+
+constant_declaration:
+ constant_declaration ',' T_STRING '=' static_scalar {
+ NMORE($$, $5);
+ $$->appendChild(
+ NNEW(n_CONSTANT_DECLARATION)
+ ->appendChild(NTYPE($3, n_STRING))
+ ->appendChild($5));
+ }
+| T_CONST T_STRING '=' static_scalar {
+ NSPAN($$, n_CONSTANT_DECLARATION_LIST, $4);
+ $$->appendChild(
+ NNEW(n_CONSTANT_DECLARATION)
+ ->appendChild(NTYPE($2, n_STRING))
+ ->appendChild($4));
+ }
+;
+
+inner_statement_list:
+ inner_statement_list inner_statement {
+ $$ = $1->appendChild($2);
+ }
+| %empty {
+ $$ = NNEW(n_STATEMENT_LIST);
+ }
+;
+
+inner_statement:
+ statement
+| function_declaration_statement
+| class_declaration_statement
+| T_HALT_COMPILER '(' ')' ';' {
+ $1 = NSPAN($1, n_HALT_COMPILER, $3);
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $4);
+ }
+;
+
+statement:
+ unticked_statement
+| T_STRING ':' {
+ NTYPE($1, n_STRING);
+ $$ = NNEW(n_LABEL);
+ $$->appendChild($1);
+ NMORE($$, $2);
+ }
+| T_OPEN_TAG {
+ $$ = NTYPE($1, n_OPEN_TAG);
+ }
+| T_OPEN_TAG_WITH_ECHO {
+ $$ = NTYPE($1, n_OPEN_TAG);
+ }
+| T_CLOSE_TAG {
+ $$ = NTYPE($1, n_CLOSE_TAG);
+ }
+;
+
+unticked_statement:
+ '{' inner_statement_list '}' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+| T_IF '(' expr ')' statement elseif_list else_single {
+ $$ = NNEW(n_CONDITION_LIST);
+
+ $1 = NTYPE($1, n_IF);
+ $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
+ $1->appendChild($5);
+
+ $$->appendChild($1);
+ $$->appendChildren($6);
+
+ // Hacks: merge a list of if (x) { } else if (y) { } into a single condition
+ // list instead of a condition tree.
+
+ if ($7->type == n_EMPTY) {
+ // Ignore.
+ } else if ($7->type == n_ELSE) {
+ xhpast::Node *stype = $7->firstChild()->firstChild();
+ if (stype && stype->type == n_CONDITION_LIST) {
+ NTYPE(stype->firstChild(), n_ELSEIF);
+ stype->firstChild()->l_tok = $7->l_tok;
+ $$->appendChildren(stype);
+ } else {
+ $$->appendChild($7);
+ }
+ } else {
+ $$->appendChild($7);
+ }
+
+ $$ = NNEW(n_STATEMENT)->appendChild($$);
+ }
+| T_IF '(' expr ')' ':'
+ inner_statement_list
+ new_elseif_list
+ new_else_single
+ T_ENDIF ';' {
+
+ $$ = NNEW(n_CONDITION_LIST);
+ NTYPE($1, n_IF);
+ $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
+ $1->appendChild($6);
+
+ $$->appendChild($1);
+ $$->appendChildren($7);
+ $$->appendChild($8);
+ NMORE($$, $9);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($$);
+ NMORE($$, $10);
+ }
+| T_WHILE '(' expr ')' while_statement {
+ NTYPE($1, n_WHILE);
+ $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
+ $1->appendChild($5);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_DO statement T_WHILE '(' expr ')' ';' {
+ NTYPE($1, n_DO_WHILE);
+ $1->appendChild($2);
+ $1->appendChild(NSPAN($4, n_CONTROL_CONDITION, $6)->appendChild($5));
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $7);
+ }
+| T_FOR '(' for_expr ';' for_expr ';' for_expr ')' for_statement {
+ NTYPE($1, n_FOR);
+
+ NSPAN($2, n_FOR_EXPRESSION, $8)
+ ->appendChild($3)
+ ->appendChild($5)
+ ->appendChild($7);
+
+ $1->appendChild($2);
+ $1->appendChild($9);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_SWITCH '(' expr ')' switch_case_list {
+ NTYPE($1, n_SWITCH);
+ $1->appendChild(NSPAN($2, n_CONTROL_CONDITION, $4)->appendChild($3));
+ $1->appendChild($5);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_BREAK ';' {
+ NTYPE($1, n_BREAK);
+ $1->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+| T_BREAK expr ';' {
+ NTYPE($1, n_BREAK);
+ $1->appendChild($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+ }
+| T_CONTINUE ';' {
+ NTYPE($1, n_CONTINUE);
+ $1->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+| T_CONTINUE expr ';' {
+ NTYPE($1, n_CONTINUE);
+ $1->appendChild($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+ }
+| T_RETURN ';' {
+ NTYPE($1, n_RETURN);
+ $1->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+| T_RETURN expr_without_variable ';' {
+ NTYPE($1, n_RETURN);
+ $1->appendChild($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+ }
+| T_RETURN variable ';' {
+ NTYPE($1, n_RETURN);
+ $1->appendChild($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+ }
+| T_GLOBAL global_var_list ';' {
+ NMORE($2, $1);
+ $$ = NNEW(n_STATEMENT)->appendChild($2);
+ NMORE($$, $3);
+ }
+| T_STATIC static_var_list ';' {
+ NMORE($2, $1);
+ $$ = NNEW(n_STATEMENT)->appendChild($2);
+ NMORE($$, $3);
+ }
+| T_ECHO echo_expr_list ';' {
+ NMORE($2, $1);
+ $$ = NNEW(n_STATEMENT)->appendChild($2);
+ NMORE($$, $3);
+ }
+| T_INLINE_HTML {
+ NTYPE($1, n_INLINE_HTML);
+ $$ = $1;
+ }
+| expr ';' {
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+| yield_expr ';' {
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+| T_UNSET '(' unset_variables ')' ';' {
+ NMORE($3, $4);
+ NMORE($3, $1);
+ $$ = NNEW(n_STATEMENT)->appendChild($3);
+ NMORE($$, $5);
+ }
+| T_FOREACH '(' variable T_AS foreach_variable foreach_optional_arg ')'
+ foreach_statement {
+ NTYPE($1, n_FOREACH);
+ NSPAN($2, n_FOREACH_EXPRESSION, $7);
+ $2->appendChild($3);
+ if ($6->type == n_EMPTY) {
+ $2->appendChild($6);
+ $2->appendChild($5);
+ } else {
+ $2->appendChild($5);
+ $2->appendChild($6);
+ }
+ $1->appendChild($2);
+
+ $1->appendChild($8);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_FOREACH '(' expr_without_variable T_AS variable foreach_optional_arg ')'
+ foreach_statement {
+ NTYPE($1, n_FOREACH);
+ NSPAN($2, n_FOREACH_EXPRESSION, $7);
+ $2->appendChild($3);
+ if ($6->type == n_EMPTY) {
+ $2->appendChild($6);
+ $2->appendChild($5);
+ } else {
+ $2->appendChild($5);
+ $2->appendChild($6);
+ }
+ $1->appendChild($2);
+ $1->appendChild($8);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_DECLARE '(' declare_list ')' declare_statement {
+ NTYPE($1, n_DECLARE);
+ $1->appendChild($3);
+ $1->appendChild($5);
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| ';' /* empty statement */ {
+ $$ = NNEW(n_STATEMENT)->appendChild(NNEW(n_EMPTY));
+ NMORE($$, $1);
+ }
+| T_TRY '{' inner_statement_list '}' catch_list finally_statement {
+ NTYPE($1, n_TRY);
+ $1->appendChild(NEXPAND($2, $3, $4));
+
+ $1->appendChild($5);
+ $1->appendChild($6);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_TRY '{' inner_statement_list '}' non_empty_finally_statement {
+ NTYPE($1, n_TRY);
+ $1->appendChild(NEXPAND($2, $3, $4));
+
+ $1->appendChild(NNEW(n_CATCH_LIST));
+ $1->appendChild($5);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+| T_THROW expr ';' {
+ NTYPE($1, n_THROW);
+ $1->appendChild($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+
+ }
+| T_GOTO T_STRING ';' {
+ NTYPE($1, n_GOTO);
+ NTYPE($2, n_STRING);
+ $1->appendChild($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $3);
+ }
+;
+
+catch_list:
+ catch_list catch {
+ $1->appendChild($2);
+ $$ = $1;
+ }
+| catch {
+ $$ = NNEW(n_CATCH_LIST);
+ $$->appendChild($1);
+}
+
+catch:
+ T_CATCH '(' fully_qualified_class_name T_VARIABLE ')'
+ '{' inner_statement_list '}' {
+ NTYPE($1, n_CATCH);
+ $1->appendChild($3);
+ $1->appendChild(NTYPE($4, n_VARIABLE));
+ $1->appendChild(NEXPAND($6, $7, $8));
+ NMORE($1, $8);
+ $$ = $1;
+ }
+;
+
+finally_statement:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| non_empty_finally_statement
+;
+
+non_empty_finally_statement:
+ T_FINALLY '{' inner_statement_list '}' {
+ NTYPE($1, n_FINALLY);
+ $1->appendChild($3);
+ NMORE($1, $4);
+ $$ = $1;
+ }
+;
+
+unset_variables:
+ unset_variable {
+ $$ = NNEW(n_UNSET_LIST);
+ $$->appendChild($1);
+ }
+| unset_variables ',' unset_variable {
+ $1->appendChild($3);
+ $$ = $1;
+ }
+;
+
+unset_variable:
+ variable
+;
+
+function_declaration_statement:
+ unticked_function_declaration_statement
+;
+
+class_declaration_statement:
+ unticked_class_declaration_statement
+;
+
+is_reference:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| '&' {
+ $$ = NTYPE($1, n_REFERENCE);
+ }
+;
+
+unticked_function_declaration_statement:
+ function is_reference T_STRING
+ '(' parameter_list ')' return_type '{' inner_statement_list '}' {
+ NSPAN($1, n_FUNCTION_DECLARATION, $9);
+ $1->appendChild(NNEW(n_EMPTY));
+ $1->appendChild($2);
+ $1->appendChild(NTYPE($3, n_STRING));
+ $1->appendChild(NEXPAND($4, $5, $6));
+ $1->appendChild(NNEW(n_EMPTY));
+ $1->appendChild($7);
+ $1->appendChild(NEXPAND($8, $9, $10));
+
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ }
+;
+
+unticked_class_declaration_statement:
+ class_entry_type T_STRING extends_from implements_list
+ '{' class_statement_list '}' {
+ $$ = NNEW(n_CLASS_DECLARATION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_CLASS_NAME));
+ $$->appendChild($3);
+ $$->appendChild($4);
+ $$->appendChild(NEXPAND($5, $6, $7));
+ NMORE($$, $7);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($$);
+ }
+| interface_entry T_STRING interface_extends_list '{' class_statement_list '}' {
+ $$ = NNEW(n_INTERFACE_DECLARATION);
+ $$->appendChild(NNEW(n_CLASS_ATTRIBUTES));
+ NMORE($$, $1);
+ $$->appendChild(NTYPE($2, n_CLASS_NAME));
+ $$->appendChild($3);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild(NEXPAND($4, $5, $6));
+ NMORE($$, $6);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($$);
+ }
+;
+
+class_entry_type:
+ T_CLASS {
+ NTYPE($1, n_CLASS_ATTRIBUTES);
+ $$ = $1;
+ }
+| T_ABSTRACT T_CLASS {
+ NTYPE($2, n_CLASS_ATTRIBUTES);
+ NMORE($2, $1);
+ $2->appendChild(NTYPE($1, n_STRING));
+
+ $$ = $2;
+ }
+| T_FINAL T_CLASS {
+ NTYPE($2, n_CLASS_ATTRIBUTES);
+ NMORE($2, $1);
+ $2->appendChild(NTYPE($1, n_STRING));
+
+ $$ = $2;
+ }
+| T_TRAIT {
+ $$ = NNEW(n_CLASS_ATTRIBUTES);
+ $$->appendChild(NTYPE($1, n_STRING));
+ }
+;
+
+extends_from:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_EXTENDS fully_qualified_class_name {
+ $$ = NTYPE($1, n_EXTENDS_LIST)->appendChild($2);
+ }
+;
+
+interface_entry:
+ T_INTERFACE
+;
+
+interface_extends_list:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_EXTENDS interface_list {
+ NTYPE($1, n_EXTENDS_LIST);
+ $1->appendChildren($2);
+ $$ = $1;
+ }
+;
+
+implements_list:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_IMPLEMENTS interface_list {
+ NTYPE($1, n_IMPLEMENTS_LIST);
+ $1->appendChildren($2);
+ $$ = $1;
+ }
+;
+
+interface_list:
+ fully_qualified_class_name {
+ $$ = NNEW(n_IMPLEMENTS_LIST)->appendChild($1);
+ }
+| interface_list ',' fully_qualified_class_name {
+ $$ = $1->appendChild($3);
+ }
+;
+
+foreach_optional_arg:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_DOUBLE_ARROW foreach_variable {
+ $$ = $2;
+ }
+;
+
+foreach_variable:
+ variable
+| '&' variable {
+ NTYPE($1, n_VARIABLE_REFERENCE);
+ $1->appendChild($2);
+ $$ = $1;
+ }
+;
+
+for_statement:
+ statement
+| ':' inner_statement_list T_ENDFOR ';' {
+ NMORE($2, $1);
+ NMORE($2, $4);
+ $$ = $2;
+ }
+;
+
+foreach_statement:
+ statement
+| ':' inner_statement_list T_ENDFOREACH ';' {
+ NMORE($2, $1);
+ NMORE($2, $4);
+ $$ = $2;
+ }
+;
+
+declare_statement:
+ statement
+| ':' inner_statement_list T_ENDDECLARE ';' {
+ NMORE($2, $1);
+ NMORE($2, $4);
+ $$ = $2;
+ }
+;
+
+declare_list:
+ T_STRING '=' static_scalar {
+ $$ = NNEW(n_DECLARE_DECLARATION);
+ $$->appendChild(NTYPE($1, n_STRING));
+ $$->appendChild($3);
+ $$ = NNEW(n_DECLARE_DECLARATION_LIST)->appendChild($$);
+ }
+| declare_list ',' T_STRING '=' static_scalar {
+ $$ = NNEW(n_DECLARE_DECLARATION);
+ $$->appendChild(NTYPE($3, n_STRING));
+ $$->appendChild($5);
+
+ $1->appendChild($$);
+ $$ = $1;
+ }
+;
+
+switch_case_list:
+ '{' case_list '}' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+| '{' ';' case_list '}' {
+ // ...why does this rule exist?
+
+ NTYPE($2, n_STATEMENT);
+ $1->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_STATEMENT_LIST)->appendChild($2);
+ $$->appendChildren($3);
+ NEXPAND($1, $$, $4);
+ }
+| ':' case_list T_ENDSWITCH ';' {
+ NMORE($2, $4);
+ NMORE($2, $1);
+ $$ = $2;
+ }
+| ':' ';' case_list T_ENDSWITCH ';' {
+ NTYPE($2, n_STATEMENT);
+ $1->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_STATEMENT_LIST)->appendChild($2);
+ $$->appendChildren($3);
+ NMORE($$, $5);
+ NMORE($$, $1);
+ }
+;
+
+case_list:
+ %empty {
+ $$ = NNEW(n_STATEMENT_LIST);
+ }
+| case_list T_CASE expr case_separator inner_statement_list {
+ NTYPE($2, n_CASE);
+ $2->appendChild($3);
+ $2->appendChild($5);
+
+ $1->appendChild($2);
+ $$ = $1;
+ }
+| case_list T_DEFAULT case_separator inner_statement_list {
+ NTYPE($2, n_DEFAULT);
+ $2->appendChild($4);
+
+ $1->appendChild($2);
+ $$ = $1;
+ }
+;
+
+case_separator:
+ ':'
+| ';'
+;
+
+while_statement:
+ statement
+| ':' inner_statement_list T_ENDWHILE ';' {
+ NMORE($2, $4);
+ NMORE($2, $1);
+ $$ = $2;
+ }
+;
+
+elseif_list:
+ %empty {
+ $$ = NNEW(n_CONDITION_LIST);
+ }
+| elseif_list T_ELSEIF '(' expr ')' statement {
+ NTYPE($2, n_ELSEIF);
+ $2->appendChild(NSPAN($3, n_CONTROL_CONDITION, $5)->appendChild($4));
+ $2->appendChild($6);
+
+ $$ = $1->appendChild($2);
+ }
+;
+
+new_elseif_list:
+ %empty {
+ $$ = NNEW(n_CONDITION_LIST);
+ }
+| new_elseif_list T_ELSEIF '(' expr ')' ':' inner_statement_list {
+ NTYPE($2, n_ELSEIF);
+ $2->appendChild($4);
+ $2->appendChild($7);
+
+ $$ = $1->appendChild($2);
+ }
+;
+
+else_single:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_ELSE statement {
+ NTYPE($1, n_ELSE);
+ $1->appendChild($2);
+ $$ = $1;
+ }
+;
+
+new_else_single:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_ELSE ':' inner_statement_list {
+ NTYPE($1, n_ELSE);
+ $1->appendChild($3);
+ $$ = $1;
+ }
+;
+
+parameter_list:
+ non_empty_parameter_list
+| %empty {
+ $$ = NNEW(n_DECLARATION_PARAMETER_LIST);
+ }
+;
+
+non_empty_parameter_list:
+ optional_type parameter {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($1);
+ $$->appendChild($2);
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
+ }
+| optional_type '&' parameter {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_VARIABLE_REFERENCE));
+ $2->appendChild($3);
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
+ }
+| optional_type '&' parameter '=' static_scalar {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_VARIABLE_REFERENCE));
+ $2->appendChild($3);
+ $$->appendChild($5);
+
+ $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
+ }
+| optional_type parameter '=' static_scalar {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($1);
+ $$->appendChild($2);
+ $$->appendChild($4);
+
+ $$ = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild($$);
+ }
+| non_empty_parameter_list ',' optional_type parameter {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($3);
+ $$->appendChild($4);
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = $1->appendChild($$);
+ }
+| non_empty_parameter_list ',' optional_type '&' parameter {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($3);
+ $$->appendChild(NTYPE($4, n_VARIABLE_REFERENCE));
+ $4->appendChild($5);
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = $1->appendChild($$);
+ }
+| non_empty_parameter_list ',' optional_type '&'
+ parameter '=' static_scalar {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($3);
+ $$->appendChild(NTYPE($4, n_VARIABLE_REFERENCE));
+ $4->appendChild($5);
+ $$->appendChild($7);
+
+ $$ = $1->appendChild($$);
+ }
+| non_empty_parameter_list ',' optional_type
+ parameter '=' static_scalar {
+ $$ = NNEW(n_DECLARATION_PARAMETER);
+ $$->appendChild($3);
+ $$->appendChild($4);
+ $$->appendChild($6);
+
+ $$ = $1->appendChild($$);
+ }
+;
+
+parameter:
+ T_ELLIPSIS T_VARIABLE {
+ $$ = NTYPE($1, n_UNPACK);
+ $$->appendChild(NTYPE($2, n_VARIABLE));
+ }
+| T_VARIABLE {
+ $$ = NTYPE($1, n_VARIABLE);
+ }
+;
+
+optional_type:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| type
+| '?' type {
+ $$ = NNEW(n_NULLABLE_TYPE);
+ $$->appendChild($2);
+ }
+;
+
+type:
+ fully_qualified_class_name {
+ $$ = $1;
+ }
+| T_ARRAY {
+ $$ = NTYPE($1, n_TYPE_NAME);
+ }
+| T_CALLABLE {
+ $$ = NTYPE($1, n_TYPE_NAME);
+ }
+;
+
+return_type:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| ':' optional_type {
+ $$ = NNEW(n_DECLARATION_RETURN);
+ $$->appendChild($2);
+ }
+;
+
+function_call_parameter_list:
+ non_empty_function_call_parameter_list
+| %empty {
+ $$ = NNEW(n_CALL_PARAMETER_LIST);
+ }
+;
+
+non_empty_function_call_parameter_list:
+ argument {
+ $$ = NNEW(n_CALL_PARAMETER_LIST)->appendChild($1);
+ }
+| non_empty_function_call_parameter_list ',' argument {
+ $$ = $1->appendChild($3);
+ }
+;
+
+argument:
+ expr
+| T_ELLIPSIS expr {
+ $$ = NNEW(n_UNPACK)->appendChild($1);
+ }
+| '&' w_variable {
+ NTYPE($1, n_VARIABLE_REFERENCE);
+ $$ = $1->appendChild($2);
+ }
+;
+
+global_var_list:
+ global_var_list ',' global_var {
+ $1->appendChild($3);
+ $$ = $1;
+ }
+| global_var {
+ $$ = NNEW(n_GLOBAL_DECLARATION_LIST);
+ $$->appendChild($1);
+ }
+;
+
+global_var:
+ T_VARIABLE {
+ $$ = NTYPE($1, n_VARIABLE);
+ }
+| '$' r_variable {
+ $$ = NTYPE($1, n_VARIABLE_VARIABLE);
+ $$->appendChild($2);
+ }
+| '$' '{' expr '}' {
+ $$ = NTYPE($1, n_VARIABLE_VARIABLE);
+ $$->appendChild($3);
+ }
+;
+
+static_var_list:
+ static_var_list ',' T_VARIABLE {
+ NTYPE($3, n_VARIABLE);
+ $$ = NNEW(n_STATIC_DECLARATION);
+ $$->appendChild($3);
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = $1->appendChild($$);
+ }
+| static_var_list ',' T_VARIABLE '=' static_scalar {
+ NTYPE($3, n_VARIABLE);
+ $$ = NNEW(n_STATIC_DECLARATION);
+ $$->appendChild($3);
+ $$->appendChild($5);
+
+ $$ = $1->appendChild($$);
+ }
+| T_VARIABLE {
+ NTYPE($1, n_VARIABLE);
+ $$ = NNEW(n_STATIC_DECLARATION);
+ $$->appendChild($1);
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_STATIC_DECLARATION_LIST)->appendChild($$);
+ }
+| T_VARIABLE '=' static_scalar {
+ NTYPE($1, n_VARIABLE);
+ $$ = NNEW(n_STATIC_DECLARATION);
+ $$->appendChild($1);
+ $$->appendChild($3);
+
+ $$ = NNEW(n_STATIC_DECLARATION_LIST)->appendChild($$);
+ }
+;
+
+class_statement_list:
+ class_statement_list class_statement {
+ $$ = $1->appendChild($2);
+ }
+| %empty {
+ $$ = NNEW(n_STATEMENT_LIST);
+ }
+;
+
+class_statement:
+ variable_modifiers class_variable_declaration ';' {
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION_LIST);
+ $$->appendChild($1);
+ $$->appendChildren($2);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($$);
+ NMORE($$, $3);
+ }
+| class_constant_declaration ';' {
+ $$ = NNEW(n_STATEMENT)->appendChild($1);
+ NMORE($$, $2);
+ }
+| trait_use_statement {
+ $$ = $1;
+ }
+| method_modifiers function {
+ /* empty */
+ } is_reference T_STRING '(' parameter_list ')' return_type method_body {
+ $$ = NNEW(n_METHOD_DECLARATION);
+ NMORE($$, $2);
+ $$->appendChild($1);
+ $$->appendChild($4);
+ $$->appendChild(NTYPE($5, n_STRING));
+ $$->appendChild(NEXPAND($6, $7, $8));
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild($9);
+ $$->appendChild($10);
+
+ $$ = NNEW(n_STATEMENT)->appendChild($$);
+ }
+;
+
+trait_use_statement:
+ T_USE trait_list trait_adaptations {
+ $$ = NTYPE($1, n_TRAIT_USE);
+ $$->appendChildren($2);
+ $$->appendChild($3);
+ }
+;
+
+trait_list:
+ fully_qualified_class_name {
+ $$ = NNEW(n_TRAIT_USE_LIST)->appendChild($1);
+ }
+| trait_list ',' fully_qualified_class_name {
+ $$ = $1->appendChild($3);
+ }
+;
+
+trait_adaptations:
+ ';' {
+ $$ = NNEW(n_EMPTY);
+ }
+| '{' trait_adaptation_list '}' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+;
+
+trait_adaptation_list:
+ %empty {
+ $$ = NNEW(n_TRAIT_ADAPTATION_LIST);
+ }
+| non_empty_trait_adaptation_list {
+ $$ = $1;
+ }
+;
+
+non_empty_trait_adaptation_list:
+ trait_adaptation_statement {
+ $$ = NNEW(n_TRAIT_ADAPTATION_LIST);
+ $$->appendChild($1);
+ }
+| non_empty_trait_adaptation_list trait_adaptation_statement {
+ $1->appendChild($2);
+ $$ = $1;
+ }
+;
+
+trait_adaptation_statement:
+ trait_precedence ';' {
+ $$ = NMORE($1, $2);
+ }
+| trait_alias ';' {
+ $$ = NMORE($1, $2);
+ }
+;
+
+trait_precedence:
+ trait_method_reference_fully_qualified T_INSTEADOF trait_reference_list {
+ $$ = NNEW(n_TRAIT_INSTEADOF);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ }
+;
+
+trait_reference_list:
+ fully_qualified_class_name {
+ $$ = NNEW(n_TRAIT_REFERENCE_LIST);
+ $$->appendChild($1);
+ }
+| trait_reference_list ',' fully_qualified_class_name {
+ $1->appendChild($3);
+ $$ = $1;
+ }
+;
+
+trait_method_reference:
+ T_STRING {
+ $$ = NNEW(n_TRAIT_METHOD_REFERENCE);
+ $$->appendChild(NTYPE($1, n_STRING));
+ }
+| trait_method_reference_fully_qualified {
+ $$ = $1;
+ }
+;
+
+trait_method_reference_fully_qualified:
+ fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
+ NTYPE($2, n_TRAIT_METHOD_REFERENCE);
+ NEXPAND($1, $2, NTYPE($3, n_STRING));
+ $$ = $2;
+ }
+;
+
+trait_alias:
+ trait_method_reference T_AS trait_modifiers T_STRING {
+ $$ = NNEW(n_TRAIT_AS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ $$->appendChild(NTYPE($4, n_STRING));
+ }
+| trait_method_reference T_AS member_modifier {
+ $$ = NNEW(n_TRAIT_AS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ $$->appendChild(NNEW(n_EMPTY));
+ }
+;
+
+trait_modifiers:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| member_modifier {
+ $$ = NNEW(n_METHOD_MODIFIER_LIST);
+ $$->appendChild(NTYPE($1, n_STRING));
+ }
+;
+
+
+method_body:
+ ';' /* abstract method */ {
+ $$ = NNEW(n_EMPTY);
+ }
+| '{' inner_statement_list '}' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+;
+
+variable_modifiers:
+ non_empty_member_modifiers
+| T_VAR {
+ $$ = NNEW(n_CLASS_MEMBER_MODIFIER_LIST);
+ $$->appendChild(NTYPE($1, n_STRING));
+ }
+;
+
+method_modifiers:
+ %empty {
+ $$ = NNEW(n_METHOD_MODIFIER_LIST);
+ }
+| non_empty_member_modifiers {
+ NTYPE($1, n_METHOD_MODIFIER_LIST);
+ $$ = $1;
+ }
+;
+
+non_empty_member_modifiers:
+ member_modifier {
+ $$ = NNEW(n_CLASS_MEMBER_MODIFIER_LIST);
+ $$->appendChild(NTYPE($1, n_STRING));
+ }
+| non_empty_member_modifiers member_modifier {
+ $$ = $1->appendChild(NTYPE($2, n_STRING));
+ }
+;
+
+member_modifier:
+ T_PUBLIC
+| T_PROTECTED
+| T_PRIVATE
+| T_STATIC
+| T_ABSTRACT
+| T_FINAL
+;
+
+class_variable_declaration:
+ class_variable_declaration ',' T_VARIABLE {
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
+ $$->appendChild(NTYPE($3, n_VARIABLE));
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = $1->appendChild($$);
+ }
+| class_variable_declaration ',' T_VARIABLE '=' static_scalar {
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
+ $$->appendChild(NTYPE($3, n_VARIABLE));
+ $$->appendChild($5);
+
+ $$ = $1->appendChild($$);
+ }
+| T_VARIABLE {
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
+ $$->appendChild(NTYPE($1, n_VARIABLE));
+ $$->appendChild(NNEW(n_EMPTY));
+
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION_LIST)->appendChild($$);
+ }
+| T_VARIABLE '=' static_scalar {
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION);
+ $$->appendChild(NTYPE($1, n_VARIABLE));
+ $$->appendChild($3);
+
+ $$ = NNEW(n_CLASS_MEMBER_DECLARATION_LIST)->appendChild($$);
+ }
+;
+
+class_constant_declaration:
+ class_constant_declaration ',' T_STRING '=' static_scalar {
+ $$ = NNEW(n_CLASS_CONSTANT_DECLARATION);
+ $$->appendChild(NTYPE($3, n_STRING));
+ $$->appendChild($5);
+
+ $1->appendChild($$);
+
+ $$ = $1;
+ }
+| T_CONST T_STRING '=' static_scalar {
+ NTYPE($1, n_CLASS_CONSTANT_DECLARATION_LIST);
+ $$ = NNEW(n_CLASS_CONSTANT_DECLARATION);
+ $$->appendChild(NTYPE($2, n_STRING));
+ $$->appendChild($4);
+ $1->appendChild($$);
+
+ $$ = $1;
+ }
+;
+
+echo_expr_list:
+ echo_expr_list ',' expr {
+ $1->appendChild($3);
+ }
+| expr {
+ $$ = NNEW(n_ECHO_LIST);
+ $$->appendChild($1);
+ }
+;
+
+for_expr:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| non_empty_for_expr
+;
+
+
+non_empty_for_expr:
+ non_empty_for_expr ',' expr {
+ $1->appendChild($3);
+ }
+| expr {
+ $$ = NNEW(n_EXPRESSION_LIST);
+ $$->appendChild($1);
+ }
+;
+
+expr_without_variable:
+ T_LIST '(' assignment_list ')' '=' expr {
+ NTYPE($1, n_LIST);
+ $1->appendChild(NEXPAND($2, $3, $4));
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($5, n_OPERATOR));
+ $$->appendChild($6);
+ }
+| variable '=' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable '=' '&' variable {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+
+ NTYPE($3, n_VARIABLE_REFERENCE);
+ $3->appendChild($4);
+
+ $$->appendChild($3);
+ }
+| variable '=' '&' T_NEW class_name_reference ctor_arguments {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+
+ NTYPE($4, n_NEW);
+ $4->appendChild($5);
+ $4->appendChild($6);
+
+ NTYPE($3, n_VARIABLE_REFERENCE);
+ $3->appendChild($4);
+
+ $$->appendChild($3);
+ }
+| T_CLONE expr {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| variable T_PLUS_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_MINUS_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_MUL_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_DIV_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_CONCAT_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_MOD_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_AND_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_OR_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_XOR_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_SL_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| variable T_SR_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| rw_variable T_INC {
+ $$ = NNEW(n_UNARY_POSTFIX_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ }
+| T_INC rw_variable {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| rw_variable T_DEC {
+ $$ = NNEW(n_UNARY_POSTFIX_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ }
+| T_DEC rw_variable {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| expr T_BOOLEAN_OR expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_BOOLEAN_AND expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_LOGICAL_OR expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_LOGICAL_AND expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_LOGICAL_XOR expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '|' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '&' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '^' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '.' expr {
+
+ /* The concatenation operator generates n_CONCATENATION_LIST instead of
+ n_BINARY_EXPRESSION because we tend to run into stack depth issues in a
+ lot of real-world cases otherwise (e.g., in PHP and JSON decoders). */
+
+ if ($1->type == n_CONCATENATION_LIST && $3->type == n_CONCATENATION_LIST) {
+ $1->appendChild(NTYPE($2, n_OPERATOR));
+ $1->appendChildren($3);
+ $$ = $1;
+ } else if ($1->type == n_CONCATENATION_LIST) {
+ $1->appendChild(NTYPE($2, n_OPERATOR));
+ $1->appendChild($3);
+ $$ = $1;
+ } else if ($3->type == n_CONCATENATION_LIST) {
+ $$ = NNEW(n_CONCATENATION_LIST);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChildren($3);
+ } else {
+ $$ = NNEW(n_CONCATENATION_LIST);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+ }
+| expr '+' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '-' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '*' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '/' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '%' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_SL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_SR expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| '+' expr %prec T_INC {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| '-' expr %prec T_INC {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| '!' expr {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| '~' expr {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| expr T_IS_IDENTICAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_IS_NOT_IDENTICAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_IS_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_IS_NOT_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '<' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_IS_SMALLER_OR_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr '>' expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_IS_GREATER_OR_EQUAL expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_SPACESHIP expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| expr T_INSTANCEOF class_name_reference {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| parenthesis_expr
+| new_expr
+| expr '?' expr ':' expr {
+ $$ = NNEW(n_TERNARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ $$->appendChild(NTYPE($4, n_OPERATOR));
+ $$->appendChild($5);
+ }
+| expr '?' ':' expr {
+ $$ = NNEW(n_TERNARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild(NTYPE($3, n_OPERATOR));
+ $$->appendChild($4);
+ }
+| expr T_COALESCE expr {
+ $$ = NNEW(n_BINARY_EXPRESSION);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($2, n_OPERATOR));
+ $$->appendChild($3);
+ }
+| internal_functions_in_yacc
+| T_INT_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_DOUBLE_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_STRING_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_ARRAY_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_OBJECT_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_BOOL_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_UNSET_CAST expr {
+ $$ = NNEW(n_CAST_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_CAST));
+ $$->appendChild($2);
+ }
+| T_EXIT exit_expr {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| '@' expr {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| T_BACKTICKS_EXPR {
+ NTYPE($1, n_BACKTICKS_EXPRESSION);
+ $$ = $1;
+ }
+| scalar
+| combined_scalar_offset
+| combined_scalar
+| T_PRINT expr {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| T_YIELD {
+ NTYPE($1, n_YIELD);
+ $1->appendChild(NNEW(n_EMPTY));
+ $1->appendChild(NNEW(n_EMPTY));
+ $$ = $1;
+ }
+| function is_reference
+ '(' parameter_list ')'
+ lexical_vars return_type
+ '{' inner_statement_list '}' {
+ NSPAN($1, n_FUNCTION_DECLARATION, $9);
+ $1->appendChild(NNEW(n_EMPTY));
+ $1->appendChild($2);
+ $1->appendChild(NNEW(n_EMPTY));
+ $1->appendChild(NEXPAND($3, $4, $5));
+ $1->appendChild($6);
+ $1->appendChild($7);
+ $1->appendChild(NEXPAND($8, $9, $10));
+
+ $$ = $1;
+ }
+| T_STATIC function is_reference
+ '(' parameter_list ')'
+ lexical_vars return_type
+ '{' inner_statement_list '}' {
+ NSPAN($2, n_FUNCTION_DECLARATION, $10);
+ NMORE($2, $1);
+
+ $$ = NNEW(n_FUNCTION_MODIFIER_LIST);
+ $$->appendChild(NTYPE($1, n_STRING));
+ $2->appendChild($1);
+
+ $2->appendChild(NNEW(n_EMPTY));
+ $2->appendChild($3);
+ $2->appendChild(NNEW(n_EMPTY));
+ $2->appendChild(NEXPAND($4, $5, $6));
+ $2->appendChild($7);
+ $2->appendChild($8);
+ $2->appendChild(NEXPAND($9, $10, $11));
+
+ $$ = $2;
+ }
+;
+
+yield_expr:
+ T_YIELD expr_without_variable {
+ NTYPE($1, n_YIELD);
+ $2->appendChild(NNEW(n_EMPTY));
+ $1->appendChild($2);
+ $$ = $1;
+ }
+| T_YIELD variable {
+ NTYPE($1, n_YIELD);
+ $2->appendChild(NNEW(n_EMPTY));
+ $1->appendChild($2);
+ $$ = $1;
+ }
+| T_YIELD expr T_DOUBLE_ARROW expr_without_variable {
+ NTYPE($1, n_YIELD);
+ $1->appendChild($2);
+ $1->appendChild($4);
+ $$ = $1;
+ }
+| T_YIELD expr T_DOUBLE_ARROW variable {
+ NTYPE($1, n_YIELD);
+ $1->appendChild($2);
+ $1->appendChild($4);
+ $$ = $1;
+ }
+;
+
+function:
+ T_FUNCTION
+;
+
+lexical_vars:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| T_USE '(' lexical_var_list ')' {
+ NTYPE($1, n_LEXICAL_VARIABLE_LIST);
+ $1->appendChildren($3);
+ $$ = $1;
+ }
+;
+
+lexical_var_list:
+ lexical_var_list ',' T_VARIABLE {
+ $$ = $1->appendChild(NTYPE($3, n_VARIABLE));
+ }
+| lexical_var_list ',' '&' T_VARIABLE {
+ NTYPE($3, n_VARIABLE_REFERENCE);
+ $3->appendChild(NTYPE($4, n_VARIABLE));
+ $$ = $1->appendChild($3);
+ }
+| T_VARIABLE {
+ $$ = NNEW(n_LEXICAL_VARIABLE_LIST);
+ $$->appendChild(NTYPE($1, n_VARIABLE));
+ }
+| '&' T_VARIABLE {
+ NTYPE($1, n_VARIABLE_REFERENCE);
+ $1->appendChild(NTYPE($2, n_VARIABLE));
+ $$ = NNEW(n_LEXICAL_VARIABLE_LIST);
+ $$->appendChild($1);
+ }
+;
+
+function_call:
+ namespace_name '(' function_call_parameter_list ')' {
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($1);
+ $$->appendChild(NEXPAND($2, $3, $4));
+ }
+| T_NAMESPACE T_NS_SEPARATOR namespace_name
+ '(' function_call_parameter_list ')' {
+ NMORE($3, $1);
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($3);
+ $$->appendChild(NEXPAND($4, $5, $6));
+ }
+| T_NS_SEPARATOR namespace_name '(' function_call_parameter_list ')' {
+ NMORE($2, $1);
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($2);
+ $$->appendChild(NEXPAND($3, $4, $5));
+ }
+| class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
+ '(' function_call_parameter_list ')' {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+
+ $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
+ $$->appendChild(NEXPAND($4, $5, $6));
+ }
+| variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING
+ '(' function_call_parameter_list ')' {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+
+ $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
+ $$->appendChild(NEXPAND($4, $5, $6));
+ }
+| variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects
+ '(' function_call_parameter_list ')' {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+
+ $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
+ $$->appendChild(NEXPAND($4, $5, $6));
+ }
+| class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects
+ '(' function_call_parameter_list ')' {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+
+ $$ = NNEW(n_FUNCTION_CALL)->appendChild($$);
+ $$->appendChild(NEXPAND($4, $5, $6));
+ }
+| variable_without_objects '(' function_call_parameter_list ')' {
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($1);
+ $$->appendChild(NEXPAND($2, $3, $4));
+ }
+;
+
+class_name:
+ T_STATIC {
+ $$ = NTYPE($1, n_CLASS_NAME);
+ }
+| namespace_name {
+ $$ = NTYPE($1, n_CLASS_NAME);
+ }
+| T_NAMESPACE T_NS_SEPARATOR namespace_name {
+ NMORE($3, $1);
+ $$ = NTYPE($3, n_CLASS_NAME);
+ }
+| T_NS_SEPARATOR namespace_name {
+ NMORE($2, $1);
+ $$ = NTYPE($2, n_CLASS_NAME);
+ }
+;
+
+fully_qualified_class_name:
+ namespace_name {
+ $$ = NTYPE($1, n_CLASS_NAME);
+ }
+| T_NAMESPACE T_NS_SEPARATOR namespace_name {
+ NMORE($3, $1);
+ $$ = NTYPE($3, n_CLASS_NAME);
+ }
+| T_NS_SEPARATOR namespace_name {
+ NMORE($2, $1);
+ $$ = NTYPE($2, n_CLASS_NAME);
+ }
+;
+
+class_name_reference:
+ class_name
+| dynamic_class_name_reference
+;
+
+dynamic_class_name_reference:
+ base_variable
+ T_OBJECT_OPERATOR
+ object_property
+ dynamic_class_name_variable_properties {
+ $$ = NNEW(n_OBJECT_PROPERTY_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ for (xhpast::node_list_t::iterator ii = $4->children.begin();
+ ii != $4->children.end();
+ ++ii) {
+
+ $$ = NNEW(n_OBJECT_PROPERTY_ACCESS)->appendChild($$);
+ $$->appendChild(*ii);
+ }
+ }
+| base_variable
+;
+
+dynamic_class_name_variable_properties:
+ dynamic_class_name_variable_properties dynamic_class_name_variable_property {
+ $$ = $1->appendChild($2);
+ }
+| %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+;
+
+dynamic_class_name_variable_property:
+ T_OBJECT_OPERATOR object_property {
+ $$ = $2;
+ }
+;
+
+exit_expr:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| '(' ')' {
+ NSPAN($1, n_EMPTY, $2);
+ $$ = $1;
+ }
+| '(' expr ')' {
+ NSPAN($1, n_PARENTHETICAL_EXPRESSION, $3);
+ $1->appendChild($2);
+ $$ = $1;
+ }
+;
+
+ctor_arguments:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| '(' function_call_parameter_list ')' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+;
+
+common_scalar:
+ T_LNUMBER {
+ $$ = NTYPE($1, n_NUMERIC_SCALAR);
+ }
+| T_DNUMBER {
+ $$ = NTYPE($1, n_NUMERIC_SCALAR);
+ }
+| T_CONSTANT_ENCAPSED_STRING {
+ $$ = NTYPE($1, n_STRING_SCALAR);
+ }
+| T_LINE {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_FILE {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_DIR {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_CLASS_C {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_METHOD_C {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_TRAIT_C {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_FUNC_C {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_NS_C {
+ $$ = NTYPE($1, n_MAGIC_SCALAR);
+ }
+| T_HEREDOC {
+ $$ = NTYPE($1, n_HEREDOC);
+ }
+;
+
+static_scalar: /* compile-time evaluated scalars */
+ common_scalar
+| namespace_name
+| T_NAMESPACE T_NS_SEPARATOR namespace_name {
+ NMORE($3, $1);
+ $$ = $3;
+ }
+| T_NS_SEPARATOR namespace_name {
+ NMORE($2, $1);
+ $$ = $2;
+ }
+| '+' static_scalar {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| '-' static_scalar {
+ $$ = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ $$->appendChild(NTYPE($1, n_OPERATOR));
+ $$->appendChild($2);
+ }
+| T_ARRAY '(' static_array_pair_list ')' {
+ NTYPE($1, n_ARRAY_LITERAL);
+ $1->appendChild(NEXPAND($2, $3, $4));
+ $$ = $1;
+ }
+| '[' static_array_pair_list ']' {
+ NTYPE($1, n_ARRAY_LITERAL);
+ $1->appendChild(NEXPAND($1, $2, $3));
+ $$ = $1;
+ }
+| static_class_constant
+;
+
+static_class_constant:
+ class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+ }
+;
+
+scalar:
+ T_STRING_VARNAME
+| class_constant
+| namespace_name
+| T_NAMESPACE T_NS_SEPARATOR namespace_name {
+ $$ = NMORE($3, $1);
+ }
+| T_NS_SEPARATOR namespace_name {
+ $$ = NMORE($2, $1);
+ }
+| common_scalar
+;
+
+static_array_pair_list:
+ %empty {
+ $$ = NNEW(n_ARRAY_VALUE_LIST);
+ }
+| non_empty_static_array_pair_list possible_comma {
+ $$ = NMORE($1, $2);
+ }
+;
+
+possible_comma:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| ','
+;
+
+non_empty_static_array_pair_list:
+ non_empty_static_array_pair_list
+ ','
+ static_scalar
+ T_DOUBLE_ARROW
+ static_scalar {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild($3);
+ $$->appendChild($5);
+
+ $$ = $1->appendChild($$);
+ }
+| non_empty_static_array_pair_list ',' static_scalar {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild($3);
+
+ $$ = $1->appendChild($$);
+ }
+| static_scalar T_DOUBLE_ARROW static_scalar {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild($1);
+ $$->appendChild($3);
+
+ $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
+ }
+| static_scalar {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild($1);
+
+ $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
+ }
+;
+
+expr:
+ r_variable
+| expr_without_variable
+;
+
+r_variable:
+ variable
+;
+
+w_variable:
+ variable
+;
+
+rw_variable:
+ variable
+;
+
+variable:
+ base_variable_with_function_calls
+ T_OBJECT_OPERATOR
+ object_property method_or_not
+ variable_properties {
+ $$ = NNEW(n_OBJECT_PROPERTY_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+
+ if ($4->type != n_EMPTY) {
+ $$ = NNEW(n_METHOD_CALL)->appendChild($$);
+ $$->appendChild($4);
+ }
+
+ for (xhpast::node_list_t::iterator ii = $5->children.begin();
+ ii != $5->children.end();
+ ++ii) {
+
+ if ((*ii)->type == n_CALL_PARAMETER_LIST) {
+ $$ = NNEW(n_METHOD_CALL)->appendChild($$);
+ $$->appendChild((*ii));
+ } else {
+ $$ = NNEW(n_OBJECT_PROPERTY_ACCESS)->appendChild($$);
+ $$->appendChild((*ii));
+ }
+ }
+ }
+| base_variable_with_function_calls
+;
+
+variable_properties:
+ variable_properties variable_property {
+ $$ = $1->appendChildren($2);
+ }
+| %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+;
+
+variable_property:
+ T_OBJECT_OPERATOR object_property method_or_not {
+ $$ = NNEW(n_EMPTY);
+ $$->appendChild($2);
+ if ($3->type != n_EMPTY) {
+ $$->appendChild($3);
+ }
+ }
+;
+
+array_method_dereference:
+ array_method_dereference '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| method '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+;
+
+method:
+ '(' function_call_parameter_list ')' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+;
+
+method_or_not:
+ method
+| array_method_dereference
+| %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+;
+
+variable_without_objects:
+ reference_variable
+| simple_indirect_reference reference_variable {
+ xhpast::Node *last = $1;
+ NMORE($1, $2);
+ while (last->firstChild() &&
+ last->firstChild()->type == n_VARIABLE_VARIABLE) {
+ NMORE(last, $2);
+ last = last->firstChild();
+ }
+ last->appendChild($2);
+
+ $$ = $1;
+ }
+;
+
+static_member:
+ class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ }
+| variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ }
+;
+
+variable_class_name:
+ reference_variable
+;
+
+array_function_dereference:
+ array_function_dereference '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| function_call '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+;
+
+base_variable_with_function_calls:
+ base_variable
+| array_function_dereference
+| function_call
+;
+
+base_variable:
+ reference_variable
+| '(' new_expr ')' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+| simple_indirect_reference reference_variable {
+ xhpast::Node *last = $1;
+ NMORE($1, $2);
+ while (last->firstChild() &&
+ last->firstChild()->type == n_VARIABLE_VARIABLE) {
+ NMORE(last, $2);
+ last = last->firstChild();
+ }
+ last->appendChild($2);
+
+ $$ = $1;
+ }
+| static_member
+;
+
+reference_variable:
+ reference_variable '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| reference_variable '{' expr '}' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| compound_variable
+;
+
+compound_variable:
+ T_VARIABLE {
+ NTYPE($1, n_VARIABLE);
+ }
+| '$' '{' expr '}' {
+ NSPAN($1, n_VARIABLE_EXPRESSION, $4);
+ $1->appendChild($3);
+ $$ = $1;
+ }
+;
+
+dim_offset:
+ %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+| expr {
+ $$ = $1;
+ }
+;
+
+object_property:
+ object_dim_list
+| variable_without_objects
+;
+
+object_dim_list:
+ object_dim_list '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| object_dim_list '{' expr '}' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| variable_name
+;
+
+variable_name:
+ T_STRING {
+ NTYPE($1, n_STRING);
+ $$ = $1;
+ }
+| '{' expr '}' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+;
+
+simple_indirect_reference:
+ '$' {
+ $$ = NTYPE($1, n_VARIABLE_VARIABLE);
+ }
+| simple_indirect_reference '$' {
+ $2 = NTYPE($2, n_VARIABLE_VARIABLE);
+
+ xhpast::Node *last = $1;
+ while (last->firstChild() &&
+ last->firstChild()->type == n_VARIABLE_VARIABLE) {
+ last = last->firstChild();
+ }
+ last->appendChild($2);
+
+ $$ = $1;
+ }
+;
+
+assignment_list:
+ assignment_list ',' assignment_list_element {
+ $$ = $1->appendChild($3);
+ }
+| assignment_list_element {
+ $$ = NNEW(n_ASSIGNMENT_LIST);
+ $$->appendChild($1);
+ }
+;
+
+assignment_list_element:
+ variable
+| T_LIST '(' assignment_list ')' {
+ $$ = NNEW(n_LIST);
+ $$->appendChild(NEXPAND($2, $3, $4));
+ }
+| %empty {
+ $$ = NNEW(n_EMPTY);
+ }
+;
+
+array_pair_list:
+ %empty {
+ $$ = NNEW(n_ARRAY_VALUE_LIST);
+ }
+| non_empty_array_pair_list possible_comma {
+ $$ = NMORE($1, $2);
+ }
+;
+
+non_empty_array_pair_list:
+ non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild($3);
+ $$->appendChild($5);
+
+ $$ = $1->appendChild($$);
+ }
+| non_empty_array_pair_list ',' expr {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild($3);
+
+ $$ = $1->appendChild($$);
+ }
+| expr T_DOUBLE_ARROW expr {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild($1);
+ $$->appendChild($3);
+
+ $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
+ }
+| expr {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild($1);
+
+ $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
+ }
+| non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild($3);
+ $$->appendChild(NTYPE($5, n_VARIABLE_REFERENCE)->appendChild($6));
+
+ $$ = $1->appendChild($$);
+ }
+| non_empty_array_pair_list ',' '&' w_variable {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild(NTYPE($3, n_VARIABLE_REFERENCE)->appendChild($4));
+
+ $$ = $1->appendChild($$);
+ }
+| expr T_DOUBLE_ARROW '&' w_variable {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_VARIABLE_REFERENCE)->appendChild($4));
+
+ $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
+ }
+| '&' w_variable {
+ $$ = NNEW(n_ARRAY_VALUE);
+ $$->appendChild(NNEW(n_EMPTY));
+ $$->appendChild(NTYPE($1, n_VARIABLE_REFERENCE)->appendChild($2));
+
+ $$ = NNEW(n_ARRAY_VALUE_LIST)->appendChild($$);
+ }
+;
+
+internal_functions_in_yacc:
+ T_ISSET '(' isset_variables ')' {
+ NTYPE($1, n_SYMBOL_NAME);
+
+ NSPAN($2, n_CALL_PARAMETER_LIST, $4);
+ $2->appendChildren($3);
+
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($1);
+ $$->appendChild($2);
+ }
+| T_EMPTY '(' variable ')' {
+ NTYPE($1, n_SYMBOL_NAME);
+
+ NSPAN($2, n_CALL_PARAMETER_LIST, $4);
+ $2->appendChild($3);
+
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($1);
+ $$->appendChild($2);
+ }
+| T_INCLUDE expr {
+ $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
+ }
+| T_INCLUDE_ONCE expr {
+ $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
+ }
+| T_EVAL '(' expr ')' {
+ NTYPE($1, n_SYMBOL_NAME);
+
+ NSPAN($2, n_CALL_PARAMETER_LIST, $4);
+ $2->appendChild($3);
+
+ $$ = NNEW(n_FUNCTION_CALL);
+ $$->appendChild($1);
+ $$->appendChild($2);
+ }
+| T_REQUIRE expr {
+ $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
+ }
+| T_REQUIRE_ONCE expr {
+ $$ = NTYPE($1, n_INCLUDE_FILE)->appendChild($2);
+ }
+;
+
+isset_variables:
+ variable {
+ $$ = NNEW(n_EMPTY);
+ $$->appendChild($1);
+ }
+| isset_variables ',' variable {
+ $$ = $1->appendChild($3);
+ }
+;
+
+parenthesis_expr:
+ '(' expr ')' {
+ NSPAN($1, n_PARENTHETICAL_EXPRESSION, $3);
+ $1->appendChild($2);
+ $$ = $1;
+ }
+| '(' yield_expr ')' {
+ $$ = NEXPAND($1, $2, $3);
+ }
+;
+
+combined_scalar_offset:
+ combined_scalar '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| combined_scalar_offset '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild(NTYPE($1, n_STRING_SCALAR));
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| class_constant '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+| T_STRING '[' dim_offset ']' {
+ $$ = NNEW(n_INDEX_ACCESS);
+ $$->appendChild(NTYPE($1, n_STRING));
+ $$->appendChild($3);
+ NMORE($$, $4);
+ }
+;
+
+combined_scalar:
+ T_ARRAY '(' array_pair_list ')' {
+ NTYPE($1, n_ARRAY_LITERAL);
+ $1->appendChild(NEXPAND($2, $3, $4));
+ $$ = $1;
+ }
+| '[' array_pair_list ']' {
+ NTYPE($1, n_ARRAY_LITERAL);
+ $1->appendChild(NEXPAND($1, $2, $3));
+ $$ = $1;
+ }
+;
+
+new_expr:
+ T_NEW class_name_reference ctor_arguments {
+ NTYPE($1, n_NEW);
+ $1->appendChild($2);
+ $1->appendChild($3);
+ $$ = $1;
+ }
+;
+
+class_constant:
+ class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+ }
+| variable_class_name T_PAAMAYIM_NEKUDOTAYIM T_STRING {
+ $$ = NNEW(n_CLASS_STATIC_ACCESS);
+ $$->appendChild($1);
+ $$->appendChild(NTYPE($3, n_STRING));
+ }
+;
+
+%%
+
+const char* yytokname(int tok) {
+ if (tok < 255) {
+ return NULL;
+ }
+ return yytname[YYTRANSLATE(tok)];
+}
diff --git a/support/xhpast/parser.yacc.hpp b/support/xhpast/parser.yacc.hpp
new file mode 100644
--- /dev/null
+++ b/support/xhpast/parser.yacc.hpp
@@ -0,0 +1,202 @@
+/* A Bison parser, made by GNU Bison 3.0.4. */
+
+/* Bison interface for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see (xhpastget_extra(yyscanner))
+#undef yylineno
+#define yylineno yyextra->first_lineno
+#define push_state(s) xhp_new_push_state(s, (struct yyguts_t*) yyscanner)
+#define pop_state() xhp_new_pop_state((struct yyguts_t*) yyscanner)
+#define set_state(s) xhp_set_state(s, (struct yyguts_t*) yyscanner)
+
+#define NNEW(t) \
+ (new xhpast::Node(t))
+
+#define NTYPE(n, type) \
+ ((n)->setType(type))
+
+#define NMORE(n, end) \
+ ((n)->expandRange(end))
+
+#define NSPAN(n, type, end) \
+ (NMORE(NTYPE((n), type), end))
+
+#define NEXPAND(l, n, r) \
+ ((n)->expandRange(l)->expandRange(r))
+
+using namespace std;
+
+static void yyerror(void* yyscanner, void* _, const char* error) {
+ if (yyextra->terminated) {
+ return;
+ }
+ yyextra->terminated = true;
+ yyextra->error = error;
+}
+
+
+#line 127 "parser.yacc.cpp" /* yacc.c:339 */
+
+# ifndef YY_NULLPTR
+# if defined __cplusplus && 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* In a future release of Bison, this section will be replaced
+ by #include "parser.yacc.hpp". */
+#ifndef YY_XHPAST_PARSER_YACC_HPP_INCLUDED
+# define YY_XHPAST_PARSER_YACC_HPP_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int xhpastdebug;
+#endif
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ T_INCLUDE = 258,
+ T_INCLUDE_ONCE = 259,
+ T_EVAL = 260,
+ T_REQUIRE = 261,
+ T_REQUIRE_ONCE = 262,
+ T_LOGICAL_OR = 263,
+ T_LOGICAL_XOR = 264,
+ T_LOGICAL_AND = 265,
+ T_PRINT = 266,
+ T_PLUS_EQUAL = 267,
+ T_MINUS_EQUAL = 268,
+ T_MUL_EQUAL = 269,
+ T_DIV_EQUAL = 270,
+ T_CONCAT_EQUAL = 271,
+ T_MOD_EQUAL = 272,
+ T_AND_EQUAL = 273,
+ T_OR_EQUAL = 274,
+ T_XOR_EQUAL = 275,
+ T_SL_EQUAL = 276,
+ T_SR_EQUAL = 277,
+ T_COALESCE = 278,
+ T_BOOLEAN_OR = 279,
+ T_BOOLEAN_AND = 280,
+ T_IS_EQUAL = 281,
+ T_IS_NOT_EQUAL = 282,
+ T_IS_IDENTICAL = 283,
+ T_IS_NOT_IDENTICAL = 284,
+ T_SPACESHIP = 285,
+ T_IS_SMALLER_OR_EQUAL = 286,
+ T_IS_GREATER_OR_EQUAL = 287,
+ T_SL = 288,
+ T_SR = 289,
+ T_INSTANCEOF = 290,
+ T_INC = 291,
+ T_DEC = 292,
+ T_INT_CAST = 293,
+ T_DOUBLE_CAST = 294,
+ T_STRING_CAST = 295,
+ T_UNICODE_CAST = 296,
+ T_BINARY_CAST = 297,
+ T_ARRAY_CAST = 298,
+ T_OBJECT_CAST = 299,
+ T_BOOL_CAST = 300,
+ T_UNSET_CAST = 301,
+ T_NEW = 302,
+ T_CLONE = 303,
+ T_EXIT = 304,
+ T_IF = 305,
+ T_ELSEIF = 306,
+ T_ELSE = 307,
+ T_ENDIF = 308,
+ T_LNUMBER = 309,
+ T_DNUMBER = 310,
+ T_STRING = 311,
+ T_STRING_VARNAME = 312,
+ T_VARIABLE = 313,
+ T_NUM_STRING = 314,
+ T_INLINE_HTML = 315,
+ T_CHARACTER = 316,
+ T_BAD_CHARACTER = 317,
+ T_ENCAPSED_AND_WHITESPACE = 318,
+ T_CONSTANT_ENCAPSED_STRING = 319,
+ T_BACKTICKS_EXPR = 320,
+ T_ECHO = 321,
+ T_DO = 322,
+ T_WHILE = 323,
+ T_ENDWHILE = 324,
+ T_FOR = 325,
+ T_ENDFOR = 326,
+ T_FOREACH = 327,
+ T_ENDFOREACH = 328,
+ T_DECLARE = 329,
+ T_ENDDECLARE = 330,
+ T_AS = 331,
+ T_SWITCH = 332,
+ T_ENDSWITCH = 333,
+ T_CASE = 334,
+ T_DEFAULT = 335,
+ T_BREAK = 336,
+ T_CONTINUE = 337,
+ T_GOTO = 338,
+ T_FUNCTION = 339,
+ T_CONST = 340,
+ T_RETURN = 341,
+ T_TRY = 342,
+ T_CATCH = 343,
+ T_THROW = 344,
+ T_USE = 345,
+ T_GLOBAL = 346,
+ T_STATIC = 347,
+ T_ABSTRACT = 348,
+ T_FINAL = 349,
+ T_PRIVATE = 350,
+ T_PROTECTED = 351,
+ T_PUBLIC = 352,
+ T_VAR = 353,
+ T_UNSET = 354,
+ T_ISSET = 355,
+ T_EMPTY = 356,
+ T_HALT_COMPILER = 357,
+ T_CLASS = 358,
+ T_INTERFACE = 359,
+ T_EXTENDS = 360,
+ T_IMPLEMENTS = 361,
+ T_OBJECT_OPERATOR = 362,
+ T_DOUBLE_ARROW = 363,
+ T_LIST = 364,
+ T_ARRAY = 365,
+ T_CLASS_C = 366,
+ T_METHOD_C = 367,
+ T_FUNC_C = 368,
+ T_LINE = 369,
+ T_FILE = 370,
+ T_COMMENT = 371,
+ T_DOC_COMMENT = 372,
+ T_OPEN_TAG = 373,
+ T_OPEN_TAG_WITH_ECHO = 374,
+ T_OPEN_TAG_FAKE = 375,
+ T_CLOSE_TAG = 376,
+ T_WHITESPACE = 377,
+ T_START_HEREDOC = 378,
+ T_END_HEREDOC = 379,
+ T_HEREDOC = 380,
+ T_DOLLAR_OPEN_CURLY_BRACES = 381,
+ T_CURLY_OPEN = 382,
+ T_PAAMAYIM_NEKUDOTAYIM = 383,
+ T_BINARY_DOUBLE = 384,
+ T_BINARY_HEREDOC = 385,
+ T_NAMESPACE = 386,
+ T_NS_C = 387,
+ T_DIR = 388,
+ T_NS_SEPARATOR = 389,
+ T_INSTEADOF = 390,
+ T_CALLABLE = 391,
+ T_TRAIT = 392,
+ T_TRAIT_C = 393,
+ T_YIELD = 394,
+ T_FINALLY = 395,
+ T_ELLIPSIS = 396
+ };
+#endif
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef int YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+int xhpastparse (void* yyscanner, xhpast::Node** root);
+
+#endif /* !YY_XHPAST_PARSER_YACC_HPP_INCLUDED */
+
+/* Copy the second part of user declarations. */
+
+#line 319 "parser.yacc.cpp" /* yacc.c:358 */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+# include /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+# if ENABLE_NLS
+# include /* INFRINGES ON USER NAME SPACE */
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__ \
+ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
+ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+# define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+# define _Noreturn __declspec (noreturn)
+# else
+# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_USE_ALLOCA
+# if YYSTACK_USE_ALLOCA
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
+# else
+# define YYSTACK_ALLOC alloca
+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+# include /* INFRINGES ON USER NAME SPACE */
+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include /* INFRINGES ON USER NAME SPACE */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+# else
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 3
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 7552
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 168
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 135
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 442
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 908
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+ by yylex, with out-of-bounds checking. */
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 396
+
+#define YYTRANSLATE(YYX) \
+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, without out-of-bounds checking. */
+static const yytype_uint8 yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 50, 2, 2, 166, 49, 32, 2,
+ 161, 162, 47, 44, 8, 45, 46, 48, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 26, 163,
+ 38, 13, 40, 25, 64, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 65, 2, 167, 31, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 164, 30, 165, 52, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
+ 5, 6, 7, 9, 10, 11, 12, 14, 15, 16,
+ 17, 18, 19, 20, 21, 22, 23, 24, 27, 28,
+ 29, 33, 34, 35, 36, 37, 39, 41, 42, 43,
+ 51, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+ 62, 63, 66, 67, 68, 69, 70, 71, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
+ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+ 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
+ 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+ 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
+ 154, 155, 156, 157, 158, 159, 160
+};
+
+#if YYDEBUG
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
+static const yytype_uint16 yyrline[] =
+{
+ 0, 210, 210, 216, 219, 225, 228, 234, 235, 236,
+ 237, 242, 249, 255, 263, 268, 275, 278, 285, 290,
+ 296, 302, 312, 319, 329, 332, 338, 339, 340, 341,
+ 349, 350, 356, 359, 362, 368, 371, 401, 420, 427,
+ 435, 448, 455, 462, 469, 476, 483, 490, 497, 504,
+ 509, 514, 519, 523, 527, 531, 537, 555, 572, 578,
+ 582, 591, 600, 608, 619, 623, 629, 641, 644, 648,
+ 657, 661, 668, 672, 676, 680, 683, 689, 705, 717,
+ 732, 736, 743, 750, 757, 760, 766, 770, 773, 781,
+ 784, 792, 795, 801, 804, 810, 811, 819, 820, 828,
+ 829, 837, 838, 846, 852, 863, 866, 876, 881, 893,
+ 896, 904, 914, 915, 919, 920, 928, 931, 941, 944,
+ 954, 957, 965, 968, 976, 977, 983, 991, 1000, 1009,
+ 1017, 1025, 1034, 1044, 1056, 1060, 1066, 1069, 1070, 1077,
+ 1080, 1083, 1089, 1092, 1099, 1100, 1106, 1109, 1115, 1116,
+ 1119, 1126, 1130, 1137, 1140, 1144, 1151, 1159, 1167, 1175,
+ 1186, 1189, 1195, 1203, 1207, 1210, 1210, 1228, 1236, 1239,
+ 1245, 1248, 1254, 1257, 1263, 1267, 1274, 1277, 1283, 1291,
+ 1295, 1302, 1306, 1312, 1320, 1326, 1335, 1338, 1346, 1349,
+ 1355, 1356, 1363, 1366, 1373, 1377, 1383, 1384, 1385, 1386,
+ 1387, 1388, 1392, 1399, 1406, 1413, 1423, 1432, 1444, 1447,
+ 1454, 1457, 1462, 1465, 1472, 1480, 1486, 1496, 1510, 1515,
+ 1521, 1527, 1533, 1539, 1545, 1551, 1557, 1563, 1569, 1575,
+ 1581, 1586, 1591, 1596, 1601, 1607, 1613, 1619, 1625, 1631,
+ 1637, 1643, 1649, 1675, 1681, 1687, 1693, 1699, 1705, 1711,
+ 1717, 1722, 1727, 1732, 1737, 1743, 1749, 1755, 1761, 1767,
+ 1773, 1779, 1785, 1791, 1797, 1798, 1799, 1807, 1815, 1821,
+ 1822, 1827, 1832, 1837, 1842, 1847, 1852, 1857, 1862, 1867,
+ 1871, 1872, 1873, 1874, 1879, 1885, 1900, 1924, 1930, 1936,
+ 1942, 1951, 1955, 1958, 1966, 1969, 1974, 1978, 1987, 1992,
+ 1999, 2005, 2014, 2023, 2032, 2041, 2049, 2052, 2055, 2059,
+ 2066, 2069, 2073, 2080, 2081, 2085, 2100, 2104, 2107, 2113,
+ 2119, 2122, 2126, 2134, 2137, 2143, 2146, 2149, 2152, 2155,
+ 2158, 2161, 2164, 2167, 2170, 2173, 2176, 2182, 2183, 2184,
+ 2188, 2192, 2197, 2202, 2207, 2212, 2216, 2224, 2225, 2226,
+ 2227, 2230, 2233, 2237, 2240, 2246, 2249, 2253, 2264, 2271,
+ 2278, 2288, 2289, 2293, 2297, 2301, 2305, 2331, 2335, 2338,
+ 2344, 2354, 2360, 2369, 2375, 2376, 2377, 2383, 2384, 2399,
+ 2404, 2412, 2416, 2422, 2431, 2432, 2433, 2437, 2438, 2441,
+ 2453, 2457, 2463, 2469, 2473, 2476, 2484, 2487, 2493, 2494,
+ 2498, 2504, 2510, 2514, 2518, 2524, 2527, 2542, 2545, 2552,
+ 2553, 2557, 2563, 2566, 2572, 2579, 2586, 2593, 2600, 2607,
+ 2614, 2621, 2631, 2641, 2651, 2654, 2657, 2667, 2670, 2676,
+ 2680, 2686, 2691, 2697, 2703, 2709, 2715, 2721, 2730, 2735,
+ 2743, 2752, 2757
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 1
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+ "$end", "error", "$undefined", "T_INCLUDE", "T_INCLUDE_ONCE", "T_EVAL",
+ "T_REQUIRE", "T_REQUIRE_ONCE", "','", "T_LOGICAL_OR", "T_LOGICAL_XOR",
+ "T_LOGICAL_AND", "T_PRINT", "'='", "T_PLUS_EQUAL", "T_MINUS_EQUAL",
+ "T_MUL_EQUAL", "T_DIV_EQUAL", "T_CONCAT_EQUAL", "T_MOD_EQUAL",
+ "T_AND_EQUAL", "T_OR_EQUAL", "T_XOR_EQUAL", "T_SL_EQUAL", "T_SR_EQUAL",
+ "'?'", "':'", "T_COALESCE", "T_BOOLEAN_OR", "T_BOOLEAN_AND", "'|'",
+ "'^'", "'&'", "T_IS_EQUAL", "T_IS_NOT_EQUAL", "T_IS_IDENTICAL",
+ "T_IS_NOT_IDENTICAL", "T_SPACESHIP", "'<'", "T_IS_SMALLER_OR_EQUAL",
+ "'>'", "T_IS_GREATER_OR_EQUAL", "T_SL", "T_SR", "'+'", "'-'", "'.'",
+ "'*'", "'/'", "'%'", "'!'", "T_INSTANCEOF", "'~'", "T_INC", "T_DEC",
+ "T_INT_CAST", "T_DOUBLE_CAST", "T_STRING_CAST", "T_UNICODE_CAST",
+ "T_BINARY_CAST", "T_ARRAY_CAST", "T_OBJECT_CAST", "T_BOOL_CAST",
+ "T_UNSET_CAST", "'@'", "'['", "T_NEW", "T_CLONE", "T_EXIT", "T_IF",
+ "T_ELSEIF", "T_ELSE", "T_ENDIF", "T_LNUMBER", "T_DNUMBER", "T_STRING",
+ "T_STRING_VARNAME", "T_VARIABLE", "T_NUM_STRING", "T_INLINE_HTML",
+ "T_CHARACTER", "T_BAD_CHARACTER", "T_ENCAPSED_AND_WHITESPACE",
+ "T_CONSTANT_ENCAPSED_STRING", "T_BACKTICKS_EXPR", "T_ECHO", "T_DO",
+ "T_WHILE", "T_ENDWHILE", "T_FOR", "T_ENDFOR", "T_FOREACH",
+ "T_ENDFOREACH", "T_DECLARE", "T_ENDDECLARE", "T_AS", "T_SWITCH",
+ "T_ENDSWITCH", "T_CASE", "T_DEFAULT", "T_BREAK", "T_CONTINUE", "T_GOTO",
+ "T_FUNCTION", "T_CONST", "T_RETURN", "T_TRY", "T_CATCH", "T_THROW",
+ "T_USE", "T_GLOBAL", "T_STATIC", "T_ABSTRACT", "T_FINAL", "T_PRIVATE",
+ "T_PROTECTED", "T_PUBLIC", "T_VAR", "T_UNSET", "T_ISSET", "T_EMPTY",
+ "T_HALT_COMPILER", "T_CLASS", "T_INTERFACE", "T_EXTENDS", "T_IMPLEMENTS",
+ "T_OBJECT_OPERATOR", "T_DOUBLE_ARROW", "T_LIST", "T_ARRAY", "T_CLASS_C",
+ "T_METHOD_C", "T_FUNC_C", "T_LINE", "T_FILE", "T_COMMENT",
+ "T_DOC_COMMENT", "T_OPEN_TAG", "T_OPEN_TAG_WITH_ECHO", "T_OPEN_TAG_FAKE",
+ "T_CLOSE_TAG", "T_WHITESPACE", "T_START_HEREDOC", "T_END_HEREDOC",
+ "T_HEREDOC", "T_DOLLAR_OPEN_CURLY_BRACES", "T_CURLY_OPEN",
+ "T_PAAMAYIM_NEKUDOTAYIM", "T_BINARY_DOUBLE", "T_BINARY_HEREDOC",
+ "T_NAMESPACE", "T_NS_C", "T_DIR", "T_NS_SEPARATOR", "T_INSTEADOF",
+ "T_CALLABLE", "T_TRAIT", "T_TRAIT_C", "T_YIELD", "T_FINALLY",
+ "T_ELLIPSIS", "'('", "')'", "';'", "'{'", "'}'", "'$'", "']'", "$accept",
+ "start", "top_statement_list", "namespace_name", "top_statement",
+ "use_declarations", "use_declaration", "constant_declaration",
+ "inner_statement_list", "inner_statement", "statement",
+ "unticked_statement", "catch_list", "catch", "finally_statement",
+ "non_empty_finally_statement", "unset_variables", "unset_variable",
+ "function_declaration_statement", "class_declaration_statement",
+ "is_reference", "unticked_function_declaration_statement",
+ "unticked_class_declaration_statement", "class_entry_type",
+ "extends_from", "interface_entry", "interface_extends_list",
+ "implements_list", "interface_list", "foreach_optional_arg",
+ "foreach_variable", "for_statement", "foreach_statement",
+ "declare_statement", "declare_list", "switch_case_list", "case_list",
+ "case_separator", "while_statement", "elseif_list", "new_elseif_list",
+ "else_single", "new_else_single", "parameter_list",
+ "non_empty_parameter_list", "parameter", "optional_type", "type",
+ "return_type", "function_call_parameter_list",
+ "non_empty_function_call_parameter_list", "argument", "global_var_list",
+ "global_var", "static_var_list", "class_statement_list",
+ "class_statement", "$@1", "trait_use_statement", "trait_list",
+ "trait_adaptations", "trait_adaptation_list",
+ "non_empty_trait_adaptation_list", "trait_adaptation_statement",
+ "trait_precedence", "trait_reference_list", "trait_method_reference",
+ "trait_method_reference_fully_qualified", "trait_alias",
+ "trait_modifiers", "method_body", "variable_modifiers",
+ "method_modifiers", "non_empty_member_modifiers", "member_modifier",
+ "class_variable_declaration", "class_constant_declaration",
+ "echo_expr_list", "for_expr", "non_empty_for_expr",
+ "expr_without_variable", "yield_expr", "function", "lexical_vars",
+ "lexical_var_list", "function_call", "class_name",
+ "fully_qualified_class_name", "class_name_reference",
+ "dynamic_class_name_reference", "dynamic_class_name_variable_properties",
+ "dynamic_class_name_variable_property", "exit_expr", "ctor_arguments",
+ "common_scalar", "static_scalar", "static_class_constant", "scalar",
+ "static_array_pair_list", "possible_comma",
+ "non_empty_static_array_pair_list", "expr", "r_variable", "w_variable",
+ "rw_variable", "variable", "variable_properties", "variable_property",
+ "array_method_dereference", "method", "method_or_not",
+ "variable_without_objects", "static_member", "variable_class_name",
+ "array_function_dereference", "base_variable_with_function_calls",
+ "base_variable", "reference_variable", "compound_variable", "dim_offset",
+ "object_property", "object_dim_list", "variable_name",
+ "simple_indirect_reference", "assignment_list",
+ "assignment_list_element", "array_pair_list",
+ "non_empty_array_pair_list", "internal_functions_in_yacc",
+ "isset_variables", "parenthesis_expr", "combined_scalar_offset",
+ "combined_scalar", "new_expr", "class_constant", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
+static const yytype_uint16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 44, 263,
+ 264, 265, 266, 61, 267, 268, 269, 270, 271, 272,
+ 273, 274, 275, 276, 277, 63, 58, 278, 279, 280,
+ 124, 94, 38, 281, 282, 283, 284, 285, 60, 286,
+ 62, 287, 288, 289, 43, 45, 46, 42, 47, 37,
+ 33, 290, 126, 291, 292, 293, 294, 295, 296, 297,
+ 298, 299, 300, 301, 64, 91, 302, 303, 304, 305,
+ 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
+ 316, 317, 318, 319, 320, 321, 322, 323, 324, 325,
+ 326, 327, 328, 329, 330, 331, 332, 333, 334, 335,
+ 336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
+ 346, 347, 348, 349, 350, 351, 352, 353, 354, 355,
+ 356, 357, 358, 359, 360, 361, 362, 363, 364, 365,
+ 366, 367, 368, 369, 370, 371, 372, 373, 374, 375,
+ 376, 377, 378, 379, 380, 381, 382, 383, 384, 385,
+ 386, 387, 388, 389, 390, 391, 392, 393, 394, 395,
+ 396, 40, 41, 59, 123, 125, 36, 93
+};
+# endif
+
+#define YYPACT_NINF -702
+
+#define yypact_value_is_default(Yystate) \
+ (!!((Yystate) == (-702)))
+
+#define YYTABLE_NINF -382
+
+#define yytable_value_is_error(Yytable_value) \
+ (!!((Yytable_value) == (-382)))
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int16 yypact[] =
+{
+ -702, 51, 1810, -702, 5980, 5980, -97, 5980, 5980, 5980,
+ 5980, 5980, 5980, 5980, 394, 394, 5980, 5980, 5980, 5980,
+ 5980, 5980, 5980, 5980, 4650, 440, 5980, -95, -85, -702,
+ -702, 33, -702, -702, -702, 13, -702, 5980, 4508, -76,
+ -71, -62, 38, 64, 4783, 4916, 107, -702, 155, 5049,
+ 7, 5980, 138, 48, -17, 116, 184, 92, 143, 161,
+ 166, -702, -702, 174, 177, -702, -702, -702, -702, -702,
+ -702, -702, -702, -702, 84, -702, -702, 275, -702, -702,
+ 5980, 6113, -702, -702, 194, -73, -702, 9, -702, -702,
+ -702, -702, -702, -702, 291, 299, -702, 215, 347, 315,
+ 234, -702, -702, 6536, -702, 41, 1047, 221, -702, 240,
+ 323, 264, -702, -9, -702, 56, -702, -702, 326, 327,
+ -702, 330, 332, 295, 248, -702, 347, 7366, 7366, 5980,
+ 7366, 7366, 7433, -702, -702, 352, -702, -702, -702, 253,
+ 275, 342, -98, 265, -702, -702, 269, -702, -702, -702,
+ -702, -702, -702, -702, -702, -702, 394, 7126, 244, 409,
+ 267, 275, 268, 271, 262, -702, 280, 302, -11, 56,
+ -702, 5182, -702, 5980, -702, 5980, 5980, 16, 7366, 363,
+ 5980, 5980, 5980, 377, 5980, -702, 6579, -702, 6622, 290,
+ 442, -702, 294, 7366, 959, -702, 6673, 275, 115, 17,
+ -702, -702, 249, 20, -702, 448, 21, 347, -702, -702,
+ 394, 394, 394, 301, 298, 4650, 275, -702, 150, 103,
+ 104, 7169, 96, 303, 6716, 304, 1952, 5980, 393, 1276,
+ 395, -702, 348, 349, -702, -702, 6, 5980, -27, 5980,
+ 5980, 5980, 5315, 5980, 5980, 5980, 5980, 5980, 5980, 5980,
+ 5980, 5980, 5980, 5980, 5980, 5980, 5980, 5980, 5980, 5980,
+ 5980, 5980, 5980, 5980, 5980, 5980, 440, -702, -702, -702,
+ 5448, 5980, 5980, 5980, 5980, 5980, 5980, 5980, 5980, 5980,
+ 5980, 5980, 1276, 52, 5980, 91, 5980, 5980, 194, 0,
+ 5980, 5980, 5980, 316, 6759, 275, -86, 304, 67, 126,
+ -702, -702, 5581, -702, 5714, -702, 275, 268, 81, 1276,
+ -702, 81, 91, -21, -702, 6810, 6854, 7366, 311, 317,
+ 5980, -702, 322, 6897, 328, 484, 7366, 399, 1032, 483,
+ 25, 6946, -702, -702, -702, 7235, -702, -702, 2094, -702,
+ 117, 423, 138, -702, 5980, -702, -702, 48, -702, 7235,
+ 422, -702, 345, 26, -702, -702, -702, 27, 351, 346,
+ 350, -702, 28, -702, 357, 118, 1498, -702, -702, 1276,
+ 5980, -702, -702, -702, 353, -702, -702, -702, -702, -702,
+ 6258, -702, 394, 5980, 360, 510, -702, 7366, 511, 165,
+ 401, 165, 368, 366, 66, 369, 374, 378, -21, 56,
+ 7408, 1202, 7433, 5980, 7294, 7458, 1659, 7480, 7501, 4703,
+ 1449, 1802, 1802, 1802, 1802, 1802, 1219, 1219, 1219, 1219,
+ 398, 398, 314, 314, 314, 352, 352, 352, -702, 206,
+ 7433, 7433, 7433, 7433, 7433, 7433, 7433, 7433, 7433, 7433,
+ 7433, 7433, 379, 381, 382, 373, -702, 5980, -702, 384,
+ -7, -702, 385, 6301, 386, 387, 389, -702, -82, 374,
+ 381, 394, 7366, 394, 7227, 268, -702, 403, -702, -702,
+ -702, 3798, -702, -702, 7366, 5980, 3940, 5980, 5980, 394,
+ 70, 7235, 471, 4082, 1, 7235, 7235, 7235, -702, 388,
+ 404, 275, 49, 414, -702, -702, -702, -58, 488, -702,
+ -702, 6344, -702, -702, 556, 66, 394, 408, 394, -702,
+ -702, -702, 298, 298, 559, -702, 1276, -702, 1668, 411,
+ 124, 947, 412, -702, -702, 7366, -702, 1276, 7235, 424,
+ 275, 268, -702, 165, 415, 567, -702, -702, 66, 202,
+ -702, -702, 416, 573, 10, -702, -702, -702, 1276, 1276,
+ -21, 7458, 5980, 440, -702, -702, 1276, 1276, -702, 6397,
+ 1276, 517, 520, -702, 5980, 5980, -702, -702, -702, -702,
+ -702, -702, -702, 5847, -702, 460, -702, -702, 6990, -702,
+ -702, -702, 425, 7366, 462, 394, 462, -702, -702, 578,
+ -702, -702, -702, 431, 432, -702, -702, -702, 472, 435,
+ 590, 7235, 275, 98, 528, 444, 447, -58, -702, -702,
+ -702, -702, 7235, 452, -702, -702, -702, 29, -702, 5980,
+ 453, -702, -702, 455, -702, -702, 275, 268, 567, -702,
+ 165, 582, 454, -702, 513, 79, 86, -702, 542, 607,
+ 461, 464, 7458, 262, 474, 476, -702, 477, 5980, 5980,
+ 498, 466, 6440, 394, 7366, 91, -702, 3656, 263, 479,
+ 2236, 5980, 70, 481, -702, 482, 7235, 2378, -702, 213,
+ -702, -37, 7235, -702, 7235, -702, 485, 131, -702, 165,
+ -702, -702, -702, -702, -702, 513, -702, 7433, -702, -702,
+ 268, 661, -702, 571, 165, -702, -702, -702, -702, -702,
+ -702, -702, -702, -702, -702, 557, 295, 319, -702, 22,
+ 624, 490, 624, 57, 640, -702, 7235, -702, -702, -702,
+ -702, -702, -702, 487, 495, 91, -702, -702, -702, -702,
+ -702, 272, 502, 4508, -702, -702, 501, 506, -702, 4224,
+ 4224, -702, 507, 222, 508, 5980, 14, 128, -702, -702,
+ 545, -702, 596, 2520, 624, -702, 662, 11, -702, 663,
+ 23, -702, -702, 602, -702, 79, 514, 162, 516, 86,
+ 668, 7235, -702, -702, -702, 384, 522, 659, 615, 5980,
+ -702, -702, 4366, -702, -702, -702, -702, -702, 529, -702,
+ 6485, -702, -702, -702, -702, 7235, 538, -702, 537, 7235,
+ 165, -702, 179, -702, 7235, 626, -702, 347, 692, -702,
+ -702, 632, -702, 31, -702, 710, 7235, -702, -702, 5980,
+ -702, 561, 7033, -702, -702, -702, 2662, -702, -702, 3656,
+ -702, 563, -702, -702, -702, 630, 564, 179, -702, 565,
+ 635, 577, 569, 594, -702, 724, 667, 7235, 2804, -702,
+ 172, -702, 2946, 7235, -702, 7082, 3656, -702, 4508, 3088,
+ 580, 3656, -702, 3230, -702, -702, -702, 604, 165, -702,
+ 669, 7235, 584, -702, -702, 671, -702, -702, -702, 720,
+ -702, 586, -702, 3372, -702, 675, 678, 746, -702, -702,
+ -702, 66, -702, -702, -702, -702, -702, 165, 595, 3656,
+ -702, 624, 182, -702, -702, -702, 3514, -702
+};
+
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_uint16 yydefact[] =
+{
+ 4, 0, 2, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 412, 0, 0, 320, 0, 325,
+ 326, 5, 347, 394, 52, 327, 279, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 291, 0, 0,
+ 0, 0, 0, 0, 306, 0, 0, 0, 0, 0,
+ 0, 80, 86, 0, 0, 331, 332, 334, 328, 329,
+ 32, 33, 34, 336, 0, 335, 330, 0, 83, 333,
+ 284, 0, 59, 25, 405, 349, 3, 0, 7, 30,
+ 8, 9, 73, 74, 0, 0, 362, 0, 75, 386,
+ 0, 352, 280, 0, 361, 0, 363, 0, 390, 0,
+ 385, 367, 384, 387, 393, 0, 269, 264, 281, 282,
+ 265, 348, 5, 306, 0, 284, 75, 424, 425, 0,
+ 427, 428, 283, 250, 251, 252, 253, 5, 306, 0,
+ 0, 0, 307, 0, 231, 365, 0, 233, 270, 271,
+ 272, 273, 274, 275, 276, 278, 0, 417, 0, 355,
+ 0, 0, 307, 313, 323, 314, 0, 316, 387, 0,
+ 218, 0, 277, 0, 31, 396, 396, 0, 209, 0,
+ 0, 210, 0, 0, 0, 42, 0, 44, 0, 0,
+ 0, 46, 362, 0, 363, 25, 0, 0, 18, 0,
+ 17, 153, 0, 0, 152, 158, 0, 75, 81, 82,
+ 0, 0, 0, 0, 411, 412, 0, 4, 0, 351,
+ 362, 0, 363, 0, 0, 265, 0, 0, 0, 145,
+ 0, 15, 84, 87, 54, 76, 0, 396, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 53, 230, 232,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 145, 0, 396, 0, 396, 0, 406, 389,
+ 396, 396, 396, 0, 0, 0, 309, 0, 0, 0,
+ 421, 364, 0, 439, 356, 413, 0, 309, 0, 145,
+ 440, 0, 0, 389, 321, 0, 0, 397, 0, 0,
+ 0, 51, 0, 0, 0, 211, 213, 362, 363, 0,
+ 0, 0, 43, 45, 63, 0, 47, 48, 0, 62,
+ 20, 0, 0, 14, 0, 154, 363, 0, 49, 0,
+ 0, 50, 0, 0, 70, 72, 429, 0, 0, 0,
+ 0, 409, 0, 408, 0, 350, 0, 11, 4, 145,
+ 0, 432, 431, 388, 0, 35, 24, 26, 27, 28,
+ 0, 6, 0, 0, 0, 144, 146, 148, 0, 0,
+ 89, 0, 0, 0, 136, 0, 441, 379, 377, 0,
+ 236, 238, 237, 0, 0, 268, 234, 235, 239, 241,
+ 240, 256, 257, 254, 255, 262, 258, 259, 260, 261,
+ 248, 249, 243, 244, 242, 245, 246, 247, 263, 0,
+ 215, 219, 220, 221, 222, 223, 224, 225, 226, 227,
+ 228, 229, 0, 442, 380, 0, 403, 0, 399, 376,
+ 398, 402, 0, 0, 0, 0, 0, 426, 308, 0,
+ 0, 0, 416, 0, 415, 308, 379, 0, 380, 318,
+ 322, 0, 437, 435, 208, 0, 0, 210, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 353, 327, 0,
+ 0, 0, 338, 0, 337, 23, 345, 0, 0, 19,
+ 16, 0, 151, 159, 156, 136, 0, 0, 0, 422,
+ 423, 10, 411, 411, 0, 438, 145, 13, 0, 0,
+ 362, 363, 0, 395, 150, 149, 298, 0, 0, 0,
+ 0, 310, 85, 0, 0, 88, 91, 161, 136, 0,
+ 140, 141, 0, 124, 0, 137, 139, 383, 145, 145,
+ 378, 267, 0, 0, 216, 305, 145, 145, 382, 0,
+ 145, 375, 374, 369, 396, 0, 391, 392, 434, 433,
+ 436, 420, 419, 0, 324, 315, 25, 116, 0, 25,
+ 114, 38, 0, 212, 93, 0, 93, 95, 103, 0,
+ 25, 101, 58, 109, 109, 41, 341, 342, 360, 0,
+ 355, 353, 0, 340, 0, 0, 0, 67, 65, 61,
+ 21, 155, 0, 0, 71, 55, 430, 0, 407, 0,
+ 0, 12, 300, 0, 147, 22, 0, 312, 90, 161,
+ 0, 192, 0, 138, 292, 136, 0, 135, 0, 126,
+ 0, 0, 266, 323, 0, 0, 404, 0, 396, 396,
+ 366, 0, 0, 0, 414, 0, 317, 118, 120, 0,
+ 0, 210, 0, 0, 96, 0, 0, 0, 109, 0,
+ 109, 0, 0, 344, 356, 354, 0, 339, 346, 0,
+ 25, 64, 60, 68, 157, 292, 410, 214, 299, 29,
+ 311, 192, 92, 0, 0, 199, 200, 201, 198, 197,
+ 196, 191, 79, 160, 164, 0, 0, 190, 194, 0,
+ 142, 0, 142, 0, 127, 134, 0, 301, 304, 217,
+ 302, 303, 373, 0, 0, 0, 368, 400, 401, 418,
+ 319, 122, 0, 0, 36, 39, 0, 0, 94, 0,
+ 0, 104, 0, 0, 0, 0, 0, 0, 105, 359,
+ 358, 343, 0, 0, 142, 78, 0, 0, 168, 204,
+ 0, 165, 195, 0, 163, 136, 0, 0, 0, 0,
+ 130, 0, 129, 371, 372, 376, 0, 0, 0, 0,
+ 121, 115, 0, 25, 99, 57, 56, 102, 0, 107,
+ 0, 112, 113, 25, 106, 0, 0, 69, 0, 0,
+ 0, 170, 172, 167, 0, 0, 162, 75, 0, 143,
+ 25, 0, 296, 0, 25, 131, 0, 128, 370, 0,
+ 25, 0, 0, 25, 97, 40, 0, 108, 25, 111,
+ 357, 0, 25, 207, 169, 5, 0, 173, 174, 0,
+ 0, 182, 0, 0, 205, 202, 0, 0, 0, 297,
+ 0, 293, 0, 0, 133, 0, 123, 37, 0, 0,
+ 0, 110, 25, 0, 171, 175, 176, 186, 0, 177,
+ 0, 0, 0, 206, 77, 0, 294, 285, 132, 0,
+ 117, 0, 100, 0, 286, 0, 185, 178, 179, 183,
+ 203, 136, 295, 25, 98, 66, 184, 0, 0, 119,
+ 180, 142, 0, 188, 25, 166, 0, 189
+};
+
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int16 yypgoto[] =
+{
+ -702, -702, -199, -5, -702, -702, 419, -702, -183, -702,
+ 19, -702, -702, 149, -702, 156, -702, 256, 2, 3,
+ -125, -702, -702, -702, -702, -702, -702, -702, 231, 181,
+ 106, -702, 39, -702, -702, -702, -562, -8, -702, -702,
+ -702, -702, -702, -497, -702, -591, -589, 230, -701, -209,
+ -702, 254, -702, 436, -702, 157, -702, -702, -702, -702,
+ -702, -702, -702, -53, -702, -702, -702, -702, -702, -702,
+ -702, -702, -702, -702, -694, -702, -702, -702, -463, -702,
+ -42, 706, -2, 108, -702, -702, 227, -66, -251, -702,
+ -702, -702, -702, 145, -187, -212, -702, -702, 188, 191,
+ -702, 908, 598, -356, 339, 356, -702, -702, -702, -702,
+ 30, -215, -702, 793, -702, -702, -22, -23, -702, -160,
+ -306, -702, -702, -3, 284, 279, 583, -702, -702, -702,
+ -702, -702, -702, -38, -702
+};
+
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int16 yydefgoto[] =
+{
+ -1, 1, 2, 85, 86, 199, 200, 87, 226, 376,
+ 377, 89, 607, 608, 682, 609, 353, 354, 378, 379,
+ 236, 92, 93, 94, 390, 95, 392, 534, 535, 663,
+ 586, 825, 785, 592, 330, 595, 669, 793, 581, 658,
+ 731, 734, 778, 542, 543, 639, 544, 545, 766, 384,
+ 385, 386, 203, 204, 206, 631, 703, 807, 704, 757,
+ 803, 836, 837, 838, 839, 887, 840, 841, 842, 885,
+ 905, 705, 706, 707, 708, 760, 709, 177, 324, 325,
+ 96, 97, 126, 712, 813, 99, 100, 546, 164, 165,
+ 575, 656, 172, 310, 101, 598, 496, 102, 599, 305,
+ 600, 103, 104, 300, 105, 106, 650, 726, 561, 562,
+ 563, 107, 108, 109, 110, 111, 112, 113, 114, 318,
+ 449, 450, 451, 115, 362, 363, 158, 159, 116, 357,
+ 117, 118, 119, 120, 121
+};
+
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
+static const yytype_int16 yytable[] =
+{
+ 98, 293, 168, 167, 90, 91, 469, 192, 613, 142,
+ 142, 768, 338, 762, 582, 428, 319, 230, 366, 800,
+ 162, 88, 169, 397, 320, 342, 524, 593, 347, 350,
+ 763, 805, 671, 482, 506, 508, 513, 513, 220, 850,
+ 791, 632, 636, 225, 286, 714, 713, 198, 396, 605,
+ 33, 3, 207, 798, 286, 228, 286, 179, 564, 174,
+ 205, 745, 746, 229, 129, 286, 171, 228, 444, 218,
+ 448, 228, 219, 442, -307, 369, 173, 395, 176, 516,
+ 228, 393, 352, 397, 444, 180, 47, 637, 229, 769,
+ 181, 539, 289, 466, 268, 269, 468, 448, 175, 182,
+ 467, 606, 585, 297, 539, 571, 743, 572, 747, 270,
+ 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
+ 281, 207, 770, 495, 445, 201, 452, 443, 748, 33,
+ 454, 455, 456, 33, 637, 296, -381, 503, -381, 84,
+ 327, 137, 459, 287, 33, 137, 313, 33, 494, -365,
+ -365, 142, -377, 287, 137, 287, 307, 565, 33, 137,
+ 519, -378, 494, 637, 287, 594, 446, 394, 33, 518,
+ 638, 195, 231, 886, 801, 802, 809, 792, 815, 321,
+ 343, 138, 189, 348, 351, 764, 806, 483, 507, 509,
+ 514, 686, 340, 851, 811, 540, -307, 142, 737, 183,
+ 902, 460, 228, 33, 875, 142, 142, 142, 540, 142,
+ 341, 365, 498, 137, 202, 398, 529, 638, 84, 530,
+ 139, 541, 288, 140, 98, 184, 745, 746, -125, 529,
+ 190, 141, 530, 84, 541, 399, 84, 216, 208, 812,
+ 137, 143, 143, 168, 167, -309, 638, 84, 217, 876,
+ -309, 228, 163, 210, 835, 447, 228, 84, -288, -288,
+ 398, 162, 398, 169, 369, -308, -287, -287, 228, 588,
+ 228, 228, 553, 596, 597, 398, 398, 137, -308, 516,
+ 399, 137, 399, 33, 228, 398, -289, -289, 398, 398,
+ 458, 197, 84, 794, 494, 399, 399, 729, 494, 494,
+ 494, 465, 643, 228, 211, 399, 209, 620, 399, 399,
+ 744, 745, 746, 367, 368, 529, 625, 138, 530, 788,
+ 745, 746, 212, 532, 137, 536, 33, 213, 520, 529,
+ 492, 540, 530, 732, 733, 214, 98, 198, 215, 640,
+ 641, 494, 776, 777, 492, 903, 904, 644, 645, 730,
+ 137, 647, 529, 144, 147, 530, 139, 541, 227, 140,
+ 138, 263, 264, 265, 98, 266, 232, 141, 90, 91,
+ 145, 145, 84, 137, 233, 33, 550, 142, 234, 235,
+ 237, 238, 282, 143, 531, 88, 531, 283, 284, 531,
+ 285, 290, 291, 657, 898, 292, 660, 175, 47, 139,
+ 684, 216, 140, 266, 651, 194, 295, 667, 25, 138,
+ 141, 303, 298, 344, 494, 84, 299, 304, 308, 775,
+ 306, 228, -193, 309, 142, 494, 360, 311, 312, 143,
+ 695, 696, 697, 698, 699, 700, 222, 143, 143, 143,
+ 448, 143, 260, 261, 262, 263, 264, 265, 139, 266,
+ 322, 140, 329, 334, 741, 335, 142, 336, 142, 141,
+ 749, 349, 750, 359, 84, 371, 373, 536, 381, 137,
+ 388, 33, 389, 391, 142, 142, 492, 394, 472, 494,
+ 492, 492, 492, 475, 473, 494, 603, 494, 723, 724,
+ 577, 477, 478, 163, 479, 580, 481, 753, 499, 504,
+ 531, 142, 591, 142, 772, 138, 505, 142, 142, 511,
+ 448, 512, 301, 510, 522, 137, 98, 33, 527, 515,
+ 90, 91, 526, 492, 528, 627, 533, 538, 531, 494,
+ 168, 167, 537, 531, 531, 548, 547, 88, 328, 549,
+ 558, 555, 556, 557, 139, 560, 589, 140, 162, 601,
+ 169, 138, 566, 568, 569, 141, 570, 602, 346, 817,
+ 84, 604, 493, 610, 692, 574, 355, 356, 358, 612,
+ 361, 615, 619, 622, 623, 630, 493, 626, 634, 629,
+ 142, 635, 648, 830, 494, 649, 655, 833, 661, 662,
+ 160, 666, 844, 161, 668, 670, 492, 677, 674, 672,
+ 826, 141, 673, 678, 854, 679, 84, 492, 494, 143,
+ 829, 680, 494, 752, 685, 688, 710, 494, 689, 715,
+ 716, 690, 711, 717, 725, 531, 718, 848, 758, 494,
+ 531, 852, 398, 727, 759, 873, 720, 856, 721, 722,
+ 859, 878, 735, 739, 740, 861, 756, 751, 142, 863,
+ 765, 767, 399, 771, 773, 98, 143, 142, 98, 890,
+ 494, 492, 774, 779, 781, 98, 494, 492, 782, 492,
+ 787, 789, 795, 796, 531, 799, 804, 808, 810, 883,
+ 814, 816, 846, 819, 494, 820, 693, 821, 143, 531,
+ 143, 694, 827, 695, 696, 697, 698, 699, 700, 701,
+ 831, 832, 398, 845, 761, 847, 143, 143, 493, 849,
+ 899, 492, 493, 493, 493, 695, 696, 697, 698, 699,
+ 700, 906, 399, 853, 857, -181, 521, 862, 866, 864,
+ 867, 868, 869, 143, 834, 143, 843, 871, 301, 143,
+ 143, 870, 872, 882, 889, 891, 893, 702, 892, 894,
+ 896, 98, 780, -187, 897, 493, 681, 901, 784, 784,
+ 531, 500, 614, 683, 628, 693, 492, 665, 738, 633,
+ 694, 843, 695, 696, 697, 698, 699, 700, 701, 786,
+ 163, 624, 828, 502, 865, 554, 691, 223, 719, 676,
+ 492, 675, 618, 754, 492, 531, 617, 531, 364, 492,
+ 345, 824, 888, 0, 0, 818, 0, 146, 146, 0,
+ 0, 492, 143, 0, 0, 0, 0, 301, 166, 301,
+ 0, 0, 0, 0, 98, 0, 755, 98, 493, 0,
+ 0, 900, 531, 0, 0, 584, 587, 0, 0, 493,
+ 0, 0, 492, 0, 0, 0, 98, 0, 492, 0,
+ 98, 0, 0, 0, 98, 0, 0, 98, 0, 98,
+ 0, 98, 355, 531, 616, 0, 492, 0, 361, 361,
+ 0, 0, 0, 0, 0, 0, 0, 880, 0, 0,
+ 143, 98, 0, 0, 0, 0, 531, 0, 0, 143,
+ 0, 0, 531, 493, 0, 0, 0, 98, 0, 493,
+ 0, 493, 0, 0, 98, 0, 0, 0, 0, 0,
+ 0, 0, 127, 128, 0, 130, 131, 132, 133, 134,
+ 135, 136, 0, 0, 148, 149, 150, 151, 152, 153,
+ 154, 155, 157, 0, 170, 0, 0, 0, 0, 0,
+ 0, 664, 0, 493, 0, 178, 0, 0, 0, 146,
+ 0, 0, 186, 188, 0, 0, 0, 193, 0, 196,
+ 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
+ 280, 281, 270, 271, 272, 273, 274, 275, 276, 277,
+ 278, 279, 280, 281, 0, 0, 0, 0, 221, 224,
+ 0, 0, 0, 0, 0, 146, 0, 0, 493, 0,
+ -365, -365, 0, 146, 146, 146, 0, 146, 0, 301,
+ 0, 0, -365, -365, 0, 0, 0, 0, 587, 0,
+ 0, 0, 493, 0, 0, 0, 493, 0, 0, 0,
+ 0, 493, 0, 0, 0, 0, 0, 294, 0, 0,
+ 0, 0, 0, 493, 0, 270, 271, 272, 273, 274,
+ 275, 276, 277, 278, 279, 280, 281, 0, 0, 166,
+ 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
+ 280, 281, 0, 0, 493, 0, 0, 0, 0, 315,
+ 493, 316, 0, 317, 317, -365, -365, 0, 323, 326,
+ 193, 0, 331, 0, 0, 0, 0, 0, 493, 0,
+ -365, -365, 0, 0, 0, 0, 0, 0, 0, -290,
+ -290, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 337, 157, 0, 0, 0, 480, 0, 0,
+ 0, 0, 0, 0, 0, 380, 0, 387, 0, 0,
+ 0, 0, 0, 0, 0, 317, 0, 400, 401, 402,
+ 404, 405, 406, 407, 408, 409, 410, 411, 412, 413,
+ 414, 415, 416, 417, 418, 419, 420, 421, 422, 423,
+ 424, 425, 426, 427, 0, 146, 0, 0, 430, 431,
+ 432, 433, 434, 435, 436, 437, 438, 439, 440, 441,
+ 387, 0, 317, 0, 317, 453, 0, 0, 317, 317,
+ 317, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 462, 0, 464, 241, 0, 0, 0, 387, 0, 0,
+ 0, 0, 146, 0, 0, 0, 0, 242, 474, 243,
+ 244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
+ 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
+ 264, 265, 501, 266, 146, 0, 146, -382, -382, -382,
+ -382, 258, 259, 260, 261, 262, 263, 264, 265, 0,
+ 266, 0, 146, 146, 0, 0, 0, 387, 193, 4,
+ 5, 6, 7, 8, 0, 0, 0, 0, 9, 0,
+ 0, 525, 0, 0, 0, 0, 0, 0, 0, 146,
+ 0, 146, 0, 0, 0, 146, 146, 0, 382, 0,
+ 0, 551, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10, 11, 0, 0, 0, 0, 12, 0, 13, 14,
+ 15, 16, 17, 18, 0, 0, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 0, 166, 0, 0, 29,
+ 30, 122, 32, 33, 0, 559, 0, 0, 0, 35,
+ 36, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 146, 47,
+ 0, 0, 0, 578, 0, 326, 583, 123, 0, 0,
+ 0, 0, 0, 0, 0, 58, 59, 0, 0, 0,
+ 0, 0, 0, 0, 63, 64, 65, 66, 67, 68,
+ 69, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 73, 0, 0, 0, 387, 0, 124, 75, 76, 77,
+ 0, 0, 0, 79, 125, 387, 383, 81, 0, 0,
+ 0, 0, 84, 0, 0, 0, 146, 0, 0, 0,
+ 0, 0, 0, 0, 0, 146, 387, 387, 0, 0,
+ 642, 0, 0, 0, 387, 387, 0, 0, 387, 0,
+ 0, 0, 317, 652, 0, 0, 0, 0, 0, 0,
+ 0, 654, 249, 250, 251, 252, 253, 254, 255, 256,
+ 257, 258, 259, 260, 261, 262, 263, 264, 265, 0,
+ 266, 4, 5, 6, 7, 8, 0, 0, 0, 0,
+ 9, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 687, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 317, 317, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 0, 326,
+ 0, 29, 30, 31, 32, 33, 0, 34, 0, 0,
+ 0, 35, 36, 37, 38, 39, 0, 40, 0, 41,
+ 0, 42, 0, 0, 43, 0, 0, 0, 44, 45,
+ 46, 47, 48, 49, 50, 0, 51, 52, 53, 54,
+ 55, 56, 0, 0, 0, 0, 57, 58, 59, 60,
+ 61, 62, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 0, 70, 71, 0, 72, 0,
+ 0, 0, 73, 0, 0, 0, 0, 0, 74, 75,
+ 76, 77, 0, 790, 78, 79, 80, 0, 0, 81,
+ 0, 82, 83, 517, 84, 0, 0, 0, 0, 0,
+ 0, 4, 5, 6, 7, 8, 0, 0, 0, 0,
+ 9, 0, 0, 0, 0, 0, 0, 822, 245, 246,
+ 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
+ 257, 258, 259, 260, 261, 262, 263, 264, 265, 0,
+ 266, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 0, 855, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 0, 0,
+ 0, 29, 30, 31, 32, 33, 0, 34, 0, 0,
+ 0, 35, 36, 37, 38, 39, 0, 40, 0, 41,
+ 0, 42, 0, 0, 43, 0, 0, 0, 44, 45,
+ 46, 47, 48, 49, 50, 0, 51, 52, 53, 54,
+ 55, 56, 0, 0, 0, 0, 57, 58, 59, 60,
+ 61, 62, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 0, 70, 71, 0, 72, 0,
+ 0, 0, 73, 4, 5, 6, 7, 8, 74, 75,
+ 76, 77, 9, 0, 78, 79, 80, 0, 0, 81,
+ 0, 82, 83, 621, 84, -382, -382, -382, -382, -382,
+ 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
+ 264, 265, 0, 266, 10, 11, 0, 0, 0, 0,
+ 12, 0, 13, 14, 15, 16, 17, 18, 0, 0,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+ 0, 0, 0, 29, 30, 31, 32, 33, 0, 34,
+ 0, 0, 0, 35, 36, 37, 38, 39, 0, 40,
+ 0, 41, 0, 42, 0, 0, 43, 0, 0, 0,
+ 44, 45, 46, 47, 48, 49, 50, 0, 51, 52,
+ 53, 54, 55, 56, 0, 0, 0, 0, 57, 58,
+ 59, 60, 61, 62, 0, 0, 0, 0, 63, 64,
+ 65, 66, 67, 68, 69, 0, 0, 70, 71, 0,
+ 72, 0, 0, 0, 73, 4, 5, 6, 7, 8,
+ 74, 75, 76, 77, 9, 0, 78, 79, 80, 0,
+ 0, 81, 0, 82, 83, 0, 84, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 10, 11, 0, 0,
+ 0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
+ 0, 0, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 0, 0, 0, 29, 30, 31, 32, 33,
+ 0, 34, 0, 0, 0, 35, 36, 37, 38, 39,
+ 0, 40, 0, 41, 0, 42, 0, 0, 43, 0,
+ 0, 0, 44, 45, 46, 47, 0, 49, 50, 0,
+ 51, 0, 53, 54, 55, 56, 0, 0, 0, 0,
+ 57, 58, 59, 374, 61, 62, 0, 0, 0, 0,
+ 63, 64, 65, 66, 67, 68, 69, 0, 0, 70,
+ 71, 0, 72, 0, 0, 0, 73, 4, 5, 6,
+ 7, 8, 124, 75, 76, 77, 9, 0, 78, 79,
+ 80, 0, 0, 81, 0, 82, 83, 375, 84, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 10, 11,
+ 0, 0, 0, 0, 12, 0, 13, 14, 15, 16,
+ 17, 18, 0, 0, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 28, 0, 0, 0, 29, 30, 31,
+ 32, 33, 0, 34, 0, 0, 0, 35, 36, 37,
+ 38, 39, 0, 40, 0, 41, 0, 42, 0, 0,
+ 43, 0, 0, 0, 44, 45, 46, 47, 0, 49,
+ 50, 0, 51, 0, 53, 54, 55, 56, 0, 0,
+ 0, 0, 57, 58, 59, 374, 61, 62, 0, 0,
+ 0, 0, 63, 64, 65, 66, 67, 68, 69, 0,
+ 0, 70, 71, 0, 72, 0, 0, 0, 73, 4,
+ 5, 6, 7, 8, 124, 75, 76, 77, 9, 0,
+ 78, 79, 80, 0, 0, 81, 0, 82, 83, 497,
+ 84, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10, 11, 0, 0, 0, 0, 12, 0, 13, 14,
+ 15, 16, 17, 18, 0, 0, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 28, 0, 0, 0, 29,
+ 30, 31, 32, 33, 0, 34, 0, 0, 0, 35,
+ 36, 37, 38, 39, 736, 40, 0, 41, 0, 42,
+ 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
+ 0, 49, 50, 0, 51, 0, 53, 54, 55, 56,
+ 0, 0, 0, 0, 57, 58, 59, 374, 61, 62,
+ 0, 0, 0, 0, 63, 64, 65, 66, 67, 68,
+ 69, 0, 0, 70, 71, 0, 72, 0, 0, 0,
+ 73, 4, 5, 6, 7, 8, 124, 75, 76, 77,
+ 9, 0, 78, 79, 80, 0, 0, 81, 0, 82,
+ 83, 0, 84, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 0, 0, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 0, 0,
+ 0, 29, 30, 31, 32, 33, 0, 34, 0, 0,
+ 0, 35, 36, 37, 38, 39, 0, 40, 0, 41,
+ 0, 42, 742, 0, 43, 0, 0, 0, 44, 45,
+ 46, 47, 0, 49, 50, 0, 51, 0, 53, 54,
+ 55, 56, 0, 0, 0, 0, 57, 58, 59, 374,
+ 61, 62, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 0, 70, 71, 0, 72, 0,
+ 0, 0, 73, 4, 5, 6, 7, 8, 124, 75,
+ 76, 77, 9, 0, 78, 79, 80, 0, 0, 81,
+ 0, 82, 83, 0, 84, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 10, 11, 0, 0, 0, 0,
+ 12, 0, 13, 14, 15, 16, 17, 18, 0, 0,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+ 0, 0, 0, 29, 30, 31, 32, 33, 0, 34,
+ 0, 0, 0, 35, 36, 37, 38, 39, 0, 40,
+ 0, 41, 0, 42, 0, 0, 43, 0, 0, 0,
+ 44, 45, 46, 47, 0, 49, 50, 0, 51, 0,
+ 53, 54, 55, 56, 0, 0, 0, 0, 57, 58,
+ 59, 374, 61, 62, 0, 0, 0, 0, 63, 64,
+ 65, 66, 67, 68, 69, 0, 0, 70, 71, 0,
+ 72, 0, 0, 0, 73, 4, 5, 6, 7, 8,
+ 124, 75, 76, 77, 9, 0, 78, 79, 80, 0,
+ 0, 81, 0, 82, 83, 797, 84, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 10, 11, 0, 0,
+ 0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
+ 0, 0, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 0, 0, 0, 29, 30, 31, 32, 33,
+ 0, 34, 0, 0, 0, 35, 36, 37, 38, 39,
+ 0, 40, 0, 41, 860, 42, 0, 0, 43, 0,
+ 0, 0, 44, 45, 46, 47, 0, 49, 50, 0,
+ 51, 0, 53, 54, 55, 56, 0, 0, 0, 0,
+ 57, 58, 59, 374, 61, 62, 0, 0, 0, 0,
+ 63, 64, 65, 66, 67, 68, 69, 0, 0, 70,
+ 71, 0, 72, 0, 0, 0, 73, 4, 5, 6,
+ 7, 8, 124, 75, 76, 77, 9, 0, 78, 79,
+ 80, 0, 0, 81, 0, 82, 83, 0, 84, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 10, 11,
+ 0, 0, 0, 0, 12, 0, 13, 14, 15, 16,
+ 17, 18, 0, 0, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 28, 0, 0, 0, 29, 30, 31,
+ 32, 33, 0, 34, 0, 0, 0, 35, 36, 37,
+ 38, 39, 0, 40, 0, 41, 0, 42, 0, 0,
+ 43, 0, 0, 0, 44, 45, 46, 47, 0, 49,
+ 50, 0, 51, 0, 53, 54, 55, 56, 0, 0,
+ 0, 0, 57, 58, 59, 374, 61, 62, 0, 0,
+ 0, 0, 63, 64, 65, 66, 67, 68, 69, 0,
+ 0, 70, 71, 0, 72, 0, 0, 0, 73, 4,
+ 5, 6, 7, 8, 124, 75, 76, 77, 9, 0,
+ 78, 79, 80, 0, 0, 81, 0, 82, 83, 874,
+ 84, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10, 11, 0, 0, 0, 0, 12, 0, 13, 14,
+ 15, 16, 17, 18, 0, 0, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 28, 0, 0, 0, 29,
+ 30, 31, 32, 33, 0, 34, 0, 0, 0, 35,
+ 36, 37, 38, 39, 0, 40, 0, 41, 0, 42,
+ 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
+ 0, 49, 50, 0, 51, 0, 53, 54, 55, 56,
+ 0, 0, 0, 0, 57, 58, 59, 374, 61, 62,
+ 0, 0, 0, 0, 63, 64, 65, 66, 67, 68,
+ 69, 0, 0, 70, 71, 0, 72, 0, 0, 0,
+ 73, 4, 5, 6, 7, 8, 124, 75, 76, 77,
+ 9, 0, 78, 79, 80, 0, 0, 81, 0, 82,
+ 83, 877, 84, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 0, 0, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 0, 0,
+ 0, 29, 30, 31, 32, 33, 0, 34, 0, 0,
+ 0, 35, 36, 37, 38, 39, 0, 40, 881, 41,
+ 0, 42, 0, 0, 43, 0, 0, 0, 44, 45,
+ 46, 47, 0, 49, 50, 0, 51, 0, 53, 54,
+ 55, 56, 0, 0, 0, 0, 57, 58, 59, 374,
+ 61, 62, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 0, 70, 71, 0, 72, 0,
+ 0, 0, 73, 4, 5, 6, 7, 8, 124, 75,
+ 76, 77, 9, 0, 78, 79, 80, 0, 0, 81,
+ 0, 82, 83, 0, 84, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 10, 11, 0, 0, 0, 0,
+ 12, 0, 13, 14, 15, 16, 17, 18, 0, 0,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+ 0, 0, 0, 29, 30, 31, 32, 33, 0, 34,
+ 0, 0, 0, 35, 36, 37, 38, 39, 0, 40,
+ 0, 41, 0, 42, 0, 0, 43, 0, 0, 0,
+ 44, 45, 46, 47, 0, 49, 50, 0, 51, 0,
+ 53, 54, 55, 56, 0, 0, 0, 0, 57, 58,
+ 59, 374, 61, 62, 0, 0, 0, 0, 63, 64,
+ 65, 66, 67, 68, 69, 0, 0, 70, 71, 0,
+ 72, 0, 0, 0, 73, 4, 5, 6, 7, 8,
+ 124, 75, 76, 77, 9, 0, 78, 79, 80, 0,
+ 0, 81, 0, 82, 83, 884, 84, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 10, 11, 0, 0,
+ 0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
+ 0, 0, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 0, 0, 0, 29, 30, 31, 32, 33,
+ 0, 34, 0, 0, 0, 35, 36, 37, 38, 39,
+ 0, 40, 0, 41, 0, 42, 0, 0, 43, 0,
+ 0, 0, 44, 45, 46, 47, 0, 49, 50, 0,
+ 51, 0, 53, 54, 55, 56, 0, 0, 0, 0,
+ 57, 58, 59, 374, 61, 62, 0, 0, 0, 0,
+ 63, 64, 65, 66, 67, 68, 69, 0, 0, 70,
+ 71, 0, 72, 0, 0, 0, 73, 4, 5, 6,
+ 7, 8, 124, 75, 76, 77, 9, 0, 78, 79,
+ 80, 0, 0, 81, 0, 82, 83, 895, 84, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 10, 11,
+ 0, 0, 0, 0, 12, 0, 13, 14, 15, 16,
+ 17, 18, 0, 0, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 28, 0, 0, 0, 29, 30, 31,
+ 32, 33, 0, 34, 0, 0, 0, 35, 36, 37,
+ 38, 39, 0, 40, 0, 41, 0, 42, 0, 0,
+ 43, 0, 0, 0, 44, 45, 46, 47, 0, 49,
+ 50, 0, 51, 0, 53, 54, 55, 56, 0, 0,
+ 0, 0, 57, 58, 59, 374, 61, 62, 0, 0,
+ 0, 0, 63, 64, 65, 66, 67, 68, 69, 0,
+ 0, 70, 71, 0, 72, 0, 0, 0, 73, 4,
+ 5, 6, 7, 8, 124, 75, 76, 77, 9, 0,
+ 78, 79, 80, 0, 0, 81, 0, 82, 83, 907,
+ 84, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10, 11, 0, 0, 0, 0, 12, 0, 13, 14,
+ 15, 16, 17, 18, 0, 0, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 28, 0, 0, 0, 29,
+ 30, 31, 32, 33, 0, 34, 0, 0, 0, 35,
+ 36, 37, 38, 39, 0, 40, 0, 41, 0, 42,
+ 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
+ 0, 49, 50, 0, 51, 0, 53, 54, 55, 56,
+ 0, 0, 0, 0, 57, 58, 59, 374, 61, 62,
+ 0, 0, 0, 0, 63, 64, 65, 66, 67, 68,
+ 69, 0, 0, 70, 71, 0, 72, 0, 0, 0,
+ 73, 4, 5, 6, 7, 8, 124, 75, 76, 77,
+ 9, 0, 78, 79, 80, 0, 0, 81, 0, 82,
+ 83, 0, 84, 0, 576, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 0, 0, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 0, 0,
+ 0, 29, 30, 31, 32, 33, 0, 34, 0, 0,
+ 0, 35, 36, 37, 38, 39, 0, 40, 0, 41,
+ 0, 42, 0, 0, 43, 0, 0, 0, 44, 45,
+ 46, 47, 0, 49, 50, 0, 51, 0, 53, 54,
+ 0, 0, 0, 0, 0, 0, 57, 58, 59, 0,
+ 0, 0, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 0, 70, 71, 0, 72, 0,
+ 0, 0, 73, 4, 5, 6, 7, 8, 124, 75,
+ 76, 77, 9, 0, 0, 79, 80, 0, 0, 81,
+ 0, 82, 83, 0, 84, 0, 579, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 10, 11, 0, 0, 0, 0,
+ 12, 0, 13, 14, 15, 16, 17, 18, 0, 0,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+ 0, 0, 0, 29, 30, 31, 32, 33, 0, 34,
+ 0, 0, 0, 35, 36, 37, 38, 39, 0, 40,
+ 0, 41, 0, 42, 0, 0, 43, 0, 0, 0,
+ 44, 45, 46, 47, 0, 49, 50, 0, 51, 0,
+ 53, 54, 0, 0, 0, 0, 0, 0, 57, 58,
+ 59, 0, 0, 0, 0, 0, 0, 0, 63, 64,
+ 65, 66, 67, 68, 69, 0, 0, 70, 71, 0,
+ 72, 0, 0, 0, 73, 4, 5, 6, 7, 8,
+ 124, 75, 76, 77, 9, 0, 0, 79, 80, 0,
+ 0, 81, 0, 82, 83, 0, 84, 0, 590, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 10, 11, 0, 0,
+ 0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
+ 0, 0, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 0, 0, 0, 29, 30, 31, 32, 33,
+ 0, 34, 0, 0, 0, 35, 36, 37, 38, 39,
+ 0, 40, 0, 41, 0, 42, 0, 0, 43, 0,
+ 0, 0, 44, 45, 46, 47, 0, 49, 50, 0,
+ 51, 0, 53, 54, 0, 0, 0, 0, 0, 0,
+ 57, 58, 59, 0, 0, 0, 0, 0, 0, 0,
+ 63, 64, 65, 66, 67, 68, 69, 0, 0, 70,
+ 71, 0, 72, 0, 0, 0, 73, 4, 5, 6,
+ 7, 8, 124, 75, 76, 77, 9, 0, 0, 79,
+ 80, 0, 0, 81, 0, 82, 83, 0, 84, 0,
+ 783, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 10, 11,
+ 0, 0, 0, 0, 12, 0, 13, 14, 15, 16,
+ 17, 18, 0, 0, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 28, 0, 0, 0, 29, 30, 31,
+ 32, 33, 0, 34, 0, 0, 0, 35, 36, 37,
+ 38, 39, 0, 40, 0, 41, 0, 42, 0, 0,
+ 43, 0, 0, 0, 44, 45, 46, 47, 0, 49,
+ 50, 0, 51, 0, 53, 54, 0, 0, 0, 0,
+ 0, 0, 57, 58, 59, 0, 0, 0, 0, 0,
+ 0, 0, 63, 64, 65, 66, 67, 68, 69, 0,
+ 0, 70, 71, 0, 72, 0, 0, 0, 73, 4,
+ 5, 6, 7, 8, 124, 75, 76, 77, 9, 0,
+ 0, 79, 80, 0, 0, 81, 0, 82, 83, 0,
+ 84, 0, 823, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10, 11, 0, 0, 0, 0, 12, 0, 13, 14,
+ 15, 16, 17, 18, 0, 0, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 28, 0, 0, 0, 29,
+ 30, 31, 32, 33, 0, 34, 0, 0, 0, 35,
+ 36, 37, 38, 39, 0, 40, 0, 41, 0, 42,
+ 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
+ 0, 49, 50, 0, 51, 0, 53, 54, 0, 0,
+ 0, 0, 0, 0, 57, 58, 59, 0, 0, 0,
+ 0, 0, 0, 0, 63, 64, 65, 66, 67, 68,
+ 69, 0, 0, 70, 71, 0, 72, 0, 0, 0,
+ 73, 4, 5, 6, 7, 8, 124, 75, 76, 77,
+ 9, 0, 0, 79, 80, 0, 0, 81, 0, 82,
+ 83, 0, 84, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 0, 0, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 0, 0,
+ 0, 29, 30, 31, 32, 33, 0, 34, 0, 0,
+ 0, 35, 36, 37, 38, 39, 0, 40, 0, 41,
+ 0, 42, 0, 0, 43, 0, 0, 0, 44, 45,
+ 46, 47, 0, 49, 50, 0, 51, 0, 53, 54,
+ 0, 0, 0, 0, 0, 0, 57, 58, 59, 0,
+ 0, 0, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 0, 70, 71, 0, 72, 0,
+ 0, 0, 73, 4, 5, 6, 7, 8, 124, 75,
+ 76, 77, 9, 0, 0, 79, 80, 0, 0, 81,
+ 0, 82, 83, 0, 84, 0, 0, 0, 0, 0,
+ 0, 0, 156, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 10, 11, 0, 0, 0, 0,
+ 12, 0, 13, 14, 15, 16, 17, 18, 0, 0,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 0,
+ 0, 0, 0, 29, 30, 122, 32, 33, 0, 0,
+ 0, 0, 0, 35, 36, 248, 249, 250, 251, 252,
+ 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
+ 263, 264, 265, 47, 266, 0, 0, 0, 0, 0,
+ 0, 123, 0, 0, 0, 0, 0, 0, 0, 58,
+ 59, 0, 0, 0, 0, 0, 0, 0, 63, 64,
+ 65, 66, 67, 68, 69, 0, 4, 5, 6, 7,
+ 8, 0, 0, 0, 73, 9, 0, 0, 0, 0,
+ 124, 75, 76, 77, 0, 0, 0, 79, 125, 0,
+ 0, 81, 0, 0, 0, 0, 84, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 10, 11, 0,
+ 0, 0, 0, 12, 0, 13, 14, 15, 16, 17,
+ 18, 0, 0, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 0, 0, 0, 0, 29, 30, 122, 32,
+ 33, 0, 0, 0, 0, 0, 35, 36, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 47, 0, 0, 0,
+ 0, 0, 0, 0, 123, 0, 0, 0, 0, 0,
+ 0, 0, 58, 59, 0, 0, 0, 0, 0, 0,
+ 0, 63, 64, 65, 66, 67, 68, 69, 0, 4,
+ 5, 6, 7, 8, 0, 0, 0, 73, 9, 0,
+ 0, 0, 0, 124, 75, 76, 77, 0, 0, 0,
+ 79, 125, 0, 0, 81, 0, 185, 0, 0, 84,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 10, 11, 0, 0, 0, 0, 12, 0, 13, 14,
+ 15, 16, 17, 18, 0, 0, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 0, 0, 0, 0, 29,
+ 30, 122, 32, 33, 0, 0, 0, 0, 0, 35,
+ 36, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
+ 0, 0, 0, 0, 0, 0, 0, 123, 0, 0,
+ 0, 0, 0, 0, 0, 58, 59, 0, 0, 0,
+ 0, 0, 0, 0, 63, 64, 65, 66, 67, 68,
+ 69, 0, 4, 5, 6, 7, 8, 0, 0, 0,
+ 73, 9, 0, 0, 0, 0, 124, 75, 76, 77,
+ 0, 0, 0, 79, 125, 0, 0, 81, 0, 187,
+ 0, 0, 84, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 10, 11, 0, 0, 0, 0, 12,
+ 0, 13, 14, 15, 16, 17, 18, 0, 0, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 0, 0,
+ 0, 0, 29, 30, 122, 32, 33, 0, 0, 0,
+ 0, 0, 35, 36, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 47, 0, 0, 0, 0, 0, 0, 0,
+ 123, 0, 0, 0, 0, 0, 0, 0, 58, 59,
+ 0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
+ 66, 67, 68, 69, 0, 4, 5, 6, 7, 8,
+ 0, 0, 0, 73, 9, 0, 0, 0, 0, 124,
+ 75, 76, 77, 0, 0, 0, 79, 125, 0, 0,
+ 81, 0, 191, 0, 0, 84, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 10, 11, 0, 0,
+ 0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
+ 0, 0, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 0, 0, 0, 0, 29, 30, 122, 32, 33,
+ 0, 0, 0, 0, 0, 35, 36, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 47, 0, 0, 0, 0,
+ 0, 0, 0, 123, 0, 0, 0, 0, 0, 0,
+ 0, 58, 59, 0, 0, 0, 0, 0, 0, 0,
+ 63, 64, 65, 66, 67, 68, 69, 0, 4, 5,
+ 6, 7, 8, 0, 0, 0, 73, 9, 0, 0,
+ 0, 0, 124, 75, 76, 77, 0, 0, 0, 79,
+ 125, 403, 0, 81, 314, 0, 0, 0, 84, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 10,
+ 11, 0, 0, 0, 0, 12, 0, 13, 14, 15,
+ 16, 17, 18, 0, 0, 19, 20, 21, 22, 23,
+ 24, 25, 26, 27, 0, 0, 0, 0, 29, 30,
+ 122, 32, 33, 0, 0, 0, 0, 0, 35, 36,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 47, 0,
+ 0, 0, 0, 0, 0, 0, 123, 0, 0, 0,
+ 0, 0, 0, 0, 58, 59, 0, 0, 0, 0,
+ 0, 0, 0, 63, 64, 65, 66, 67, 68, 69,
+ 0, 4, 5, 6, 7, 8, 0, 0, 0, 73,
+ 9, 0, 0, 0, 0, 124, 75, 76, 77, 0,
+ 0, 0, 79, 125, 0, 0, 81, 0, 0, 0,
+ 429, 84, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 10, 11, 0, 0, 0, 0, 12, 0,
+ 13, 14, 15, 16, 17, 18, 0, 0, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 0, 0, 0,
+ 0, 29, 30, 122, 32, 33, 0, 0, 0, 0,
+ 0, 35, 36, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 47, 0, 0, 0, 0, 0, 0, 0, 123,
+ 0, 0, 0, 0, 0, 0, 0, 58, 59, 0,
+ 0, 0, 0, 0, 0, 0, 63, 64, 65, 66,
+ 67, 68, 69, 0, 4, 5, 6, 7, 8, 0,
+ 0, 0, 73, 9, 0, 0, 0, 0, 124, 75,
+ 76, 77, 0, 0, 0, 79, 125, 0, 0, 81,
+ 0, 0, 0, 461, 84, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 10, 11, 0, 0, 0,
+ 0, 12, 0, 13, 14, 15, 16, 17, 18, 0,
+ 0, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+ 0, 0, 0, 0, 29, 30, 122, 32, 33, 0,
+ 0, 0, 0, 0, 35, 36, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 47, 0, 0, 0, 0, 0,
+ 0, 0, 123, 0, 0, 0, 0, 0, 0, 0,
+ 58, 59, 0, 0, 0, 0, 0, 0, 0, 63,
+ 64, 65, 66, 67, 68, 69, 0, 4, 5, 6,
+ 7, 8, 0, 0, 0, 73, 9, 0, 0, 0,
+ 0, 124, 75, 76, 77, 0, 0, 0, 79, 125,
+ 0, 0, 81, 0, 0, 0, 463, 84, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 10, 11,
+ 0, 0, 0, 0, 12, 0, 13, 14, 15, 16,
+ 17, 18, 0, 0, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 0, 0, 0, 0, 29, 30, 122,
+ 32, 33, 0, 0, 0, 0, 0, 35, 36, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 47, 0, 0,
+ 0, 0, 0, 0, 0, 123, 0, 0, 0, 0,
+ 0, 0, 0, 58, 59, 0, 0, 0, 0, 0,
+ 0, 0, 63, 64, 65, 66, 67, 68, 69, 0,
+ 4, 5, 6, 7, 8, 0, 0, 0, 73, 9,
+ 0, 0, 0, 0, 124, 75, 76, 77, 0, 0,
+ 0, 79, 125, 0, 0, 81, 0, 0, 0, 653,
+ 84, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 10, 11, 0, 0, 0, 0, 12, 0, 13,
+ 14, 15, 16, 17, 18, 0, 0, 19, 20, 21,
+ 22, 23, 24, 25, 26, 27, 0, 0, 0, 0,
+ 29, 30, 122, 32, 33, 0, 0, 0, 0, 0,
+ 35, 36, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 47, 0, 0, 0, 0, 0, 0, 0, 123, 0,
+ 0, 0, 0, 0, 0, 0, 58, 59, 0, 0,
+ 0, 0, 0, 0, 0, 63, 64, 65, 66, 67,
+ 68, 69, 0, 4, 5, 6, 7, 8, 0, 0,
+ 0, 73, 9, 0, 0, 0, 0, 124, 75, 76,
+ 77, 0, 0, 0, 79, 125, 0, 0, 81, 0,
+ 0, 0, 0, 84, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 10, 11, 0, 0, 0, 0,
+ 12, 0, 13, 14, 15, 16, 17, 18, 0, 0,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 0,
+ 0, 0, 0, 29, 30, 122, 32, 33, 0, 0,
+ 0, 0, 0, 35, 36, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 47, 0, 0, 0, 0, 0, 0,
+ 0, 123, 0, 0, 0, 0, 0, 0, 0, 58,
+ 59, 0, 0, 0, 0, 0, 0, 0, 63, 64,
+ 65, 66, 67, 68, 69, 0, 4, 5, 6, 7,
+ 8, 0, 0, 0, 73, 9, 0, 0, 0, 0,
+ 124, 75, 76, 77, 0, 0, 0, 79, 125, 0,
+ 0, 81, 0, 0, 0, 0, 84, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 10, 11, 0,
+ 0, 0, 0, 12, 0, 13, 14, 15, 16, 17,
+ 18, 0, 0, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 0, 0, 0, 0, 29, 30, 122, 32,
+ 33, 0, 0, 0, 0, 0, 35, 36, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 47, 0, 0, 0,
+ 0, 0, 0, 0, 123, 0, 0, 0, 0, 0,
+ 0, 0, 58, 59, 0, 0, 0, 0, 0, 0,
+ 0, 63, 64, 65, 66, 67, 68, 69, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 73, 0, 0,
+ 0, 0, 0, 124, 75, 76, 77, 239, 240, 241,
+ 79, 80, 0, 0, 81, 0, 0, 0, 0, 84,
+ 0, 0, 0, 242, 0, 243, 244, 245, 246, 247,
+ 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
+ 258, 259, 260, 261, 262, 263, 264, 265, 0, 266,
+ 239, 240, 241, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 242, 0, 243, 244,
+ 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
+ 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 0, 266, 239, 240, 241, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 242,
+ 0, 243, 244, 245, 246, 247, 248, 249, 250, 251,
+ 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
+ 262, 263, 264, 265, 0, 266, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 239, 240, 241, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 242, 523, 243, 244, 245, 246, 247, 248,
+ 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
+ 259, 260, 261, 262, 263, 264, 265, 0, 266, 239,
+ 240, 241, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 242, 567, 243, 244, 245,
+ 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+ 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
+ 0, 266, 0, 0, 239, 240, 241, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 611,
+ 242, 791, 243, 244, 245, 246, 247, 248, 249, 250,
+ 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
+ 261, 262, 263, 264, 265, 0, 266, 0, 0, 0,
+ 0, 0, 0, 0, 0, 239, 240, 241, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 242, 646, 243, 244, 245, 246, 247, 248, 249,
+ 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
+ 260, 261, 262, 263, 264, 265, 0, 266, 239, 240,
+ 241, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 242, 728, 243, 244, 245, 246,
+ 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
+ 257, 258, 259, 260, 261, 262, 263, 264, 265, 0,
+ 266, 239, 240, 241, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 242, 792, 243,
+ 244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
+ 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
+ 264, 265, 0, 266, 0, 0, 0, 0, 0, 0,
+ 0, 0, 239, 240, 241, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 242, 267,
+ 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
+ 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
+ 263, 264, 265, 0, 266, 239, 240, 241, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 242, 332, 243, 244, 245, 246, 247, 248, 249,
+ 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
+ 260, 261, 262, 263, 264, 265, 0, 266, 239, 240,
+ 241, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 242, 333, 243, 244, 245, 246,
+ 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
+ 257, 258, 259, 260, 261, 262, 263, 264, 265, 0,
+ 266, 0, 0, 0, 0, 0, 0, 0, 0, 239,
+ 240, 241, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 242, 339, 243, 244, 245,
+ 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+ 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
+ 0, 266, 0, 239, 240, 241, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 372, 242,
+ 0, 243, 244, 245, 246, 247, 248, 249, 250, 251,
+ 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
+ 262, 263, 264, 265, 0, 266, 239, 240, 241, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 457, 242, 0, 243, 244, 245, 246, 247, 248,
+ 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
+ 259, 260, 261, 262, 263, 264, 265, 0, 266, 0,
+ 0, 0, 0, 0, 0, 239, 240, 241, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 242, 470, 243, 244, 245, 246, 247, 248, 249,
+ 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
+ 260, 261, 262, 263, 264, 265, 0, 266, 0, 239,
+ 240, 241, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 242, 471, 243, 244, 245,
+ 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+ 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
+ 0, 266, 239, 240, 241, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 242, 476,
+ 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
+ 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
+ 263, 264, 265, 0, 266, 0, 0, 0, 0, 0,
+ 0, 239, 240, 241, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 242, 484, 243,
+ 244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
+ 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
+ 264, 265, 0, 266, 0, 239, 240, 241, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 242, 659, 243, 244, 245, 246, 247, 248, 249,
+ 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
+ 260, 261, 262, 263, 264, 265, 0, 266, 239, 240,
+ 241, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 242, 858, 243, 244, 245, 246,
+ 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
+ 257, 258, 259, 260, 261, 262, 263, 264, 265, 0,
+ 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 239, 240, 241, 0,
+ 0, 0, 0, 0, 879, 0, 0, 0, 0, 0,
+ 0, 0, 242, 302, 243, 244, 245, 246, 247, 248,
+ 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
+ 259, 260, 261, 262, 263, 264, 265, 0, 266, 485,
+ 486, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 370, 0, 0, 0,
+ 487, 0, 0, 239, 240, 241, 0, 0, 29, 30,
+ 137, 0, 0, 0, 0, 0, 0, 0, 488, 242,
+ 552, 243, 244, 245, 246, 247, 248, 249, 250, 251,
+ 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
+ 262, 263, 264, 265, 0, 266, 138, 0, 0, 0,
+ 0, 0, 0, 0, 573, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 489, 65, 66, 67, 68, 69,
+ 0, 0, 0, 0, 0, 239, 240, 241, 0, 73,
+ 0, 0, 0, 0, 0, 490, 75, 76, 491, 0,
+ 0, 242, 79, 243, 244, 245, 246, 247, 248, 249,
+ 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
+ 260, 261, 262, 263, 264, 265, 0, 266, 240, 241,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 242, 0, 243, 244, 245, 246, 247,
+ 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
+ 258, 259, 260, 261, 262, 263, 264, 265, 242, 266,
+ 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
+ 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
+ 263, 264, 265, 0, 266, 243, 244, 245, 246, 247,
+ 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
+ 258, 259, 260, 261, 262, 263, 264, 265, 0, 266,
+ 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+ 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
+ 0, 266, 247, 248, 249, 250, 251, 252, 253, 254,
+ 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 0, 266
+};
+
+static const yytype_int16 yycheck[] =
+{
+ 2, 126, 25, 25, 2, 2, 312, 49, 505, 14,
+ 15, 712, 195, 707, 477, 266, 176, 8, 217, 8,
+ 25, 2, 25, 238, 8, 8, 382, 26, 8, 8,
+ 8, 8, 594, 8, 8, 8, 8, 8, 80, 8,
+ 26, 538, 32, 81, 65, 636, 635, 52, 75, 107,
+ 77, 0, 54, 754, 65, 153, 65, 38, 65, 26,
+ 77, 98, 99, 161, 161, 65, 161, 153, 283, 74,
+ 285, 153, 77, 282, 147, 161, 161, 237, 65, 161,
+ 153, 75, 207, 298, 299, 161, 103, 77, 161, 32,
+ 161, 25, 115, 308, 53, 54, 311, 312, 65, 161,
+ 309, 159, 32, 141, 25, 461, 668, 463, 670, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 123, 713, 335, 284, 77, 286, 75, 165, 77,
+ 290, 291, 292, 77, 77, 140, 147, 349, 147, 166,
+ 182, 75, 75, 164, 77, 75, 169, 77, 335, 53,
+ 54, 156, 161, 164, 75, 164, 161, 164, 77, 75,
+ 369, 161, 349, 77, 164, 164, 75, 161, 77, 368,
+ 160, 164, 163, 867, 163, 164, 765, 163, 769, 163,
+ 163, 111, 75, 163, 163, 163, 163, 162, 162, 162,
+ 162, 162, 197, 162, 32, 129, 147, 202, 661, 161,
+ 901, 75, 153, 77, 32, 210, 211, 212, 129, 214,
+ 95, 216, 95, 75, 166, 238, 150, 160, 166, 153,
+ 150, 155, 166, 153, 226, 161, 98, 99, 162, 150,
+ 75, 161, 153, 166, 155, 238, 166, 153, 122, 77,
+ 75, 14, 15, 266, 266, 147, 160, 166, 164, 77,
+ 147, 153, 25, 161, 75, 164, 153, 166, 162, 163,
+ 283, 266, 285, 266, 161, 147, 162, 163, 153, 481,
+ 153, 153, 66, 485, 486, 298, 299, 75, 147, 161,
+ 283, 75, 285, 77, 153, 308, 162, 163, 311, 312,
+ 295, 153, 166, 165, 481, 298, 299, 653, 485, 486,
+ 487, 306, 553, 153, 161, 308, 122, 516, 311, 312,
+ 97, 98, 99, 163, 164, 150, 528, 111, 153, 97,
+ 98, 99, 161, 389, 75, 391, 77, 161, 370, 150,
+ 335, 129, 153, 70, 71, 161, 338, 342, 161, 548,
+ 549, 528, 70, 71, 349, 163, 164, 556, 557, 655,
+ 75, 560, 150, 14, 15, 153, 150, 155, 164, 153,
+ 111, 47, 48, 49, 366, 51, 75, 161, 366, 366,
+ 14, 15, 166, 75, 75, 77, 399, 382, 163, 32,
+ 65, 147, 161, 156, 389, 366, 391, 147, 65, 394,
+ 126, 65, 65, 576, 891, 65, 579, 65, 103, 150,
+ 612, 153, 153, 51, 564, 49, 153, 590, 66, 111,
+ 161, 167, 147, 164, 601, 166, 147, 8, 147, 725,
+ 153, 153, 103, 161, 429, 612, 128, 147, 126, 202,
+ 111, 112, 113, 114, 115, 116, 80, 210, 211, 212,
+ 655, 214, 44, 45, 46, 47, 48, 49, 150, 51,
+ 87, 153, 75, 163, 666, 13, 461, 163, 463, 161,
+ 672, 13, 674, 162, 166, 162, 162, 533, 75, 75,
+ 75, 77, 124, 124, 479, 480, 481, 161, 167, 666,
+ 485, 486, 487, 161, 167, 672, 491, 674, 648, 649,
+ 471, 163, 8, 266, 95, 476, 13, 680, 75, 77,
+ 505, 506, 483, 508, 716, 111, 161, 512, 513, 163,
+ 725, 161, 156, 162, 161, 75, 518, 77, 8, 162,
+ 518, 518, 162, 528, 13, 530, 125, 161, 533, 716,
+ 553, 553, 164, 538, 539, 161, 167, 518, 182, 161,
+ 167, 162, 161, 161, 150, 161, 75, 153, 553, 161,
+ 553, 111, 167, 167, 167, 161, 167, 153, 202, 771,
+ 166, 147, 335, 75, 630, 162, 210, 211, 212, 13,
+ 214, 163, 13, 162, 162, 8, 349, 153, 162, 164,
+ 585, 8, 65, 795, 771, 65, 126, 799, 163, 127,
+ 150, 13, 804, 153, 163, 163, 601, 602, 8, 127,
+ 783, 161, 167, 75, 816, 161, 166, 612, 795, 382,
+ 793, 164, 799, 679, 162, 162, 162, 804, 163, 77,
+ 13, 626, 109, 162, 126, 630, 162, 810, 694, 816,
+ 635, 814, 655, 167, 77, 847, 162, 820, 162, 162,
+ 823, 853, 163, 162, 162, 828, 75, 162, 653, 832,
+ 26, 161, 655, 13, 167, 657, 429, 662, 660, 871,
+ 847, 666, 167, 161, 163, 667, 853, 672, 162, 674,
+ 163, 163, 127, 77, 679, 13, 13, 75, 164, 862,
+ 164, 13, 807, 161, 871, 26, 104, 72, 461, 694,
+ 463, 109, 163, 111, 112, 113, 114, 115, 116, 117,
+ 162, 164, 725, 77, 706, 13, 479, 480, 481, 77,
+ 893, 716, 485, 486, 487, 111, 112, 113, 114, 115,
+ 116, 904, 725, 13, 163, 95, 370, 164, 163, 165,
+ 95, 154, 163, 506, 800, 508, 802, 13, 382, 512,
+ 513, 147, 75, 163, 75, 161, 26, 165, 77, 163,
+ 75, 753, 733, 75, 8, 528, 607, 162, 739, 740,
+ 765, 342, 506, 607, 533, 104, 771, 586, 662, 539,
+ 109, 837, 111, 112, 113, 114, 115, 116, 117, 740,
+ 553, 527, 790, 347, 837, 429, 629, 81, 643, 601,
+ 795, 600, 513, 685, 799, 800, 512, 802, 215, 804,
+ 202, 782, 868, -1, -1, 775, -1, 14, 15, -1,
+ -1, 816, 585, -1, -1, -1, -1, 461, 25, 463,
+ -1, -1, -1, -1, 826, -1, 165, 829, 601, -1,
+ -1, 897, 837, -1, -1, 479, 480, -1, -1, 612,
+ -1, -1, 847, -1, -1, -1, 848, -1, 853, -1,
+ 852, -1, -1, -1, 856, -1, -1, 859, -1, 861,
+ -1, 863, 506, 868, 508, -1, 871, -1, 512, 513,
+ -1, -1, -1, -1, -1, -1, -1, 858, -1, -1,
+ 653, 883, -1, -1, -1, -1, 891, -1, -1, 662,
+ -1, -1, 897, 666, -1, -1, -1, 899, -1, 672,
+ -1, 674, -1, -1, 906, -1, -1, -1, -1, -1,
+ -1, -1, 4, 5, -1, 7, 8, 9, 10, 11,
+ 12, 13, -1, -1, 16, 17, 18, 19, 20, 21,
+ 22, 23, 24, -1, 26, -1, -1, -1, -1, -1,
+ -1, 585, -1, 716, -1, 37, -1, -1, -1, 156,
+ -1, -1, 44, 45, -1, -1, -1, 49, -1, 51,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+ 23, 24, 13, 14, 15, 16, 17, 18, 19, 20,
+ 21, 22, 23, 24, -1, -1, -1, -1, 80, 81,
+ -1, -1, -1, -1, -1, 202, -1, -1, 771, -1,
+ 53, 54, -1, 210, 211, 212, -1, 214, -1, 653,
+ -1, -1, 53, 54, -1, -1, -1, -1, 662, -1,
+ -1, -1, 795, -1, -1, -1, 799, -1, -1, -1,
+ -1, 804, -1, -1, -1, -1, -1, 129, -1, -1,
+ -1, -1, -1, 816, -1, 13, 14, 15, 16, 17,
+ 18, 19, 20, 21, 22, 23, 24, -1, -1, 266,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+ 23, 24, -1, -1, 847, -1, -1, -1, -1, 171,
+ 853, 173, -1, 175, 176, 53, 54, -1, 180, 181,
+ 182, -1, 184, -1, -1, -1, -1, -1, 871, -1,
+ 53, 54, -1, -1, -1, -1, -1, -1, -1, 162,
+ 163, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 163, 215, -1, -1, -1, 95, -1, -1,
+ -1, -1, -1, -1, -1, 227, -1, 229, -1, -1,
+ -1, -1, -1, -1, -1, 237, -1, 239, 240, 241,
+ 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
+ 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
+ 262, 263, 264, 265, -1, 382, -1, -1, 270, 271,
+ 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
+ 282, -1, 284, -1, 286, 287, -1, -1, 290, 291,
+ 292, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 302, -1, 304, 11, -1, -1, -1, 309, -1, -1,
+ -1, -1, 429, -1, -1, -1, -1, 25, 320, 27,
+ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 344, 51, 461, -1, 463, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, -1,
+ 51, -1, 479, 480, -1, -1, -1, 369, 370, 3,
+ 4, 5, 6, 7, -1, -1, -1, -1, 12, -1,
+ -1, 383, -1, -1, -1, -1, -1, -1, -1, 506,
+ -1, 508, -1, -1, -1, 512, 513, -1, 32, -1,
+ -1, 403, -1, -1, -1, -1, -1, -1, -1, -1,
+ 44, 45, -1, -1, -1, -1, 50, -1, 52, 53,
+ 54, 55, 56, 57, -1, -1, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, -1, 553, -1, -1, 73,
+ 74, 75, 76, 77, -1, 447, -1, -1, -1, 83,
+ 84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 585, 103,
+ -1, -1, -1, 475, -1, 477, 478, 111, -1, -1,
+ -1, -1, -1, -1, -1, 119, 120, -1, -1, -1,
+ -1, -1, -1, -1, 128, 129, 130, 131, 132, 133,
+ 134, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 144, -1, -1, -1, 516, -1, 150, 151, 152, 153,
+ -1, -1, -1, 157, 158, 527, 160, 161, -1, -1,
+ -1, -1, 166, -1, -1, -1, 653, -1, -1, -1,
+ -1, -1, -1, -1, -1, 662, 548, 549, -1, -1,
+ 552, -1, -1, -1, 556, 557, -1, -1, 560, -1,
+ -1, -1, 564, 565, -1, -1, -1, -1, -1, -1,
+ -1, 573, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, -1,
+ 51, 3, 4, 5, 6, 7, -1, -1, -1, -1,
+ 12, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 619, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, 648, 649, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, -1, 661,
+ -1, 73, 74, 75, 76, 77, -1, 79, -1, -1,
+ -1, 83, 84, 85, 86, 87, -1, 89, -1, 91,
+ -1, 93, -1, -1, 96, -1, -1, -1, 100, 101,
+ 102, 103, 104, 105, 106, -1, 108, 109, 110, 111,
+ 112, 113, -1, -1, -1, -1, 118, 119, 120, 121,
+ 122, 123, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, -1, 137, 138, -1, 140, -1,
+ -1, -1, 144, -1, -1, -1, -1, -1, 150, 151,
+ 152, 153, -1, 745, 156, 157, 158, -1, -1, 161,
+ -1, 163, 164, 165, 166, -1, -1, -1, -1, -1,
+ -1, 3, 4, 5, 6, 7, -1, -1, -1, -1,
+ 12, -1, -1, -1, -1, -1, -1, 779, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, -1,
+ 51, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, -1, 819, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, -1, -1,
+ -1, 73, 74, 75, 76, 77, -1, 79, -1, -1,
+ -1, 83, 84, 85, 86, 87, -1, 89, -1, 91,
+ -1, 93, -1, -1, 96, -1, -1, -1, 100, 101,
+ 102, 103, 104, 105, 106, -1, 108, 109, 110, 111,
+ 112, 113, -1, -1, -1, -1, 118, 119, 120, 121,
+ 122, 123, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, -1, 137, 138, -1, 140, -1,
+ -1, -1, 144, 3, 4, 5, 6, 7, 150, 151,
+ 152, 153, 12, -1, 156, 157, 158, -1, -1, 161,
+ -1, 163, 164, 165, 166, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, -1, 51, 44, 45, -1, -1, -1, -1,
+ 50, -1, 52, 53, 54, 55, 56, 57, -1, -1,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+ -1, -1, -1, 73, 74, 75, 76, 77, -1, 79,
+ -1, -1, -1, 83, 84, 85, 86, 87, -1, 89,
+ -1, 91, -1, 93, -1, -1, 96, -1, -1, -1,
+ 100, 101, 102, 103, 104, 105, 106, -1, 108, 109,
+ 110, 111, 112, 113, -1, -1, -1, -1, 118, 119,
+ 120, 121, 122, 123, -1, -1, -1, -1, 128, 129,
+ 130, 131, 132, 133, 134, -1, -1, 137, 138, -1,
+ 140, -1, -1, -1, 144, 3, 4, 5, 6, 7,
+ 150, 151, 152, 153, 12, -1, 156, 157, 158, -1,
+ -1, 161, -1, 163, 164, -1, 166, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
+ -1, -1, 50, -1, 52, 53, 54, 55, 56, 57,
+ -1, -1, 60, 61, 62, 63, 64, 65, 66, 67,
+ 68, 69, -1, -1, -1, 73, 74, 75, 76, 77,
+ -1, 79, -1, -1, -1, 83, 84, 85, 86, 87,
+ -1, 89, -1, 91, -1, 93, -1, -1, 96, -1,
+ -1, -1, 100, 101, 102, 103, -1, 105, 106, -1,
+ 108, -1, 110, 111, 112, 113, -1, -1, -1, -1,
+ 118, 119, 120, 121, 122, 123, -1, -1, -1, -1,
+ 128, 129, 130, 131, 132, 133, 134, -1, -1, 137,
+ 138, -1, 140, -1, -1, -1, 144, 3, 4, 5,
+ 6, 7, 150, 151, 152, 153, 12, -1, 156, 157,
+ 158, -1, -1, 161, -1, 163, 164, 165, 166, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
+ -1, -1, -1, -1, 50, -1, 52, 53, 54, 55,
+ 56, 57, -1, -1, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, 69, -1, -1, -1, 73, 74, 75,
+ 76, 77, -1, 79, -1, -1, -1, 83, 84, 85,
+ 86, 87, -1, 89, -1, 91, -1, 93, -1, -1,
+ 96, -1, -1, -1, 100, 101, 102, 103, -1, 105,
+ 106, -1, 108, -1, 110, 111, 112, 113, -1, -1,
+ -1, -1, 118, 119, 120, 121, 122, 123, -1, -1,
+ -1, -1, 128, 129, 130, 131, 132, 133, 134, -1,
+ -1, 137, 138, -1, 140, -1, -1, -1, 144, 3,
+ 4, 5, 6, 7, 150, 151, 152, 153, 12, -1,
+ 156, 157, 158, -1, -1, 161, -1, 163, 164, 165,
+ 166, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 44, 45, -1, -1, -1, -1, 50, -1, 52, 53,
+ 54, 55, 56, 57, -1, -1, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, -1, -1, -1, 73,
+ 74, 75, 76, 77, -1, 79, -1, -1, -1, 83,
+ 84, 85, 86, 87, 88, 89, -1, 91, -1, 93,
+ -1, -1, 96, -1, -1, -1, 100, 101, 102, 103,
+ -1, 105, 106, -1, 108, -1, 110, 111, 112, 113,
+ -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
+ -1, -1, -1, -1, 128, 129, 130, 131, 132, 133,
+ 134, -1, -1, 137, 138, -1, 140, -1, -1, -1,
+ 144, 3, 4, 5, 6, 7, 150, 151, 152, 153,
+ 12, -1, 156, 157, 158, -1, -1, 161, -1, 163,
+ 164, -1, 166, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, -1, -1, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, -1, -1,
+ -1, 73, 74, 75, 76, 77, -1, 79, -1, -1,
+ -1, 83, 84, 85, 86, 87, -1, 89, -1, 91,
+ -1, 93, 94, -1, 96, -1, -1, -1, 100, 101,
+ 102, 103, -1, 105, 106, -1, 108, -1, 110, 111,
+ 112, 113, -1, -1, -1, -1, 118, 119, 120, 121,
+ 122, 123, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, -1, 137, 138, -1, 140, -1,
+ -1, -1, 144, 3, 4, 5, 6, 7, 150, 151,
+ 152, 153, 12, -1, 156, 157, 158, -1, -1, 161,
+ -1, 163, 164, -1, 166, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
+ 50, -1, 52, 53, 54, 55, 56, 57, -1, -1,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+ -1, -1, -1, 73, 74, 75, 76, 77, -1, 79,
+ -1, -1, -1, 83, 84, 85, 86, 87, -1, 89,
+ -1, 91, -1, 93, -1, -1, 96, -1, -1, -1,
+ 100, 101, 102, 103, -1, 105, 106, -1, 108, -1,
+ 110, 111, 112, 113, -1, -1, -1, -1, 118, 119,
+ 120, 121, 122, 123, -1, -1, -1, -1, 128, 129,
+ 130, 131, 132, 133, 134, -1, -1, 137, 138, -1,
+ 140, -1, -1, -1, 144, 3, 4, 5, 6, 7,
+ 150, 151, 152, 153, 12, -1, 156, 157, 158, -1,
+ -1, 161, -1, 163, 164, 165, 166, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
+ -1, -1, 50, -1, 52, 53, 54, 55, 56, 57,
+ -1, -1, 60, 61, 62, 63, 64, 65, 66, 67,
+ 68, 69, -1, -1, -1, 73, 74, 75, 76, 77,
+ -1, 79, -1, -1, -1, 83, 84, 85, 86, 87,
+ -1, 89, -1, 91, 92, 93, -1, -1, 96, -1,
+ -1, -1, 100, 101, 102, 103, -1, 105, 106, -1,
+ 108, -1, 110, 111, 112, 113, -1, -1, -1, -1,
+ 118, 119, 120, 121, 122, 123, -1, -1, -1, -1,
+ 128, 129, 130, 131, 132, 133, 134, -1, -1, 137,
+ 138, -1, 140, -1, -1, -1, 144, 3, 4, 5,
+ 6, 7, 150, 151, 152, 153, 12, -1, 156, 157,
+ 158, -1, -1, 161, -1, 163, 164, -1, 166, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
+ -1, -1, -1, -1, 50, -1, 52, 53, 54, 55,
+ 56, 57, -1, -1, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, 69, -1, -1, -1, 73, 74, 75,
+ 76, 77, -1, 79, -1, -1, -1, 83, 84, 85,
+ 86, 87, -1, 89, -1, 91, -1, 93, -1, -1,
+ 96, -1, -1, -1, 100, 101, 102, 103, -1, 105,
+ 106, -1, 108, -1, 110, 111, 112, 113, -1, -1,
+ -1, -1, 118, 119, 120, 121, 122, 123, -1, -1,
+ -1, -1, 128, 129, 130, 131, 132, 133, 134, -1,
+ -1, 137, 138, -1, 140, -1, -1, -1, 144, 3,
+ 4, 5, 6, 7, 150, 151, 152, 153, 12, -1,
+ 156, 157, 158, -1, -1, 161, -1, 163, 164, 165,
+ 166, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 44, 45, -1, -1, -1, -1, 50, -1, 52, 53,
+ 54, 55, 56, 57, -1, -1, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, -1, -1, -1, 73,
+ 74, 75, 76, 77, -1, 79, -1, -1, -1, 83,
+ 84, 85, 86, 87, -1, 89, -1, 91, -1, 93,
+ -1, -1, 96, -1, -1, -1, 100, 101, 102, 103,
+ -1, 105, 106, -1, 108, -1, 110, 111, 112, 113,
+ -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
+ -1, -1, -1, -1, 128, 129, 130, 131, 132, 133,
+ 134, -1, -1, 137, 138, -1, 140, -1, -1, -1,
+ 144, 3, 4, 5, 6, 7, 150, 151, 152, 153,
+ 12, -1, 156, 157, 158, -1, -1, 161, -1, 163,
+ 164, 165, 166, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, -1, -1, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, -1, -1,
+ -1, 73, 74, 75, 76, 77, -1, 79, -1, -1,
+ -1, 83, 84, 85, 86, 87, -1, 89, 90, 91,
+ -1, 93, -1, -1, 96, -1, -1, -1, 100, 101,
+ 102, 103, -1, 105, 106, -1, 108, -1, 110, 111,
+ 112, 113, -1, -1, -1, -1, 118, 119, 120, 121,
+ 122, 123, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, -1, 137, 138, -1, 140, -1,
+ -1, -1, 144, 3, 4, 5, 6, 7, 150, 151,
+ 152, 153, 12, -1, 156, 157, 158, -1, -1, 161,
+ -1, 163, 164, -1, 166, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
+ 50, -1, 52, 53, 54, 55, 56, 57, -1, -1,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+ -1, -1, -1, 73, 74, 75, 76, 77, -1, 79,
+ -1, -1, -1, 83, 84, 85, 86, 87, -1, 89,
+ -1, 91, -1, 93, -1, -1, 96, -1, -1, -1,
+ 100, 101, 102, 103, -1, 105, 106, -1, 108, -1,
+ 110, 111, 112, 113, -1, -1, -1, -1, 118, 119,
+ 120, 121, 122, 123, -1, -1, -1, -1, 128, 129,
+ 130, 131, 132, 133, 134, -1, -1, 137, 138, -1,
+ 140, -1, -1, -1, 144, 3, 4, 5, 6, 7,
+ 150, 151, 152, 153, 12, -1, 156, 157, 158, -1,
+ -1, 161, -1, 163, 164, 165, 166, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
+ -1, -1, 50, -1, 52, 53, 54, 55, 56, 57,
+ -1, -1, 60, 61, 62, 63, 64, 65, 66, 67,
+ 68, 69, -1, -1, -1, 73, 74, 75, 76, 77,
+ -1, 79, -1, -1, -1, 83, 84, 85, 86, 87,
+ -1, 89, -1, 91, -1, 93, -1, -1, 96, -1,
+ -1, -1, 100, 101, 102, 103, -1, 105, 106, -1,
+ 108, -1, 110, 111, 112, 113, -1, -1, -1, -1,
+ 118, 119, 120, 121, 122, 123, -1, -1, -1, -1,
+ 128, 129, 130, 131, 132, 133, 134, -1, -1, 137,
+ 138, -1, 140, -1, -1, -1, 144, 3, 4, 5,
+ 6, 7, 150, 151, 152, 153, 12, -1, 156, 157,
+ 158, -1, -1, 161, -1, 163, 164, 165, 166, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
+ -1, -1, -1, -1, 50, -1, 52, 53, 54, 55,
+ 56, 57, -1, -1, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, 69, -1, -1, -1, 73, 74, 75,
+ 76, 77, -1, 79, -1, -1, -1, 83, 84, 85,
+ 86, 87, -1, 89, -1, 91, -1, 93, -1, -1,
+ 96, -1, -1, -1, 100, 101, 102, 103, -1, 105,
+ 106, -1, 108, -1, 110, 111, 112, 113, -1, -1,
+ -1, -1, 118, 119, 120, 121, 122, 123, -1, -1,
+ -1, -1, 128, 129, 130, 131, 132, 133, 134, -1,
+ -1, 137, 138, -1, 140, -1, -1, -1, 144, 3,
+ 4, 5, 6, 7, 150, 151, 152, 153, 12, -1,
+ 156, 157, 158, -1, -1, 161, -1, 163, 164, 165,
+ 166, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 44, 45, -1, -1, -1, -1, 50, -1, 52, 53,
+ 54, 55, 56, 57, -1, -1, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, -1, -1, -1, 73,
+ 74, 75, 76, 77, -1, 79, -1, -1, -1, 83,
+ 84, 85, 86, 87, -1, 89, -1, 91, -1, 93,
+ -1, -1, 96, -1, -1, -1, 100, 101, 102, 103,
+ -1, 105, 106, -1, 108, -1, 110, 111, 112, 113,
+ -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
+ -1, -1, -1, -1, 128, 129, 130, 131, 132, 133,
+ 134, -1, -1, 137, 138, -1, 140, -1, -1, -1,
+ 144, 3, 4, 5, 6, 7, 150, 151, 152, 153,
+ 12, -1, 156, 157, 158, -1, -1, 161, -1, 163,
+ 164, -1, 166, -1, 26, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, -1, -1, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, -1, -1,
+ -1, 73, 74, 75, 76, 77, -1, 79, -1, -1,
+ -1, 83, 84, 85, 86, 87, -1, 89, -1, 91,
+ -1, 93, -1, -1, 96, -1, -1, -1, 100, 101,
+ 102, 103, -1, 105, 106, -1, 108, -1, 110, 111,
+ -1, -1, -1, -1, -1, -1, 118, 119, 120, -1,
+ -1, -1, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, -1, 137, 138, -1, 140, -1,
+ -1, -1, 144, 3, 4, 5, 6, 7, 150, 151,
+ 152, 153, 12, -1, -1, 157, 158, -1, -1, 161,
+ -1, 163, 164, -1, 166, -1, 26, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
+ 50, -1, 52, 53, 54, 55, 56, 57, -1, -1,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+ -1, -1, -1, 73, 74, 75, 76, 77, -1, 79,
+ -1, -1, -1, 83, 84, 85, 86, 87, -1, 89,
+ -1, 91, -1, 93, -1, -1, 96, -1, -1, -1,
+ 100, 101, 102, 103, -1, 105, 106, -1, 108, -1,
+ 110, 111, -1, -1, -1, -1, -1, -1, 118, 119,
+ 120, -1, -1, -1, -1, -1, -1, -1, 128, 129,
+ 130, 131, 132, 133, 134, -1, -1, 137, 138, -1,
+ 140, -1, -1, -1, 144, 3, 4, 5, 6, 7,
+ 150, 151, 152, 153, 12, -1, -1, 157, 158, -1,
+ -1, 161, -1, 163, 164, -1, 166, -1, 26, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
+ -1, -1, 50, -1, 52, 53, 54, 55, 56, 57,
+ -1, -1, 60, 61, 62, 63, 64, 65, 66, 67,
+ 68, 69, -1, -1, -1, 73, 74, 75, 76, 77,
+ -1, 79, -1, -1, -1, 83, 84, 85, 86, 87,
+ -1, 89, -1, 91, -1, 93, -1, -1, 96, -1,
+ -1, -1, 100, 101, 102, 103, -1, 105, 106, -1,
+ 108, -1, 110, 111, -1, -1, -1, -1, -1, -1,
+ 118, 119, 120, -1, -1, -1, -1, -1, -1, -1,
+ 128, 129, 130, 131, 132, 133, 134, -1, -1, 137,
+ 138, -1, 140, -1, -1, -1, 144, 3, 4, 5,
+ 6, 7, 150, 151, 152, 153, 12, -1, -1, 157,
+ 158, -1, -1, 161, -1, 163, 164, -1, 166, -1,
+ 26, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
+ -1, -1, -1, -1, 50, -1, 52, 53, 54, 55,
+ 56, 57, -1, -1, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, 69, -1, -1, -1, 73, 74, 75,
+ 76, 77, -1, 79, -1, -1, -1, 83, 84, 85,
+ 86, 87, -1, 89, -1, 91, -1, 93, -1, -1,
+ 96, -1, -1, -1, 100, 101, 102, 103, -1, 105,
+ 106, -1, 108, -1, 110, 111, -1, -1, -1, -1,
+ -1, -1, 118, 119, 120, -1, -1, -1, -1, -1,
+ -1, -1, 128, 129, 130, 131, 132, 133, 134, -1,
+ -1, 137, 138, -1, 140, -1, -1, -1, 144, 3,
+ 4, 5, 6, 7, 150, 151, 152, 153, 12, -1,
+ -1, 157, 158, -1, -1, 161, -1, 163, 164, -1,
+ 166, -1, 26, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 44, 45, -1, -1, -1, -1, 50, -1, 52, 53,
+ 54, 55, 56, 57, -1, -1, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, -1, -1, -1, 73,
+ 74, 75, 76, 77, -1, 79, -1, -1, -1, 83,
+ 84, 85, 86, 87, -1, 89, -1, 91, -1, 93,
+ -1, -1, 96, -1, -1, -1, 100, 101, 102, 103,
+ -1, 105, 106, -1, 108, -1, 110, 111, -1, -1,
+ -1, -1, -1, -1, 118, 119, 120, -1, -1, -1,
+ -1, -1, -1, -1, 128, 129, 130, 131, 132, 133,
+ 134, -1, -1, 137, 138, -1, 140, -1, -1, -1,
+ 144, 3, 4, 5, 6, 7, 150, 151, 152, 153,
+ 12, -1, -1, 157, 158, -1, -1, 161, -1, 163,
+ 164, -1, 166, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, -1, -1, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, 69, -1, -1,
+ -1, 73, 74, 75, 76, 77, -1, 79, -1, -1,
+ -1, 83, 84, 85, 86, 87, -1, 89, -1, 91,
+ -1, 93, -1, -1, 96, -1, -1, -1, 100, 101,
+ 102, 103, -1, 105, 106, -1, 108, -1, 110, 111,
+ -1, -1, -1, -1, -1, -1, 118, 119, 120, -1,
+ -1, -1, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, -1, 137, 138, -1, 140, -1,
+ -1, -1, 144, 3, 4, 5, 6, 7, 150, 151,
+ 152, 153, 12, -1, -1, 157, 158, -1, -1, 161,
+ -1, 163, 164, -1, 166, -1, -1, -1, -1, -1,
+ -1, -1, 32, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
+ 50, -1, 52, 53, 54, 55, 56, 57, -1, -1,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, -1,
+ -1, -1, -1, 73, 74, 75, 76, 77, -1, -1,
+ -1, -1, -1, 83, 84, 32, 33, 34, 35, 36,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 49, 103, 51, -1, -1, -1, -1, -1,
+ -1, 111, -1, -1, -1, -1, -1, -1, -1, 119,
+ 120, -1, -1, -1, -1, -1, -1, -1, 128, 129,
+ 130, 131, 132, 133, 134, -1, 3, 4, 5, 6,
+ 7, -1, -1, -1, 144, 12, -1, -1, -1, -1,
+ 150, 151, 152, 153, -1, -1, -1, 157, 158, -1,
+ -1, 161, -1, -1, -1, -1, 166, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 44, 45, -1,
+ -1, -1, -1, 50, -1, 52, 53, 54, 55, 56,
+ 57, -1, -1, 60, 61, 62, 63, 64, 65, 66,
+ 67, 68, -1, -1, -1, -1, 73, 74, 75, 76,
+ 77, -1, -1, -1, -1, -1, 83, 84, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 103, -1, -1, -1,
+ -1, -1, -1, -1, 111, -1, -1, -1, -1, -1,
+ -1, -1, 119, 120, -1, -1, -1, -1, -1, -1,
+ -1, 128, 129, 130, 131, 132, 133, 134, -1, 3,
+ 4, 5, 6, 7, -1, -1, -1, 144, 12, -1,
+ -1, -1, -1, 150, 151, 152, 153, -1, -1, -1,
+ 157, 158, -1, -1, 161, -1, 163, -1, -1, 166,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 44, 45, -1, -1, -1, -1, 50, -1, 52, 53,
+ 54, 55, 56, 57, -1, -1, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, -1, -1, -1, -1, 73,
+ 74, 75, 76, 77, -1, -1, -1, -1, -1, 83,
+ 84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 103,
+ -1, -1, -1, -1, -1, -1, -1, 111, -1, -1,
+ -1, -1, -1, -1, -1, 119, 120, -1, -1, -1,
+ -1, -1, -1, -1, 128, 129, 130, 131, 132, 133,
+ 134, -1, 3, 4, 5, 6, 7, -1, -1, -1,
+ 144, 12, -1, -1, -1, -1, 150, 151, 152, 153,
+ -1, -1, -1, 157, 158, -1, -1, 161, -1, 163,
+ -1, -1, 166, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 44, 45, -1, -1, -1, -1, 50,
+ -1, 52, 53, 54, 55, 56, 57, -1, -1, 60,
+ 61, 62, 63, 64, 65, 66, 67, 68, -1, -1,
+ -1, -1, 73, 74, 75, 76, 77, -1, -1, -1,
+ -1, -1, 83, 84, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 103, -1, -1, -1, -1, -1, -1, -1,
+ 111, -1, -1, -1, -1, -1, -1, -1, 119, 120,
+ -1, -1, -1, -1, -1, -1, -1, 128, 129, 130,
+ 131, 132, 133, 134, -1, 3, 4, 5, 6, 7,
+ -1, -1, -1, 144, 12, -1, -1, -1, -1, 150,
+ 151, 152, 153, -1, -1, -1, 157, 158, -1, -1,
+ 161, -1, 163, -1, -1, 166, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
+ -1, -1, 50, -1, 52, 53, 54, 55, 56, 57,
+ -1, -1, 60, 61, 62, 63, 64, 65, 66, 67,
+ 68, -1, -1, -1, -1, 73, 74, 75, 76, 77,
+ -1, -1, -1, -1, -1, 83, 84, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 103, -1, -1, -1, -1,
+ -1, -1, -1, 111, -1, -1, -1, -1, -1, -1,
+ -1, 119, 120, -1, -1, -1, -1, -1, -1, -1,
+ 128, 129, 130, 131, 132, 133, 134, -1, 3, 4,
+ 5, 6, 7, -1, -1, -1, 144, 12, -1, -1,
+ -1, -1, 150, 151, 152, 153, -1, -1, -1, 157,
+ 158, 26, -1, 161, 162, -1, -1, -1, 166, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
+ 45, -1, -1, -1, -1, 50, -1, 52, 53, 54,
+ 55, 56, 57, -1, -1, 60, 61, 62, 63, 64,
+ 65, 66, 67, 68, -1, -1, -1, -1, 73, 74,
+ 75, 76, 77, -1, -1, -1, -1, -1, 83, 84,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 103, -1,
+ -1, -1, -1, -1, -1, -1, 111, -1, -1, -1,
+ -1, -1, -1, -1, 119, 120, -1, -1, -1, -1,
+ -1, -1, -1, 128, 129, 130, 131, 132, 133, 134,
+ -1, 3, 4, 5, 6, 7, -1, -1, -1, 144,
+ 12, -1, -1, -1, -1, 150, 151, 152, 153, -1,
+ -1, -1, 157, 158, -1, -1, 161, -1, -1, -1,
+ 32, 166, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 44, 45, -1, -1, -1, -1, 50, -1,
+ 52, 53, 54, 55, 56, 57, -1, -1, 60, 61,
+ 62, 63, 64, 65, 66, 67, 68, -1, -1, -1,
+ -1, 73, 74, 75, 76, 77, -1, -1, -1, -1,
+ -1, 83, 84, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 103, -1, -1, -1, -1, -1, -1, -1, 111,
+ -1, -1, -1, -1, -1, -1, -1, 119, 120, -1,
+ -1, -1, -1, -1, -1, -1, 128, 129, 130, 131,
+ 132, 133, 134, -1, 3, 4, 5, 6, 7, -1,
+ -1, -1, 144, 12, -1, -1, -1, -1, 150, 151,
+ 152, 153, -1, -1, -1, 157, 158, -1, -1, 161,
+ -1, -1, -1, 32, 166, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 44, 45, -1, -1, -1,
+ -1, 50, -1, 52, 53, 54, 55, 56, 57, -1,
+ -1, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+ -1, -1, -1, -1, 73, 74, 75, 76, 77, -1,
+ -1, -1, -1, -1, 83, 84, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 103, -1, -1, -1, -1, -1,
+ -1, -1, 111, -1, -1, -1, -1, -1, -1, -1,
+ 119, 120, -1, -1, -1, -1, -1, -1, -1, 128,
+ 129, 130, 131, 132, 133, 134, -1, 3, 4, 5,
+ 6, 7, -1, -1, -1, 144, 12, -1, -1, -1,
+ -1, 150, 151, 152, 153, -1, -1, -1, 157, 158,
+ -1, -1, 161, -1, -1, -1, 32, 166, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
+ -1, -1, -1, -1, 50, -1, 52, 53, 54, 55,
+ 56, 57, -1, -1, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, -1, -1, -1, -1, 73, 74, 75,
+ 76, 77, -1, -1, -1, -1, -1, 83, 84, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 103, -1, -1,
+ -1, -1, -1, -1, -1, 111, -1, -1, -1, -1,
+ -1, -1, -1, 119, 120, -1, -1, -1, -1, -1,
+ -1, -1, 128, 129, 130, 131, 132, 133, 134, -1,
+ 3, 4, 5, 6, 7, -1, -1, -1, 144, 12,
+ -1, -1, -1, -1, 150, 151, 152, 153, -1, -1,
+ -1, 157, 158, -1, -1, 161, -1, -1, -1, 32,
+ 166, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 44, 45, -1, -1, -1, -1, 50, -1, 52,
+ 53, 54, 55, 56, 57, -1, -1, 60, 61, 62,
+ 63, 64, 65, 66, 67, 68, -1, -1, -1, -1,
+ 73, 74, 75, 76, 77, -1, -1, -1, -1, -1,
+ 83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 103, -1, -1, -1, -1, -1, -1, -1, 111, -1,
+ -1, -1, -1, -1, -1, -1, 119, 120, -1, -1,
+ -1, -1, -1, -1, -1, 128, 129, 130, 131, 132,
+ 133, 134, -1, 3, 4, 5, 6, 7, -1, -1,
+ -1, 144, 12, -1, -1, -1, -1, 150, 151, 152,
+ 153, -1, -1, -1, 157, 158, -1, -1, 161, -1,
+ -1, -1, -1, 166, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
+ 50, -1, 52, 53, 54, 55, 56, 57, -1, -1,
+ 60, 61, 62, 63, 64, 65, 66, 67, 68, -1,
+ -1, -1, -1, 73, 74, 75, 76, 77, -1, -1,
+ -1, -1, -1, 83, 84, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 103, -1, -1, -1, -1, -1, -1,
+ -1, 111, -1, -1, -1, -1, -1, -1, -1, 119,
+ 120, -1, -1, -1, -1, -1, -1, -1, 128, 129,
+ 130, 131, 132, 133, 134, -1, 3, 4, 5, 6,
+ 7, -1, -1, -1, 144, 12, -1, -1, -1, -1,
+ 150, 151, 152, 153, -1, -1, -1, 157, 158, -1,
+ -1, 161, -1, -1, -1, -1, 166, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 44, 45, -1,
+ -1, -1, -1, 50, -1, 52, 53, 54, 55, 56,
+ 57, -1, -1, 60, 61, 62, 63, 64, 65, 66,
+ 67, 68, -1, -1, -1, -1, 73, 74, 75, 76,
+ 77, -1, -1, -1, -1, -1, 83, 84, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 103, -1, -1, -1,
+ -1, -1, -1, -1, 111, -1, -1, -1, -1, -1,
+ -1, -1, 119, 120, -1, -1, -1, -1, -1, -1,
+ -1, 128, 129, 130, 131, 132, 133, 134, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 144, -1, -1,
+ -1, -1, -1, 150, 151, 152, 153, 9, 10, 11,
+ 157, 158, -1, -1, 161, -1, -1, -1, -1, 166,
+ -1, -1, -1, 25, -1, 27, 28, 29, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 45, 46, 47, 48, 49, -1, 51,
+ 9, 10, 11, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 25, -1, 27, 28,
+ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, -1, 51, 9, 10, 11, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 25,
+ -1, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, -1, 51, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 25, 165, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+ 43, 44, 45, 46, 47, 48, 49, -1, 51, 9,
+ 10, 11, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 25, 165, 27, 28, 29,
+ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+ -1, 51, -1, -1, 9, 10, 11, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 165,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+ 45, 46, 47, 48, 49, -1, 51, -1, -1, -1,
+ -1, -1, -1, -1, -1, 9, 10, 11, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 25, 165, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, -1, 51, 9, 10,
+ 11, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 25, 165, 27, 28, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, -1,
+ 51, 9, 10, 11, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 25, 163, 27,
+ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, -1, 51, -1, -1, -1, -1, -1, -1,
+ -1, -1, 9, 10, 11, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 25, 163,
+ 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 49, -1, 51, 9, 10, 11, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 25, 163, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, -1, 51, 9, 10,
+ 11, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 25, 163, 27, 28, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, -1,
+ 51, -1, -1, -1, -1, -1, -1, -1, -1, 9,
+ 10, 11, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 25, 163, 27, 28, 29,
+ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+ -1, 51, -1, 9, 10, 11, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 162, 25,
+ -1, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, -1, 51, 9, 10, 11, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 162, 25, -1, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+ 43, 44, 45, 46, 47, 48, 49, -1, 51, -1,
+ -1, -1, -1, -1, -1, 9, 10, 11, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 25, 162, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, -1, 51, -1, 9,
+ 10, 11, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 25, 162, 27, 28, 29,
+ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+ -1, 51, 9, 10, 11, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 25, 162,
+ 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 49, -1, 51, -1, -1, -1, -1, -1,
+ -1, 9, 10, 11, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 25, 162, 27,
+ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, -1, 51, -1, 9, 10, 11, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 25, 162, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, -1, 51, 9, 10,
+ 11, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 25, 162, 27, 28, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, -1,
+ 51, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 9, 10, 11, -1,
+ -1, -1, -1, -1, 162, -1, -1, -1, -1, -1,
+ -1, -1, 25, 127, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+ 43, 44, 45, 46, 47, 48, 49, -1, 51, 44,
+ 45, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 127, -1, -1, -1,
+ 65, -1, -1, 9, 10, 11, -1, -1, 73, 74,
+ 75, -1, -1, -1, -1, -1, -1, -1, 83, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, -1, 51, 111, -1, -1, -1,
+ -1, -1, -1, -1, 127, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
+ -1, -1, -1, -1, -1, 9, 10, 11, -1, 144,
+ -1, -1, -1, -1, -1, 150, 151, 152, 153, -1,
+ -1, 25, 157, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, -1, 51, 10, 11,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 25, -1, 27, 28, 29, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 45, 46, 47, 48, 49, 25, 51,
+ 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 49, -1, 51, 27, 28, 29, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 45, 46, 47, 48, 49, -1, 51,
+ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+ -1, 51, 31, 32, 33, 34, 35, 36, 37, 38,
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, -1, 51
+};
+
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_uint16 yystos[] =
+{
+ 0, 169, 170, 0, 3, 4, 5, 6, 7, 12,
+ 44, 45, 50, 52, 53, 54, 55, 56, 57, 60,
+ 61, 62, 63, 64, 65, 66, 67, 68, 69, 73,
+ 74, 75, 76, 77, 79, 83, 84, 85, 86, 87,
+ 89, 91, 93, 96, 100, 101, 102, 103, 104, 105,
+ 106, 108, 109, 110, 111, 112, 113, 118, 119, 120,
+ 121, 122, 123, 128, 129, 130, 131, 132, 133, 134,
+ 137, 138, 140, 144, 150, 151, 152, 153, 156, 157,
+ 158, 161, 163, 164, 166, 171, 172, 175, 178, 179,
+ 186, 187, 189, 190, 191, 193, 248, 249, 250, 253,
+ 254, 262, 265, 269, 270, 272, 273, 279, 280, 281,
+ 282, 283, 284, 285, 286, 291, 296, 298, 299, 300,
+ 301, 302, 75, 111, 150, 158, 250, 269, 269, 161,
+ 269, 269, 269, 269, 269, 269, 269, 75, 111, 150,
+ 153, 161, 171, 254, 272, 273, 281, 272, 269, 269,
+ 269, 269, 269, 269, 269, 269, 32, 269, 294, 295,
+ 150, 153, 171, 254, 256, 257, 281, 284, 285, 291,
+ 269, 161, 260, 161, 26, 65, 65, 245, 269, 178,
+ 161, 161, 161, 161, 161, 163, 269, 163, 269, 75,
+ 75, 163, 248, 269, 273, 164, 269, 153, 171, 173,
+ 174, 77, 166, 220, 221, 77, 222, 250, 122, 122,
+ 161, 161, 161, 161, 161, 161, 153, 164, 171, 171,
+ 248, 269, 273, 249, 269, 301, 176, 164, 153, 161,
+ 8, 163, 75, 75, 163, 32, 188, 65, 147, 9,
+ 10, 11, 25, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, 51, 163, 53, 54,
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+ 23, 24, 161, 147, 65, 126, 65, 164, 166, 285,
+ 65, 65, 65, 188, 269, 153, 171, 301, 147, 147,
+ 271, 273, 127, 167, 8, 267, 153, 171, 147, 161,
+ 261, 147, 126, 285, 162, 269, 269, 269, 287, 287,
+ 8, 163, 87, 269, 246, 247, 269, 248, 273, 75,
+ 202, 269, 163, 163, 163, 13, 163, 163, 176, 163,
+ 171, 95, 8, 163, 164, 270, 273, 8, 163, 13,
+ 8, 163, 188, 184, 185, 273, 273, 297, 273, 162,
+ 128, 273, 292, 293, 294, 171, 170, 163, 164, 161,
+ 127, 162, 162, 162, 121, 165, 177, 178, 186, 187,
+ 269, 75, 32, 160, 217, 218, 219, 269, 75, 124,
+ 192, 124, 194, 75, 161, 287, 75, 279, 285, 291,
+ 269, 269, 269, 26, 269, 269, 269, 269, 269, 269,
+ 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
+ 269, 269, 269, 269, 269, 269, 269, 269, 256, 32,
+ 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
+ 269, 269, 217, 75, 279, 287, 75, 164, 279, 288,
+ 289, 290, 287, 269, 287, 287, 287, 162, 171, 75,
+ 75, 32, 269, 32, 269, 171, 279, 217, 279, 288,
+ 162, 162, 167, 167, 269, 161, 162, 163, 8, 95,
+ 95, 13, 8, 162, 162, 44, 45, 65, 83, 129,
+ 150, 153, 171, 254, 262, 263, 264, 165, 95, 75,
+ 174, 269, 221, 263, 77, 161, 8, 162, 8, 162,
+ 162, 163, 161, 8, 162, 162, 161, 165, 170, 217,
+ 248, 273, 161, 165, 271, 269, 162, 8, 13, 150,
+ 153, 171, 255, 125, 195, 196, 255, 164, 161, 25,
+ 129, 155, 211, 212, 214, 215, 255, 167, 161, 161,
+ 285, 269, 26, 66, 273, 162, 161, 161, 167, 269,
+ 161, 276, 277, 278, 65, 164, 167, 165, 167, 167,
+ 167, 271, 271, 127, 162, 258, 26, 178, 269, 26,
+ 178, 206, 246, 269, 273, 32, 198, 273, 263, 75,
+ 26, 178, 201, 26, 164, 203, 263, 263, 263, 266,
+ 268, 161, 153, 171, 147, 107, 159, 180, 181, 183,
+ 75, 165, 13, 211, 185, 163, 273, 292, 293, 13,
+ 217, 165, 162, 162, 219, 263, 153, 171, 196, 164,
+ 8, 223, 211, 215, 162, 8, 32, 77, 160, 213,
+ 217, 217, 269, 256, 217, 217, 165, 217, 65, 65,
+ 274, 287, 269, 32, 269, 126, 259, 176, 207, 162,
+ 176, 163, 127, 197, 273, 197, 13, 176, 163, 204,
+ 163, 204, 127, 167, 8, 267, 266, 171, 75, 161,
+ 164, 181, 182, 183, 263, 162, 162, 269, 162, 163,
+ 171, 223, 255, 104, 109, 111, 112, 113, 114, 115,
+ 116, 117, 165, 224, 226, 239, 240, 241, 242, 244,
+ 162, 109, 251, 214, 213, 77, 13, 162, 162, 261,
+ 162, 162, 162, 287, 287, 126, 275, 167, 165, 271,
+ 288, 208, 70, 71, 209, 163, 88, 246, 198, 162,
+ 162, 263, 94, 204, 97, 98, 99, 204, 165, 263,
+ 263, 162, 255, 176, 251, 165, 75, 227, 255, 77,
+ 243, 250, 242, 8, 163, 26, 216, 161, 216, 32,
+ 213, 13, 263, 167, 167, 288, 70, 71, 210, 161,
+ 178, 163, 162, 26, 178, 200, 200, 163, 97, 163,
+ 269, 26, 163, 205, 165, 127, 77, 165, 216, 13,
+ 8, 163, 164, 228, 13, 8, 163, 225, 75, 214,
+ 164, 32, 77, 252, 164, 213, 13, 263, 278, 161,
+ 26, 72, 269, 26, 178, 199, 176, 163, 205, 176,
+ 263, 162, 164, 263, 255, 75, 229, 230, 231, 232,
+ 234, 235, 236, 255, 263, 77, 188, 13, 176, 77,
+ 8, 162, 176, 13, 263, 269, 176, 163, 162, 176,
+ 92, 176, 164, 176, 165, 231, 163, 95, 154, 163,
+ 147, 13, 75, 263, 165, 32, 77, 165, 263, 162,
+ 178, 90, 163, 176, 165, 237, 242, 233, 255, 75,
+ 263, 161, 77, 26, 163, 165, 75, 8, 211, 176,
+ 255, 162, 216, 163, 164, 238, 176, 165
+};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_uint16 yyr1[] =
+{
+ 0, 168, 169, 170, 170, 171, 171, 172, 172, 172,
+ 172, 172, 172, 172, 172, 172, 173, 173, 174, 174,
+ 174, 174, 175, 175, 176, 176, 177, 177, 177, 177,
+ 178, 178, 178, 178, 178, 179, 179, 179, 179, 179,
+ 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
+ 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
+ 179, 179, 179, 179, 180, 180, 181, 182, 182, 183,
+ 184, 184, 185, 186, 187, 188, 188, 189, 190, 190,
+ 191, 191, 191, 191, 192, 192, 193, 194, 194, 195,
+ 195, 196, 196, 197, 197, 198, 198, 199, 199, 200,
+ 200, 201, 201, 202, 202, 203, 203, 203, 203, 204,
+ 204, 204, 205, 205, 206, 206, 207, 207, 208, 208,
+ 209, 209, 210, 210, 211, 211, 212, 212, 212, 212,
+ 212, 212, 212, 212, 213, 213, 214, 214, 214, 215,
+ 215, 215, 216, 216, 217, 217, 218, 218, 219, 219,
+ 219, 220, 220, 221, 221, 221, 222, 222, 222, 222,
+ 223, 223, 224, 224, 224, 225, 224, 226, 227, 227,
+ 228, 228, 229, 229, 230, 230, 231, 231, 232, 233,
+ 233, 234, 234, 235, 236, 236, 237, 237, 238, 238,
+ 239, 239, 240, 240, 241, 241, 242, 242, 242, 242,
+ 242, 242, 243, 243, 243, 243, 244, 244, 245, 245,
+ 246, 246, 247, 247, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+ 248, 248, 248, 248, 248, 248, 248, 249, 249, 249,
+ 249, 250, 251, 251, 252, 252, 252, 252, 253, 253,
+ 253, 253, 253, 253, 253, 253, 254, 254, 254, 254,
+ 255, 255, 255, 256, 256, 257, 257, 258, 258, 259,
+ 260, 260, 260, 261, 261, 262, 262, 262, 262, 262,
+ 262, 262, 262, 262, 262, 262, 262, 263, 263, 263,
+ 263, 263, 263, 263, 263, 263, 264, 265, 265, 265,
+ 265, 265, 265, 266, 266, 267, 267, 268, 268, 268,
+ 268, 269, 269, 270, 271, 272, 273, 273, 274, 274,
+ 275, 276, 276, 277, 278, 278, 278, 279, 279, 280,
+ 280, 281, 282, 282, 283, 283, 283, 284, 284, 284,
+ 284, 285, 285, 285, 286, 286, 287, 287, 288, 288,
+ 289, 289, 289, 290, 290, 291, 291, 292, 292, 293,
+ 293, 293, 294, 294, 295, 295, 295, 295, 295, 295,
+ 295, 295, 296, 296, 296, 296, 296, 296, 296, 297,
+ 297, 298, 298, 299, 299, 299, 299, 299, 300, 300,
+ 301, 302, 302
+};
+
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_uint8 yyr2[] =
+{
+ 0, 2, 1, 2, 0, 1, 3, 1, 1, 1,
+ 4, 3, 5, 4, 3, 2, 3, 1, 1, 3,
+ 2, 4, 5, 4, 2, 0, 1, 1, 1, 4,
+ 1, 2, 1, 1, 1, 3, 7, 10, 5, 7,
+ 9, 5, 2, 3, 2, 3, 2, 3, 3, 3,
+ 3, 3, 1, 2, 2, 5, 8, 8, 5, 1,
+ 6, 5, 3, 3, 2, 1, 8, 0, 1, 4,
+ 1, 3, 1, 1, 1, 0, 1, 10, 7, 6,
+ 1, 2, 2, 1, 0, 2, 1, 0, 2, 0,
+ 2, 1, 3, 0, 2, 1, 2, 1, 4, 1,
+ 4, 1, 4, 3, 5, 3, 4, 4, 5, 0,
+ 5, 4, 1, 1, 1, 4, 0, 6, 0, 7,
+ 0, 2, 0, 3, 1, 0, 2, 3, 5, 4,
+ 4, 5, 7, 6, 2, 1, 0, 1, 2, 1,
+ 1, 1, 0, 2, 1, 0, 1, 3, 1, 2,
+ 2, 3, 1, 1, 2, 4, 3, 5, 1, 3,
+ 2, 0, 3, 2, 1, 0, 10, 3, 1, 3,
+ 1, 3, 0, 1, 1, 2, 2, 2, 3, 1,
+ 3, 1, 1, 3, 4, 3, 0, 1, 1, 3,
+ 1, 1, 0, 1, 1, 2, 1, 1, 1, 1,
+ 1, 1, 3, 5, 1, 3, 5, 4, 3, 1,
+ 0, 1, 3, 1, 6, 3, 4, 6, 2, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 1, 1, 5, 4, 3, 1,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1,
+ 1, 1, 1, 2, 1, 10, 11, 2, 2, 4,
+ 4, 1, 0, 4, 3, 4, 1, 2, 4, 6,
+ 5, 6, 6, 6, 6, 4, 1, 1, 3, 2,
+ 1, 3, 2, 1, 1, 4, 1, 2, 0, 2,
+ 0, 2, 3, 0, 3, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+ 2, 2, 2, 4, 3, 1, 3, 1, 1, 1,
+ 3, 2, 1, 0, 2, 0, 1, 5, 3, 3,
+ 1, 1, 1, 1, 1, 1, 5, 1, 2, 0,
+ 3, 4, 4, 3, 1, 1, 0, 1, 2, 3,
+ 3, 1, 4, 4, 1, 1, 1, 1, 3, 2,
+ 1, 4, 4, 1, 1, 4, 0, 1, 1, 1,
+ 4, 4, 1, 1, 3, 1, 2, 3, 1, 1,
+ 4, 0, 0, 2, 5, 3, 3, 1, 6, 4,
+ 4, 2, 4, 4, 2, 2, 4, 2, 2, 1,
+ 3, 3, 3, 4, 4, 4, 4, 4, 4, 3,
+ 3, 3, 3
+};
+
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY (-2)
+#define YYEOF 0
+
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
+
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (yyscanner, root, YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+while (0)
+
+/* Error token number */
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value, yyscanner, root); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT. |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void* yyscanner, xhpast::Node** root)
+{
+ FILE *yyo = yyoutput;
+ YYUSE (yyo);
+ YYUSE (yyscanner);
+ YYUSE (root);
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+ YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void* yyscanner, xhpast::Node** root)
+{
+ YYFPRINTF (yyoutput, "%s %s (",
+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner, root);
+ YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, void* yyscanner, xhpast::Node** root)
+{
+ unsigned long int yylno = yyrline[yyrule];
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr,
+ yystos[yyssp[yyi + 1 - yynrhs]],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ , yyscanner, root);
+ YYFPRINTF (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, root); \
+} while (0)
+
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+# if defined __GLIBC__ && defined _STRING_H
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
+ continue;
+ return yylen;
+}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+ char *yyd = yydest;
+ const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+ quotes and backslashes, so that it's suitable for yyerror. The
+ heuristic is that double-quoting is unnecessary unless the string
+ contains an apostrophe, a comma, or backslash (other than
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
+ null, do not copy; instead, return the length of what the result
+ would have been. */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYSIZE_T yyn = 0;
+ char const *yyp = yystr;
+
+ for (;;)
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ /* Fall through. */
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
+
+ if (! yyres)
+ return yystrlen (yystr);
+
+ return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+ about the unexpected token YYTOKEN for the state stack whose top is
+ YYSSP.
+
+ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
+ not large enough to hold the message. In that case, also set
+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
+ required number of bytes is too large to store. */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+ yytype_int16 *yyssp, int yytoken)
+{
+ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+ YYSIZE_T yysize = yysize0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = YY_NULLPTR;
+ /* Arguments of yyformat. */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[*yyssp];
+ yyarg[yycount++] = yytname[yytoken];
+ if (!yypact_value_is_default (yyn))
+ {
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yyx;
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ {
+ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+ if (! (yysize <= yysize1
+ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
+ }
+ }
+ }
+
+ switch (yycount)
+ {
+# define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ YYCASE_(0, YY_("syntax error"));
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+ }
+
+ {
+ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
+
+ if (*yymsg_alloc < yysize)
+ {
+ *yymsg_alloc = 2 * yysize;
+ if (! (yysize <= *yymsg_alloc
+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+ return 1;
+ }
+
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ {
+ char *yyp = *yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat) != '\0')
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
+ }
+ else
+ {
+ yyp++;
+ yyformat++;
+ }
+ }
+ return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void* yyscanner, xhpast::Node** root)
+{
+ YYUSE (yyvaluep);
+ YYUSE (yyscanner);
+ YYUSE (root);
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YYUSE (yytype);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/*----------.
+| yyparse. |
+`----------*/
+
+int
+yyparse (void* yyscanner, xhpast::Node** root)
+{
+/* The lookahead symbol. */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol. */
+/* Default value used for initialization, for pacifying older GCCs
+ or non-GCC compilers. */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+ /* Number of syntax errors so far. */
+ int yynerrs;
+
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+
+ /* The stacks and their tools:
+ 'yyss': related to states.
+ 'yyvs': related to semantic values.
+
+ Refer to the stacks through separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
+
+ YYSIZE_T yystacksize;
+
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken = 0;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ yyssp = yyss = yyssa;
+ yyvsp = yyvs = yyvsa;
+ yystacksize = YYINITDEPTH;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+ goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. So pushing a state here evens the stacks. */
+ yyssp++;
+
+ yysetstate:
+ *yyssp = yystate;
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ yytype_int16 *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+# else
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yytype_int16 *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ goto yybackup;
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+
+ /* Do appropriate processing given the current state. Read a
+ lookahead token if we need one and don't already have one. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yypact_value_is_default (yyn))
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
+ if (yychar == YYEMPTY)
+ {
+ YYDPRINTF ((stderr, "Reading a token: "));
+ yychar = yylex (&yylval, yyscanner);
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yytable_value_is_error (yyn))
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+
+ yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ '$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 2:
+#line 210 "parser.y" /* yacc.c:1646 */
+ {
+ *root = NNEW(n_PROGRAM)->appendChild((yyvsp[0]));
+ }
+#line 3439 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 3:
+#line 216 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-1])->appendChild((yyvsp[0]));
+ }
+#line 3447 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 4:
+#line 219 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT_LIST);
+ }
+#line 3455 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 5:
+#line 225 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_SYMBOL_NAME);
+ }
+#line 3463 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 6:
+#line 228 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[-2]), (yyvsp[0]));
+ }
+#line 3471 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 10:
+#line 237 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-3]) = NSPAN((yyvsp[-3]), n_HALT_COMPILER, (yyvsp[-1]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-3]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3481 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 11:
+#line 242 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-2]), n_NAMESPACE, (yyvsp[-1]));
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+ (yyvsp[-2])->appendChild(NNEW(n_EMPTY));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3493 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 12:
+#line 249 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-4]), n_NAMESPACE, (yyvsp[0]));
+ (yyvsp[-4])->appendChild((yyvsp[-3]));
+ (yyvsp[-4])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-4]));
+ }
+#line 3504 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 13:
+#line 255 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-3]), n_NAMESPACE, (yyvsp[0]));
+ (yyvsp[-3])->appendChild(NNEW(n_EMPTY));
+ NMORE((yyvsp[-1]), (yyvsp[0]));
+ NMORE((yyvsp[-1]), (yyvsp[-2]));
+ (yyvsp[-3])->appendChild((yyvsp[-1]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-3]));
+ }
+#line 3517 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 14:
+#line 263 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-1]), (yyvsp[-2]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3527 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 15:
+#line 268 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3536 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 16:
+#line 275 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 3544 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 17:
+#line 278 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_USE_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 3553 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 18:
+#line 285 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_USE);
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ }
+#line 3563 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 19:
+#line 290 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_USE);
+ (yyval)->appendChild((yyvsp[-2]));
+ NTYPE((yyvsp[0]), n_STRING);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 3574 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 20:
+#line 296 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_USE);
+ NMORE((yyvsp[0]), (yyvsp[-1]));
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ }
+#line 3585 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 21:
+#line 302 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_USE);
+ NMORE((yyvsp[-2]), (yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ NTYPE((yyvsp[0]), n_STRING);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 3597 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 22:
+#line 312 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyval), (yyvsp[0]));
+ (yyval)->appendChild(
+ NNEW(n_CONSTANT_DECLARATION)
+ ->appendChild(NTYPE((yyvsp[-2]), n_STRING))
+ ->appendChild((yyvsp[0])));
+ }
+#line 3609 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 23:
+#line 319 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyval), n_CONSTANT_DECLARATION_LIST, (yyvsp[0]));
+ (yyval)->appendChild(
+ NNEW(n_CONSTANT_DECLARATION)
+ ->appendChild(NTYPE((yyvsp[-2]), n_STRING))
+ ->appendChild((yyvsp[0])));
+ }
+#line 3621 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 24:
+#line 329 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-1])->appendChild((yyvsp[0]));
+ }
+#line 3629 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 25:
+#line 332 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT_LIST);
+ }
+#line 3637 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 29:
+#line 341 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-3]) = NSPAN((yyvsp[-3]), n_HALT_COMPILER, (yyvsp[-1]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-3]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3647 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 31:
+#line 350 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_STRING);
+ (yyval) = NNEW(n_LABEL);
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3658 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 32:
+#line 356 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_OPEN_TAG);
+ }
+#line 3666 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 33:
+#line 359 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_OPEN_TAG);
+ }
+#line 3674 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 34:
+#line 362 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_CLOSE_TAG);
+ }
+#line 3682 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 35:
+#line 368 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 3690 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 36:
+#line 371 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CONDITION_LIST);
+
+ (yyvsp[-6]) = NTYPE((yyvsp[-6]), n_IF);
+ (yyvsp[-6])->appendChild(NSPAN((yyvsp[-5]), n_CONTROL_CONDITION, (yyvsp[-3]))->appendChild((yyvsp[-4])));
+ (yyvsp[-6])->appendChild((yyvsp[-2]));
+
+ (yyval)->appendChild((yyvsp[-6]));
+ (yyval)->appendChildren((yyvsp[-1]));
+
+ // Hacks: merge a list of if (x) { } else if (y) { } into a single condition
+ // list instead of a condition tree.
+
+ if ((yyvsp[0])->type == n_EMPTY) {
+ // Ignore.
+ } else if ((yyvsp[0])->type == n_ELSE) {
+ xhpast::Node *stype = (yyvsp[0])->firstChild()->firstChild();
+ if (stype && stype->type == n_CONDITION_LIST) {
+ NTYPE(stype->firstChild(), n_ELSEIF);
+ stype->firstChild()->l_tok = (yyvsp[0])->l_tok;
+ (yyval)->appendChildren(stype);
+ } else {
+ (yyval)->appendChild((yyvsp[0]));
+ }
+ } else {
+ (yyval)->appendChild((yyvsp[0]));
+ }
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyval));
+ }
+#line 3725 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 37:
+#line 405 "parser.y" /* yacc.c:1646 */
+ {
+
+ (yyval) = NNEW(n_CONDITION_LIST);
+ NTYPE((yyvsp[-9]), n_IF);
+ (yyvsp[-9])->appendChild(NSPAN((yyvsp[-8]), n_CONTROL_CONDITION, (yyvsp[-6]))->appendChild((yyvsp[-7])));
+ (yyvsp[-9])->appendChild((yyvsp[-4]));
+
+ (yyval)->appendChild((yyvsp[-9]));
+ (yyval)->appendChildren((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyval));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3745 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 38:
+#line 420 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-4]), n_WHILE);
+ (yyvsp[-4])->appendChild(NSPAN((yyvsp[-3]), n_CONTROL_CONDITION, (yyvsp[-1]))->appendChild((yyvsp[-2])));
+ (yyvsp[-4])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-4]));
+ }
+#line 3757 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 39:
+#line 427 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-6]), n_DO_WHILE);
+ (yyvsp[-6])->appendChild((yyvsp[-5]));
+ (yyvsp[-6])->appendChild(NSPAN((yyvsp[-3]), n_CONTROL_CONDITION, (yyvsp[-1]))->appendChild((yyvsp[-2])));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-6]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3770 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 40:
+#line 435 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-8]), n_FOR);
+
+ NSPAN((yyvsp[-7]), n_FOR_EXPRESSION, (yyvsp[-1]))
+ ->appendChild((yyvsp[-6]))
+ ->appendChild((yyvsp[-4]))
+ ->appendChild((yyvsp[-2]));
+
+ (yyvsp[-8])->appendChild((yyvsp[-7]));
+ (yyvsp[-8])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-8]));
+ }
+#line 3788 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 41:
+#line 448 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-4]), n_SWITCH);
+ (yyvsp[-4])->appendChild(NSPAN((yyvsp[-3]), n_CONTROL_CONDITION, (yyvsp[-1]))->appendChild((yyvsp[-2])));
+ (yyvsp[-4])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-4]));
+ }
+#line 3800 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 42:
+#line 455 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_BREAK);
+ (yyvsp[-1])->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3812 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 43:
+#line 462 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_BREAK);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3824 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 44:
+#line 469 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_CONTINUE);
+ (yyvsp[-1])->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3836 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 45:
+#line 476 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_CONTINUE);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3848 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 46:
+#line 483 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_RETURN);
+ (yyvsp[-1])->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3860 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 47:
+#line 490 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_RETURN);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3872 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 48:
+#line 497 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_RETURN);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3884 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 49:
+#line 504 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-1]), (yyvsp[-2]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3894 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 50:
+#line 509 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-1]), (yyvsp[-2]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3904 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 51:
+#line 514 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-1]), (yyvsp[-2]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3914 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 52:
+#line 519 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_INLINE_HTML);
+ (yyval) = (yyvsp[0]);
+ }
+#line 3923 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 53:
+#line 523 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3932 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 54:
+#line 527 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3941 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 55:
+#line 531 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-2]), (yyvsp[-1]));
+ NMORE((yyvsp[-2]), (yyvsp[-4]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 3952 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 56:
+#line 538 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-7]), n_FOREACH);
+ NSPAN((yyvsp[-6]), n_FOREACH_EXPRESSION, (yyvsp[-1]));
+ (yyvsp[-6])->appendChild((yyvsp[-5]));
+ if ((yyvsp[-2])->type == n_EMPTY) {
+ (yyvsp[-6])->appendChild((yyvsp[-2]));
+ (yyvsp[-6])->appendChild((yyvsp[-3]));
+ } else {
+ (yyvsp[-6])->appendChild((yyvsp[-3]));
+ (yyvsp[-6])->appendChild((yyvsp[-2]));
+ }
+ (yyvsp[-7])->appendChild((yyvsp[-6]));
+
+ (yyvsp[-7])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-7]));
+ }
+#line 3974 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 57:
+#line 556 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-7]), n_FOREACH);
+ NSPAN((yyvsp[-6]), n_FOREACH_EXPRESSION, (yyvsp[-1]));
+ (yyvsp[-6])->appendChild((yyvsp[-5]));
+ if ((yyvsp[-2])->type == n_EMPTY) {
+ (yyvsp[-6])->appendChild((yyvsp[-2]));
+ (yyvsp[-6])->appendChild((yyvsp[-3]));
+ } else {
+ (yyvsp[-6])->appendChild((yyvsp[-3]));
+ (yyvsp[-6])->appendChild((yyvsp[-2]));
+ }
+ (yyvsp[-7])->appendChild((yyvsp[-6]));
+ (yyvsp[-7])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-7]));
+ }
+#line 3995 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 58:
+#line 572 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-4]), n_DECLARE);
+ (yyvsp[-4])->appendChild((yyvsp[-2]));
+ (yyvsp[-4])->appendChild((yyvsp[0]));
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-4]));
+ }
+#line 4006 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 59:
+#line 578 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT)->appendChild(NNEW(n_EMPTY));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 4015 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 60:
+#line 582 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-5]), n_TRY);
+ (yyvsp[-5])->appendChild(NEXPAND((yyvsp[-4]), (yyvsp[-3]), (yyvsp[-2])));
+
+ (yyvsp[-5])->appendChild((yyvsp[-1]));
+ (yyvsp[-5])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-5]));
+ }
+#line 4029 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 61:
+#line 591 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-4]), n_TRY);
+ (yyvsp[-4])->appendChild(NEXPAND((yyvsp[-3]), (yyvsp[-2]), (yyvsp[-1])));
+
+ (yyvsp[-4])->appendChild(NNEW(n_CATCH_LIST));
+ (yyvsp[-4])->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-4]));
+ }
+#line 4043 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 62:
+#line 600 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_THROW);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+
+ }
+#line 4056 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 63:
+#line 608 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_GOTO);
+ NTYPE((yyvsp[-1]), n_STRING);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 4069 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 64:
+#line 619 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 4078 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 65:
+#line 623 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CATCH_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+}
+#line 4087 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 66:
+#line 630 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-7]), n_CATCH);
+ (yyvsp[-7])->appendChild((yyvsp[-5]));
+ (yyvsp[-7])->appendChild(NTYPE((yyvsp[-4]), n_VARIABLE));
+ (yyvsp[-7])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ NMORE((yyvsp[-7]), (yyvsp[0]));
+ (yyval) = (yyvsp[-7]);
+ }
+#line 4100 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 67:
+#line 641 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4108 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 69:
+#line 648 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_FINALLY);
+ (yyvsp[-3])->appendChild((yyvsp[-1]));
+ NMORE((yyvsp[-3]), (yyvsp[0]));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 4119 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 70:
+#line 657 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNSET_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 4128 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 71:
+#line 661 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4137 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 75:
+#line 680 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4145 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 76:
+#line 683 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_REFERENCE);
+ }
+#line 4153 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 77:
+#line 690 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-9]), n_FUNCTION_DECLARATION, (yyvsp[-1]));
+ (yyvsp[-9])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-9])->appendChild((yyvsp[-8]));
+ (yyvsp[-9])->appendChild(NTYPE((yyvsp[-7]), n_STRING));
+ (yyvsp[-9])->appendChild(NEXPAND((yyvsp[-6]), (yyvsp[-5]), (yyvsp[-4])));
+ (yyvsp[-9])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-9])->appendChild((yyvsp[-3]));
+ (yyvsp[-9])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-9]));
+ }
+#line 4170 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 78:
+#line 706 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_DECLARATION);
+ (yyval)->appendChild((yyvsp[-6]));
+ (yyval)->appendChild(NTYPE((yyvsp[-5]), n_CLASS_NAME));
+ (yyval)->appendChild((yyvsp[-4]));
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ NMORE((yyval), (yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyval));
+ }
+#line 4186 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 79:
+#line 717 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INTERFACE_DECLARATION);
+ (yyval)->appendChild(NNEW(n_CLASS_ATTRIBUTES));
+ NMORE((yyval), (yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-4]), n_CLASS_NAME));
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ NMORE((yyval), (yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyval));
+ }
+#line 4203 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 80:
+#line 732 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_CLASS_ATTRIBUTES);
+ (yyval) = (yyvsp[0]);
+ }
+#line 4212 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 81:
+#line 736 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_CLASS_ATTRIBUTES);
+ NMORE((yyvsp[0]), (yyvsp[-1]));
+ (yyvsp[0])->appendChild(NTYPE((yyvsp[-1]), n_STRING));
+
+ (yyval) = (yyvsp[0]);
+ }
+#line 4224 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 82:
+#line 743 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_CLASS_ATTRIBUTES);
+ NMORE((yyvsp[0]), (yyvsp[-1]));
+ (yyvsp[0])->appendChild(NTYPE((yyvsp[-1]), n_STRING));
+
+ (yyval) = (yyvsp[0]);
+ }
+#line 4236 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 83:
+#line 750 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_ATTRIBUTES);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 4245 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 84:
+#line 757 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4253 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 85:
+#line 760 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_EXTENDS_LIST)->appendChild((yyvsp[0]));
+ }
+#line 4261 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 87:
+#line 770 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4269 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 88:
+#line 773 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_EXTENDS_LIST);
+ (yyvsp[-1])->appendChildren((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 4279 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 89:
+#line 781 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4287 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 90:
+#line 784 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_IMPLEMENTS_LIST);
+ (yyvsp[-1])->appendChildren((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 4297 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 91:
+#line 792 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_IMPLEMENTS_LIST)->appendChild((yyvsp[0]));
+ }
+#line 4305 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 92:
+#line 795 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 4313 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 93:
+#line 801 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4321 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 94:
+#line 804 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 4329 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 96:
+#line 811 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE);
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 4339 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 98:
+#line 820 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-2]), (yyvsp[-3]));
+ NMORE((yyvsp[-2]), (yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4349 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 100:
+#line 829 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-2]), (yyvsp[-3]));
+ NMORE((yyvsp[-2]), (yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4359 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 102:
+#line 838 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-2]), (yyvsp[-3]));
+ NMORE((yyvsp[-2]), (yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4369 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 103:
+#line 846 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARE_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_STRING));
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval) = NNEW(n_DECLARE_DECLARATION_LIST)->appendChild((yyval));
+ }
+#line 4380 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 104:
+#line 852 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARE_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_STRING));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyvsp[-4])->appendChild((yyval));
+ (yyval) = (yyvsp[-4]);
+ }
+#line 4393 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 105:
+#line 863 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 4401 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 106:
+#line 866 "parser.y" /* yacc.c:1646 */
+ {
+ // ...why does this rule exist?
+
+ NTYPE((yyvsp[-2]), n_STATEMENT);
+ (yyvsp[-3])->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_STATEMENT_LIST)->appendChild((yyvsp[-2]));
+ (yyval)->appendChildren((yyvsp[-1]));
+ NEXPAND((yyvsp[-3]), (yyval), (yyvsp[0]));
+ }
+#line 4416 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 107:
+#line 876 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-2]), (yyvsp[0]));
+ NMORE((yyvsp[-2]), (yyvsp[-3]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4426 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 108:
+#line 881 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_STATEMENT);
+ (yyvsp[-4])->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_STATEMENT_LIST)->appendChild((yyvsp[-3]));
+ (yyval)->appendChildren((yyvsp[-2]));
+ NMORE((yyval), (yyvsp[0]));
+ NMORE((yyval), (yyvsp[-4]));
+ }
+#line 4440 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 109:
+#line 893 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT_LIST);
+ }
+#line 4448 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 110:
+#line 896 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_CASE);
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+ (yyvsp[-3])->appendChild((yyvsp[0]));
+
+ (yyvsp[-4])->appendChild((yyvsp[-3]));
+ (yyval) = (yyvsp[-4]);
+ }
+#line 4461 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 111:
+#line 904 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_DEFAULT);
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 4473 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 115:
+#line 920 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-2]), (yyvsp[0]));
+ NMORE((yyvsp[-2]), (yyvsp[-3]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4483 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 116:
+#line 928 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CONDITION_LIST);
+ }
+#line 4491 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 117:
+#line 931 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-4]), n_ELSEIF);
+ (yyvsp[-4])->appendChild(NSPAN((yyvsp[-3]), n_CONTROL_CONDITION, (yyvsp[-1]))->appendChild((yyvsp[-2])));
+ (yyvsp[-4])->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-5])->appendChild((yyvsp[-4]));
+ }
+#line 4503 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 118:
+#line 941 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CONDITION_LIST);
+ }
+#line 4511 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 119:
+#line 944 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-5]), n_ELSEIF);
+ (yyvsp[-5])->appendChild((yyvsp[-3]));
+ (yyvsp[-5])->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-6])->appendChild((yyvsp[-5]));
+ }
+#line 4523 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 120:
+#line 954 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4531 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 121:
+#line 957 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_ELSE);
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 4541 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 122:
+#line 965 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4549 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 123:
+#line 968 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_ELSE);
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4559 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 125:
+#line 977 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER_LIST);
+ }
+#line 4567 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 126:
+#line 983 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-1]));
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild((yyval));
+ }
+#line 4580 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 127:
+#line 991 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE));
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild((yyval));
+ }
+#line 4594 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 128:
+#line 1000 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-4]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_VARIABLE_REFERENCE));
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild((yyval));
+ }
+#line 4608 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 129:
+#line 1009 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_DECLARATION_PARAMETER_LIST)->appendChild((yyval));
+ }
+#line 4621 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 130:
+#line 1017 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-1]));
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = (yyvsp[-3])->appendChild((yyval));
+ }
+#line 4634 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 131:
+#line 1025 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE));
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = (yyvsp[-4])->appendChild((yyval));
+ }
+#line 4648 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 132:
+#line 1035 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-4]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_VARIABLE_REFERENCE));
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-6])->appendChild((yyval));
+ }
+#line 4662 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 133:
+#line 1045 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_PARAMETER);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-5])->appendChild((yyval));
+ }
+#line 4675 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 134:
+#line 1056 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_UNPACK);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ }
+#line 4684 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 135:
+#line 1060 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_VARIABLE);
+ }
+#line 4692 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 136:
+#line 1066 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4700 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 138:
+#line 1070 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_NULLABLE_TYPE);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 4709 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 139:
+#line 1077 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 4717 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 140:
+#line 1080 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_TYPE_NAME);
+ }
+#line 4725 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 141:
+#line 1083 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_TYPE_NAME);
+ }
+#line 4733 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 142:
+#line 1089 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4741 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 143:
+#line 1092 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_DECLARATION_RETURN);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 4750 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 145:
+#line 1100 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CALL_PARAMETER_LIST);
+ }
+#line 4758 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 146:
+#line 1106 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CALL_PARAMETER_LIST)->appendChild((yyvsp[0]));
+ }
+#line 4766 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 147:
+#line 1109 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 4774 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 149:
+#line 1116 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNPACK)->appendChild((yyvsp[-1]));
+ }
+#line 4782 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 150:
+#line 1119 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE);
+ (yyval) = (yyvsp[-1])->appendChild((yyvsp[0]));
+ }
+#line 4791 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 151:
+#line 1126 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 4800 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 152:
+#line 1130 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_GLOBAL_DECLARATION_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 4809 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 153:
+#line 1137 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_VARIABLE);
+ }
+#line 4817 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 154:
+#line 1140 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_VARIABLE_VARIABLE);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 4826 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 155:
+#line 1144 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-3]), n_VARIABLE_VARIABLE);
+ (yyval)->appendChild((yyvsp[-1]));
+ }
+#line 4835 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 156:
+#line 1151 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_VARIABLE);
+ (yyval) = NNEW(n_STATIC_DECLARATION);
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = (yyvsp[-2])->appendChild((yyval));
+ }
+#line 4848 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 157:
+#line 1159 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_VARIABLE);
+ (yyval) = NNEW(n_STATIC_DECLARATION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-4])->appendChild((yyval));
+ }
+#line 4861 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 158:
+#line 1167 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_VARIABLE);
+ (yyval) = NNEW(n_STATIC_DECLARATION);
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_STATIC_DECLARATION_LIST)->appendChild((yyval));
+ }
+#line 4874 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 159:
+#line 1175 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_VARIABLE);
+ (yyval) = NNEW(n_STATIC_DECLARATION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATIC_DECLARATION_LIST)->appendChild((yyval));
+ }
+#line 4887 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 160:
+#line 1186 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-1])->appendChild((yyvsp[0]));
+ }
+#line 4895 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 161:
+#line 1189 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT_LIST);
+ }
+#line 4903 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 162:
+#line 1195 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION_LIST);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChildren((yyvsp[-1]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyval));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 4916 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 163:
+#line 1203 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 4925 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 164:
+#line 1207 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 4933 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 165:
+#line 1210 "parser.y" /* yacc.c:1646 */
+ {
+ /* empty */
+ }
+#line 4941 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 166:
+#line 1212 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_METHOD_DECLARATION);
+ NMORE((yyval), (yyvsp[-8]));
+ (yyval)->appendChild((yyvsp[-9]));
+ (yyval)->appendChild((yyvsp[-6]));
+ (yyval)->appendChild(NTYPE((yyvsp[-5]), n_STRING));
+ (yyval)->appendChild(NEXPAND((yyvsp[-4]), (yyvsp[-3]), (yyvsp[-2])));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild((yyvsp[-1]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_STATEMENT)->appendChild((yyval));
+ }
+#line 4959 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 167:
+#line 1228 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-2]), n_TRAIT_USE);
+ (yyval)->appendChildren((yyvsp[-1]));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 4969 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 168:
+#line 1236 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_USE_LIST)->appendChild((yyvsp[0]));
+ }
+#line 4977 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 169:
+#line 1239 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 4985 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 170:
+#line 1245 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 4993 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 171:
+#line 1248 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 5001 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 172:
+#line 1254 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_ADAPTATION_LIST);
+ }
+#line 5009 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 173:
+#line 1257 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 5017 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 174:
+#line 1263 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_ADAPTATION_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5026 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 175:
+#line 1267 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 5035 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 176:
+#line 1274 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[-1]), (yyvsp[0]));
+ }
+#line 5043 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 177:
+#line 1277 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[-1]), (yyvsp[0]));
+ }
+#line 5051 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 178:
+#line 1283 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_INSTEADOF);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5061 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 179:
+#line 1291 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_REFERENCE_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5070 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 180:
+#line 1295 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 5079 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 181:
+#line 1302 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_METHOD_REFERENCE);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 5088 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 182:
+#line 1306 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 5096 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 183:
+#line 1312 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_TRAIT_METHOD_REFERENCE);
+ NEXPAND((yyvsp[-2]), (yyvsp[-1]), NTYPE((yyvsp[0]), n_STRING));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 5106 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 184:
+#line 1320 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_AS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 5117 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 185:
+#line 1326 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TRAIT_AS);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ }
+#line 5128 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 186:
+#line 1335 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 5136 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 187:
+#line 1338 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_METHOD_MODIFIER_LIST);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 5145 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 188:
+#line 1346 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 5153 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 189:
+#line 1349 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 5161 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 191:
+#line 1356 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_MODIFIER_LIST);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 5170 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 192:
+#line 1363 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_METHOD_MODIFIER_LIST);
+ }
+#line 5178 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 193:
+#line 1366 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_METHOD_MODIFIER_LIST);
+ (yyval) = (yyvsp[0]);
+ }
+#line 5187 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 194:
+#line 1373 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_MODIFIER_LIST);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 5196 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 195:
+#line 1377 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-1])->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 5204 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 202:
+#line 1392 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = (yyvsp[-2])->appendChild((yyval));
+ }
+#line 5216 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 203:
+#line 1399 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_VARIABLE));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-4])->appendChild((yyval));
+ }
+#line 5228 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 204:
+#line 1406 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION_LIST)->appendChild((yyval));
+ }
+#line 5240 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 205:
+#line 1413 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_VARIABLE));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_CLASS_MEMBER_DECLARATION_LIST)->appendChild((yyval));
+ }
+#line 5252 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 206:
+#line 1423 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_CONSTANT_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_STRING));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyvsp[-4])->appendChild((yyval));
+
+ (yyval) = (yyvsp[-4]);
+ }
+#line 5266 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 207:
+#line 1432 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_CLASS_CONSTANT_DECLARATION_LIST);
+ (yyval) = NNEW(n_CLASS_CONSTANT_DECLARATION);
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_STRING));
+ (yyval)->appendChild((yyvsp[0]));
+ (yyvsp[-3])->appendChild((yyval));
+
+ (yyval) = (yyvsp[-3]);
+ }
+#line 5280 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 208:
+#line 1444 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 5288 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 209:
+#line 1447 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ECHO_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5297 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 210:
+#line 1454 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 5305 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 212:
+#line 1462 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 5313 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 213:
+#line 1465 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EXPRESSION_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5322 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 214:
+#line 1472 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-5]), n_LIST);
+ (yyvsp[-5])->appendChild(NEXPAND((yyvsp[-4]), (yyvsp[-3]), (yyvsp[-2])));
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5335 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 215:
+#line 1480 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5346 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 216:
+#line 1486 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_OPERATOR));
+
+ NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE);
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+
+ (yyval)->appendChild((yyvsp[-1]));
+ }
+#line 5361 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 217:
+#line 1496 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-4]), n_OPERATOR));
+
+ NTYPE((yyvsp[-2]), n_NEW);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+
+ NTYPE((yyvsp[-3]), n_VARIABLE_REFERENCE);
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+
+ (yyval)->appendChild((yyvsp[-3]));
+ }
+#line 5380 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 218:
+#line 1510 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5390 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 219:
+#line 1515 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5401 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 220:
+#line 1521 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5412 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 221:
+#line 1527 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5423 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 222:
+#line 1533 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5434 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 223:
+#line 1539 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5445 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 224:
+#line 1545 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5456 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 225:
+#line 1551 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5467 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 226:
+#line 1557 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5478 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 227:
+#line 1563 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5489 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 228:
+#line 1569 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5500 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 229:
+#line 1575 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5511 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 230:
+#line 1581 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_POSTFIX_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-1]));
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_OPERATOR));
+ }
+#line 5521 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 231:
+#line 1586 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5531 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 232:
+#line 1591 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_POSTFIX_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-1]));
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_OPERATOR));
+ }
+#line 5541 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 233:
+#line 1596 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5551 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 234:
+#line 1601 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5562 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 235:
+#line 1607 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5573 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 236:
+#line 1613 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5584 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 237:
+#line 1619 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5595 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 238:
+#line 1625 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5606 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 239:
+#line 1631 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5617 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 240:
+#line 1637 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5628 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 241:
+#line 1643 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5639 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 242:
+#line 1649 "parser.y" /* yacc.c:1646 */
+ {
+
+ /* The concatenation operator generates n_CONCATENATION_LIST instead of
+ n_BINARY_EXPRESSION because we tend to run into stack depth issues in a
+ lot of real-world cases otherwise (e.g., in PHP and JSON decoders). */
+
+ if ((yyvsp[-2])->type == n_CONCATENATION_LIST && (yyvsp[0])->type == n_CONCATENATION_LIST) {
+ (yyvsp[-2])->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyvsp[-2])->appendChildren((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ } else if ((yyvsp[-2])->type == n_CONCATENATION_LIST) {
+ (yyvsp[-2])->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ } else if ((yyvsp[0])->type == n_CONCATENATION_LIST) {
+ (yyval) = NNEW(n_CONCATENATION_LIST);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChildren((yyvsp[0]));
+ } else {
+ (yyval) = NNEW(n_CONCATENATION_LIST);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+ }
+#line 5670 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 243:
+#line 1675 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5681 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 244:
+#line 1681 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5692 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 245:
+#line 1687 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5703 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 246:
+#line 1693 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5714 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 247:
+#line 1699 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5725 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 248:
+#line 1705 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5736 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 249:
+#line 1711 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5747 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 250:
+#line 1717 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5757 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 251:
+#line 1722 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5767 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 252:
+#line 1727 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5777 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 253:
+#line 1732 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5787 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 254:
+#line 1737 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5798 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 255:
+#line 1743 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5809 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 256:
+#line 1749 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5820 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 257:
+#line 1755 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5831 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 258:
+#line 1761 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5842 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 259:
+#line 1767 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5853 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 260:
+#line 1773 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5864 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 261:
+#line 1779 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5875 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 262:
+#line 1785 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5886 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 263:
+#line 1791 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5897 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 266:
+#line 1799 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TERNARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-4]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5910 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 267:
+#line 1807 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_TERNARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NTYPE((yyvsp[-2]), n_OPERATOR));
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5923 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 268:
+#line 1815 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_BINARY_EXPRESSION);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5934 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 270:
+#line 1822 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5944 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 271:
+#line 1827 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5954 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 272:
+#line 1832 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5964 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 273:
+#line 1837 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5974 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 274:
+#line 1842 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5984 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 275:
+#line 1847 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 5994 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 276:
+#line 1852 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CAST_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_CAST));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6004 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 277:
+#line 1857 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6014 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 278:
+#line 1862 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6024 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 279:
+#line 1867 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_BACKTICKS_EXPRESSION);
+ (yyval) = (yyvsp[0]);
+ }
+#line 6033 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 283:
+#line 1874 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6043 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 284:
+#line 1879 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_YIELD);
+ (yyvsp[0])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[0])->appendChild(NNEW(n_EMPTY));
+ (yyval) = (yyvsp[0]);
+ }
+#line 6054 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 285:
+#line 1888 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-9]), n_FUNCTION_DECLARATION, (yyvsp[-1]));
+ (yyvsp[-9])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-9])->appendChild((yyvsp[-8]));
+ (yyvsp[-9])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-9])->appendChild(NEXPAND((yyvsp[-7]), (yyvsp[-6]), (yyvsp[-5])));
+ (yyvsp[-9])->appendChild((yyvsp[-4]));
+ (yyvsp[-9])->appendChild((yyvsp[-3]));
+ (yyvsp[-9])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+
+ (yyval) = (yyvsp[-9]);
+ }
+#line 6071 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 286:
+#line 1903 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-9]), n_FUNCTION_DECLARATION, (yyvsp[-1]));
+ NMORE((yyvsp[-9]), (yyvsp[-10]));
+
+ (yyval) = NNEW(n_FUNCTION_MODIFIER_LIST);
+ (yyval)->appendChild(NTYPE((yyvsp[-10]), n_STRING));
+ (yyvsp[-9])->appendChild((yyvsp[-10]));
+
+ (yyvsp[-9])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-9])->appendChild((yyvsp[-8]));
+ (yyvsp[-9])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-9])->appendChild(NEXPAND((yyvsp[-7]), (yyvsp[-6]), (yyvsp[-5])));
+ (yyvsp[-9])->appendChild((yyvsp[-4]));
+ (yyvsp[-9])->appendChild((yyvsp[-3]));
+ (yyvsp[-9])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+
+ (yyval) = (yyvsp[-9]);
+ }
+#line 6094 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 287:
+#line 1924 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_YIELD);
+ (yyvsp[0])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 6105 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 288:
+#line 1930 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_YIELD);
+ (yyvsp[0])->appendChild(NNEW(n_EMPTY));
+ (yyvsp[-1])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 6116 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 289:
+#line 1936 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_YIELD);
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+ (yyvsp[-3])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 6127 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 290:
+#line 1942 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_YIELD);
+ (yyvsp[-3])->appendChild((yyvsp[-2]));
+ (yyvsp[-3])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 6138 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 292:
+#line 1955 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6146 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 293:
+#line 1958 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_LEXICAL_VARIABLE_LIST);
+ (yyvsp[-3])->appendChildren((yyvsp[-1]));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 6156 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 294:
+#line 1966 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ }
+#line 6164 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 295:
+#line 1969 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE);
+ (yyvsp[-1])->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ (yyval) = (yyvsp[-3])->appendChild((yyvsp[-1]));
+ }
+#line 6174 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 296:
+#line 1974 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_LEXICAL_VARIABLE_LIST);
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ }
+#line 6183 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 297:
+#line 1978 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE);
+ (yyvsp[-1])->appendChild(NTYPE((yyvsp[0]), n_VARIABLE));
+ (yyval) = NNEW(n_LEXICAL_VARIABLE_LIST);
+ (yyval)->appendChild((yyvsp[-1]));
+ }
+#line 6194 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 298:
+#line 1987 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6204 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 299:
+#line 1993 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-3]), (yyvsp[-5]));
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6215 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 300:
+#line 1999 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[-3]), (yyvsp[-4]));
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6226 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 301:
+#line 2006 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_STRING));
+
+ (yyval) = NNEW(n_FUNCTION_CALL)->appendChild((yyval));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6239 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 302:
+#line 2015 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_STRING));
+
+ (yyval) = NNEW(n_FUNCTION_CALL)->appendChild((yyval));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6252 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 303:
+#line 2024 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_STRING));
+
+ (yyval) = NNEW(n_FUNCTION_CALL)->appendChild((yyval));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6265 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 304:
+#line 2033 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-5]));
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_STRING));
+
+ (yyval) = NNEW(n_FUNCTION_CALL)->appendChild((yyval));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6278 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 305:
+#line 2041 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 6288 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 306:
+#line 2049 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6296 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 307:
+#line 2052 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6304 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 308:
+#line 2055 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[0]), (yyvsp[-2]));
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6313 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 309:
+#line 2059 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[0]), (yyvsp[-1]));
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6322 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 310:
+#line 2066 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6330 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 311:
+#line 2069 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[0]), (yyvsp[-2]));
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6339 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 312:
+#line 2073 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[0]), (yyvsp[-1]));
+ (yyval) = NTYPE((yyvsp[0]), n_CLASS_NAME);
+ }
+#line 6348 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 315:
+#line 2088 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_OBJECT_PROPERTY_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ for (xhpast::node_list_t::iterator ii = (yyvsp[0])->children.begin();
+ ii != (yyvsp[0])->children.end();
+ ++ii) {
+
+ (yyval) = NNEW(n_OBJECT_PROPERTY_ACCESS)->appendChild((yyval));
+ (yyval)->appendChild(*ii);
+ }
+ }
+#line 6365 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 317:
+#line 2104 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-1])->appendChild((yyvsp[0]));
+ }
+#line 6373 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 318:
+#line 2107 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6381 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 319:
+#line 2113 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 6389 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 320:
+#line 2119 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6397 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 321:
+#line 2122 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-1]), n_EMPTY, (yyvsp[0]));
+ (yyval) = (yyvsp[-1]);
+ }
+#line 6406 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 322:
+#line 2126 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-2]), n_PARENTHETICAL_EXPRESSION, (yyvsp[0]));
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 6416 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 323:
+#line 2134 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6424 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 324:
+#line 2137 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 6432 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 325:
+#line 2143 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_NUMERIC_SCALAR);
+ }
+#line 6440 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 326:
+#line 2146 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_NUMERIC_SCALAR);
+ }
+#line 6448 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 327:
+#line 2149 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_STRING_SCALAR);
+ }
+#line 6456 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 328:
+#line 2152 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6464 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 329:
+#line 2155 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6472 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 330:
+#line 2158 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6480 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 331:
+#line 2161 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6488 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 332:
+#line 2164 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6496 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 333:
+#line 2167 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6504 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 334:
+#line 2170 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6512 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 335:
+#line 2173 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_MAGIC_SCALAR);
+ }
+#line 6520 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 336:
+#line 2176 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_HEREDOC);
+ }
+#line 6528 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 339:
+#line 2184 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[0]), (yyvsp[-2]));
+ (yyval) = (yyvsp[0]);
+ }
+#line 6537 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 340:
+#line 2188 "parser.y" /* yacc.c:1646 */
+ {
+ NMORE((yyvsp[0]), (yyvsp[-1]));
+ (yyval) = (yyvsp[0]);
+ }
+#line 6546 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 341:
+#line 2192 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6556 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 342:
+#line 2197 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_UNARY_PREFIX_EXPRESSION);
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_OPERATOR));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6566 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 343:
+#line 2202 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_ARRAY_LITERAL);
+ (yyvsp[-3])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 6576 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 344:
+#line 2207 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_ARRAY_LITERAL);
+ (yyvsp[-2])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 6586 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 346:
+#line 2216 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 6596 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 350:
+#line 2227 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[0]), (yyvsp[-2]));
+ }
+#line 6604 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 351:
+#line 2230 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[0]), (yyvsp[-1]));
+ }
+#line 6612 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 353:
+#line 2237 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST);
+ }
+#line 6620 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 354:
+#line 2240 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[-1]), (yyvsp[0]));
+ }
+#line 6628 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 355:
+#line 2246 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6636 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 357:
+#line 2257 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-4])->appendChild((yyval));
+ }
+#line 6648 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 358:
+#line 2264 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-2])->appendChild((yyval));
+ }
+#line 6660 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 359:
+#line 2271 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST)->appendChild((yyval));
+ }
+#line 6672 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 360:
+#line 2278 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST)->appendChild((yyval));
+ }
+#line 6684 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 366:
+#line 2308 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_OBJECT_PROPERTY_ACCESS);
+ (yyval)->appendChild((yyvsp[-4]));
+ (yyval)->appendChild((yyvsp[-2]));
+
+ if ((yyvsp[-1])->type != n_EMPTY) {
+ (yyval) = NNEW(n_METHOD_CALL)->appendChild((yyval));
+ (yyval)->appendChild((yyvsp[-1]));
+ }
+
+ for (xhpast::node_list_t::iterator ii = (yyvsp[0])->children.begin();
+ ii != (yyvsp[0])->children.end();
+ ++ii) {
+
+ if ((*ii)->type == n_CALL_PARAMETER_LIST) {
+ (yyval) = NNEW(n_METHOD_CALL)->appendChild((yyval));
+ (yyval)->appendChild((*ii));
+ } else {
+ (yyval) = NNEW(n_OBJECT_PROPERTY_ACCESS)->appendChild((yyval));
+ (yyval)->appendChild((*ii));
+ }
+ }
+ }
+#line 6712 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 368:
+#line 2335 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-1])->appendChildren((yyvsp[0]));
+ }
+#line 6720 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 369:
+#line 2338 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6728 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 370:
+#line 2344 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ (yyval)->appendChild((yyvsp[-1]));
+ if ((yyvsp[0])->type != n_EMPTY) {
+ (yyval)->appendChild((yyvsp[0]));
+ }
+ }
+#line 6740 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 371:
+#line 2354 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6751 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 372:
+#line 2360 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6762 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 373:
+#line 2369 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 6770 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 376:
+#line 2377 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6778 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 378:
+#line 2384 "parser.y" /* yacc.c:1646 */
+ {
+ xhpast::Node *last = (yyvsp[-1]);
+ NMORE((yyvsp[-1]), (yyvsp[0]));
+ while (last->firstChild() &&
+ last->firstChild()->type == n_VARIABLE_VARIABLE) {
+ NMORE(last, (yyvsp[0]));
+ last = last->firstChild();
+ }
+ last->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-1]);
+ }
+#line 6795 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 379:
+#line 2399 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6805 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 380:
+#line 2404 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6815 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 382:
+#line 2416 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6826 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 383:
+#line 2422 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6837 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 388:
+#line 2438 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 6845 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 389:
+#line 2441 "parser.y" /* yacc.c:1646 */
+ {
+ xhpast::Node *last = (yyvsp[-1]);
+ NMORE((yyvsp[-1]), (yyvsp[0]));
+ while (last->firstChild() &&
+ last->firstChild()->type == n_VARIABLE_VARIABLE) {
+ NMORE(last, (yyvsp[0]));
+ last = last->firstChild();
+ }
+ last->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-1]);
+ }
+#line 6862 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 391:
+#line 2457 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6873 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 392:
+#line 2463 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6884 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 394:
+#line 2473 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_VARIABLE);
+ }
+#line 6892 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 395:
+#line 2476 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-3]), n_VARIABLE_EXPRESSION, (yyvsp[0]));
+ (yyvsp[-3])->appendChild((yyvsp[-1]));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 6902 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 396:
+#line 2484 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 6910 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 397:
+#line 2487 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[0]);
+ }
+#line 6918 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 400:
+#line 2498 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6929 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 401:
+#line 2504 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 6940 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 403:
+#line 2514 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[0]), n_STRING);
+ (yyval) = (yyvsp[0]);
+ }
+#line 6949 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 404:
+#line 2518 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 6957 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 405:
+#line 2524 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[0]), n_VARIABLE_VARIABLE);
+ }
+#line 6965 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 406:
+#line 2527 "parser.y" /* yacc.c:1646 */
+ {
+ (yyvsp[0]) = NTYPE((yyvsp[0]), n_VARIABLE_VARIABLE);
+
+ xhpast::Node *last = (yyvsp[-1]);
+ while (last->firstChild() &&
+ last->firstChild()->type == n_VARIABLE_VARIABLE) {
+ last = last->firstChild();
+ }
+ last->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-1]);
+ }
+#line 6982 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 407:
+#line 2542 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 6990 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 408:
+#line 2545 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ASSIGNMENT_LIST);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 6999 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 410:
+#line 2553 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_LIST);
+ (yyval)->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ }
+#line 7008 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 411:
+#line 2557 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ }
+#line 7016 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 412:
+#line 2563 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST);
+ }
+#line 7024 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 413:
+#line 2566 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NMORE((yyvsp[-1]), (yyvsp[0]));
+ }
+#line 7032 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 414:
+#line 2572 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-4])->appendChild((yyval));
+ }
+#line 7044 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 415:
+#line 2579 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = (yyvsp[-2])->appendChild((yyval));
+ }
+#line 7056 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 416:
+#line 2586 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST)->appendChild((yyval));
+ }
+#line 7068 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 417:
+#line 2593 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild((yyvsp[0]));
+
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST)->appendChild((yyval));
+ }
+#line 7080 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 418:
+#line 2600 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE)->appendChild((yyvsp[0])));
+
+ (yyval) = (yyvsp[-5])->appendChild((yyval));
+ }
+#line 7092 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 419:
+#line 2607 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE)->appendChild((yyvsp[0])));
+
+ (yyval) = (yyvsp[-3])->appendChild((yyval));
+ }
+#line 7104 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 420:
+#line 2614 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE)->appendChild((yyvsp[0])));
+
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST)->appendChild((yyval));
+ }
+#line 7116 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 421:
+#line 2621 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_ARRAY_VALUE);
+ (yyval)->appendChild(NNEW(n_EMPTY));
+ (yyval)->appendChild(NTYPE((yyvsp[-1]), n_VARIABLE_REFERENCE)->appendChild((yyvsp[0])));
+
+ (yyval) = NNEW(n_ARRAY_VALUE_LIST)->appendChild((yyval));
+ }
+#line 7128 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 422:
+#line 2631 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_SYMBOL_NAME);
+
+ NSPAN((yyvsp[-2]), n_CALL_PARAMETER_LIST, (yyvsp[0]));
+ (yyvsp[-2])->appendChildren((yyvsp[-1]));
+
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ }
+#line 7143 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 423:
+#line 2641 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_SYMBOL_NAME);
+
+ NSPAN((yyvsp[-2]), n_CALL_PARAMETER_LIST, (yyvsp[0]));
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ }
+#line 7158 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 424:
+#line 2651 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_INCLUDE_FILE)->appendChild((yyvsp[0]));
+ }
+#line 7166 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 425:
+#line 2654 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_INCLUDE_FILE)->appendChild((yyvsp[0]));
+ }
+#line 7174 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 426:
+#line 2657 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_SYMBOL_NAME);
+
+ NSPAN((yyvsp[-2]), n_CALL_PARAMETER_LIST, (yyvsp[0]));
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+
+ (yyval) = NNEW(n_FUNCTION_CALL);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-2]));
+ }
+#line 7189 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 427:
+#line 2667 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_INCLUDE_FILE)->appendChild((yyvsp[0]));
+ }
+#line 7197 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 428:
+#line 2670 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NTYPE((yyvsp[-1]), n_INCLUDE_FILE)->appendChild((yyvsp[0]));
+ }
+#line 7205 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 429:
+#line 2676 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_EMPTY);
+ (yyval)->appendChild((yyvsp[0]));
+ }
+#line 7214 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 430:
+#line 2680 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = (yyvsp[-2])->appendChild((yyvsp[0]));
+ }
+#line 7222 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 431:
+#line 2686 "parser.y" /* yacc.c:1646 */
+ {
+ NSPAN((yyvsp[-2]), n_PARENTHETICAL_EXPRESSION, (yyvsp[0]));
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 7232 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 432:
+#line 2691 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0]));
+ }
+#line 7240 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 433:
+#line 2697 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 7251 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 434:
+#line 2703 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 7262 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 435:
+#line 2709 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_STRING_SCALAR));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 7273 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 436:
+#line 2715 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild((yyvsp[-3]));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 7284 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 437:
+#line 2721 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_INDEX_ACCESS);
+ (yyval)->appendChild(NTYPE((yyvsp[-3]), n_STRING));
+ (yyval)->appendChild((yyvsp[-1]));
+ NMORE((yyval), (yyvsp[0]));
+ }
+#line 7295 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 438:
+#line 2730 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-3]), n_ARRAY_LITERAL);
+ (yyvsp[-3])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ (yyval) = (yyvsp[-3]);
+ }
+#line 7305 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 439:
+#line 2735 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_ARRAY_LITERAL);
+ (yyvsp[-2])->appendChild(NEXPAND((yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 7315 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 440:
+#line 2743 "parser.y" /* yacc.c:1646 */
+ {
+ NTYPE((yyvsp[-2]), n_NEW);
+ (yyvsp[-2])->appendChild((yyvsp[-1]));
+ (yyvsp[-2])->appendChild((yyvsp[0]));
+ (yyval) = (yyvsp[-2]);
+ }
+#line 7326 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 441:
+#line 2752 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 7336 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+ case 442:
+#line 2757 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval) = NNEW(n_CLASS_STATIC_ACCESS);
+ (yyval)->appendChild((yyvsp[-2]));
+ (yyval)->appendChild(NTYPE((yyvsp[0]), n_STRING));
+ }
+#line 7346 "parser.yacc.cpp" /* yacc.c:1646 */
+ break;
+
+
+#line 7350 "parser.yacc.cpp" /* yacc.c:1646 */
+ default: break;
+ }
+ /* User semantic actions sometimes alter yychar, and that requires
+ that yytoken be updated with the new translation. We take the
+ approach of translating immediately before every use of yytoken.
+ One alternative is translating here after every semantic action,
+ but that translation would be missed if the semantic action invokes
+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
+ incorrect destructor might then be invoked immediately. In the
+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
+ to an incorrect destructor call or verbose syntax error message
+ before the lookahead is translated. */
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+
+ *++yyvsp = yyval;
+
+ /* Now 'shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTOKENS];
+
+ goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
+yyerrlab:
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+#if ! YYERROR_VERBOSE
+ yyerror (yyscanner, root, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+ yyssp, yytoken)
+ {
+ char const *yymsgp = YY_("syntax error");
+ int yysyntax_error_status;
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ if (yysyntax_error_status == 0)
+ yymsgp = yymsg;
+ else if (yysyntax_error_status == 1)
+ {
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+ if (!yymsg)
+ {
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
+ yysyntax_error_status = 2;
+ }
+ else
+ {
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ yymsgp = yymsg;
+ }
+ }
+ yyerror (yyscanner, root, yymsgp);
+ if (yysyntax_error_status == 2)
+ goto yyexhaustedlab;
+ }
+# undef YYSYNTAX_ERROR
+#endif
+ }
+
+
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval, yyscanner, root);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+
+ /* Pacify compilers like GCC when the user code never invokes
+ YYERROR and the label yyerrorlab therefore never appears in user
+ code. */
+ if (/*CONSTCOND*/ 0)
+ goto yyerrorlab;
+
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (!yypact_value_is_default (yyn))
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
+
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
+
+
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp, yyscanner, root);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (yyscanner, root, YY_("memory exhausted"));
+ yyresult = 2;
+ /* Fall through. */
+#endif
+
+yyreturn:
+ if (yychar != YYEMPTY)
+ {
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = YYTRANSLATE (yychar);
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval, yyscanner, root);
+ }
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ yystos[*yyssp], yyvsp, yyscanner, root);
+ YYPOPSTACK (1);
+ }
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ return yyresult;
+}
+#line 2764 "parser.y" /* yacc.c:1906 */
+
+
+const char* yytokname(int tok) {
+ if (tok < 255) {
+ return NULL;
+ }
+ return yytname[YYTRANSLATE(tok)];
+}
+/* @generated */
diff --git a/support/xhpast/parser_nodes.php b/support/xhpast/parser_nodes.php
new file mode 100644
--- /dev/null
+++ b/support/xhpast/parser_nodes.php
@@ -0,0 +1,127 @@
+ 'n_PROGRAM',
+ 9001 => 'n_SYMBOL_NAME',
+ 9002 => 'n_HALT_COMPILER',
+ 9003 => 'n_NAMESPACE',
+ 9004 => 'n_STATEMENT',
+ 9005 => 'n_EMPTY',
+ 9006 => 'n_STATEMENT_LIST',
+ 9007 => 'n_OPEN_TAG',
+ 9008 => 'n_CLOSE_TAG',
+ 9009 => 'n_USE_LIST',
+ 9010 => 'n_USE',
+ 9011 => 'n_CONSTANT_DECLARATION_LIST',
+ 9012 => 'n_CONSTANT_DECLARATION',
+ 9013 => 'n_STRING',
+ 9014 => 'n_LABEL',
+ 9015 => 'n_CONDITION_LIST',
+ 9016 => 'n_CONTROL_CONDITION',
+ 9017 => 'n_IF',
+ 9018 => 'n_ELSEIF',
+ 9019 => 'n_ELSE',
+ 9020 => 'n_WHILE',
+ 9021 => 'n_DO_WHILE',
+ 9022 => 'n_FOR',
+ 9023 => 'n_FOR_EXPRESSION',
+ 9024 => 'n_SWITCH',
+ 9025 => 'n_BREAK',
+ 9026 => 'n_CONTINUE',
+ 9027 => 'n_RETURN',
+ 9028 => 'n_GLOBAL_DECLARATION_LIST',
+ 9029 => 'n_GLOBAL_DECLARATION',
+ 9030 => 'n_STATIC_DECLARATION_LIST',
+ 9031 => 'n_STATIC_DECLARATION',
+ 9032 => 'n_ECHO_LIST',
+ 9033 => 'n_ECHO',
+ 9034 => 'n_INLINE_HTML',
+ 9035 => 'n_UNSET_LIST',
+ 9036 => 'n_UNSET',
+ 9037 => 'n_FOREACH',
+ 9038 => 'n_FOREACH_EXPRESSION',
+ 9039 => 'n_THROW',
+ 9040 => 'n_GOTO',
+ 9041 => 'n_TRY',
+ 9042 => 'n_CATCH_LIST',
+ 9043 => 'n_CATCH',
+ 9044 => 'n_DECLARE',
+ 9045 => 'n_DECLARE_DECLARATION_LIST',
+ 9046 => 'n_DECLARE_DECLARATION',
+ 9047 => 'n_VARIABLE',
+ 9048 => 'n_REFERENCE',
+ 9049 => 'n_VARIABLE_REFERENCE',
+ 9050 => 'n_FUNCTION_DECLARATION',
+ 9051 => 'n_CLASS_DECLARATION',
+ 9052 => 'n_CLASS_ATTRIBUTES',
+ 9053 => 'n_EXTENDS',
+ 9054 => 'n_EXTENDS_LIST',
+ 9055 => 'n_IMPLEMENTS_LIST',
+ 9056 => 'n_INTERFACE_DECLARATION',
+ 9057 => 'n_CASE',
+ 9058 => 'n_DEFAULT',
+ 9059 => 'n_DECLARATION_PARAMETER_LIST',
+ 9060 => 'n_DECLARATION_PARAMETER',
+ 9061 => 'n_TYPE_NAME',
+ 9062 => 'n_VARIABLE_VARIABLE',
+ 9063 => 'n_CLASS_MEMBER_DECLARATION_LIST',
+ 9064 => 'n_CLASS_MEMBER_DECLARATION',
+ 9065 => 'n_CLASS_CONSTANT_DECLARATION_LIST',
+ 9066 => 'n_CLASS_CONSTANT_DECLARATION',
+ 9067 => 'n_METHOD_DECLARATION',
+ 9068 => 'n_METHOD_MODIFIER_LIST',
+ 9069 => 'n_FUNCTION_MODIFIER_LIST',
+ 9070 => 'n_CLASS_MEMBER_MODIFIER_LIST',
+ 9071 => 'n_EXPRESSION_LIST',
+ 9072 => 'n_LIST',
+ 9073 => 'n_ASSIGNMENT',
+ 9074 => 'n_NEW',
+ 9075 => 'n_UNARY_PREFIX_EXPRESSION',
+ 9076 => 'n_UNARY_POSTFIX_EXPRESSION',
+ 9077 => 'n_BINARY_EXPRESSION',
+ 9078 => 'n_TERNARY_EXPRESSION',
+ 9079 => 'n_CAST_EXPRESSION',
+ 9080 => 'n_CAST',
+ 9081 => 'n_OPERATOR',
+ 9082 => 'n_ARRAY_LITERAL',
+ 9083 => 'n_EXIT_EXPRESSION',
+ 9084 => 'n_BACKTICKS_EXPRESSION',
+ 9085 => 'n_LEXICAL_VARIABLE_LIST',
+ 9086 => 'n_NUMERIC_SCALAR',
+ 9087 => 'n_STRING_SCALAR',
+ 9088 => 'n_MAGIC_SCALAR',
+ 9089 => 'n_CLASS_STATIC_ACCESS',
+ 9090 => 'n_CLASS_NAME',
+ 9091 => 'n_MAGIC_CLASS_KEYWORD',
+ 9092 => 'n_OBJECT_PROPERTY_ACCESS',
+ 9093 => 'n_ARRAY_VALUE_LIST',
+ 9094 => 'n_ARRAY_VALUE',
+ 9095 => 'n_CALL_PARAMETER_LIST',
+ 9096 => 'n_VARIABLE_EXPRESSION',
+ 9097 => 'n_INCLUDE_FILE',
+ 9098 => 'n_HEREDOC',
+ 9099 => 'n_FUNCTION_CALL',
+ 9100 => 'n_INDEX_ACCESS',
+ 9101 => 'n_ASSIGNMENT_LIST',
+ 9102 => 'n_METHOD_CALL',
+ 9103 => 'n_CONCATENATION_LIST',
+ 9104 => 'n_PARENTHETICAL_EXPRESSION',
+ 9105 => 'n_TRAIT_USE',
+ 9106 => 'n_TRAIT_USE_LIST',
+ 9107 => 'n_TRAIT_ADAPTATION_LIST',
+ 9108 => 'n_TRAIT_INSTEADOF',
+ 9109 => 'n_TRAIT_REFERENCE_LIST',
+ 9110 => 'n_TRAIT_METHOD_REFERENCE',
+ 9111 => 'n_TRAIT_AS',
+ 9112 => 'n_YIELD',
+ 9113 => 'n_FINALLY',
+ 9114 => 'n_UNPACK',
+ 9115 => 'n_DECLARATION_RETURN',
+ 9116 => 'n_NULLABLE_TYPE',
+ );
+}
diff --git a/support/xhpast/scanner.l b/support/xhpast/scanner.l
new file mode 100644
--- /dev/null
+++ b/support/xhpast/scanner.l
@@ -0,0 +1,488 @@
+%{
+#include "ast.hpp"
+#define push_state(s) xhp_new_push_state(s, yyg)
+#define pop_state() xhp_new_pop_state(yyg)
+#define set_state(s) xhp_set_state(s, yyg)
+
+#define pttok(t, txt) \
+ yyextra->token_list.push_back( \
+ new xhpast::Token(t, txt, yyextra->list_size++)); \
+ *yylval = new xhpast::Node(0, yyextra->list_size - 1);
+#define ptok(t) \
+ pttok(t, yytext);
+#define tok(t) \
+ ptok(t); \
+ return yy_token(t, yyg)
+#define YY_USER_INIT \
+ if (yyextra->insert_token) { \
+ yyg->yy_init = 0; \
+ int ft = yyextra->insert_token; \
+ yyextra->insert_token = 0; \
+ return yy_token(ft, yyg); \
+ }
+
+using namespace std;
+
+const char* yytokname(int tok);
+static int yy_token(int tok, struct yyguts_t* yyg);
+static void yy_scan_newlines(const char* text, struct yyguts_t* yyg);
+
+%}
+
+%option prefix="xhpast"
+%option reentrant
+ /* PHP allows IF or if */
+%option case-insensitive
+%option noyywrap nodefault
+%option stack
+%option bison-bridge
+%option 8bit
+
+ /* The different lexing states. Note that the transitions are done either
+ * in the lex actions, or in a generic manner in yy_token(). */
+%s PHP
+%s PHP_COMMENT
+%s PHP_EOL_COMMENT
+%s PHP_DOC_COMMENT
+%s PHP_HEREDOC_START
+%s PHP_HEREDOC_NSTART
+%s PHP_HEREDOC_NEWLINE
+%s PHP_NO_RESERVED_WORDS
+%s PHP_NO_RESERVED_WORDS_PERSIST
+%s PHP_
+
+LNUM [0-9]+
+DNUM ([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)
+EXPONENT_DNUM (({LNUM}|{DNUM})[eE][+-]?{LNUM})
+HNUM "0x"[0-9a-fA-F]+
+BNUM "0b"[01]+
+
+LABEL [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
+BYTE (.|\n)
+
+WHITESPACE [ \n\r\t]+
+TABS_AND_SPACES [ \t]*
+NEWLINE ("\r\n"|"\n"|"\r")
+
+%%
+
+ /* Open / close PHP + inline HTML */
+{
+ "{
+ ("?>"|""){NEWLINE}? {
+ yy_scan_newlines(yytext + 2, yyg);
+ tok(T_CLOSE_TAG);
+ }
+}
+
+ /* Comments and whitespace */
+{
+ "#"|"//" {
+ push_state(PHP_EOL_COMMENT);
+ yymore();
+ }
+ "/**"{WHITESPACE} {
+ yy_scan_newlines(yytext + 3, yyg);
+ push_state(PHP_DOC_COMMENT);
+ yymore();
+ }
+ "/*" {
+ push_state(PHP_COMMENT);
+ yymore();
+ }
+ {WHITESPACE}+ {
+ yy_scan_newlines(yytext, yyg);
+ ptok(T_WHITESPACE);
+ }
+}
+<