peter-gribanov / sphinx-php-client

src/functions.php

Spacing +32 added lines, -32 removed lines

@@ -38,19 +38,19 @@ 
     assert(is_numeric($value));
 
     // x64
-    if (PHP_INT_SIZE >= 8) {
+    if (PHP_INT_SIZE>=8) {
         $value = (int)$value;
         return pack('NN', $value >> 32, $value & 0xFFFFFFFF);
     }
 
     // x32, int
     if (is_int($value)) {
-        return pack('NN', $value < 0 ? -1 : 0, $value);
+        return pack('NN', $value<0 ? -1 : 0, $value);
     }
 
     // x32, bcmath
     if (function_exists('bcmul')) {
-        if (bccomp($value, 0) == -1) {
+        if (bccomp($value, 0)==-1) {
             $value = bcadd('18446744073709551616', $value);
         }
         $h = bcdiv($value, '4294967296', 0);
@@ -68,8 +68,8 @@ 
     $l = $m - ($q * 4294967296.0);
     $h = $hi * 2328.0 + $q; // (10 ^ 13) / (1 << 32) = 2328
 
-    if ($value < 0) {
-        if ($l == 0) {
+    if ($value<0) {
+        if ($l==0) {
             $h = 4294967296.0 - $h;
         } else {
             $h = 4294967295.0 - $h;
@@ -91,8 +91,8 @@ 
     assert(is_numeric($value));
 
     // x64
-    if (PHP_INT_SIZE >= 8) {
-        assert($value >= 0);
+    if (PHP_INT_SIZE>=8) {
+        assert($value>=0);
 
         // x64, int
         if (is_int($value)) {
@@ -154,16 +154,16 @@ 
 {
     list($hi, $lo) = array_values(unpack('N*N*', $value));
 
-    if (PHP_INT_SIZE >= 8) {
-        if ($hi < 0) { // because php 5.2.2 to 5.2.5 is totally fucked up again
+    if (PHP_INT_SIZE>=8) {
+        if ($hi<0) { // because php 5.2.2 to 5.2.5 is totally fucked up again
             $hi += 1 << 32;
         }
-        if ($lo < 0) {
+        if ($lo<0) {
             $lo += 1 << 32;
         }
 
         // x64, int
-        if ($hi <= 2147483647) {
+        if ($hi<=2147483647) {
             return ($hi << 32) + $lo;
         }
 
@@ -176,20 +176,20 @@ 
         $C = 100000;
         $h = ((int)($hi / $C) << 32) + (int)($lo / $C);
         $l = (($hi % $C) << 32) + ($lo % $C);
-        if ($l > $C) {
+        if ($l>$C) {
             $h += (int)($l / $C);
             $l  = $l % $C;
         }
 
-        if ($h == 0) {
+        if ($h==0) {
             return $l;
         }
         return sprintf('%d%05d', $h, $l);
     }
 
     // x32, int
-    if ($hi == 0) {
-        if ($lo > 0) {
+    if ($hi==0) {
+        if ($lo>0) {
             return $lo;
         }
         return sprintf('%u', $lo);
@@ -216,10 +216,10 @@ 
 
     $h = sprintf('%.0f', $h);
     $l = sprintf('%07.0f', $l);
-    if ($h == '0') {
+    if ($h=='0') {
         return sprintf('%.0f', (float)$l);
     }
-    return $h . $l;
+    return $h.$l;
 }
 
 /**
@@ -234,24 +234,24 @@ 
     list($hi, $lo) = array_values(unpack('N*N*', $value));
 
     // x64
-    if (PHP_INT_SIZE >= 8) {
-        if ($hi < 0) { // because php 5.2.2 to 5.2.5 is totally fucked up again
+    if (PHP_INT_SIZE>=8) {
+        if ($hi<0) { // because php 5.2.2 to 5.2.5 is totally fucked up again
             $hi += 1 << 32;
         }
-        if ($lo < 0) {
+        if ($lo<0) {
             $lo += 1 << 32;
         }
 
         return ($hi << 32) + $lo;
     }
 
-    if ($hi == 0) { // x32, int
-        if ($lo > 0) {
+    if ($hi==0) { // x32, int
+        if ($lo>0) {
             return $lo;
         }
         return sprintf('%u', $lo);
-    } elseif ($hi == -1) { // x32, int
-        if ($lo < 0) {
+    } elseif ($hi==-1) { // x32, int
+        if ($lo<0) {
             return $lo;
         }
         return sprintf('%.0f', $lo - 4294967296.0);
@@ -259,7 +259,7 @@ 
 
     $neg = '';
     $c = 0;
-    if ($hi < 0) {
+    if ($hi<0) {
         $hi = ~$hi;
         $lo = ~$lo;
         $c = 1;
@@ -271,7 +271,7 @@ 
 
     // x32, bcmath
     if (function_exists('bcmul')) {
-        return $neg . bcadd(bcadd($lo, bcmul($hi, '4294967296')), $c);
+        return $neg.bcadd(bcadd($lo, bcmul($hi, '4294967296')), $c);
     }
 
     // x32, no-bcmath
@@ -284,17 +284,17 @@ 
     $mq = floor($m / 10000000.0);
     $l = $m - $mq * 10000000.0 + $c;
     $h = $q * 4294967296.0 + $r * 429.0 + $mq;
-    if ($l == 10000000) {
+    if ($l==10000000) {
         $l = 0;
         $h += 1;
     }
 
     $h = sprintf('%.0f', $h);
     $l = sprintf('%07.0f', $l);
-    if ($h == '0') {
-        return $neg . sprintf('%.0f', (float)$l);
+    if ($h=='0') {
+        return $neg.sprintf('%.0f', (float)$l);
     }
-    return $neg . $h . $l;
+    return $neg.$h.$l;
 }
 
 /**
@@ -304,9 +304,9 @@ 
  */
 function sphFixUint($value)
 {
-    if (PHP_INT_SIZE >= 8) {
+    if (PHP_INT_SIZE>=8) {
         // x64 route, workaround broken unpack() in 5.2.2+
-        if ($value < 0) {
+        if ($value<0) {
             $value += 1 << 32;
         }
         return $value;

src/SphinxClient.php

Spacing +117 added lines, -117 removed lines

@@ -414,7 +414,7 @@ 
 
     public function __destruct()
     {
-        if ($this->socket !== false) {
+        if ($this->socket!==false) {
             fclose($this->socket);
         }
     }
@@ -454,19 +454,19 @@ 
     public function setServer($host, $port = 0)
     {
         assert(is_string($host));
-        if ($host[0] == '/') {
-            $this->path = 'unix://' . $host;
+        if ($host[0]=='/') {
+            $this->path = 'unix://'.$host;
             return;
         }
-        if (substr($host, 0, 7) == 'unix://') {
+        if (substr($host, 0, 7)=='unix://') {
             $this->path = $host;
             return;
         }
 
         $this->host = $host;
         $port = intval($port);
-        assert(0 <= $port && $port < 65536);
-        $this->port = $port == 0 ? 9312 : $port;
+        assert(0<=$port && $port<65536);
+        $this->port = $port==0 ? 9312 : $port;
         $this->path = '';
     }
 
@@ -490,7 +490,7 @@ 
      */
     protected function send($handle, $data, $length)
     {
-        if (feof($handle) || fwrite($handle, $data, $length) !== $length) {
+        if (feof($handle) || fwrite($handle, $data, $length)!==$length) {
             $this->error = 'connection unexpectedly closed (timed out?)';
             $this->conn_error = true;
             return false;
@@ -529,7 +529,7 @@ 
      */
     protected function connect()
     {
-        if ($this->socket !== false) {
+        if ($this->socket!==false) {
             // we are in persistent connection mode, so we have a socket
             // however, need to check whether it's still alive
             if (!@feof($this->socket)) {
@@ -552,7 +552,7 @@ 
             $port = $this->port;
         }
 
-        if ($this->timeout <= 0) {
+        if ($this->timeout<=0) {
             $fp = @fsockopen($host, $port, $errno, $errstr);
         } else {
             $fp = @fsockopen($host, $port, $errno, $errstr, $this->timeout);
@@ -584,7 +584,7 @@ 
         // check version
         list(, $v) = unpack('N*', fread($fp, 4));
         $v = (int)$v;
-        if ($v < 1) {
+        if ($v<1) {
             fclose($fp);
             $this->error = "expected searchd protocol version 1+, got version '$v'";
             return false;
@@ -607,10 +607,10 @@ 
         $len = 0;
 
         $header = fread($fp, 8);
-        if (strlen($header) == 8) {
+        if (strlen($header)==8) {
             list($status, $ver, $len) = array_values(unpack('n2a/Nb', $header));
             $left = $len;
-            while ($left > 0 && !feof($fp)) {
+            while ($left>0 && !feof($fp)) {
                 $chunk = fread($fp, min(8192, $left));
                 if ($chunk) {
                     $response .= $chunk;
@@ -619,13 +619,13 @@ 
             }
         }
 
-        if ($this->socket === false) {
+        if ($this->socket===false) {
             fclose($fp);
         }
 
         // check response
         $read = strlen($response);
-        if (!$response || $read != $len) {
+        if (!$response || $read!=$len) {
             $this->error = $len
                 ? "failed to read searchd response (status=$status, ver=$ver, len=$len, read=$read)"
                 : 'received zero-sized searchd response';
@@ -633,26 +633,26 @@ 
         }
 
         // check status
-        if ($status == self::SEARCHD_WARNING) {
+        if ($status==self::SEARCHD_WARNING) {
             list(, $wlen) = unpack('N*', substr($response, 0, 4));
             $this->warning = substr($response, 4, $wlen);
             return substr($response, 4 + $wlen);
         }
-        if ($status == self::SEARCHD_ERROR) {
-            $this->error = 'searchd error: ' . substr($response, 4);
+        if ($status==self::SEARCHD_ERROR) {
+            $this->error = 'searchd error: '.substr($response, 4);
             return false;
         }
-        if ($status == self::SEARCHD_RETRY) {
-            $this->error = 'temporary searchd error: ' . substr($response, 4);
+        if ($status==self::SEARCHD_RETRY) {
+            $this->error = 'temporary searchd error: '.substr($response, 4);
             return false;
         }
-        if ($status != self::SEARCHD_OK) {
+        if ($status!=self::SEARCHD_OK) {
             $this->error = "unknown status code '$status'";
             return false;
         }
 
         // check version
-        if ($ver < $client_ver) {
+        if ($ver<$client_ver) {
             $this->warning = sprintf(
                 'searchd command v.%d.%d older than client\'s v.%d.%d, some options might not work',
                 $ver >> 8,
@@ -681,15 +681,15 @@ 
     {
         assert(is_int($offset));
         assert(is_int($limit));
-        assert($offset >= 0);
-        assert($limit > 0);
-        assert($max >= 0);
+        assert($offset>=0);
+        assert($limit>0);
+        assert($max>=0);
         $this->offset = $offset;
         $this->limit = $limit;
-        if ($max > 0) {
+        if ($max>0) {
             $this->max_matches = $max;
         }
-        if ($cutoff > 0) {
+        if ($cutoff>0) {
             $this->cutoff = $cutoff;
         }
     }
@@ -702,7 +702,7 @@ 
     public function setMaxQueryTime($max)
     {
         assert(is_int($max));
-        assert($max >= 0);
+        assert($max>=0);
         $this->max_query_time = $max;
     }
 
@@ -735,9 +735,9 @@ 
      * @param int $ranker
      * @param string $rank_expr
      */
-    public function setRankingMode($ranker, $rank_expr='')
+    public function setRankingMode($ranker, $rank_expr = '')
     {
-        assert($ranker === 0 || $ranker >= 1 && $ranker < self::RANK_TOTAL);
+        assert($ranker===0 || $ranker>=1 && $ranker<self::RANK_TOTAL);
         assert(is_string($rank_expr));
         $this->ranker = $ranker;
         $this->rank_expr = $rank_expr;
@@ -760,7 +760,7 @@ 
             self::SORT_EXPR
         )));
         assert(is_string($sort_by));
-        assert($mode == self::SORT_RELEVANCE || strlen($sort_by) > 0);
+        assert($mode==self::SORT_RELEVANCE || strlen($sort_by)>0);
 
         $this->sort = $mode;
         $this->sort_by = $sort_by;
@@ -814,7 +814,7 @@ 
     {
         assert(is_numeric($min));
         assert(is_numeric($max));
-        assert($min <= $max);
+        assert($min<=$max);
 
         $this->min_id = $min;
         $this->max_id = $max;
@@ -878,7 +878,7 @@ 
         assert(is_string($attribute));
         assert(is_numeric($min));
         assert(is_numeric($max));
-        assert($min <= $max);
+        assert($min<=$max);
 
         $this->filters[] = array(
             'type' => self::FILTER_RANGE,
@@ -903,7 +903,7 @@ 
         assert(is_string($attribute));
         assert(is_float($min));
         assert(is_float($max));
-        assert($min <= $max);
+        assert($min<=$max);
 
         $this->filters[] = array(
             'type' => self::FILTER_FLOAT_RANGE,
@@ -983,8 +983,8 @@ 
      */
     public function setRetries($count, $delay = 0)
     {
-        assert(is_int($count) && $count >= 0);
-        assert(is_int($delay) && $delay >= 0);
+        assert(is_int($count) && $count>=0);
+        assert(is_int($delay) && $delay>=0);
         $this->retry_count = $count;
         $this->retry_delay = $delay;
     }
@@ -1060,12 +1060,12 @@ 
             'global_idf',
             'low_priority'
         );
-        $flags = array (
+        $flags = array(
             'reverse_scan' => array(0, 1),
             'sort_method' => array('pq', 'kbuffer'),
             'max_predicted_time' => array(0),
             'boolean_simplify' => array(true, false),
-            'idf' => array ('normalized', 'plain', 'tfidf_normalized', 'tfidf_unnormalized'),
+            'idf' => array('normalized', 'plain', 'tfidf_normalized', 'tfidf_unnormalized'),
             'global_idf' => array(true, false),
             'low_priority' => array(true, false)
         );
@@ -1073,29 +1073,29 @@ 
         assert(isset($flag_name, $known_names));
         assert(
             in_array($flag_value, $flags[$flag_name], true) ||
-            ($flag_name == 'max_predicted_time' && is_int($flag_value) && $flag_value >= 0)
+            ($flag_name=='max_predicted_time' && is_int($flag_value) && $flag_value>=0)
         );
 
         switch ($flag_name) {
             case 'reverse_scan':
-                $this->query_flags = sphSetBit($this->query_flags, 0, $flag_value == 1);
+                $this->query_flags = sphSetBit($this->query_flags, 0, $flag_value==1);
                 break;
             case 'sort_method':
-                $this->query_flags = sphSetBit($this->query_flags, 1, $flag_value == 'kbuffer');
+                $this->query_flags = sphSetBit($this->query_flags, 1, $flag_value=='kbuffer');
                 break;
             case 'max_predicted_time':
-                $this->query_flags = sphSetBit($this->query_flags, 2, $flag_value > 0);
+                $this->query_flags = sphSetBit($this->query_flags, 2, $flag_value>0);
                 $this->predicted_time = (int)$flag_value;
                 break;
             case 'boolean_simplify':
                 $this->query_flags = sphSetBit($this->query_flags, 3, $flag_value);
                 break;
             case 'idf':
-                if ($flag_value == 'normalized' || $flag_value == 'plain') {
-                    $this->query_flags = sphSetBit($this->query_flags, 4, $flag_value == 'plain');
+                if ($flag_value=='normalized' || $flag_value=='plain') {
+                    $this->query_flags = sphSetBit($this->query_flags, 4, $flag_value=='plain');
                 }
-                if ($flag_value == 'tfidf_normalized' || $flag_value == 'tfidf_unnormalized') {
-                    $this->query_flags = sphSetBit($this->query_flags, 6, $flag_value == 'tfidf_normalized');
+                if ($flag_value=='tfidf_normalized' || $flag_value=='tfidf_unnormalized') {
+                    $this->query_flags = sphSetBit($this->query_flags, 6, $flag_value=='tfidf_normalized');
                 }
                 break;
             case 'global_idf':
@@ -1119,8 +1119,8 @@ 
         assert(is_string($order_by));
         assert(is_int($offset));
         assert(is_int($limit));
-        assert($offset >= 0);
-        assert($limit > 0);
+        assert($offset>=0);
+        assert($limit>0);
 
         $this->outer_order_by = $order_by;
         $this->outer_offset = $offset;
@@ -1199,7 +1199,7 @@ 
         $this->error = $results[0]['error'];
         $this->warning = $results[0]['warning'];
 
-        if ($results[0]['status'] == self::SEARCHD_ERROR) {
+        if ($results[0]['status']==self::SEARCHD_ERROR) {
             return false;
         } else {
             return $results[0];
@@ -1237,24 +1237,24 @@ 
 
         // build request
         $req = pack('NNNNN', $this->query_flags, $this->offset, $this->limit, $this->mode, $this->ranker);
-        if ($this->ranker == self::RANK_EXPR) {
-            $req .= pack('N', strlen($this->rank_expr)) . $this->rank_expr;
+        if ($this->ranker==self::RANK_EXPR) {
+            $req .= pack('N', strlen($this->rank_expr)).$this->rank_expr;
         }
         $req .= pack('N', $this->sort); // (deprecated) sort mode
-        $req .= pack('N', strlen($this->sort_by)) . $this->sort_by;
-        $req .= pack('N', strlen($query)) . $query; // query itself
+        $req .= pack('N', strlen($this->sort_by)).$this->sort_by;
+        $req .= pack('N', strlen($query)).$query; // query itself
         $req .= pack('N', count($this->weights)); // weights
         foreach ($this->weights as $weight) {
             $req .= pack('N', (int)$weight);
         }
-        $req .= pack('N', strlen($index)) . $index; // indexes
+        $req .= pack('N', strlen($index)).$index; // indexes
         $req .= pack('N', 1); // id64 range marker
-        $req .= sphPackU64($this->min_id) . sphPackU64($this->max_id); // id64 range
+        $req .= sphPackU64($this->min_id).sphPackU64($this->max_id); // id64 range
 
         // filters
         $req .= pack('N', count($this->filters));
         foreach ($this->filters as $filter) {
-            $req .= pack('N', strlen($filter['attr'])) . $filter['attr'];
+            $req .= pack('N', strlen($filter['attr'])).$filter['attr'];
             $req .= pack('N', $filter['type']);
             switch ($filter['type']) {
                 case self::FILTER_VALUES:
@@ -1264,13 +1264,13 @@ 
                     }
                     break;
                 case self::FILTER_RANGE:
-                    $req .= sphPackI64($filter['min']) . sphPackI64($filter['max']);
+                    $req .= sphPackI64($filter['min']).sphPackI64($filter['max']);
                     break;
                 case self::FILTER_FLOAT_RANGE:
-                    $req .= $this->packFloat($filter['min']) . $this->packFloat($filter['max']);
+                    $req .= $this->packFloat($filter['min']).$this->packFloat($filter['max']);
                     break;
                 case self::FILTER_STRING:
-                    $req .= pack('N', strlen($filter['value'])) . $filter['value'];
+                    $req .= pack('N', strlen($filter['value'])).$filter['value'];
                     break;
                 default:
                     assert(0 && 'internal error: unhandled filter type');
@@ -1279,27 +1279,27 @@ 
         }
 
         // group-by clause, max-matches count, group-sort clause, cutoff count
-        $req .= pack('NN', $this->group_func, strlen($this->group_by)) . $this->group_by;
+        $req .= pack('NN', $this->group_func, strlen($this->group_by)).$this->group_by;
         $req .= pack('N', $this->max_matches);
-        $req .= pack('N', strlen($this->group_sort)) . $this->group_sort;
+        $req .= pack('N', strlen($this->group_sort)).$this->group_sort;
         $req .= pack('NNN', $this->cutoff, $this->retry_count, $this->retry_delay);
-        $req .= pack('N', strlen($this->group_distinct)) . $this->group_distinct;
+        $req .= pack('N', strlen($this->group_distinct)).$this->group_distinct;
 
         // anchor point
         if (empty($this->anchor)) {
             $req .= pack('N', 0);
         } else {
-            $a =& $this->anchor;
+            $a = & $this->anchor;
             $req .= pack('N', 1);
-            $req .= pack('N', strlen($a['attrlat'])) . $a['attrlat'];
-            $req .= pack('N', strlen($a['attrlong'])) . $a['attrlong'];
-            $req .= $this->packFloat($a['lat']) . $this->packFloat($a['long']);
+            $req .= pack('N', strlen($a['attrlat'])).$a['attrlat'];
+            $req .= pack('N', strlen($a['attrlong'])).$a['attrlong'];
+            $req .= $this->packFloat($a['lat']).$this->packFloat($a['long']);
         }
 
         // per-index weights
         $req .= pack('N', count($this->index_weights));
         foreach ($this->index_weights as $idx => $weight) {
-            $req .= pack('N', strlen($idx)) . $idx . pack('N', $weight);
+            $req .= pack('N', strlen($idx)).$idx.pack('N', $weight);
         }
 
         // max query time
@@ -1308,16 +1308,16 @@ 
         // per-field weights
         $req .= pack('N', count($this->field_weights));
         foreach ($this->field_weights as $field => $weight) {
-            $req .= pack('N', strlen($field)) . $field . pack('N', $weight);
+            $req .= pack('N', strlen($field)).$field.pack('N', $weight);
         }
 
         // comment
-        $req .= pack('N', strlen($comment)) . $comment;
+        $req .= pack('N', strlen($comment)).$comment;
 
         // attribute overrides
         $req .= pack('N', count($this->overrides));
         foreach ($this->overrides as $key => $entry) {
-            $req .= pack('N', strlen($entry['attr'])) . $entry['attr'];
+            $req .= pack('N', strlen($entry['attr'])).$entry['attr'];
             $req .= pack('NN', $entry['type'], count($entry['values']));
             foreach ($entry['values'] as $id => $val) {
                 assert(is_numeric($id));
@@ -1339,14 +1339,14 @@ 
         }
 
         // select-list
-        $req .= pack('N', strlen($this->select)) . $this->select;
+        $req .= pack('N', strlen($this->select)).$this->select;
 
         // max_predicted_time
-        if ($this->predicted_time > 0) {
+        if ($this->predicted_time>0) {
             $req .= pack('N', (int)$this->predicted_time);
         }
 
-        $req .= pack('N', strlen($this->outer_order_by)) . $this->outer_order_by;
+        $req .= pack('N', strlen($this->outer_order_by)).$this->outer_order_by;
         $req .= pack('NN', $this->outer_offset, $this->outer_limit);
         if ($this->has_outer) {
             $req .= pack('N', 1);
@@ -1386,7 +1386,7 @@ 
         $nreqs = count($this->reqs);
         $req = join('', $this->reqs);
         $len = 8 + strlen($req);
-        $req = pack('nnNNN', self::SEARCHD_COMMAND_SEARCH, self::VER_COMMAND_SEARCH, $len, 0, $nreqs) . $req; // add header
+        $req = pack('nnNNN', self::SEARCHD_COMMAND_SEARCH, self::VER_COMMAND_SEARCH, $len, 0, $nreqs).$req; // add header
 
         if (!$this->send($fp, $req, $len + 8) || !($response = $this->getResponse($fp, self::VER_COMMAND_SEARCH))) {
             $this->mbPop();
@@ -1414,9 +1414,9 @@ 
         $max = strlen($response); // max position for checks, to protect against broken responses
 
         $results = array();
-        for ($ires = 0; $ires < $nreqs && $p < $max; $ires++) {
+        for ($ires = 0; $ires<$nreqs && $p<$max; $ires++) {
             $results[] = array();
-            $result =& $results[$ires];
+            $result = & $results[$ires];
 
             $result['error'] = '';
             $result['warning'] = '';
@@ -1425,13 +1425,13 @@ 
             list(, $status) = unpack('N*', substr($response, $p, 4));
             $p += 4;
             $result['status'] = $status;
-            if ($status != self::SEARCHD_OK) {
+            if ($status!=self::SEARCHD_OK) {
                 list(, $len) = unpack('N*', substr($response, $p, 4));
                 $p += 4;
                 $message = substr($response, $p, $len);
                 $p += $len;
 
-                if ($status == self::SEARCHD_WARNING) {
+                if ($status==self::SEARCHD_WARNING) {
                     $result['warning'] = $message;
                 } else {
                     $result['error'] = $message;
@@ -1445,7 +1445,7 @@ 
 
             list(, $nfields) = unpack('N*', substr($response, $p, 4));
             $p += 4;
-            while ($nfields --> 0 && $p < $max) {
+            while ($nfields-->0 && $p<$max) {
                 list(, $len) = unpack('N*', substr($response, $p, 4));
                 $p += 4;
                 $fields[] = substr($response, $p, $len);
@@ -1455,7 +1455,7 @@ 
 
             list(, $nattrs) = unpack('N*', substr($response, $p, 4));
             $p += 4;
-            while ($nattrs --> 0 && $p < $max) {
+            while ($nattrs-->0 && $p<$max) {
                 list(, $len) = unpack('N*', substr($response, $p, 4));
                 $p += 4;
                 $attr = substr($response, $p, $len);
@@ -1474,7 +1474,7 @@ 
 
             // read matches
             $idx = -1;
-            while ($count --> 0 && $p < $max) {
+            while ($count-->0 && $p<$max) {
                 // index into result array
                 $idx++;
 
@@ -1502,14 +1502,14 @@ 
                 $attrvals = array();
                 foreach ($attrs as $attr => $type) {
                     // handle 64bit ints
-                    if ($type == self::ATTR_BIGINT) {
+                    if ($type==self::ATTR_BIGINT) {
                         $attrvals[$attr] = sphUnpackI64(substr($response, $p, 8));
                         $p += 8;
                         continue;
                     }
 
                     // handle floats
-                    if ($type == self::ATTR_FLOAT) {
+                    if ($type==self::ATTR_FLOAT) {
                         list(, $uval) = unpack('N*', substr($response, $p, 4));
                         $p += 4;
                         list(, $fval) = unpack('f*', pack('L', $uval));
@@ -1520,28 +1520,28 @@ 
                     // handle everything else as unsigned ints
                     list(, $val) = unpack('N*', substr($response, $p, 4));
                     $p += 4;
-                    if ($type == self::ATTR_MULTI) {
+                    if ($type==self::ATTR_MULTI) {
                         $attrvals[$attr] = array();
                         $nvalues = $val;
-                        while ($nvalues --> 0 && $p < $max) {
+                        while ($nvalues-->0 && $p<$max) {
                             list(, $val) = unpack('N*', substr($response, $p, 4));
                             $p += 4;
                             $attrvals[$attr][] = sphFixUint($val);
                         }
-                    } elseif ($type == self::ATTR_MULTI64) {
+                    } elseif ($type==self::ATTR_MULTI64) {
                         $attrvals[$attr] = array();
                         $nvalues = $val;
-                        while ($nvalues > 0 && $p < $max) {
+                        while ($nvalues>0 && $p<$max) {
                             $attrvals[$attr][] = sphUnpackI64(substr($response, $p, 8));
                             $p += 8;
                             $nvalues -= 2;
                         }
-                    } elseif ($type == self::ATTR_STRING) {
+                    } elseif ($type==self::ATTR_STRING) {
                         $attrvals[$attr] = substr($response, $p, $val);
                         $p += $val;
-                    } elseif ($type == self::ATTR_FACTORS) {
+                    } elseif ($type==self::ATTR_FACTORS) {
                         $attrvals[$attr] = substr($response, $p, $val - 4);
-                        $p += $val-4;
+                        $p += $val - 4;
                     } else {
                         $attrvals[$attr] = sphFixUint($val);
                     }
@@ -1560,14 +1560,14 @@ 
             $result['time'] = sprintf('%.3f', $msecs / 1000);
             $p += 16;
 
-            while ($words --> 0 && $p < $max) {
+            while ($words-->0 && $p<$max) {
                 list(, $len) = unpack('N*', substr($response, $p, 4));
                 $p += 4;
                 $word = substr($response, $p, $len);
                 $p += $len;
                 list($docs, $hits) = array_values(unpack('N*N*', substr($response, $p, 8)));
                 $p += 8;
-                $result['words'][$word] = array (
+                $result['words'][$word] = array(
                     'docs' => sprintf('%u', $docs),
                     'hits' => sprintf('%u', $hits)
                 );
@@ -1669,23 +1669,23 @@ 
             $flags |= 1024;
         }
         $req = pack('NN', 0, $flags); // mode=0, flags=$flags
-        $req .= pack('N', strlen($index)) . $index; // req index
-        $req .= pack('N', strlen($words)) . $words; // req words
+        $req .= pack('N', strlen($index)).$index; // req index
+        $req .= pack('N', strlen($words)).$words; // req words
 
         // options
-        $req .= pack('N', strlen($opts['before_match'])) . $opts['before_match'];
-        $req .= pack('N', strlen($opts['after_match'])) . $opts['after_match'];
-        $req .= pack('N', strlen($opts['chunk_separator'])) . $opts['chunk_separator'];
+        $req .= pack('N', strlen($opts['before_match'])).$opts['before_match'];
+        $req .= pack('N', strlen($opts['after_match'])).$opts['after_match'];
+        $req .= pack('N', strlen($opts['chunk_separator'])).$opts['chunk_separator'];
         $req .= pack('NN', (int)$opts['limit'], (int)$opts['around']);
         $req .= pack('NNN', (int)$opts['limit_passages'], (int)$opts['limit_words'], (int)$opts['start_passage_id']); // v.1.2
-        $req .= pack('N', strlen($opts['html_strip_mode'])) . $opts['html_strip_mode'];
-        $req .= pack('N', strlen($opts['passage_boundary'])) . $opts['passage_boundary'];
+        $req .= pack('N', strlen($opts['html_strip_mode'])).$opts['html_strip_mode'];
+        $req .= pack('N', strlen($opts['passage_boundary'])).$opts['passage_boundary'];
 
         // documents
         $req .= pack('N', count($docs));
         foreach ($docs as $doc) {
             assert(is_string($doc));
-            $req .= pack('N', strlen($doc)) . $doc;
+            $req .= pack('N', strlen($doc)).$doc;
         }
 
         ////////////////////////////
@@ -1693,7 +1693,7 @@ 
         ////////////////////////////
 
         $len = strlen($req);
-        $req = pack('nnN', self::SEARCHD_COMMAND_EXCERPT, self::VER_COMMAND_EXCERPT, $len) . $req; // add header
+        $req = pack('nnN', self::SEARCHD_COMMAND_EXCERPT, self::VER_COMMAND_EXCERPT, $len).$req; // add header
         if (!$this->send($fp, $req, $len + 8) || !($response = $this->getResponse($fp, self::VER_COMMAND_EXCERPT))) {
             $this->mbPop();
             return false;
@@ -1711,7 +1711,7 @@ 
             list(, $len) = unpack('N*', substr($response, $pos, 4));
             $pos += 4;
 
-            if ($pos + $len > $rlen) {
+            if ($pos + $len>$rlen) {
                 $this->error = 'incomplete reply';
                 $this->mbPop();
                 return false;
@@ -1757,8 +1757,8 @@ 
         /////////////////
 
         // v.1.0 req
-        $req  = pack('N', strlen($query)) . $query; // req query
-        $req .= pack('N', strlen($index)) . $index; // req index
+        $req  = pack('N', strlen($query)).$query; // req query
+        $req .= pack('N', strlen($index)).$index; // req index
         $req .= pack('N', (int)$hits);
 
         ////////////////////////////
@@ -1766,7 +1766,7 @@ 
         ////////////////////////////
 
         $len = strlen($req);
-        $req = pack('nnN', self::SEARCHD_COMMAND_KEYWORDS, self::VER_COMMAND_KEYWORDS, $len) . $req; // add header
+        $req = pack('nnN', self::SEARCHD_COMMAND_KEYWORDS, self::VER_COMMAND_KEYWORDS, $len).$req; // add header
         if (!$this->send($fp, $req, $len + 8) || !($response = $this->getResponse($fp, self::VER_COMMAND_KEYWORDS))) {
             $this->mbPop();
             return false;
@@ -1781,7 +1781,7 @@ 
         $rlen = strlen($response);
         list(, $nwords) = unpack('N*', substr($response, $pos, 4));
         $pos += 4;
-        for ($i = 0; $i < $nwords; $i++) {
+        for ($i = 0; $i<$nwords; $i++) {
             list(, $len) = unpack('N*', substr($response, $pos, 4));
             $pos += 4;
             $tokenized = $len ? substr($response, $pos, $len) : '';
@@ -1804,7 +1804,7 @@ 
                 $res[$i]['hits'] = $nhits;
             }
 
-            if ($pos > $rlen) {
+            if ($pos>$rlen) {
                 $this->error = 'incomplete reply';
                 $this->mbPop();
                 return false;
@@ -1822,8 +1822,8 @@ 
      */
     public function escapeString($string)
     {
-        $from = array('\\', '(',')','|','-','!','@','~','"','&', '/', '^', '$', '=', '<');
-        $to   = array('\\\\', '\(','\)','\|','\-','\!','\@','\~','\"', '\&', '\/', '\^', '\$', '\=', '\<');
+        $from = array('\\', '(', ')', '|', '-', '!', '@', '~', '"', '&', '/', '^', '$', '=', '<');
+        $to   = array('\\\\', '\(', '\)', '\|', '\-', '\!', '\@', '\~', '\"', '\&', '\/', '\^', '\$', '\=', '\<');
 
         return str_replace($from, $to, $string);
     }
@@ -1858,7 +1858,7 @@ 
         foreach ($values as $id => $entry) {
             assert(is_numeric($id));
             assert(is_array($entry));
-            assert(count($entry) == count($attrs));
+            assert(count($entry)==count($attrs));
             foreach ($entry as $v) {
                 if ($mva) {
                     assert(is_array($v));
@@ -1873,12 +1873,12 @@ 
 
         // build request
         $this->mbPush();
-        $req = pack('N', strlen($index)) . $index;
+        $req = pack('N', strlen($index)).$index;
 
         $req .= pack('N', count($attrs));
         $req .= pack('N', $ignore_non_existent ? 1 : 0);
         foreach ($attrs as $attr) {
-            $req .= pack('N', strlen($attr)) . $attr;
+            $req .= pack('N', strlen($attr)).$attr;
             $req .= pack('N', $mva ? 1 : 0);
         }
 
@@ -1902,7 +1902,7 @@ 
         }
 
         $len = strlen($req);
-        $req = pack('nnN', self::SEARCHD_COMMAND_UPDATE, self::VER_COMMAND_UPDATE, $len) . $req; // add header
+        $req = pack('nnN', self::SEARCHD_COMMAND_UPDATE, self::VER_COMMAND_UPDATE, $len).$req; // add header
         if (!$this->send($fp, $req, $len + 8)) {
             $this->mbPop();
             return -1;
@@ -1928,7 +1928,7 @@ 
      */
     public function open()
     {
-        if ($this->socket !== false) {
+        if ($this->socket!==false) {
             $this->error = 'already connected';
             return false;
         }
@@ -1950,7 +1950,7 @@ 
      */
     public function close()
     {
-        if ($this->socket === false) {
+        if ($this->socket===false) {
             $this->error = 'not connected';
             return false;
         }
@@ -1992,8 +1992,8 @@ 
         $p += 8;
 
         $res = array();
-        for ($i = 0; $i < $rows; $i++) {
-            for ($j = 0; $j < $cols; $j++) {
+        for ($i = 0; $i<$rows; $i++) {
+            for ($j = 0; $j<$cols; $j++) {
                 list(, $len) = unpack('N*', substr($response, $p, 4));
                 $p += 4;
                 $res[$i][] = substr($response, $p, $len);
@@ -2027,7 +2027,7 @@ 
         }
 
         $tag = -1;
-        if (strlen($response) == 4) {
+        if (strlen($response)==4) {
             list(, $tag) = unpack('N*', $response);
         } else {
             $this->error = 'unexpected response length';

src/const.php

Spacing +52 added lines, -52 removed lines

@@ -2,59 +2,59 @@ 
 
 // known searchd commands
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_SEARCH */
-define('SEARCHD_COMMAND_SEARCH',     0);
+define('SEARCHD_COMMAND_SEARCH', 0);
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_EXCERPT */
-define('SEARCHD_COMMAND_EXCERPT',    1);
+define('SEARCHD_COMMAND_EXCERPT', 1);
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_UPDATE */
-define('SEARCHD_COMMAND_UPDATE',     2);
+define('SEARCHD_COMMAND_UPDATE', 2);
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_KEYWORDS */
-define('SEARCHD_COMMAND_KEYWORDS',   3);
+define('SEARCHD_COMMAND_KEYWORDS', 3);
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_PERSIST */
-define('SEARCHD_COMMAND_PERSIST',    4);
+define('SEARCHD_COMMAND_PERSIST', 4);
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_STATUS */
-define('SEARCHD_COMMAND_STATUS',     5);
+define('SEARCHD_COMMAND_STATUS', 5);
 /* @deprecated use SphinxClient::SEARCHD_COMMAND_FLUSHATTRS */
 define('SEARCHD_COMMAND_FLUSHATTRS', 7);
 
 // current client-side command implementation versions
 /* @deprecated use SphinxClient::VER_COMMAND_SEARCH */
-define('VER_COMMAND_SEARCH',     0x11E);
+define('VER_COMMAND_SEARCH', 0x11E);
 /* @deprecated use SphinxClient::VER_COMMAND_EXCERPT */
-define('VER_COMMAND_EXCERPT',    0x104);
+define('VER_COMMAND_EXCERPT', 0x104);
 /* @deprecated use SphinxClient::VER_COMMAND_UPDATE */
-define('VER_COMMAND_UPDATE',     0x103);
+define('VER_COMMAND_UPDATE', 0x103);
 /* @deprecated use SphinxClient::VER_COMMAND_KEYWORDS */
-define('VER_COMMAND_KEYWORDS',   0x100);
+define('VER_COMMAND_KEYWORDS', 0x100);
 /* @deprecated use SphinxClient::VER_COMMAND_STATUS */
-define('VER_COMMAND_STATUS',     0x101);
+define('VER_COMMAND_STATUS', 0x101);
 /* @deprecated use SphinxClient::VER_COMMAND_QUERY */
-define('VER_COMMAND_QUERY',      0x100);
+define('VER_COMMAND_QUERY', 0x100);
 /* @deprecated use SphinxClient::VER_COMMAND_FLUSH_ATTRS */
 define('VER_COMMAND_FLUSHATTRS', 0x100);
 
 // known searchd status codes
 /* @deprecated use SphinxClient::SEARCHD_OK */
-define('SEARCHD_OK',      0);
+define('SEARCHD_OK', 0);
 /* @deprecated use SphinxClient::SEARCHD_ERROR */
-define('SEARCHD_ERROR',   1);
+define('SEARCHD_ERROR', 1);
 /* @deprecated use SphinxClient::SEARCHD_RETRY */
-define('SEARCHD_RETRY',   2);
+define('SEARCHD_RETRY', 2);
 /* @deprecated use SphinxClient::SEARCHD_WARNING */
 define('SEARCHD_WARNING', 3);
 
 // known match modes
 /* @deprecated use SphinxClient::MATCH_ALL */
-define('SPH_MATCH_ALL',       0);
+define('SPH_MATCH_ALL', 0);
 /* @deprecated use SphinxClient::MATCH_ANY */
-define('SPH_MATCH_ANY',       1);
+define('SPH_MATCH_ANY', 1);
 /* @deprecated use SphinxClient::MATCH_PHRASE */
-define('SPH_MATCH_PHRASE',    2);
+define('SPH_MATCH_PHRASE', 2);
 /* @deprecated use SphinxClient::MATCH_BOOLEAN */
-define('SPH_MATCH_BOOLEAN',   3);
+define('SPH_MATCH_BOOLEAN', 3);
 /* @deprecated use SphinxClient::MATCH_EXTENDED */
-define('SPH_MATCH_EXTENDED',  4);
+define('SPH_MATCH_EXTENDED', 4);
 /* @deprecated use SphinxClient::MATCH_FULL_SCAN */
-define('SPH_MATCH_FULLSCAN',  5);
+define('SPH_MATCH_FULLSCAN', 5);
 /* @deprecated use SphinxClient::MATCH_EXTENDED2 */
 define('SPH_MATCH_EXTENDED2', 6); // extended engine V2 (TEMPORARY, WILL BE REMOVED)
 
@@ -62,80 +62,80 @@ 
 /* @deprecated use SphinxClient::RANK_PROXIMITY_BM25 */
 define('SPH_RANK_PROXIMITY_BM25', 0); // default mode, phrase proximity major factor and BM25 minor one
 /* @deprecated use SphinxClient::RANK_BM25 */
-define('SPH_RANK_BM25',           1); // statistical mode, BM25 ranking only (faster but worse quality)
+define('SPH_RANK_BM25', 1); // statistical mode, BM25 ranking only (faster but worse quality)
 /* @deprecated use SphinxClient::RANK_NONE */
-define('SPH_RANK_NONE',           2); // no ranking, all matches get a weight of 1
+define('SPH_RANK_NONE', 2); // no ranking, all matches get a weight of 1
 /* @deprecated use SphinxClient::RANK_WORD_COUNT */
-define('SPH_RANK_WORDCOUNT',      3); // simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts
+define('SPH_RANK_WORDCOUNT', 3); // simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts
 /* @deprecated use SphinxClient::RANK_PROXIMITY */
-define('SPH_RANK_PROXIMITY',      4);
+define('SPH_RANK_PROXIMITY', 4);
 /* @deprecated use SphinxClient::RANK_MATCH_ANY */
-define('SPH_RANK_MATCHANY',       5);
+define('SPH_RANK_MATCHANY', 5);
 /* @deprecated use SphinxClient::RANK_FIELD_MASK */
-define('SPH_RANK_FIELDMASK',      6);
+define('SPH_RANK_FIELDMASK', 6);
 /* @deprecated use SphinxClient::RANK_SPH04 */
-define('SPH_RANK_SPH04',          7);
+define('SPH_RANK_SPH04', 7);
 /* @deprecated use SphinxClient::RANK_EXPR */
-define('SPH_RANK_EXPR',           8);
+define('SPH_RANK_EXPR', 8);
 /* @deprecated use SphinxClient::RANK_TOTAL */
-define('SPH_RANK_TOTAL',          9);
+define('SPH_RANK_TOTAL', 9);
 
 // known sort modes
 /* @deprecated use SphinxClient::SORT_RELEVANCE */
-define('SPH_SORT_RELEVANCE',     0);
+define('SPH_SORT_RELEVANCE', 0);
 /* @deprecated use SphinxClient::SORT_ATTR_DESC */
-define('SPH_SORT_ATTR_DESC',     1);
+define('SPH_SORT_ATTR_DESC', 1);
 /* @deprecated use SphinxClient::SORT_ATTR_ASC */
-define('SPH_SORT_ATTR_ASC',      2);
+define('SPH_SORT_ATTR_ASC', 2);
 /* @deprecated use SphinxClient::SORT_TIME_SEGMENTS */
 define('SPH_SORT_TIME_SEGMENTS', 3);
 /* @deprecated use SphinxClient::SORT_EXTENDED */
-define('SPH_SORT_EXTENDED',      4);
+define('SPH_SORT_EXTENDED', 4);
 /* @deprecated use SphinxClient::SORT_EXPR */
-define('SPH_SORT_EXPR',          5);
+define('SPH_SORT_EXPR', 5);
 
 // known filter types
 /* @deprecated use SphinxClient::FILTER_VALUES */
-define('SPH_FILTER_VALUES',     0);
+define('SPH_FILTER_VALUES', 0);
 /* @deprecated use SphinxClient::FILTER_RANGE */
-define('SPH_FILTER_RANGE',      1);
+define('SPH_FILTER_RANGE', 1);
 /* @deprecated use SphinxClient::FILTER_FLOAT_RANGE */
 define('SPH_FILTER_FLOATRANGE', 2);
 /* @deprecated use SphinxClient::FILTER_STRING */
-define('SPH_FILTER_STRING',     3);
+define('SPH_FILTER_STRING', 3);
 
 // known attribute types
 /* @deprecated use SphinxClient::ATTR_INTEGER */
-define('SPH_ATTR_INTEGER',   1);
+define('SPH_ATTR_INTEGER', 1);
 /* @deprecated use SphinxClient::ATTR_TIMESTAMP */
 define('SPH_ATTR_TIMESTAMP', 2);
 /* @deprecated use SphinxClient::ATTR_ORDINAL */
-define('SPH_ATTR_ORDINAL',   3);
+define('SPH_ATTR_ORDINAL', 3);
 /* @deprecated use SphinxClient::ATTR_BOOL */
-define('SPH_ATTR_BOOL',      4);
+define('SPH_ATTR_BOOL', 4);
 /* @deprecated use SphinxClient::ATTR_FLOAT */
-define('SPH_ATTR_FLOAT',     5);
+define('SPH_ATTR_FLOAT', 5);
 /* @deprecated use SphinxClient::ATTR_BIGINT */
-define('SPH_ATTR_BIGINT',    6);
+define('SPH_ATTR_BIGINT', 6);
 /* @deprecated use SphinxClient::ATTR_STRING */
-define('SPH_ATTR_STRING',    7);
+define('SPH_ATTR_STRING', 7);
 /* @deprecated use SphinxClient::ATTR_FACTORS */
-define('SPH_ATTR_FACTORS',   1001);
+define('SPH_ATTR_FACTORS', 1001);
 /* @deprecated use SphinxClient::ATTR_MULTI */
-define('SPH_ATTR_MULTI',     0x40000001);
+define('SPH_ATTR_MULTI', 0x40000001);
 /* @deprecated use SphinxClient::ATTR_MULTI64 */
-define('SPH_ATTR_MULTI64',   0x40000002);
+define('SPH_ATTR_MULTI64', 0x40000002);
 
 // known grouping functions
 /* @deprecated use SphinxClient::GROUP_BY_DAY */
-define('SPH_GROUPBY_DAY',      0);
+define('SPH_GROUPBY_DAY', 0);
 /* @deprecated use SphinxClient::GROUP_BY_WEEK */
-define('SPH_GROUPBY_WEEK',     1);
+define('SPH_GROUPBY_WEEK', 1);
 /* @deprecated use SphinxClient::GROUP_BY_MONTH */
-define('SPH_GROUPBY_MONTH',    2);
+define('SPH_GROUPBY_MONTH', 2);
 /* @deprecated use SphinxClient::GROUP_BY_YEAR */
-define('SPH_GROUPBY_YEAR',     3);
+define('SPH_GROUPBY_YEAR', 3);
 /* @deprecated use SphinxClient::GROUP_BY_ATTR */
-define('SPH_GROUPBY_ATTR',     4);
+define('SPH_GROUPBY_ATTR', 4);
 /* @deprecated use SphinxClient::GROUP_BY_ATTR_PAIR */
 define('SPH_GROUPBY_ATTRPAIR', 5);