diff --git a/lib/php/coding_standards.md b/lib/php/coding_standards.md
index fa0390b..e217539 100644
--- a/lib/php/coding_standards.md
+++ b/lib/php/coding_standards.md
@@ -1 +1,5 @@
-Please follow [General Coding Standards](/doc/coding_standards.md)
+## PHP Coding Standards
+
+Please follow:
+ * [Thrift General Coding Standards](/doc/coding_standards.md)
+ * [PSR-2](http://www.php-fig.org/psr/psr-2/)
diff --git a/lib/php/lib/Base/TBase.php b/lib/php/lib/Base/TBase.php
index 4195f75..f2c514a 100644
--- a/lib/php/lib/Base/TBase.php
+++ b/lib/php/lib/Base/TBase.php
@@ -33,348 +33,350 @@
  */
 abstract class TBase
 {
-  static $tmethod = array(TType::BOOL   => 'Bool',
-                          TType::BYTE   => 'Byte',
-                          TType::I16    => 'I16',
-                          TType::I32    => 'I32',
-                          TType::I64    => 'I64',
-                          TType::DOUBLE => 'Double',
-                          TType::STRING => 'String');
+    static public $tmethod = array(
+        TType::BOOL => 'Bool',
+        TType::BYTE => 'Byte',
+        TType::I16 => 'I16',
+        TType::I32 => 'I32',
+        TType::I64 => 'I64',
+        TType::DOUBLE => 'Double',
+        TType::STRING => 'String'
+    );
 
-  abstract public function read($input);
+    abstract public function read($input);
 
-  abstract public function write($output);
+    abstract public function write($output);
 
-  public function __construct($spec=null, $vals=null)
-  {
-    if (is_array($spec) && is_array($vals)) {
-      foreach ($spec as $fid => $fspec) {
-        $var = $fspec['var'];
-        if (isset($vals[$var])) {
-          $this->$var = $vals[$var];
-        }
-      }
-    }
-  }
-
-  public function __wakeup()
-  {
-    $this->__construct(get_object_vars($this));
-  }
-
-  private function _readMap(&$var, $spec, $input)
-  {
-    $xfer = 0;
-    $ktype = $spec['ktype'];
-    $vtype = $spec['vtype'];
-    $kread = $vread = null;
-    if (isset(TBase::$tmethod[$ktype])) {
-      $kread = 'read'.TBase::$tmethod[$ktype];
-    } else {
-      $kspec = $spec['key'];
-    }
-    if (isset(TBase::$tmethod[$vtype])) {
-      $vread = 'read'.TBase::$tmethod[$vtype];
-    } else {
-      $vspec = $spec['val'];
-    }
-    $var = array();
-    $_ktype = $_vtype = $size = 0;
-    $xfer += $input->readMapBegin($_ktype, $_vtype, $size);
-    for ($i = 0; $i < $size; ++$i) {
-      $key = $val = null;
-      if ($kread !== null) {
-        $xfer += $input->$kread($key);
-      } else {
-        switch ($ktype) {
-        case TType::STRUCT:
-          $class = $kspec['class'];
-          $key = new $class();
-          $xfer += $key->read($input);
-          break;
-        case TType::MAP:
-          $xfer += $this->_readMap($key, $kspec, $input);
-          break;
-        case TType::LST:
-          $xfer += $this->_readList($key, $kspec, $input, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_readList($key, $kspec, $input, true);
-          break;
-        }
-      }
-      if ($vread !== null) {
-        $xfer += $input->$vread($val);
-      } else {
-        switch ($vtype) {
-        case TType::STRUCT:
-          $class = $vspec['class'];
-          $val = new $class();
-          $xfer += $val->read($input);
-          break;
-        case TType::MAP:
-          $xfer += $this->_readMap($val, $vspec, $input);
-          break;
-        case TType::LST:
-          $xfer += $this->_readList($val, $vspec, $input, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_readList($val, $vspec, $input, true);
-          break;
-        }
-      }
-      $var[$key] = $val;
-    }
-    $xfer += $input->readMapEnd();
-
-    return $xfer;
-  }
-
-  private function _readList(&$var, $spec, $input, $set=false)
-  {
-    $xfer = 0;
-    $etype = $spec['etype'];
-    $eread = $vread = null;
-    if (isset(TBase::$tmethod[$etype])) {
-      $eread = 'read'.TBase::$tmethod[$etype];
-    } else {
-      $espec = $spec['elem'];
-    }
-    $var = array();
-    $_etype = $size = 0;
-    if ($set) {
-      $xfer += $input->readSetBegin($_etype, $size);
-    } else {
-      $xfer += $input->readListBegin($_etype, $size);
-    }
-    for ($i = 0; $i < $size; ++$i) {
-      $elem = null;
-      if ($eread !== null) {
-        $xfer += $input->$eread($elem);
-      } else {
-        $espec = $spec['elem'];
-        switch ($etype) {
-        case TType::STRUCT:
-          $class = $espec['class'];
-          $elem = new $class();
-          $xfer += $elem->read($input);
-          break;
-        case TType::MAP:
-          $xfer += $this->_readMap($elem, $espec, $input);
-          break;
-        case TType::LST:
-          $xfer += $this->_readList($elem, $espec, $input, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_readList($elem, $espec, $input, true);
-          break;
-        }
-      }
-      if ($set) {
-        $var[$elem] = true;
-      } else {
-        $var []= $elem;
-      }
-    }
-    if ($set) {
-      $xfer += $input->readSetEnd();
-    } else {
-      $xfer += $input->readListEnd();
-    }
-
-    return $xfer;
-  }
-
-  protected function _read($class, $spec, $input)
-  {
-    $xfer = 0;
-    $fname = null;
-    $ftype = 0;
-    $fid = 0;
-    $xfer += $input->readStructBegin($fname);
-    while (true) {
-      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-      if ($ftype == TType::STOP) {
-        break;
-      }
-      if (isset($spec[$fid])) {
-        $fspec = $spec[$fid];
-        $var = $fspec['var'];
-        if ($ftype == $fspec['type']) {
-          $xfer = 0;
-          if (isset(TBase::$tmethod[$ftype])) {
-            $func = 'read'.TBase::$tmethod[$ftype];
-            $xfer += $input->$func($this->$var);
-          } else {
-            switch ($ftype) {
-            case TType::STRUCT:
-              $class = $fspec['class'];
-              $this->$var = new $class();
-              $xfer += $this->$var->read($input);
-              break;
-            case TType::MAP:
-              $xfer += $this->_readMap($this->$var, $fspec, $input);
-              break;
-            case TType::LST:
-              $xfer += $this->_readList($this->$var, $fspec, $input, false);
-              break;
-            case TType::SET:
-              $xfer += $this->_readList($this->$var, $fspec, $input, true);
-              break;
+    public function __construct($spec = null, $vals = null)
+    {
+        if (is_array($spec) && is_array($vals)) {
+            foreach ($spec as $fid => $fspec) {
+                $var = $fspec['var'];
+                if (isset($vals[$var])) {
+                    $this->$var = $vals[$var];
+                }
             }
-          }
+        }
+    }
+
+    public function __wakeup()
+    {
+        $this->__construct(get_object_vars($this));
+    }
+
+    private function _readMap(&$var, $spec, $input)
+    {
+        $xfer = 0;
+        $ktype = $spec['ktype'];
+        $vtype = $spec['vtype'];
+        $kread = $vread = null;
+        if (isset(TBase::$tmethod[$ktype])) {
+            $kread = 'read' . TBase::$tmethod[$ktype];
         } else {
-          $xfer += $input->skip($ftype);
+            $kspec = $spec['key'];
         }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      $xfer += $input->readFieldEnd();
-    }
-    $xfer += $input->readStructEnd();
-
-    return $xfer;
-  }
-
-  private function _writeMap($var, $spec, $output)
-  {
-    $xfer = 0;
-    $ktype = $spec['ktype'];
-    $vtype = $spec['vtype'];
-    $kwrite = $vwrite = null;
-    if (isset(TBase::$tmethod[$ktype])) {
-      $kwrite = 'write'.TBase::$tmethod[$ktype];
-    } else {
-      $kspec = $spec['key'];
-    }
-    if (isset(TBase::$tmethod[$vtype])) {
-      $vwrite = 'write'.TBase::$tmethod[$vtype];
-    } else {
-      $vspec = $spec['val'];
-    }
-    $xfer += $output->writeMapBegin($ktype, $vtype, count($var));
-    foreach ($var as $key => $val) {
-      if (isset($kwrite)) {
-        $xfer += $output->$kwrite($key);
-      } else {
-        switch ($ktype) {
-        case TType::STRUCT:
-          $xfer += $key->write($output);
-          break;
-        case TType::MAP:
-          $xfer += $this->_writeMap($key, $kspec, $output);
-          break;
-        case TType::LST:
-          $xfer += $this->_writeList($key, $kspec, $output, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_writeList($key, $kspec, $output, true);
-          break;
-        }
-      }
-      if (isset($vwrite)) {
-        $xfer += $output->$vwrite($val);
-      } else {
-        switch ($vtype) {
-        case TType::STRUCT:
-          $xfer += $val->write($output);
-          break;
-        case TType::MAP:
-          $xfer += $this->_writeMap($val, $vspec, $output);
-          break;
-        case TType::LST:
-          $xfer += $this->_writeList($val, $vspec, $output, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_writeList($val, $vspec, $output, true);
-          break;
-        }
-      }
-    }
-    $xfer += $output->writeMapEnd();
-
-    return $xfer;
-  }
-
-  private function _writeList($var, $spec, $output, $set=false)
-  {
-    $xfer = 0;
-    $etype = $spec['etype'];
-    $ewrite = null;
-    if (isset(TBase::$tmethod[$etype])) {
-      $ewrite = 'write'.TBase::$tmethod[$etype];
-    } else {
-      $espec = $spec['elem'];
-    }
-    if ($set) {
-      $xfer += $output->writeSetBegin($etype, count($var));
-    } else {
-      $xfer += $output->writeListBegin($etype, count($var));
-    }
-    foreach ($var as $key => $val) {
-      $elem = $set ? $key : $val;
-      if (isset($ewrite)) {
-        $xfer += $output->$ewrite($elem);
-      } else {
-        switch ($etype) {
-        case TType::STRUCT:
-          $xfer += $elem->write($output);
-          break;
-        case TType::MAP:
-          $xfer += $this->_writeMap($elem, $espec, $output);
-          break;
-        case TType::LST:
-          $xfer += $this->_writeList($elem, $espec, $output, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_writeList($elem, $espec, $output, true);
-          break;
-        }
-      }
-    }
-    if ($set) {
-      $xfer += $output->writeSetEnd();
-    } else {
-      $xfer += $output->writeListEnd();
-    }
-
-    return $xfer;
-  }
-
-  protected function _write($class, $spec, $output)
-  {
-    $xfer = 0;
-    $xfer += $output->writeStructBegin($class);
-    foreach ($spec as $fid => $fspec) {
-      $var = $fspec['var'];
-      if ($this->$var !== null) {
-        $ftype = $fspec['type'];
-        $xfer += $output->writeFieldBegin($var, $ftype, $fid);
-        if (isset(TBase::$tmethod[$ftype])) {
-          $func = 'write'.TBase::$tmethod[$ftype];
-          $xfer += $output->$func($this->$var);
+        if (isset(TBase::$tmethod[$vtype])) {
+            $vread = 'read' . TBase::$tmethod[$vtype];
         } else {
-          switch ($ftype) {
-          case TType::STRUCT:
-            $xfer += $this->$var->write($output);
-            break;
-          case TType::MAP:
-            $xfer += $this->_writeMap($this->$var, $fspec, $output);
-            break;
-          case TType::LST:
-            $xfer += $this->_writeList($this->$var, $fspec, $output, false);
-            break;
-          case TType::SET:
-            $xfer += $this->_writeList($this->$var, $fspec, $output, true);
-            break;
-          }
+            $vspec = $spec['val'];
         }
-        $xfer += $output->writeFieldEnd();
-      }
-    }
-    $xfer += $output->writeFieldStop();
-    $xfer += $output->writeStructEnd();
+        $var = array();
+        $_ktype = $_vtype = $size = 0;
+        $xfer += $input->readMapBegin($_ktype, $_vtype, $size);
+        for ($i = 0; $i < $size; ++$i) {
+            $key = $val = null;
+            if ($kread !== null) {
+                $xfer += $input->$kread($key);
+            } else {
+                switch ($ktype) {
+                    case TType::STRUCT:
+                        $class = $kspec['class'];
+                        $key = new $class();
+                        $xfer += $key->read($input);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_readMap($key, $kspec, $input);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_readList($key, $kspec, $input, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_readList($key, $kspec, $input, true);
+                        break;
+                }
+            }
+            if ($vread !== null) {
+                $xfer += $input->$vread($val);
+            } else {
+                switch ($vtype) {
+                    case TType::STRUCT:
+                        $class = $vspec['class'];
+                        $val = new $class();
+                        $xfer += $val->read($input);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_readMap($val, $vspec, $input);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_readList($val, $vspec, $input, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_readList($val, $vspec, $input, true);
+                        break;
+                }
+            }
+            $var[$key] = $val;
+        }
+        $xfer += $input->readMapEnd();
 
-    return $xfer;
-  }
+        return $xfer;
+    }
+
+    private function _readList(&$var, $spec, $input, $set = false)
+    {
+        $xfer = 0;
+        $etype = $spec['etype'];
+        $eread = $vread = null;
+        if (isset(TBase::$tmethod[$etype])) {
+            $eread = 'read' . TBase::$tmethod[$etype];
+        } else {
+            $espec = $spec['elem'];
+        }
+        $var = array();
+        $_etype = $size = 0;
+        if ($set) {
+            $xfer += $input->readSetBegin($_etype, $size);
+        } else {
+            $xfer += $input->readListBegin($_etype, $size);
+        }
+        for ($i = 0; $i < $size; ++$i) {
+            $elem = null;
+            if ($eread !== null) {
+                $xfer += $input->$eread($elem);
+            } else {
+                $espec = $spec['elem'];
+                switch ($etype) {
+                    case TType::STRUCT:
+                        $class = $espec['class'];
+                        $elem = new $class();
+                        $xfer += $elem->read($input);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_readMap($elem, $espec, $input);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_readList($elem, $espec, $input, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_readList($elem, $espec, $input, true);
+                        break;
+                }
+            }
+            if ($set) {
+                $var[$elem] = true;
+            } else {
+                $var [] = $elem;
+            }
+        }
+        if ($set) {
+            $xfer += $input->readSetEnd();
+        } else {
+            $xfer += $input->readListEnd();
+        }
+
+        return $xfer;
+    }
+
+    protected function _read($class, $spec, $input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            if (isset($spec[$fid])) {
+                $fspec = $spec[$fid];
+                $var = $fspec['var'];
+                if ($ftype == $fspec['type']) {
+                    $xfer = 0;
+                    if (isset(TBase::$tmethod[$ftype])) {
+                        $func = 'read' . TBase::$tmethod[$ftype];
+                        $xfer += $input->$func($this->$var);
+                    } else {
+                        switch ($ftype) {
+                            case TType::STRUCT:
+                                $class = $fspec['class'];
+                                $this->$var = new $class();
+                                $xfer += $this->$var->read($input);
+                                break;
+                            case TType::MAP:
+                                $xfer += $this->_readMap($this->$var, $fspec, $input);
+                                break;
+                            case TType::LST:
+                                $xfer += $this->_readList($this->$var, $fspec, $input, false);
+                                break;
+                            case TType::SET:
+                                $xfer += $this->_readList($this->$var, $fspec, $input, true);
+                                break;
+                        }
+                    }
+                } else {
+                    $xfer += $input->skip($ftype);
+                }
+            } else {
+                $xfer += $input->skip($ftype);
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+
+        return $xfer;
+    }
+
+    private function _writeMap($var, $spec, $output)
+    {
+        $xfer = 0;
+        $ktype = $spec['ktype'];
+        $vtype = $spec['vtype'];
+        $kwrite = $vwrite = null;
+        if (isset(TBase::$tmethod[$ktype])) {
+            $kwrite = 'write' . TBase::$tmethod[$ktype];
+        } else {
+            $kspec = $spec['key'];
+        }
+        if (isset(TBase::$tmethod[$vtype])) {
+            $vwrite = 'write' . TBase::$tmethod[$vtype];
+        } else {
+            $vspec = $spec['val'];
+        }
+        $xfer += $output->writeMapBegin($ktype, $vtype, count($var));
+        foreach ($var as $key => $val) {
+            if (isset($kwrite)) {
+                $xfer += $output->$kwrite($key);
+            } else {
+                switch ($ktype) {
+                    case TType::STRUCT:
+                        $xfer += $key->write($output);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_writeMap($key, $kspec, $output);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_writeList($key, $kspec, $output, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_writeList($key, $kspec, $output, true);
+                        break;
+                }
+            }
+            if (isset($vwrite)) {
+                $xfer += $output->$vwrite($val);
+            } else {
+                switch ($vtype) {
+                    case TType::STRUCT:
+                        $xfer += $val->write($output);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_writeMap($val, $vspec, $output);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_writeList($val, $vspec, $output, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_writeList($val, $vspec, $output, true);
+                        break;
+                }
+            }
+        }
+        $xfer += $output->writeMapEnd();
+
+        return $xfer;
+    }
+
+    private function _writeList($var, $spec, $output, $set = false)
+    {
+        $xfer = 0;
+        $etype = $spec['etype'];
+        $ewrite = null;
+        if (isset(TBase::$tmethod[$etype])) {
+            $ewrite = 'write' . TBase::$tmethod[$etype];
+        } else {
+            $espec = $spec['elem'];
+        }
+        if ($set) {
+            $xfer += $output->writeSetBegin($etype, count($var));
+        } else {
+            $xfer += $output->writeListBegin($etype, count($var));
+        }
+        foreach ($var as $key => $val) {
+            $elem = $set ? $key : $val;
+            if (isset($ewrite)) {
+                $xfer += $output->$ewrite($elem);
+            } else {
+                switch ($etype) {
+                    case TType::STRUCT:
+                        $xfer += $elem->write($output);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_writeMap($elem, $espec, $output);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_writeList($elem, $espec, $output, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_writeList($elem, $espec, $output, true);
+                        break;
+                }
+            }
+        }
+        if ($set) {
+            $xfer += $output->writeSetEnd();
+        } else {
+            $xfer += $output->writeListEnd();
+        }
+
+        return $xfer;
+    }
+
+    protected function _write($class, $spec, $output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin($class);
+        foreach ($spec as $fid => $fspec) {
+            $var = $fspec['var'];
+            if ($this->$var !== null) {
+                $ftype = $fspec['type'];
+                $xfer += $output->writeFieldBegin($var, $ftype, $fid);
+                if (isset(TBase::$tmethod[$ftype])) {
+                    $func = 'write' . TBase::$tmethod[$ftype];
+                    $xfer += $output->$func($this->$var);
+                } else {
+                    switch ($ftype) {
+                        case TType::STRUCT:
+                            $xfer += $this->$var->write($output);
+                            break;
+                        case TType::MAP:
+                            $xfer += $this->_writeMap($this->$var, $fspec, $output);
+                            break;
+                        case TType::LST:
+                            $xfer += $this->_writeList($this->$var, $fspec, $output, false);
+                            break;
+                        case TType::SET:
+                            $xfer += $this->_writeList($this->$var, $fspec, $output, true);
+                            break;
+                    }
+                }
+                $xfer += $output->writeFieldEnd();
+            }
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+
+        return $xfer;
+    }
 }
diff --git a/lib/php/lib/ClassLoader/ThriftClassLoader.php b/lib/php/lib/ClassLoader/ThriftClassLoader.php
index 67575ce..4361bd8 100644
--- a/lib/php/lib/ClassLoader/ThriftClassLoader.php
+++ b/lib/php/lib/ClassLoader/ThriftClassLoader.php
@@ -54,7 +54,7 @@
     /**
      * Set autoloader to use APC cache
      * @param boolean $apc
-     * @param string  $apc_prefix
+     * @param string $apc_prefix
      */
     public function __construct($apc = false, $apc_prefix = null)
     {
@@ -65,23 +65,23 @@
     /**
      * Registers a namespace.
      *
-     * @param string       $namespace The namespace
-     * @param array|string $paths     The location(s) of the namespace
+     * @param string $namespace The namespace
+     * @param array|string $paths The location(s) of the namespace
      */
     public function registerNamespace($namespace, $paths)
     {
-        $this->namespaces[$namespace] = (array) $paths;
+        $this->namespaces[$namespace] = (array)$paths;
     }
 
     /**
      * Registers a Thrift definition namespace.
      *
-     * @param string       $namespace The definition namespace
-     * @param array|string $paths     The location(s) of the definition namespace
+     * @param string $namespace The definition namespace
+     * @param array|string $paths The location(s) of the definition namespace
      */
     public function registerDefinition($namespace, $paths)
     {
-        $this->definitions[$namespace] = (array) $paths;
+        $this->definitions[$namespace] = (array)$paths;
     }
 
     /**
@@ -101,11 +101,9 @@
      */
     public function loadClass($class)
     {
-        if (
-            (true === $this->apc && ($file = $this->findFileInApc($class))) or
+        if ((true === $this->apc && ($file = $this->findFileInApc($class))) or
             ($file = $this->findFile($class))
-        )
-        {
+        ) {
             require_once $file;
         }
     }
@@ -117,8 +115,8 @@
      */
     protected function findFileInApc($class)
     {
-        if (false === $file = apc_fetch($this->apc_prefix.$class)) {
-            apc_store($this->apc_prefix.$class, $file = $this->findFile($class));
+        if (false === $file = apc_fetch($this->apc_prefix . $class)) {
+            apc_store($this->apc_prefix . $class, $file = $this->findFile($class));
         }
 
         return $file;
@@ -150,10 +148,10 @@
                 foreach ($dirs as $dir) {
                     $className = substr($class, $pos + 1);
 
-                    $file = $dir.DIRECTORY_SEPARATOR.
-                                 str_replace('\\', DIRECTORY_SEPARATOR, $namespace).
-                                 DIRECTORY_SEPARATOR.
-                                 $className.'.php';
+                    $file = $dir . DIRECTORY_SEPARATOR .
+                        str_replace('\\', DIRECTORY_SEPARATOR, $namespace) .
+                        DIRECTORY_SEPARATOR .
+                        $className . '.php';
 
                     if (file_exists($file)) {
                         return $file;
@@ -185,20 +183,18 @@
                      * Available in service: Interface, Client, Processor, Rest
                      * And every service methods (_.+)
                      */
-                    if(
-                        0 === preg_match('#(.+)(if|client|processor|rest)$#i', $class, $n) and
+                    if (0 === preg_match('#(.+)(if|client|processor|rest)$#i', $class, $n) and
                         0 === preg_match('#(.+)_[a-z0-9]+_(args|result)$#i', $class, $n)
-                    )
-                    {
+                    ) {
                         $className = 'Types';
                     } else {
                         $className = $n[1];
                     }
 
-                    $file = $dir.DIRECTORY_SEPARATOR .
-                                 str_replace('\\', DIRECTORY_SEPARATOR, $namespace) .
-                                 DIRECTORY_SEPARATOR .
-                                 $className . '.php';
+                    $file = $dir . DIRECTORY_SEPARATOR .
+                        str_replace('\\', DIRECTORY_SEPARATOR, $namespace) .
+                        DIRECTORY_SEPARATOR .
+                        $className . '.php';
 
                     if (file_exists($file)) {
                         return $file;
diff --git a/lib/php/lib/Exception/TApplicationException.php b/lib/php/lib/Exception/TApplicationException.php
index b1689fc..228add5 100644
--- a/lib/php/lib/Exception/TApplicationException.php
+++ b/lib/php/lib/Exception/TApplicationException.php
@@ -26,51 +26,51 @@
 
 class TApplicationException extends TException
 {
-  static $_TSPEC =
-    array(1 => array('var' => 'message',
-                     'type' => TType::STRING),
-          2 => array('var' => 'code',
-                     'type' => TType::I32));
+    static public $_TSPEC =
+        array(1 => array('var' => 'message',
+            'type' => TType::STRING),
+            2 => array('var' => 'code',
+                'type' => TType::I32));
 
-  const UNKNOWN = 0;
-  const UNKNOWN_METHOD = 1;
-  const INVALID_MESSAGE_TYPE = 2;
-  const WRONG_METHOD_NAME = 3;
-  const BAD_SEQUENCE_ID = 4;
-  const MISSING_RESULT = 5;
-  const INTERNAL_ERROR = 6;
-  const PROTOCOL_ERROR = 7;
-  const INVALID_TRANSFORM = 8;
-  const INVALID_PROTOCOL = 9;
-  const UNSUPPORTED_CLIENT_TYPE = 10;
+    const UNKNOWN = 0;
+    const UNKNOWN_METHOD = 1;
+    const INVALID_MESSAGE_TYPE = 2;
+    const WRONG_METHOD_NAME = 3;
+    const BAD_SEQUENCE_ID = 4;
+    const MISSING_RESULT = 5;
+    const INTERNAL_ERROR = 6;
+    const PROTOCOL_ERROR = 7;
+    const INVALID_TRANSFORM = 8;
+    const INVALID_PROTOCOL = 9;
+    const UNSUPPORTED_CLIENT_TYPE = 10;
 
-  public function __construct($message=null, $code=0)
-  {
-    parent::__construct($message, $code);
-  }
-
-  public function read($output)
-  {
-    return $this->_read('TApplicationException', self::$_TSPEC, $output);
-  }
-
-  public function write($output)
-  {
-    $xfer = 0;
-    $xfer += $output->writeStructBegin('TApplicationException');
-    if ($message = $this->getMessage()) {
-      $xfer += $output->writeFieldBegin('message', TType::STRING, 1);
-      $xfer += $output->writeString($message);
-      $xfer += $output->writeFieldEnd();
+    public function __construct($message = null, $code = 0)
+    {
+        parent::__construct($message, $code);
     }
-    if ($code = $this->getCode()) {
-      $xfer += $output->writeFieldBegin('type', TType::I32, 2);
-      $xfer += $output->writeI32($code);
-      $xfer += $output->writeFieldEnd();
-    }
-    $xfer += $output->writeFieldStop();
-    $xfer += $output->writeStructEnd();
 
-    return $xfer;
-  }
+    public function read($output)
+    {
+        return $this->_read('TApplicationException', self::$_TSPEC, $output);
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('TApplicationException');
+        if ($message = $this->getMessage()) {
+            $xfer += $output->writeFieldBegin('message', TType::STRING, 1);
+            $xfer += $output->writeString($message);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($code = $this->getCode()) {
+            $xfer += $output->writeFieldBegin('type', TType::I32, 2);
+            $xfer += $output->writeI32($code);
+            $xfer += $output->writeFieldEnd();
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+
+        return $xfer;
+    }
 }
diff --git a/lib/php/lib/Exception/TException.php b/lib/php/lib/Exception/TException.php
index 5c06843..e9c7c71 100644
--- a/lib/php/lib/Exception/TException.php
+++ b/lib/php/lib/Exception/TException.php
@@ -40,344 +40,345 @@
  */
 class TException extends \Exception
 {
-  public function __construct($p1=null, $p2=0)
-  {
-    if (is_array($p1) && is_array($p2)) {
-      $spec = $p1;
-      $vals = $p2;
-      foreach ($spec as $fid => $fspec) {
-        $var = $fspec['var'];
-        if (isset($vals[$var])) {
-          $this->$var = $vals[$var];
-        }
-      }
-    } else {
-      parent::__construct($p1, $p2);
-    }
-  }
-
-  static $tmethod = array(TType::BOOL   => 'Bool',
-                          TType::BYTE   => 'Byte',
-                          TType::I16    => 'I16',
-                          TType::I32    => 'I32',
-                          TType::I64    => 'I64',
-                          TType::DOUBLE => 'Double',
-                          TType::STRING => 'String');
-
-  private function _readMap(&$var, $spec, $input)
-  {
-    $xfer = 0;
-    $ktype = $spec['ktype'];
-    $vtype = $spec['vtype'];
-    $kread = $vread = null;
-    if (isset(TBase::$tmethod[$ktype])) {
-      $kread = 'read'.TBase::$tmethod[$ktype];
-    } else {
-      $kspec = $spec['key'];
-    }
-    if (isset(TBase::$tmethod[$vtype])) {
-      $vread = 'read'.TBase::$tmethod[$vtype];
-    } else {
-      $vspec = $spec['val'];
-    }
-    $var = array();
-    $_ktype = $_vtype = $size = 0;
-    $xfer += $input->readMapBegin($_ktype, $_vtype, $size);
-    for ($i = 0; $i < $size; ++$i) {
-      $key = $val = null;
-      if ($kread !== null) {
-        $xfer += $input->$kread($key);
-      } else {
-        switch ($ktype) {
-        case TType::STRUCT:
-          $class = $kspec['class'];
-          $key = new $class();
-          $xfer += $key->read($input);
-          break;
-        case TType::MAP:
-          $xfer += $this->_readMap($key, $kspec, $input);
-          break;
-        case TType::LST:
-          $xfer += $this->_readList($key, $kspec, $input, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_readList($key, $kspec, $input, true);
-          break;
-        }
-      }
-      if ($vread !== null) {
-        $xfer += $input->$vread($val);
-      } else {
-        switch ($vtype) {
-        case TType::STRUCT:
-          $class = $vspec['class'];
-          $val = new $class();
-          $xfer += $val->read($input);
-          break;
-        case TType::MAP:
-          $xfer += $this->_readMap($val, $vspec, $input);
-          break;
-        case TType::LST:
-          $xfer += $this->_readList($val, $vspec, $input, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_readList($val, $vspec, $input, true);
-          break;
-        }
-      }
-      $var[$key] = $val;
-    }
-    $xfer += $input->readMapEnd();
-
-    return $xfer;
-  }
-
-  private function _readList(&$var, $spec, $input, $set=false)
-  {
-    $xfer = 0;
-    $etype = $spec['etype'];
-    $eread = $vread = null;
-    if (isset(TBase::$tmethod[$etype])) {
-      $eread = 'read'.TBase::$tmethod[$etype];
-    } else {
-      $espec = $spec['elem'];
-    }
-    $var = array();
-    $_etype = $size = 0;
-    if ($set) {
-      $xfer += $input->readSetBegin($_etype, $size);
-    } else {
-      $xfer += $input->readListBegin($_etype, $size);
-    }
-    for ($i = 0; $i < $size; ++$i) {
-      $elem = null;
-      if ($eread !== null) {
-        $xfer += $input->$eread($elem);
-      } else {
-        $espec = $spec['elem'];
-        switch ($etype) {
-        case TType::STRUCT:
-          $class = $espec['class'];
-          $elem = new $class();
-          $xfer += $elem->read($input);
-          break;
-        case TType::MAP:
-          $xfer += $this->_readMap($elem, $espec, $input);
-          break;
-        case TType::LST:
-          $xfer += $this->_readList($elem, $espec, $input, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_readList($elem, $espec, $input, true);
-          break;
-        }
-      }
-      if ($set) {
-        $var[$elem] = true;
-      } else {
-        $var []= $elem;
-      }
-    }
-    if ($set) {
-      $xfer += $input->readSetEnd();
-    } else {
-      $xfer += $input->readListEnd();
-    }
-
-    return $xfer;
-  }
-
-  protected function _read($class, $spec, $input)
-  {
-    $xfer = 0;
-    $fname = null;
-    $ftype = 0;
-    $fid = 0;
-    $xfer += $input->readStructBegin($fname);
-    while (true) {
-      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-      if ($ftype == TType::STOP) {
-        break;
-      }
-      if (isset($spec[$fid])) {
-        $fspec = $spec[$fid];
-        $var = $fspec['var'];
-        if ($ftype == $fspec['type']) {
-          $xfer = 0;
-          if (isset(TBase::$tmethod[$ftype])) {
-            $func = 'read'.TBase::$tmethod[$ftype];
-            $xfer += $input->$func($this->$var);
-          } else {
-            switch ($ftype) {
-            case TType::STRUCT:
-              $class = $fspec['class'];
-              $this->$var = new $class();
-              $xfer += $this->$var->read($input);
-              break;
-            case TType::MAP:
-              $xfer += $this->_readMap($this->$var, $fspec, $input);
-              break;
-            case TType::LST:
-              $xfer += $this->_readList($this->$var, $fspec, $input, false);
-              break;
-            case TType::SET:
-              $xfer += $this->_readList($this->$var, $fspec, $input, true);
-              break;
+    public function __construct($p1 = null, $p2 = 0)
+    {
+        if (is_array($p1) && is_array($p2)) {
+            $spec = $p1;
+            $vals = $p2;
+            foreach ($spec as $fid => $fspec) {
+                $var = $fspec['var'];
+                if (isset($vals[$var])) {
+                    $this->$var = $vals[$var];
+                }
             }
-          }
         } else {
-          $xfer += $input->skip($ftype);
+            parent::__construct($p1, $p2);
         }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      $xfer += $input->readFieldEnd();
-    }
-    $xfer += $input->readStructEnd();
-
-    return $xfer;
-  }
-
-  private function _writeMap($var, $spec, $output)
-  {
-    $xfer = 0;
-    $ktype = $spec['ktype'];
-    $vtype = $spec['vtype'];
-    $kwrite = $vwrite = null;
-    if (isset(TBase::$tmethod[$ktype])) {
-      $kwrite = 'write'.TBase::$tmethod[$ktype];
-    } else {
-      $kspec = $spec['key'];
-    }
-    if (isset(TBase::$tmethod[$vtype])) {
-      $vwrite = 'write'.TBase::$tmethod[$vtype];
-    } else {
-      $vspec = $spec['val'];
-    }
-    $xfer += $output->writeMapBegin($ktype, $vtype, count($var));
-    foreach ($var as $key => $val) {
-      if (isset($kwrite)) {
-        $xfer += $output->$kwrite($key);
-      } else {
-        switch ($ktype) {
-        case TType::STRUCT:
-          $xfer += $key->write($output);
-          break;
-        case TType::MAP:
-          $xfer += $this->_writeMap($key, $kspec, $output);
-          break;
-        case TType::LST:
-          $xfer += $this->_writeList($key, $kspec, $output, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_writeList($key, $kspec, $output, true);
-          break;
-        }
-      }
-      if (isset($vwrite)) {
-        $xfer += $output->$vwrite($val);
-      } else {
-        switch ($vtype) {
-        case TType::STRUCT:
-          $xfer += $val->write($output);
-          break;
-        case TType::MAP:
-          $xfer += $this->_writeMap($val, $vspec, $output);
-          break;
-        case TType::LST:
-          $xfer += $this->_writeList($val, $vspec, $output, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_writeList($val, $vspec, $output, true);
-          break;
-        }
-      }
-    }
-    $xfer += $output->writeMapEnd();
-
-    return $xfer;
-  }
-
-  private function _writeList($var, $spec, $output, $set=false)
-  {
-    $xfer = 0;
-    $etype = $spec['etype'];
-    $ewrite = null;
-    if (isset(TBase::$tmethod[$etype])) {
-      $ewrite = 'write'.TBase::$tmethod[$etype];
-    } else {
-      $espec = $spec['elem'];
-    }
-    if ($set) {
-      $xfer += $output->writeSetBegin($etype, count($var));
-    } else {
-      $xfer += $output->writeListBegin($etype, count($var));
-    }
-    foreach ($var as $key => $val) {
-      $elem = $set ? $key : $val;
-      if (isset($ewrite)) {
-        $xfer += $output->$ewrite($elem);
-      } else {
-        switch ($etype) {
-        case TType::STRUCT:
-          $xfer += $elem->write($output);
-          break;
-        case TType::MAP:
-          $xfer += $this->_writeMap($elem, $espec, $output);
-          break;
-        case TType::LST:
-          $xfer += $this->_writeList($elem, $espec, $output, false);
-          break;
-        case TType::SET:
-          $xfer += $this->_writeList($elem, $espec, $output, true);
-          break;
-        }
-      }
-    }
-    if ($set) {
-      $xfer += $output->writeSetEnd();
-    } else {
-      $xfer += $output->writeListEnd();
     }
 
-    return $xfer;
-  }
+    static public $tmethod = array(
+        TType::BOOL => 'Bool',
+        TType::BYTE => 'Byte',
+        TType::I16 => 'I16',
+        TType::I32 => 'I32',
+        TType::I64 => 'I64',
+        TType::DOUBLE => 'Double',
+        TType::STRING => 'String'
+    );
 
-  protected function _write($class, $spec, $output)
-  {
-    $xfer = 0;
-    $xfer += $output->writeStructBegin($class);
-    foreach ($spec as $fid => $fspec) {
-      $var = $fspec['var'];
-      if ($this->$var !== null) {
-        $ftype = $fspec['type'];
-        $xfer += $output->writeFieldBegin($var, $ftype, $fid);
-        if (isset(TBase::$tmethod[$ftype])) {
-          $func = 'write'.TBase::$tmethod[$ftype];
-          $xfer += $output->$func($this->$var);
+    private function _readMap(&$var, $spec, $input)
+    {
+        $xfer = 0;
+        $ktype = $spec['ktype'];
+        $vtype = $spec['vtype'];
+        $kread = $vread = null;
+        if (isset(TBase::$tmethod[$ktype])) {
+            $kread = 'read' . TBase::$tmethod[$ktype];
         } else {
-          switch ($ftype) {
-          case TType::STRUCT:
-            $xfer += $this->$var->write($output);
-            break;
-          case TType::MAP:
-            $xfer += $this->_writeMap($this->$var, $fspec, $output);
-            break;
-          case TType::LST:
-            $xfer += $this->_writeList($this->$var, $fspec, $output, false);
-            break;
-          case TType::SET:
-            $xfer += $this->_writeList($this->$var, $fspec, $output, true);
-            break;
-          }
+            $kspec = $spec['key'];
         }
-        $xfer += $output->writeFieldEnd();
-      }
+        if (isset(TBase::$tmethod[$vtype])) {
+            $vread = 'read' . TBase::$tmethod[$vtype];
+        } else {
+            $vspec = $spec['val'];
+        }
+        $var = array();
+        $_ktype = $_vtype = $size = 0;
+        $xfer += $input->readMapBegin($_ktype, $_vtype, $size);
+        for ($i = 0; $i < $size; ++$i) {
+            $key = $val = null;
+            if ($kread !== null) {
+                $xfer += $input->$kread($key);
+            } else {
+                switch ($ktype) {
+                    case TType::STRUCT:
+                        $class = $kspec['class'];
+                        $key = new $class();
+                        $xfer += $key->read($input);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_readMap($key, $kspec, $input);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_readList($key, $kspec, $input, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_readList($key, $kspec, $input, true);
+                        break;
+                }
+            }
+            if ($vread !== null) {
+                $xfer += $input->$vread($val);
+            } else {
+                switch ($vtype) {
+                    case TType::STRUCT:
+                        $class = $vspec['class'];
+                        $val = new $class();
+                        $xfer += $val->read($input);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_readMap($val, $vspec, $input);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_readList($val, $vspec, $input, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_readList($val, $vspec, $input, true);
+                        break;
+                }
+            }
+            $var[$key] = $val;
+        }
+        $xfer += $input->readMapEnd();
+
+        return $xfer;
     }
-    $xfer += $output->writeFieldStop();
-    $xfer += $output->writeStructEnd();
 
-    return $xfer;
-  }
+    private function _readList(&$var, $spec, $input, $set = false)
+    {
+        $xfer = 0;
+        $etype = $spec['etype'];
+        $eread = $vread = null;
+        if (isset(TBase::$tmethod[$etype])) {
+            $eread = 'read' . TBase::$tmethod[$etype];
+        } else {
+            $espec = $spec['elem'];
+        }
+        $var = array();
+        $_etype = $size = 0;
+        if ($set) {
+            $xfer += $input->readSetBegin($_etype, $size);
+        } else {
+            $xfer += $input->readListBegin($_etype, $size);
+        }
+        for ($i = 0; $i < $size; ++$i) {
+            $elem = null;
+            if ($eread !== null) {
+                $xfer += $input->$eread($elem);
+            } else {
+                $espec = $spec['elem'];
+                switch ($etype) {
+                    case TType::STRUCT:
+                        $class = $espec['class'];
+                        $elem = new $class();
+                        $xfer += $elem->read($input);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_readMap($elem, $espec, $input);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_readList($elem, $espec, $input, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_readList($elem, $espec, $input, true);
+                        break;
+                }
+            }
+            if ($set) {
+                $var[$elem] = true;
+            } else {
+                $var [] = $elem;
+            }
+        }
+        if ($set) {
+            $xfer += $input->readSetEnd();
+        } else {
+            $xfer += $input->readListEnd();
+        }
 
+        return $xfer;
+    }
+
+    protected function _read($class, $spec, $input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            if (isset($spec[$fid])) {
+                $fspec = $spec[$fid];
+                $var = $fspec['var'];
+                if ($ftype == $fspec['type']) {
+                    $xfer = 0;
+                    if (isset(TBase::$tmethod[$ftype])) {
+                        $func = 'read' . TBase::$tmethod[$ftype];
+                        $xfer += $input->$func($this->$var);
+                    } else {
+                        switch ($ftype) {
+                            case TType::STRUCT:
+                                $class = $fspec['class'];
+                                $this->$var = new $class();
+                                $xfer += $this->$var->read($input);
+                                break;
+                            case TType::MAP:
+                                $xfer += $this->_readMap($this->$var, $fspec, $input);
+                                break;
+                            case TType::LST:
+                                $xfer += $this->_readList($this->$var, $fspec, $input, false);
+                                break;
+                            case TType::SET:
+                                $xfer += $this->_readList($this->$var, $fspec, $input, true);
+                                break;
+                        }
+                    }
+                } else {
+                    $xfer += $input->skip($ftype);
+                }
+            } else {
+                $xfer += $input->skip($ftype);
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+
+        return $xfer;
+    }
+
+    private function _writeMap($var, $spec, $output)
+    {
+        $xfer = 0;
+        $ktype = $spec['ktype'];
+        $vtype = $spec['vtype'];
+        $kwrite = $vwrite = null;
+        if (isset(TBase::$tmethod[$ktype])) {
+            $kwrite = 'write' . TBase::$tmethod[$ktype];
+        } else {
+            $kspec = $spec['key'];
+        }
+        if (isset(TBase::$tmethod[$vtype])) {
+            $vwrite = 'write' . TBase::$tmethod[$vtype];
+        } else {
+            $vspec = $spec['val'];
+        }
+        $xfer += $output->writeMapBegin($ktype, $vtype, count($var));
+        foreach ($var as $key => $val) {
+            if (isset($kwrite)) {
+                $xfer += $output->$kwrite($key);
+            } else {
+                switch ($ktype) {
+                    case TType::STRUCT:
+                        $xfer += $key->write($output);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_writeMap($key, $kspec, $output);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_writeList($key, $kspec, $output, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_writeList($key, $kspec, $output, true);
+                        break;
+                }
+            }
+            if (isset($vwrite)) {
+                $xfer += $output->$vwrite($val);
+            } else {
+                switch ($vtype) {
+                    case TType::STRUCT:
+                        $xfer += $val->write($output);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_writeMap($val, $vspec, $output);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_writeList($val, $vspec, $output, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_writeList($val, $vspec, $output, true);
+                        break;
+                }
+            }
+        }
+        $xfer += $output->writeMapEnd();
+
+        return $xfer;
+    }
+
+    private function _writeList($var, $spec, $output, $set = false)
+    {
+        $xfer = 0;
+        $etype = $spec['etype'];
+        $ewrite = null;
+        if (isset(TBase::$tmethod[$etype])) {
+            $ewrite = 'write' . TBase::$tmethod[$etype];
+        } else {
+            $espec = $spec['elem'];
+        }
+        if ($set) {
+            $xfer += $output->writeSetBegin($etype, count($var));
+        } else {
+            $xfer += $output->writeListBegin($etype, count($var));
+        }
+        foreach ($var as $key => $val) {
+            $elem = $set ? $key : $val;
+            if (isset($ewrite)) {
+                $xfer += $output->$ewrite($elem);
+            } else {
+                switch ($etype) {
+                    case TType::STRUCT:
+                        $xfer += $elem->write($output);
+                        break;
+                    case TType::MAP:
+                        $xfer += $this->_writeMap($elem, $espec, $output);
+                        break;
+                    case TType::LST:
+                        $xfer += $this->_writeList($elem, $espec, $output, false);
+                        break;
+                    case TType::SET:
+                        $xfer += $this->_writeList($elem, $espec, $output, true);
+                        break;
+                }
+            }
+        }
+        if ($set) {
+            $xfer += $output->writeSetEnd();
+        } else {
+            $xfer += $output->writeListEnd();
+        }
+
+        return $xfer;
+    }
+
+    protected function _write($class, $spec, $output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin($class);
+        foreach ($spec as $fid => $fspec) {
+            $var = $fspec['var'];
+            if ($this->$var !== null) {
+                $ftype = $fspec['type'];
+                $xfer += $output->writeFieldBegin($var, $ftype, $fid);
+                if (isset(TBase::$tmethod[$ftype])) {
+                    $func = 'write' . TBase::$tmethod[$ftype];
+                    $xfer += $output->$func($this->$var);
+                } else {
+                    switch ($ftype) {
+                        case TType::STRUCT:
+                            $xfer += $this->$var->write($output);
+                            break;
+                        case TType::MAP:
+                            $xfer += $this->_writeMap($this->$var, $fspec, $output);
+                            break;
+                        case TType::LST:
+                            $xfer += $this->_writeList($this->$var, $fspec, $output, false);
+                            break;
+                        case TType::SET:
+                            $xfer += $this->_writeList($this->$var, $fspec, $output, true);
+                            break;
+                    }
+                }
+                $xfer += $output->writeFieldEnd();
+            }
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+
+        return $xfer;
+    }
 }
diff --git a/lib/php/lib/Exception/TProtocolException.php b/lib/php/lib/Exception/TProtocolException.php
index ba7135c..3a55d45 100644
--- a/lib/php/lib/Exception/TProtocolException.php
+++ b/lib/php/lib/Exception/TProtocolException.php
@@ -35,16 +35,16 @@
  */
 class TProtocolException extends TException
 {
-  const UNKNOWN = 0;
-  const INVALID_DATA = 1;
-  const NEGATIVE_SIZE = 2;
-  const SIZE_LIMIT = 3;
-  const BAD_VERSION = 4;
-  const NOT_IMPLEMENTED = 5;
-  const DEPTH_LIMIT = 6;
+    const UNKNOWN = 0;
+    const INVALID_DATA = 1;
+    const NEGATIVE_SIZE = 2;
+    const SIZE_LIMIT = 3;
+    const BAD_VERSION = 4;
+    const NOT_IMPLEMENTED = 5;
+    const DEPTH_LIMIT = 6;
 
-  public function __construct($message=null, $code=0)
-  {
-    parent::__construct($message, $code);
-  }
+    public function __construct($message = null, $code = 0)
+    {
+        parent::__construct($message, $code);
+    }
 }
diff --git a/lib/php/lib/Exception/TTransportException.php b/lib/php/lib/Exception/TTransportException.php
index 0074467..7d8d567 100644
--- a/lib/php/lib/Exception/TTransportException.php
+++ b/lib/php/lib/Exception/TTransportException.php
@@ -27,14 +27,14 @@
  */
 class TTransportException extends TException
 {
-  const UNKNOWN = 0;
-  const NOT_OPEN = 1;
-  const ALREADY_OPEN = 2;
-  const TIMED_OUT = 3;
-  const END_OF_FILE = 4;
+    const UNKNOWN = 0;
+    const NOT_OPEN = 1;
+    const ALREADY_OPEN = 2;
+    const TIMED_OUT = 3;
+    const END_OF_FILE = 4;
 
-  public function __construct($message=null, $code=0)
-  {
-    parent::__construct($message, $code);
-  }
+    public function __construct($message = null, $code = 0)
+    {
+        parent::__construct($message, $code);
+    }
 }
diff --git a/lib/php/lib/Factory/TBinaryProtocolFactory.php b/lib/php/lib/Factory/TBinaryProtocolFactory.php
index 0c1c4a7..2519183 100644
--- a/lib/php/lib/Factory/TBinaryProtocolFactory.php
+++ b/lib/php/lib/Factory/TBinaryProtocolFactory.php
@@ -29,17 +29,17 @@
  */
 class TBinaryProtocolFactory implements TProtocolFactory
 {
-  private $strictRead_ = false;
-  private $strictWrite_ = false;
+    private $strictRead_ = false;
+    private $strictWrite_ = false;
 
-  public function __construct($strictRead=false, $strictWrite=false)
-  {
-    $this->strictRead_ = $strictRead;
-    $this->strictWrite_ = $strictWrite;
-  }
+    public function __construct($strictRead = false, $strictWrite = false)
+    {
+        $this->strictRead_ = $strictRead;
+        $this->strictWrite_ = $strictWrite;
+    }
 
-  public function getProtocol($trans)
-  {
-    return new TBinaryProtocol($trans, $this->strictRead_, $this->strictWrite_);
-  }
+    public function getProtocol($trans)
+    {
+        return new TBinaryProtocol($trans, $this->strictRead_, $this->strictWrite_);
+    }
 }
diff --git a/lib/php/lib/Factory/TCompactProtocolFactory.php b/lib/php/lib/Factory/TCompactProtocolFactory.php
index f4b4fe3..11fb8ff 100644
--- a/lib/php/lib/Factory/TCompactProtocolFactory.php
+++ b/lib/php/lib/Factory/TCompactProtocolFactory.php
@@ -29,12 +29,12 @@
  */
 class TCompactProtocolFactory implements TProtocolFactory
 {
-  public function __construct()
-  {
-  }
+    public function __construct()
+    {
+    }
 
-  public function getProtocol($trans)
-  {
-    return new TCompactProtocol($trans);
-  }
+    public function getProtocol($trans)
+    {
+        return new TCompactProtocol($trans);
+    }
 }
diff --git a/lib/php/lib/Factory/TProtocolFactory.php b/lib/php/lib/Factory/TProtocolFactory.php
index 4c9562d..d3066c8 100644
--- a/lib/php/lib/Factory/TProtocolFactory.php
+++ b/lib/php/lib/Factory/TProtocolFactory.php
@@ -27,10 +27,10 @@
  */
 interface TProtocolFactory
 {
-  /**
-   * Build a protocol from the base transport
-   *
-   * @return Thrift\Protocol\TProtocol protocol
-   */
-  public function getProtocol($trans);
+    /**
+     * Build a protocol from the base transport
+     *
+     * @return Thrift\Protocol\TProtocol protocol
+     */
+    public function getProtocol($trans);
 }
diff --git a/lib/php/lib/Factory/TStringFuncFactory.php b/lib/php/lib/Factory/TStringFuncFactory.php
index 6ad6839..7739d16 100644
--- a/lib/php/lib/Factory/TStringFuncFactory.php
+++ b/lib/php/lib/Factory/TStringFuncFactory.php
@@ -53,13 +53,12 @@
          */
         if (ini_get('mbstring.func_overload') & 2) {
             self::$_instance = new Mbstring();
-        }
-        /**
-         * mbstring is not installed or does not have function overloading
-         * of the str* functions enabled so use PHP core str* functions for
-         * byte counting.
-         */
-        else {
+        } else {
+            /**
+             * mbstring is not installed or does not have function overloading
+             * of the str* functions enabled so use PHP core str* functions for
+             * byte counting.
+             */
             self::$_instance = new Core();
         }
     }
diff --git a/lib/php/lib/Factory/TTransportFactory.php b/lib/php/lib/Factory/TTransportFactory.php
index b32b5f4..43f2eec 100644
--- a/lib/php/lib/Factory/TTransportFactory.php
+++ b/lib/php/lib/Factory/TTransportFactory.php
@@ -6,13 +6,13 @@
 
 class TTransportFactory
 {
-  /**
-   * @static
-   * @param TTransport $transport
-   * @return TTransport
-   */
-  public static function getTransport(TTransport $transport)
-  {
-    return $transport;
-  }
+    /**
+     * @static
+     * @param TTransport $transport
+     * @return TTransport
+     */
+    public static function getTransport(TTransport $transport)
+    {
+        return $transport;
+    }
 }
diff --git a/lib/php/lib/Protocol/SimpleJSON/Context.php b/lib/php/lib/Protocol/SimpleJSON/Context.php
index dcffbcb..dbd16fa 100644
--- a/lib/php/lib/Protocol/SimpleJSON/Context.php
+++ b/lib/php/lib/Protocol/SimpleJSON/Context.php
@@ -33,4 +33,3 @@
         return false;
     }
 }
-
diff --git a/lib/php/lib/Protocol/SimpleJSON/MapContext.php b/lib/php/lib/Protocol/SimpleJSON/MapContext.php
index bb9a04d..61c060d 100644
--- a/lib/php/lib/Protocol/SimpleJSON/MapContext.php
+++ b/lib/php/lib/Protocol/SimpleJSON/MapContext.php
@@ -22,8 +22,6 @@
 
 namespace Thrift\Protocol\SimpleJSON;
 
-use Thrift\Protocol\TSimpleJSONProtocol;
-
 class MapContext extends StructContext
 {
     protected $isKey = true;
@@ -47,5 +45,3 @@
         return $this->isKey;
     }
 }
-
-
diff --git a/lib/php/lib/Protocol/SimpleJSON/StructContext.php b/lib/php/lib/Protocol/SimpleJSON/StructContext.php
index 8162f2b..38a62d1 100644
--- a/lib/php/lib/Protocol/SimpleJSON/StructContext.php
+++ b/lib/php/lib/Protocol/SimpleJSON/StructContext.php
@@ -43,11 +43,10 @@
         } else {
             $this->p_->getTransport()->write(
                 $this->colon_ ?
-                TSimpleJSONProtocol::COLON :
-                TSimpleJSONProtocol::COMMA
+                    TSimpleJSONProtocol::COLON :
+                    TSimpleJSONProtocol::COMMA
             );
             $this->colon_ = !$this->colon_;
         }
     }
 }
-
diff --git a/lib/php/lib/Protocol/TBinaryProtocol.php b/lib/php/lib/Protocol/TBinaryProtocol.php
index fe6a103..cda5c0d 100644
--- a/lib/php/lib/Protocol/TBinaryProtocol.php
+++ b/lib/php/lib/Protocol/TBinaryProtocol.php
@@ -32,422 +32,422 @@
  */
 class TBinaryProtocol extends TProtocol
 {
-  const VERSION_MASK = 0xffff0000;
-  const VERSION_1 = 0x80010000;
+    const VERSION_MASK = 0xffff0000;
+    const VERSION_1 = 0x80010000;
 
-  protected $strictRead_ = false;
-  protected $strictWrite_ = true;
+    protected $strictRead_ = false;
+    protected $strictWrite_ = true;
 
-  public function __construct($trans, $strictRead=false, $strictWrite=true)
-  {
-    parent::__construct($trans);
-    $this->strictRead_ = $strictRead;
-    $this->strictWrite_ = $strictWrite;
-  }
-
-  public function writeMessageBegin($name, $type, $seqid)
-  {
-    if ($this->strictWrite_) {
-      $version = self::VERSION_1 | $type;
-
-      return
-        $this->writeI32($version) +
-        $this->writeString($name) +
-        $this->writeI32($seqid);
-    } else {
-      return
-        $this->writeString($name) +
-        $this->writeByte($type) +
-        $this->writeI32($seqid);
+    public function __construct($trans, $strictRead = false, $strictWrite = true)
+    {
+        parent::__construct($trans);
+        $this->strictRead_ = $strictRead;
+        $this->strictWrite_ = $strictWrite;
     }
-  }
 
-  public function writeMessageEnd()
-  {
-    return 0;
-  }
+    public function writeMessageBegin($name, $type, $seqid)
+    {
+        if ($this->strictWrite_) {
+            $version = self::VERSION_1 | $type;
 
-  public function writeStructBegin($name)
-  {
-    return 0;
-  }
-
-  public function writeStructEnd()
-  {
-    return 0;
-  }
-
-  public function writeFieldBegin($fieldName, $fieldType, $fieldId)
-  {
-    return
-      $this->writeByte($fieldType) +
-      $this->writeI16($fieldId);
-  }
-
-  public function writeFieldEnd()
-  {
-    return 0;
-  }
-
-  public function writeFieldStop()
-  {
-    return
-      $this->writeByte(TType::STOP);
-  }
-
-  public function writeMapBegin($keyType, $valType, $size)
-  {
-    return
-      $this->writeByte($keyType) +
-      $this->writeByte($valType) +
-      $this->writeI32($size);
-  }
-
-  public function writeMapEnd()
-  {
-    return 0;
-  }
-
-  public function writeListBegin($elemType, $size)
-  {
-    return
-      $this->writeByte($elemType) +
-      $this->writeI32($size);
-  }
-
-  public function writeListEnd()
-  {
-    return 0;
-  }
-
-  public function writeSetBegin($elemType, $size)
-  {
-    return
-      $this->writeByte($elemType) +
-      $this->writeI32($size);
-  }
-
-  public function writeSetEnd()
-  {
-    return 0;
-  }
-
-  public function writeBool($value)
-  {
-    $data = pack('c', $value ? 1 : 0);
-    $this->trans_->write($data, 1);
-
-    return 1;
-  }
-
-  public function writeByte($value)
-  {
-    $data = pack('c', $value);
-    $this->trans_->write($data, 1);
-
-    return 1;
-  }
-
-  public function writeI16($value)
-  {
-    $data = pack('n', $value);
-    $this->trans_->write($data, 2);
-
-    return 2;
-  }
-
-  public function writeI32($value)
-  {
-    $data = pack('N', $value);
-    $this->trans_->write($data, 4);
-
-    return 4;
-  }
-
-  public function writeI64($value)
-  {
-    // If we are on a 32bit architecture we have to explicitly deal with
-    // 64-bit twos-complement arithmetic since PHP wants to treat all ints
-    // as signed and any int over 2^31 - 1 as a float
-    if (PHP_INT_SIZE == 4) {
-      $neg = $value < 0;
-
-      if ($neg) {
-        $value *= -1;
-      }
-
-      $hi = (int) ($value / 4294967296);
-      $lo = (int) $value;
-
-      if ($neg) {
-        $hi = ~$hi;
-        $lo = ~$lo;
-        if (($lo & (int) 0xffffffff) == (int) 0xffffffff) {
-          $lo = 0;
-          $hi++;
+            return
+                $this->writeI32($version) +
+                $this->writeString($name) +
+                $this->writeI32($seqid);
         } else {
-          $lo++;
+            return
+                $this->writeString($name) +
+                $this->writeByte($type) +
+                $this->writeI32($seqid);
         }
-      }
-      $data = pack('N2', $hi, $lo);
-
-    } else {
-      $hi = $value >> 32;
-      $lo = $value & 0xFFFFFFFF;
-      $data = pack('N2', $hi, $lo);
     }
 
-    $this->trans_->write($data, 8);
-
-    return 8;
-  }
-
-  public function writeDouble($value)
-  {
-    $data = pack('d', $value);
-    $this->trans_->write(strrev($data), 8);
-
-    return 8;
-  }
-
-  public function writeString($value)
-  {
-    $len = TStringFuncFactory::create()->strlen($value);
-    $result = $this->writeI32($len);
-    if ($len) {
-      $this->trans_->write($value, $len);
+    public function writeMessageEnd()
+    {
+        return 0;
     }
 
-    return $result + $len;
-  }
-
-  public function readMessageBegin(&$name, &$type, &$seqid)
-  {
-    $result = $this->readI32($sz);
-    if ($sz < 0) {
-      $version = (int) ($sz & self::VERSION_MASK);
-      if ($version != (int) self::VERSION_1) {
-        throw new TProtocolException('Bad version identifier: '.$sz, TProtocolException::BAD_VERSION);
-      }
-      $type = $sz & 0x000000ff;
-      $result +=
-        $this->readString($name) +
-        $this->readI32($seqid);
-    } else {
-      if ($this->strictRead_) {
-        throw new TProtocolException('No version identifier, old protocol client?', TProtocolException::BAD_VERSION);
-      } else {
-        // Handle pre-versioned input
-        $name = $this->trans_->readAll($sz);
-        $result +=
-          $sz +
-          $this->readByte($type) +
-          $this->readI32($seqid);
-      }
+    public function writeStructBegin($name)
+    {
+        return 0;
     }
 
-    return $result;
-  }
-
-  public function readMessageEnd()
-  {
-    return 0;
-  }
-
-  public function readStructBegin(&$name)
-  {
-    $name = '';
-
-    return 0;
-  }
-
-  public function readStructEnd()
-  {
-    return 0;
-  }
-
-  public function readFieldBegin(&$name, &$fieldType, &$fieldId)
-  {
-    $result = $this->readByte($fieldType);
-    if ($fieldType == TType::STOP) {
-      $fieldId = 0;
-
-      return $result;
-    }
-    $result += $this->readI16($fieldId);
-
-    return $result;
-  }
-
-  public function readFieldEnd()
-  {
-    return 0;
-  }
-
-  public function readMapBegin(&$keyType, &$valType, &$size)
-  {
-    return
-      $this->readByte($keyType) +
-      $this->readByte($valType) +
-      $this->readI32($size);
-  }
-
-  public function readMapEnd()
-  {
-    return 0;
-  }
-
-  public function readListBegin(&$elemType, &$size)
-  {
-    return
-      $this->readByte($elemType) +
-      $this->readI32($size);
-  }
-
-  public function readListEnd()
-  {
-    return 0;
-  }
-
-  public function readSetBegin(&$elemType, &$size)
-  {
-    return
-      $this->readByte($elemType) +
-      $this->readI32($size);
-  }
-
-  public function readSetEnd()
-  {
-    return 0;
-  }
-
-  public function readBool(&$value)
-  {
-    $data = $this->trans_->readAll(1);
-    $arr = unpack('c', $data);
-    $value = $arr[1] == 1;
-
-    return 1;
-  }
-
-  public function readByte(&$value)
-  {
-    $data = $this->trans_->readAll(1);
-    $arr = unpack('c', $data);
-    $value = $arr[1];
-
-    return 1;
-  }
-
-  public function readI16(&$value)
-  {
-    $data = $this->trans_->readAll(2);
-    $arr = unpack('n', $data);
-    $value = $arr[1];
-    if ($value > 0x7fff) {
-      $value = 0 - (($value - 1) ^ 0xffff);
+    public function writeStructEnd()
+    {
+        return 0;
     }
 
-    return 2;
-  }
-
-  public function readI32(&$value)
-  {
-    $data = $this->trans_->readAll(4);
-    $arr = unpack('N', $data);
-    $value = $arr[1];
-    if ($value > 0x7fffffff) {
-      $value = 0 - (($value - 1) ^ 0xffffffff);
+    public function writeFieldBegin($fieldName, $fieldType, $fieldId)
+    {
+        return
+            $this->writeByte($fieldType) +
+            $this->writeI16($fieldId);
     }
 
-    return 4;
-  }
+    public function writeFieldEnd()
+    {
+        return 0;
+    }
 
-  public function readI64(&$value)
-  {
-    $data = $this->trans_->readAll(8);
+    public function writeFieldStop()
+    {
+        return
+            $this->writeByte(TType::STOP);
+    }
 
-    $arr = unpack('N2', $data);
+    public function writeMapBegin($keyType, $valType, $size)
+    {
+        return
+            $this->writeByte($keyType) +
+            $this->writeByte($valType) +
+            $this->writeI32($size);
+    }
 
-    // If we are on a 32bit architecture we have to explicitly deal with
-    // 64-bit twos-complement arithmetic since PHP wants to treat all ints
-    // as signed and any int over 2^31 - 1 as a float
-    if (PHP_INT_SIZE == 4) {
+    public function writeMapEnd()
+    {
+        return 0;
+    }
 
-      $hi = $arr[1];
-      $lo = $arr[2];
-      $isNeg = $hi  < 0;
+    public function writeListBegin($elemType, $size)
+    {
+        return
+            $this->writeByte($elemType) +
+            $this->writeI32($size);
+    }
 
-      // Check for a negative
-      if ($isNeg) {
-        $hi = ~$hi & (int) 0xffffffff;
-        $lo = ~$lo & (int) 0xffffffff;
+    public function writeListEnd()
+    {
+        return 0;
+    }
 
-        if ($lo == (int) 0xffffffff) {
-          $hi++;
-          $lo = 0;
+    public function writeSetBegin($elemType, $size)
+    {
+        return
+            $this->writeByte($elemType) +
+            $this->writeI32($size);
+    }
+
+    public function writeSetEnd()
+    {
+        return 0;
+    }
+
+    public function writeBool($value)
+    {
+        $data = pack('c', $value ? 1 : 0);
+        $this->trans_->write($data, 1);
+
+        return 1;
+    }
+
+    public function writeByte($value)
+    {
+        $data = pack('c', $value);
+        $this->trans_->write($data, 1);
+
+        return 1;
+    }
+
+    public function writeI16($value)
+    {
+        $data = pack('n', $value);
+        $this->trans_->write($data, 2);
+
+        return 2;
+    }
+
+    public function writeI32($value)
+    {
+        $data = pack('N', $value);
+        $this->trans_->write($data, 4);
+
+        return 4;
+    }
+
+    public function writeI64($value)
+    {
+        // If we are on a 32bit architecture we have to explicitly deal with
+        // 64-bit twos-complement arithmetic since PHP wants to treat all ints
+        // as signed and any int over 2^31 - 1 as a float
+        if (PHP_INT_SIZE == 4) {
+            $neg = $value < 0;
+
+            if ($neg) {
+                $value *= -1;
+            }
+
+            $hi = (int)($value / 4294967296);
+            $lo = (int)$value;
+
+            if ($neg) {
+                $hi = ~$hi;
+                $lo = ~$lo;
+                if (($lo & (int)0xffffffff) == (int)0xffffffff) {
+                    $lo = 0;
+                    $hi++;
+                } else {
+                    $lo++;
+                }
+            }
+            $data = pack('N2', $hi, $lo);
         } else {
-          $lo++;
+            $hi = $value >> 32;
+            $lo = $value & 0xFFFFFFFF;
+            $data = pack('N2', $hi, $lo);
         }
-      }
 
-      // Force 32bit words in excess of 2G to pe positive - we deal wigh sign
-      // explicitly below
+        $this->trans_->write($data, 8);
 
-      if ($hi & (int) 0x80000000) {
-        $hi &= (int) 0x7fffffff;
-        $hi += 0x80000000;
-      }
-
-      if ($lo & (int) 0x80000000) {
-        $lo &= (int) 0x7fffffff;
-        $lo += 0x80000000;
-      }
-
-      $value = $hi * 4294967296 + $lo;
-
-      if ($isNeg) {
-        $value = 0 - $value;
-      }
-    } else {
-
-      // Upcast negatives in LSB bit
-      if ($arr[2] & 0x80000000) {
-        $arr[2] = $arr[2] & 0xffffffff;
-      }
-
-      // Check for a negative
-      if ($arr[1] & 0x80000000) {
-        $arr[1] = $arr[1] & 0xffffffff;
-        $arr[1] = $arr[1] ^ 0xffffffff;
-        $arr[2] = $arr[2] ^ 0xffffffff;
-        $value = 0 - $arr[1]*4294967296 - $arr[2] - 1;
-      } else {
-        $value = $arr[1]*4294967296 + $arr[2];
-      }
+        return 8;
     }
 
-    return 8;
-  }
+    public function writeDouble($value)
+    {
+        $data = pack('d', $value);
+        $this->trans_->write(strrev($data), 8);
 
-  public function readDouble(&$value)
-  {
-    $data = strrev($this->trans_->readAll(8));
-    $arr = unpack('d', $data);
-    $value = $arr[1];
-
-    return 8;
-  }
-
-  public function readString(&$value)
-  {
-    $result = $this->readI32($len);
-    if ($len) {
-      $value = $this->trans_->readAll($len);
-    } else {
-      $value = '';
+        return 8;
     }
 
-    return $result + $len;
-  }
+    public function writeString($value)
+    {
+        $len = TStringFuncFactory::create()->strlen($value);
+        $result = $this->writeI32($len);
+        if ($len) {
+            $this->trans_->write($value, $len);
+        }
+
+        return $result + $len;
+    }
+
+    public function readMessageBegin(&$name, &$type, &$seqid)
+    {
+        $result = $this->readI32($sz);
+        if ($sz < 0) {
+            $version = (int)($sz & self::VERSION_MASK);
+            if ($version != (int)self::VERSION_1) {
+                throw new TProtocolException('Bad version identifier: ' . $sz, TProtocolException::BAD_VERSION);
+            }
+            $type = $sz & 0x000000ff;
+            $result +=
+                $this->readString($name) +
+                $this->readI32($seqid);
+        } else {
+            if ($this->strictRead_) {
+                throw new TProtocolException(
+                    'No version identifier, old protocol client?',
+                    TProtocolException::BAD_VERSION
+                );
+            } else {
+                // Handle pre-versioned input
+                $name = $this->trans_->readAll($sz);
+                $result +=
+                    $sz +
+                    $this->readByte($type) +
+                    $this->readI32($seqid);
+            }
+        }
+
+        return $result;
+    }
+
+    public function readMessageEnd()
+    {
+        return 0;
+    }
+
+    public function readStructBegin(&$name)
+    {
+        $name = '';
+
+        return 0;
+    }
+
+    public function readStructEnd()
+    {
+        return 0;
+    }
+
+    public function readFieldBegin(&$name, &$fieldType, &$fieldId)
+    {
+        $result = $this->readByte($fieldType);
+        if ($fieldType == TType::STOP) {
+            $fieldId = 0;
+
+            return $result;
+        }
+        $result += $this->readI16($fieldId);
+
+        return $result;
+    }
+
+    public function readFieldEnd()
+    {
+        return 0;
+    }
+
+    public function readMapBegin(&$keyType, &$valType, &$size)
+    {
+        return
+            $this->readByte($keyType) +
+            $this->readByte($valType) +
+            $this->readI32($size);
+    }
+
+    public function readMapEnd()
+    {
+        return 0;
+    }
+
+    public function readListBegin(&$elemType, &$size)
+    {
+        return
+            $this->readByte($elemType) +
+            $this->readI32($size);
+    }
+
+    public function readListEnd()
+    {
+        return 0;
+    }
+
+    public function readSetBegin(&$elemType, &$size)
+    {
+        return
+            $this->readByte($elemType) +
+            $this->readI32($size);
+    }
+
+    public function readSetEnd()
+    {
+        return 0;
+    }
+
+    public function readBool(&$value)
+    {
+        $data = $this->trans_->readAll(1);
+        $arr = unpack('c', $data);
+        $value = $arr[1] == 1;
+
+        return 1;
+    }
+
+    public function readByte(&$value)
+    {
+        $data = $this->trans_->readAll(1);
+        $arr = unpack('c', $data);
+        $value = $arr[1];
+
+        return 1;
+    }
+
+    public function readI16(&$value)
+    {
+        $data = $this->trans_->readAll(2);
+        $arr = unpack('n', $data);
+        $value = $arr[1];
+        if ($value > 0x7fff) {
+            $value = 0 - (($value - 1) ^ 0xffff);
+        }
+
+        return 2;
+    }
+
+    public function readI32(&$value)
+    {
+        $data = $this->trans_->readAll(4);
+        $arr = unpack('N', $data);
+        $value = $arr[1];
+        if ($value > 0x7fffffff) {
+            $value = 0 - (($value - 1) ^ 0xffffffff);
+        }
+
+        return 4;
+    }
+
+    public function readI64(&$value)
+    {
+        $data = $this->trans_->readAll(8);
+
+        $arr = unpack('N2', $data);
+
+        // If we are on a 32bit architecture we have to explicitly deal with
+        // 64-bit twos-complement arithmetic since PHP wants to treat all ints
+        // as signed and any int over 2^31 - 1 as a float
+        if (PHP_INT_SIZE == 4) {
+            $hi = $arr[1];
+            $lo = $arr[2];
+            $isNeg = $hi < 0;
+
+            // Check for a negative
+            if ($isNeg) {
+                $hi = ~$hi & (int)0xffffffff;
+                $lo = ~$lo & (int)0xffffffff;
+
+                if ($lo == (int)0xffffffff) {
+                    $hi++;
+                    $lo = 0;
+                } else {
+                    $lo++;
+                }
+            }
+
+            // Force 32bit words in excess of 2G to pe positive - we deal wigh sign
+            // explicitly below
+
+            if ($hi & (int)0x80000000) {
+                $hi &= (int)0x7fffffff;
+                $hi += 0x80000000;
+            }
+
+            if ($lo & (int)0x80000000) {
+                $lo &= (int)0x7fffffff;
+                $lo += 0x80000000;
+            }
+
+            $value = $hi * 4294967296 + $lo;
+
+            if ($isNeg) {
+                $value = 0 - $value;
+            }
+        } else {
+            // Upcast negatives in LSB bit
+            if ($arr[2] & 0x80000000) {
+                $arr[2] = $arr[2] & 0xffffffff;
+            }
+
+            // Check for a negative
+            if ($arr[1] & 0x80000000) {
+                $arr[1] = $arr[1] & 0xffffffff;
+                $arr[1] = $arr[1] ^ 0xffffffff;
+                $arr[2] = $arr[2] ^ 0xffffffff;
+                $value = 0 - $arr[1] * 4294967296 - $arr[2] - 1;
+            } else {
+                $value = $arr[1] * 4294967296 + $arr[2];
+            }
+        }
+
+        return 8;
+    }
+
+    public function readDouble(&$value)
+    {
+        $data = strrev($this->trans_->readAll(8));
+        $arr = unpack('d', $data);
+        $value = $arr[1];
+
+        return 8;
+    }
+
+    public function readString(&$value)
+    {
+        $result = $this->readI32($len);
+        if ($len) {
+            $value = $this->trans_->readAll($len);
+        } else {
+            $value = '';
+        }
+
+        return $result + $len;
+    }
 }
diff --git a/lib/php/lib/Protocol/TBinaryProtocolAccelerated.php b/lib/php/lib/Protocol/TBinaryProtocolAccelerated.php
index f0e0bb9..ff799a6 100644
--- a/lib/php/lib/Protocol/TBinaryProtocolAccelerated.php
+++ b/lib/php/lib/Protocol/TBinaryProtocolAccelerated.php
@@ -30,36 +30,38 @@
  */
 class TBinaryProtocolAccelerated extends TBinaryProtocol
 {
-  public function __construct($trans, $strictRead=false, $strictWrite=true)
-  {
-    // If the transport doesn't implement putBack, wrap it in a
-    // TBufferedTransport (which does)
+    public function __construct($trans, $strictRead = false, $strictWrite = true)
+    {
+        // If the transport doesn't implement putBack, wrap it in a
+        // TBufferedTransport (which does)
 
-    // NOTE (t.heintz): This is very evil to do, because the TBufferedTransport may swallow bytes, which
-    // are then never written to the underlying transport. This happens precisely when a number of bytes
-    // less than the max buffer size (512 by default) is written to the transport and then flush() is NOT
-    // called. In that case the data stays in the writeBuffer of the transport, from where it can never be
-    // accessed again (for example through read()).
-    //
-    // Since the caller of this method does not know about the wrapping transport, this creates bugs which
-    // are very difficult to find. Hence the wrapping of a transport in a buffer should be left to the
-    // calling code. An interface could used to mandate the presence of the putBack() method in the transport.
-    //
-    // I am leaving this code in nonetheless, because there may be applications depending on this behavior.
-    //
-    // @see THRIFT-1579
+        // NOTE (t.heintz): This is very evil to do, because the TBufferedTransport may swallow bytes, which
+        // are then never written to the underlying transport. This happens precisely when a number of bytes
+        // less than the max buffer size (512 by default) is written to the transport and then flush() is NOT
+        // called. In that case the data stays in the writeBuffer of the transport, from where it can never be
+        // accessed again (for example through read()).
+        //
+        // Since the caller of this method does not know about the wrapping transport, this creates bugs which
+        // are very difficult to find. Hence the wrapping of a transport in a buffer should be left to the
+        // calling code. An interface could used to mandate the presence of the putBack() method in the transport.
+        //
+        // I am leaving this code in nonetheless, because there may be applications depending on this behavior.
+        //
+        // @see THRIFT-1579
 
-    if (!method_exists($trans, 'putBack')) {
-      $trans = new TBufferedTransport($trans);
+        if (!method_exists($trans, 'putBack')) {
+            $trans = new TBufferedTransport($trans);
+        }
+        parent::__construct($trans, $strictRead, $strictWrite);
     }
-    parent::__construct($trans, $strictRead, $strictWrite);
-  }
-  public function isStrictRead()
-  {
-    return $this->strictRead_;
-  }
-  public function isStrictWrite()
-  {
-    return $this->strictWrite_;
-  }
+
+    public function isStrictRead()
+    {
+        return $this->strictRead_;
+    }
+
+    public function isStrictWrite()
+    {
+        return $this->strictWrite_;
+    }
 }
diff --git a/lib/php/lib/Protocol/TCompactProtocol.php b/lib/php/lib/Protocol/TCompactProtocol.php
index c25b050..1af2a27 100644
--- a/lib/php/lib/Protocol/TCompactProtocol.php
+++ b/lib/php/lib/Protocol/TCompactProtocol.php
@@ -32,708 +32,708 @@
  */
 class TCompactProtocol extends TProtocol
 {
-  const COMPACT_STOP = 0x00;
-  const COMPACT_TRUE = 0x01;
-  const COMPACT_FALSE = 0x02;
-  const COMPACT_BYTE = 0x03;
-  const COMPACT_I16 = 0x04;
-  const COMPACT_I32 = 0x05;
-  const COMPACT_I64 = 0x06;
-  const COMPACT_DOUBLE = 0x07;
-  const COMPACT_BINARY = 0x08;
-  const COMPACT_LIST = 0x09;
-  const COMPACT_SET = 0x0A;
-  const COMPACT_MAP = 0x0B;
-  const COMPACT_STRUCT = 0x0C;
+    const COMPACT_STOP = 0x00;
+    const COMPACT_TRUE = 0x01;
+    const COMPACT_FALSE = 0x02;
+    const COMPACT_BYTE = 0x03;
+    const COMPACT_I16 = 0x04;
+    const COMPACT_I32 = 0x05;
+    const COMPACT_I64 = 0x06;
+    const COMPACT_DOUBLE = 0x07;
+    const COMPACT_BINARY = 0x08;
+    const COMPACT_LIST = 0x09;
+    const COMPACT_SET = 0x0A;
+    const COMPACT_MAP = 0x0B;
+    const COMPACT_STRUCT = 0x0C;
 
-  const STATE_CLEAR = 0;
-  const STATE_FIELD_WRITE = 1;
-  const STATE_VALUE_WRITE = 2;
-  const STATE_CONTAINER_WRITE = 3;
-  const STATE_BOOL_WRITE = 4;
-  const STATE_FIELD_READ = 5;
-  const STATE_CONTAINER_READ = 6;
-  const STATE_VALUE_READ = 7;
-  const STATE_BOOL_READ = 8;
+    const STATE_CLEAR = 0;
+    const STATE_FIELD_WRITE = 1;
+    const STATE_VALUE_WRITE = 2;
+    const STATE_CONTAINER_WRITE = 3;
+    const STATE_BOOL_WRITE = 4;
+    const STATE_FIELD_READ = 5;
+    const STATE_CONTAINER_READ = 6;
+    const STATE_VALUE_READ = 7;
+    const STATE_BOOL_READ = 8;
 
-  const VERSION_MASK = 0x1f;
-  const VERSION = 1;
-  const PROTOCOL_ID = 0x82;
-  const TYPE_MASK = 0xe0;
-  const TYPE_BITS = 0x07;
-  const TYPE_SHIFT_AMOUNT = 5;
+    const VERSION_MASK = 0x1f;
+    const VERSION = 1;
+    const PROTOCOL_ID = 0x82;
+    const TYPE_MASK = 0xe0;
+    const TYPE_BITS = 0x07;
+    const TYPE_SHIFT_AMOUNT = 5;
 
-  protected static $ctypes = array(
-    TType::STOP => TCompactProtocol::COMPACT_STOP,
-    TType::BOOL => TCompactProtocol::COMPACT_TRUE, // used for collection
-    TType::BYTE => TCompactProtocol::COMPACT_BYTE,
-    TType::I16 => TCompactProtocol::COMPACT_I16,
-    TType::I32 => TCompactProtocol::COMPACT_I32,
-    TType::I64 => TCompactProtocol::COMPACT_I64,
-    TType::DOUBLE => TCompactProtocol::COMPACT_DOUBLE,
-    TType::STRING => TCompactProtocol::COMPACT_BINARY,
-    TType::STRUCT => TCompactProtocol::COMPACT_STRUCT,
-    TType::LST => TCompactProtocol::COMPACT_LIST,
-    TType::SET => TCompactProtocol::COMPACT_SET,
-    TType::MAP => TCompactProtocol::COMPACT_MAP,
-  );
+    protected static $ctypes = array(
+        TType::STOP => TCompactProtocol::COMPACT_STOP,
+        TType::BOOL => TCompactProtocol::COMPACT_TRUE, // used for collection
+        TType::BYTE => TCompactProtocol::COMPACT_BYTE,
+        TType::I16 => TCompactProtocol::COMPACT_I16,
+        TType::I32 => TCompactProtocol::COMPACT_I32,
+        TType::I64 => TCompactProtocol::COMPACT_I64,
+        TType::DOUBLE => TCompactProtocol::COMPACT_DOUBLE,
+        TType::STRING => TCompactProtocol::COMPACT_BINARY,
+        TType::STRUCT => TCompactProtocol::COMPACT_STRUCT,
+        TType::LST => TCompactProtocol::COMPACT_LIST,
+        TType::SET => TCompactProtocol::COMPACT_SET,
+        TType::MAP => TCompactProtocol::COMPACT_MAP,
+    );
 
-  protected static $ttypes = array(
-    TCompactProtocol::COMPACT_STOP => TType::STOP ,
-    TCompactProtocol::COMPACT_TRUE => TType::BOOL, // used for collection
-    TCompactProtocol::COMPACT_FALSE => TType::BOOL,
-    TCompactProtocol::COMPACT_BYTE => TType::BYTE,
-    TCompactProtocol::COMPACT_I16 => TType::I16,
-    TCompactProtocol::COMPACT_I32 => TType::I32,
-    TCompactProtocol::COMPACT_I64 => TType::I64,
-    TCompactProtocol::COMPACT_DOUBLE => TType::DOUBLE,
-    TCompactProtocol::COMPACT_BINARY => TType::STRING,
-    TCompactProtocol::COMPACT_STRUCT => TType::STRUCT,
-    TCompactProtocol::COMPACT_LIST => TType::LST,
-    TCompactProtocol::COMPACT_SET => TType::SET,
-    TCompactProtocol::COMPACT_MAP => TType::MAP,
-  );
+    protected static $ttypes = array(
+        TCompactProtocol::COMPACT_STOP => TType::STOP,
+        TCompactProtocol::COMPACT_TRUE => TType::BOOL, // used for collection
+        TCompactProtocol::COMPACT_FALSE => TType::BOOL,
+        TCompactProtocol::COMPACT_BYTE => TType::BYTE,
+        TCompactProtocol::COMPACT_I16 => TType::I16,
+        TCompactProtocol::COMPACT_I32 => TType::I32,
+        TCompactProtocol::COMPACT_I64 => TType::I64,
+        TCompactProtocol::COMPACT_DOUBLE => TType::DOUBLE,
+        TCompactProtocol::COMPACT_BINARY => TType::STRING,
+        TCompactProtocol::COMPACT_STRUCT => TType::STRUCT,
+        TCompactProtocol::COMPACT_LIST => TType::LST,
+        TCompactProtocol::COMPACT_SET => TType::SET,
+        TCompactProtocol::COMPACT_MAP => TType::MAP,
+    );
 
-  protected $state = TCompactProtocol::STATE_CLEAR;
-  protected $lastFid = 0;
-  protected $boolFid = null;
-  protected $boolValue = null;
-  protected $structs = array();
-  protected $containers = array();
+    protected $state = TCompactProtocol::STATE_CLEAR;
+    protected $lastFid = 0;
+    protected $boolFid = null;
+    protected $boolValue = null;
+    protected $structs = array();
+    protected $containers = array();
 
-  // Some varint / zigzag helper methods
-  public function toZigZag($n, $bits)
-  {
-    return ($n << 1) ^ ($n >> ($bits - 1));
-  }
-
-  public function fromZigZag($n)
-  {
-    return ($n >> 1) ^ -($n & 1);
-  }
-
-  public function getVarint($data)
-  {
-    $out = "";
-    while (true) {
-      if (($data & ~0x7f) === 0) {
-        $out .= chr($data);
-        break;
-      } else {
-        $out .= chr(($data & 0xff) | 0x80);
-        $data = $data >> 7;
-      }
+    // Some varint / zigzag helper methods
+    public function toZigZag($n, $bits)
+    {
+        return ($n << 1) ^ ($n >> ($bits - 1));
     }
 
-    return $out;
-  }
+    public function fromZigZag($n)
+    {
+        return ($n >> 1) ^ -($n & 1);
+    }
 
-  public function writeVarint($data)
-  {
-    $out = $this->getVarint($data);
-    $result = TStringFuncFactory::create()->strlen($out);
-    $this->trans_->write($out, $result);
+    public function getVarint($data)
+    {
+        $out = "";
+        while (true) {
+            if (($data & ~0x7f) === 0) {
+                $out .= chr($data);
+                break;
+            } else {
+                $out .= chr(($data & 0xff) | 0x80);
+                $data = $data >> 7;
+            }
+        }
 
-    return $result;
-  }
+        return $out;
+    }
 
-  public function readVarint(&$result)
-  {
-    $idx = 0;
-    $shift = 0;
-    $result = 0;
-    while (true) {
-      $x = $this->trans_->readAll(1);
-      $arr = unpack('C', $x);
-      $byte = $arr[1];
-      $idx += 1;
-      $result |= ($byte & 0x7f) << $shift;
-      if (($byte >> 7) === 0) {
+    public function writeVarint($data)
+    {
+        $out = $this->getVarint($data);
+        $result = TStringFuncFactory::create()->strlen($out);
+        $this->trans_->write($out, $result);
+
+        return $result;
+    }
+
+    public function readVarint(&$result)
+    {
+        $idx = 0;
+        $shift = 0;
+        $result = 0;
+        while (true) {
+            $x = $this->trans_->readAll(1);
+            $arr = unpack('C', $x);
+            $byte = $arr[1];
+            $idx += 1;
+            $result |= ($byte & 0x7f) << $shift;
+            if (($byte >> 7) === 0) {
+                return $idx;
+            }
+            $shift += 7;
+        }
+
         return $idx;
-      }
-      $shift += 7;
     }
 
-    return $idx;
-  }
-
-  public function __construct($trans)
-  {
-    parent::__construct($trans);
-  }
-
-  public function writeMessageBegin($name, $type, $seqid)
-  {
-    $written =
-      $this->writeUByte(TCompactProtocol::PROTOCOL_ID) +
-      $this->writeUByte(TCompactProtocol::VERSION |
-                        ($type << TCompactProtocol::TYPE_SHIFT_AMOUNT)) +
-      $this->writeVarint($seqid) +
-      $this->writeString($name);
-    $this->state = TCompactProtocol::STATE_VALUE_WRITE;
-
-    return $written;
-  }
-
-  public function writeMessageEnd()
-  {
-    $this->state = TCompactProtocol::STATE_CLEAR;
-
-    return 0;
-  }
-
-  public function writeStructBegin($name)
-  {
-    $this->structs[] = array($this->state, $this->lastFid);
-    $this->state = TCompactProtocol::STATE_FIELD_WRITE;
-    $this->lastFid = 0;
-
-    return 0;
-  }
-
-  public function writeStructEnd()
-  {
-    $old_values = array_pop($this->structs);
-    $this->state = $old_values[0];
-    $this->lastFid = $old_values[1];
-
-    return 0;
-  }
-
-  public function writeFieldStop()
-  {
-    return $this->writeByte(0);
-  }
-
-  public function writeFieldHeader($type, $fid)
-  {
-    $written = 0;
-    $delta = $fid - $this->lastFid;
-    if (0 < $delta && $delta <= 15) {
-      $written = $this->writeUByte(($delta << 4) | $type);
-    } else {
-      $written = $this->writeByte($type) +
-        $this->writeI16($fid);
-    }
-    $this->lastFid = $fid;
-
-    return $written;
-  }
-
-  public function writeFieldBegin($field_name, $field_type, $field_id)
-  {
-    if ($field_type == TTYPE::BOOL) {
-      $this->state = TCompactProtocol::STATE_BOOL_WRITE;
-      $this->boolFid = $field_id;
-
-      return 0;
-    } else {
-      $this->state = TCompactProtocol::STATE_VALUE_WRITE;
-
-      return $this->writeFieldHeader(self::$ctypes[$field_type], $field_id);
-    }
-  }
-
-  public function writeFieldEnd()
-  {
-    $this->state = TCompactProtocol::STATE_FIELD_WRITE;
-
-    return 0;
-  }
-
-  public function writeCollectionBegin($etype, $size)
-  {
-    $written = 0;
-    if ($size <= 14) {
-      $written = $this->writeUByte($size << 4 |
-                                    self::$ctypes[$etype]);
-    } else {
-      $written = $this->writeUByte(0xf0 |
-                                   self::$ctypes[$etype]) +
-        $this->writeVarint($size);
-    }
-    $this->containers[] = $this->state;
-    $this->state = TCompactProtocol::STATE_CONTAINER_WRITE;
-
-    return $written;
-  }
-
-  public function writeMapBegin($key_type, $val_type, $size)
-  {
-    $written = 0;
-    if ($size == 0) {
-      $written = $this->writeByte(0);
-    } else {
-      $written = $this->writeVarint($size) +
-        $this->writeUByte(self::$ctypes[$key_type] << 4 |
-                          self::$ctypes[$val_type]);
-    }
-    $this->containers[] = $this->state;
-
-    return $written;
-  }
-
-  public function writeCollectionEnd()
-  {
-    $this->state = array_pop($this->containers);
-
-    return 0;
-  }
-
-  public function writeMapEnd()
-  {
-    return $this->writeCollectionEnd();
-  }
-
-  public function writeListBegin($elem_type, $size)
-  {
-    return $this->writeCollectionBegin($elem_type, $size);
-  }
-
-  public function writeListEnd()
-  {
-    return $this->writeCollectionEnd();
-  }
-
-  public function writeSetBegin($elem_type, $size)
-  {
-    return $this->writeCollectionBegin($elem_type, $size);
-  }
-
-  public function writeSetEnd()
-  {
-    return $this->writeCollectionEnd();
-  }
-
-  public function writeBool($value)
-  {
-    if ($this->state == TCompactProtocol::STATE_BOOL_WRITE) {
-      $ctype = TCompactProtocol::COMPACT_FALSE;
-      if ($value) {
-        $ctype = TCompactProtocol::COMPACT_TRUE;
-      }
-
-      return $this->writeFieldHeader($ctype, $this->boolFid);
-    } elseif ($this->state == TCompactProtocol::STATE_CONTAINER_WRITE) {
-      return $this->writeByte($value ? 1 : 0);
-    } else {
-      throw new TProtocolException('Invalid state in compact protocol');
-    }
-  }
-
-  public function writeByte($value)
-  {
-    $data = pack('c', $value);
-    $this->trans_->write($data, 1);
-
-    return 1;
-  }
-
-  public function writeUByte($byte)
-  {
-    $this->trans_->write(pack('C', $byte), 1);
-
-    return 1;
-  }
-
-  public function writeI16($value)
-  {
-    $thing = $this->toZigZag($value, 16);
-
-    return $this->writeVarint($thing);
-  }
-
-  public function writeI32($value)
-  {
-    $thing = $this->toZigZag($value, 32);
-
-    return $this->writeVarint($thing);
-  }
-
-  public function writeDouble($value)
-  {
-    $data = pack('d', $value);
-    $this->trans_->write($data, 8);
-
-    return 8;
-  }
-
-  public function writeString($value)
-  {
-    $len = TStringFuncFactory::create()->strlen($value);
-    $result = $this->writeVarint($len);
-    if ($len) {
-      $this->trans_->write($value, $len);
+    public function __construct($trans)
+    {
+        parent::__construct($trans);
     }
 
-    return $result + $len;
-  }
+    public function writeMessageBegin($name, $type, $seqid)
+    {
+        $written =
+            $this->writeUByte(TCompactProtocol::PROTOCOL_ID) +
+            $this->writeUByte(TCompactProtocol::VERSION |
+                ($type << TCompactProtocol::TYPE_SHIFT_AMOUNT)) +
+            $this->writeVarint($seqid) +
+            $this->writeString($name);
+        $this->state = TCompactProtocol::STATE_VALUE_WRITE;
 
-  public function readFieldBegin(&$name, &$field_type, &$field_id)
-  {
-    $result = $this->readUByte($compact_type_and_delta);
-
-    $compact_type = $compact_type_and_delta & 0x0f;
-
-    if ($compact_type == TType::STOP) {
-      $field_type = $compact_type;
-      $field_id = 0;
-
-      return $result;
-    }
-    $delta = $compact_type_and_delta >> 4;
-    if ($delta == 0) {
-      $result += $this->readI16($field_id);
-    } else {
-      $field_id = $this->lastFid + $delta;
-    }
-    $this->lastFid = $field_id;
-    $field_type = $this->getTType($compact_type);
-
-    if ($compact_type == TCompactProtocol::COMPACT_TRUE) {
-      $this->state = TCompactProtocol::STATE_BOOL_READ;
-      $this->boolValue = true;
-    } elseif ($compact_type == TCompactProtocol::COMPACT_FALSE) {
-      $this->state = TCompactProtocol::STATE_BOOL_READ;
-      $this->boolValue = false;
-    } else {
-      $this->state = TCompactProtocol::STATE_VALUE_READ;
+        return $written;
     }
 
-    return $result;
-  }
+    public function writeMessageEnd()
+    {
+        $this->state = TCompactProtocol::STATE_CLEAR;
 
-  public function readFieldEnd()
-  {
-    $this->state = TCompactProtocol::STATE_FIELD_READ;
-
-    return 0;
-  }
-
-  public function readUByte(&$value)
-  {
-    $data = $this->trans_->readAll(1);
-    $arr = unpack('C', $data);
-    $value = $arr[1];
-
-    return 1;
-  }
-
-  public function readByte(&$value)
-  {
-    $data = $this->trans_->readAll(1);
-    $arr = unpack('c', $data);
-    $value = $arr[1];
-
-    return 1;
-  }
-
-  public function readZigZag(&$value)
-  {
-    $result = $this->readVarint($value);
-    $value = $this->fromZigZag($value);
-
-    return $result;
-  }
-
-  public function readMessageBegin(&$name, &$type, &$seqid)
-  {
-    $protoId = 0;
-    $result = $this->readUByte($protoId);
-    if ($protoId != TCompactProtocol::PROTOCOL_ID) {
-      throw new TProtocolException('Bad protocol id in TCompact message');
-    }
-    $verType = 0;
-    $result += $this->readUByte($verType);
-    $type = ($verType >> TCompactProtocol::TYPE_SHIFT_AMOUNT) & TCompactProtocol::TYPE_BITS;
-    $version = $verType & TCompactProtocol::VERSION_MASK;
-    if ($version != TCompactProtocol::VERSION) {
-      throw new TProtocolException('Bad version in TCompact message');
-    }
-    $result += $this->readVarint($seqid);
-    $result += $this->readString($name);
-
-    return $result;
-  }
-
-  public function readMessageEnd()
-  {
-    return 0;
-  }
-
-  public function readStructBegin(&$name)
-  {
-    $name = ''; // unused
-    $this->structs[] = array($this->state, $this->lastFid);
-    $this->state = TCompactProtocol::STATE_FIELD_READ;
-    $this->lastFid = 0;
-
-    return 0;
-  }
-
-  public function readStructEnd()
-  {
-    $last = array_pop($this->structs);
-    $this->state = $last[0];
-    $this->lastFid = $last[1];
-
-    return 0;
-  }
-
-  public function readCollectionBegin(&$type, &$size)
-  {
-    $sizeType = 0;
-    $result = $this->readUByte($sizeType);
-    $size = $sizeType >> 4;
-    $type = $this->getTType($sizeType);
-    if ($size == 15) {
-      $result += $this->readVarint($size);
-    }
-    $this->containers[] = $this->state;
-    $this->state = TCompactProtocol::STATE_CONTAINER_READ;
-
-    return $result;
-  }
-
-  public function readMapBegin(&$key_type, &$val_type, &$size)
-  {
-    $result = $this->readVarint($size);
-    $types = 0;
-    if ($size > 0) {
-      $result += $this->readUByte($types);
-    }
-    $val_type = $this->getTType($types);
-    $key_type = $this->getTType($types >> 4);
-    $this->containers[] = $this->state;
-    $this->state = TCompactProtocol::STATE_CONTAINER_READ;
-
-    return $result;
-  }
-
-  public function readCollectionEnd()
-  {
-    $this->state = array_pop($this->containers);
-
-    return 0;
-  }
-
-  public function readMapEnd()
-  {
-    return $this->readCollectionEnd();
-  }
-
-  public function readListBegin(&$elem_type, &$size)
-  {
-    return $this->readCollectionBegin($elem_type, $size);
-  }
-
-  public function readListEnd()
-  {
-    return $this->readCollectionEnd();
-  }
-
-  public function readSetBegin(&$elem_type, &$size)
-  {
-    return $this->readCollectionBegin($elem_type, $size);
-  }
-
-  public function readSetEnd()
-  {
-    return $this->readCollectionEnd();
-  }
-
-  public function readBool(&$value)
-  {
-    if ($this->state == TCompactProtocol::STATE_BOOL_READ) {
-      $value = $this->boolValue;
-
-      return 0;
-    } elseif ($this->state == TCompactProtocol::STATE_CONTAINER_READ) {
-      return $this->readByte($value);
-    } else {
-      throw new TProtocolException('Invalid state in compact protocol');
-    }
-  }
-
-  public function readI16(&$value)
-  {
-    return $this->readZigZag($value);
-  }
-
-  public function readI32(&$value)
-  {
-    return $this->readZigZag($value);
-  }
-
-  public function readDouble(&$value)
-  {
-    $data = $this->trans_->readAll(8);
-    $arr = unpack('d', $data);
-    $value = $arr[1];
-
-    return 8;
-  }
-
-  public function readString(&$value)
-  {
-    $result = $this->readVarint($len);
-    if ($len) {
-      $value = $this->trans_->readAll($len);
-    } else {
-      $value = '';
+        return 0;
     }
 
-    return $result + $len;
-  }
+    public function writeStructBegin($name)
+    {
+        $this->structs[] = array($this->state, $this->lastFid);
+        $this->state = TCompactProtocol::STATE_FIELD_WRITE;
+        $this->lastFid = 0;
 
-  public function getTType($byte)
-  {
-    return self::$ttypes[$byte & 0x0f];
-  }
-
-  // If we are on a 32bit architecture we have to explicitly deal with
-  // 64-bit twos-complement arithmetic since PHP wants to treat all ints
-  // as signed and any int over 2^31 - 1 as a float
-
-  // Read and write I64 as two 32 bit numbers $hi and $lo
-
-  public function readI64(&$value)
-  {
-    // Read varint from wire
-    $hi = 0;
-    $lo = 0;
-
-    $idx = 0;
-    $shift = 0;
-
-    while (true) {
-      $x = $this->trans_->readAll(1);
-      $arr = unpack('C', $x);
-      $byte = $arr[1];
-      $idx += 1;
-      // Shift hi and lo together.
-      if ($shift < 28) {
-        $lo |= (($byte & 0x7f) << $shift);
-      } elseif ($shift == 28) {
-        $lo |= (($byte & 0x0f) << 28);
-        $hi |= (($byte & 0x70) >> 4);
-      } else {
-        $hi |= (($byte & 0x7f) << ($shift - 32));
-      }
-      if (($byte >> 7) === 0) {
-        break;
-      }
-      $shift += 7;
+        return 0;
     }
 
-    // Now, unzig it.
-    $xorer = 0;
-    if ($lo & 1) {
-      $xorer = 0xffffffff;
+    public function writeStructEnd()
+    {
+        $old_values = array_pop($this->structs);
+        $this->state = $old_values[0];
+        $this->lastFid = $old_values[1];
+
+        return 0;
     }
-    $lo = ($lo >> 1) & 0x7fffffff;
-    $lo = $lo | (($hi & 1) << 31);
-    $hi = ($hi >> 1) ^ $xorer;
-    $lo = $lo ^ $xorer;
 
-    // Now put $hi and $lo back together
-    $isNeg = $hi < 0 || $hi & 0x80000000;
+    public function writeFieldStop()
+    {
+        return $this->writeByte(0);
+    }
 
-    // Check for a negative
-    if ($isNeg) {
-      $hi = ~$hi & (int) 0xffffffff;
-      $lo = ~$lo & (int) 0xffffffff;
+    public function writeFieldHeader($type, $fid)
+    {
+        $written = 0;
+        $delta = $fid - $this->lastFid;
+        if (0 < $delta && $delta <= 15) {
+            $written = $this->writeUByte(($delta << 4) | $type);
+        } else {
+            $written = $this->writeByte($type) +
+                $this->writeI16($fid);
+        }
+        $this->lastFid = $fid;
 
-      if ($lo == (int) 0xffffffff) {
-        $hi++;
+        return $written;
+    }
+
+    public function writeFieldBegin($field_name, $field_type, $field_id)
+    {
+        if ($field_type == TTYPE::BOOL) {
+            $this->state = TCompactProtocol::STATE_BOOL_WRITE;
+            $this->boolFid = $field_id;
+
+            return 0;
+        } else {
+            $this->state = TCompactProtocol::STATE_VALUE_WRITE;
+
+            return $this->writeFieldHeader(self::$ctypes[$field_type], $field_id);
+        }
+    }
+
+    public function writeFieldEnd()
+    {
+        $this->state = TCompactProtocol::STATE_FIELD_WRITE;
+
+        return 0;
+    }
+
+    public function writeCollectionBegin($etype, $size)
+    {
+        $written = 0;
+        if ($size <= 14) {
+            $written = $this->writeUByte($size << 4 |
+                self::$ctypes[$etype]);
+        } else {
+            $written = $this->writeUByte(0xf0 |
+                    self::$ctypes[$etype]) +
+                $this->writeVarint($size);
+        }
+        $this->containers[] = $this->state;
+        $this->state = TCompactProtocol::STATE_CONTAINER_WRITE;
+
+        return $written;
+    }
+
+    public function writeMapBegin($key_type, $val_type, $size)
+    {
+        $written = 0;
+        if ($size == 0) {
+            $written = $this->writeByte(0);
+        } else {
+            $written = $this->writeVarint($size) +
+                $this->writeUByte(self::$ctypes[$key_type] << 4 |
+                    self::$ctypes[$val_type]);
+        }
+        $this->containers[] = $this->state;
+
+        return $written;
+    }
+
+    public function writeCollectionEnd()
+    {
+        $this->state = array_pop($this->containers);
+
+        return 0;
+    }
+
+    public function writeMapEnd()
+    {
+        return $this->writeCollectionEnd();
+    }
+
+    public function writeListBegin($elem_type, $size)
+    {
+        return $this->writeCollectionBegin($elem_type, $size);
+    }
+
+    public function writeListEnd()
+    {
+        return $this->writeCollectionEnd();
+    }
+
+    public function writeSetBegin($elem_type, $size)
+    {
+        return $this->writeCollectionBegin($elem_type, $size);
+    }
+
+    public function writeSetEnd()
+    {
+        return $this->writeCollectionEnd();
+    }
+
+    public function writeBool($value)
+    {
+        if ($this->state == TCompactProtocol::STATE_BOOL_WRITE) {
+            $ctype = TCompactProtocol::COMPACT_FALSE;
+            if ($value) {
+                $ctype = TCompactProtocol::COMPACT_TRUE;
+            }
+
+            return $this->writeFieldHeader($ctype, $this->boolFid);
+        } elseif ($this->state == TCompactProtocol::STATE_CONTAINER_WRITE) {
+            return $this->writeByte($value ? 1 : 0);
+        } else {
+            throw new TProtocolException('Invalid state in compact protocol');
+        }
+    }
+
+    public function writeByte($value)
+    {
+        $data = pack('c', $value);
+        $this->trans_->write($data, 1);
+
+        return 1;
+    }
+
+    public function writeUByte($byte)
+    {
+        $this->trans_->write(pack('C', $byte), 1);
+
+        return 1;
+    }
+
+    public function writeI16($value)
+    {
+        $thing = $this->toZigZag($value, 16);
+
+        return $this->writeVarint($thing);
+    }
+
+    public function writeI32($value)
+    {
+        $thing = $this->toZigZag($value, 32);
+
+        return $this->writeVarint($thing);
+    }
+
+    public function writeDouble($value)
+    {
+        $data = pack('d', $value);
+        $this->trans_->write($data, 8);
+
+        return 8;
+    }
+
+    public function writeString($value)
+    {
+        $len = TStringFuncFactory::create()->strlen($value);
+        $result = $this->writeVarint($len);
+        if ($len) {
+            $this->trans_->write($value, $len);
+        }
+
+        return $result + $len;
+    }
+
+    public function readFieldBegin(&$name, &$field_type, &$field_id)
+    {
+        $result = $this->readUByte($compact_type_and_delta);
+
+        $compact_type = $compact_type_and_delta & 0x0f;
+
+        if ($compact_type == TType::STOP) {
+            $field_type = $compact_type;
+            $field_id = 0;
+
+            return $result;
+        }
+        $delta = $compact_type_and_delta >> 4;
+        if ($delta == 0) {
+            $result += $this->readI16($field_id);
+        } else {
+            $field_id = $this->lastFid + $delta;
+        }
+        $this->lastFid = $field_id;
+        $field_type = $this->getTType($compact_type);
+
+        if ($compact_type == TCompactProtocol::COMPACT_TRUE) {
+            $this->state = TCompactProtocol::STATE_BOOL_READ;
+            $this->boolValue = true;
+        } elseif ($compact_type == TCompactProtocol::COMPACT_FALSE) {
+            $this->state = TCompactProtocol::STATE_BOOL_READ;
+            $this->boolValue = false;
+        } else {
+            $this->state = TCompactProtocol::STATE_VALUE_READ;
+        }
+
+        return $result;
+    }
+
+    public function readFieldEnd()
+    {
+        $this->state = TCompactProtocol::STATE_FIELD_READ;
+
+        return 0;
+    }
+
+    public function readUByte(&$value)
+    {
+        $data = $this->trans_->readAll(1);
+        $arr = unpack('C', $data);
+        $value = $arr[1];
+
+        return 1;
+    }
+
+    public function readByte(&$value)
+    {
+        $data = $this->trans_->readAll(1);
+        $arr = unpack('c', $data);
+        $value = $arr[1];
+
+        return 1;
+    }
+
+    public function readZigZag(&$value)
+    {
+        $result = $this->readVarint($value);
+        $value = $this->fromZigZag($value);
+
+        return $result;
+    }
+
+    public function readMessageBegin(&$name, &$type, &$seqid)
+    {
+        $protoId = 0;
+        $result = $this->readUByte($protoId);
+        if ($protoId != TCompactProtocol::PROTOCOL_ID) {
+            throw new TProtocolException('Bad protocol id in TCompact message');
+        }
+        $verType = 0;
+        $result += $this->readUByte($verType);
+        $type = ($verType >> TCompactProtocol::TYPE_SHIFT_AMOUNT) & TCompactProtocol::TYPE_BITS;
+        $version = $verType & TCompactProtocol::VERSION_MASK;
+        if ($version != TCompactProtocol::VERSION) {
+            throw new TProtocolException('Bad version in TCompact message');
+        }
+        $result += $this->readVarint($seqid);
+        $result += $this->readString($name);
+
+        return $result;
+    }
+
+    public function readMessageEnd()
+    {
+        return 0;
+    }
+
+    public function readStructBegin(&$name)
+    {
+        $name = ''; // unused
+        $this->structs[] = array($this->state, $this->lastFid);
+        $this->state = TCompactProtocol::STATE_FIELD_READ;
+        $this->lastFid = 0;
+
+        return 0;
+    }
+
+    public function readStructEnd()
+    {
+        $last = array_pop($this->structs);
+        $this->state = $last[0];
+        $this->lastFid = $last[1];
+
+        return 0;
+    }
+
+    public function readCollectionBegin(&$type, &$size)
+    {
+        $sizeType = 0;
+        $result = $this->readUByte($sizeType);
+        $size = $sizeType >> 4;
+        $type = $this->getTType($sizeType);
+        if ($size == 15) {
+            $result += $this->readVarint($size);
+        }
+        $this->containers[] = $this->state;
+        $this->state = TCompactProtocol::STATE_CONTAINER_READ;
+
+        return $result;
+    }
+
+    public function readMapBegin(&$key_type, &$val_type, &$size)
+    {
+        $result = $this->readVarint($size);
+        $types = 0;
+        if ($size > 0) {
+            $result += $this->readUByte($types);
+        }
+        $val_type = $this->getTType($types);
+        $key_type = $this->getTType($types >> 4);
+        $this->containers[] = $this->state;
+        $this->state = TCompactProtocol::STATE_CONTAINER_READ;
+
+        return $result;
+    }
+
+    public function readCollectionEnd()
+    {
+        $this->state = array_pop($this->containers);
+
+        return 0;
+    }
+
+    public function readMapEnd()
+    {
+        return $this->readCollectionEnd();
+    }
+
+    public function readListBegin(&$elem_type, &$size)
+    {
+        return $this->readCollectionBegin($elem_type, $size);
+    }
+
+    public function readListEnd()
+    {
+        return $this->readCollectionEnd();
+    }
+
+    public function readSetBegin(&$elem_type, &$size)
+    {
+        return $this->readCollectionBegin($elem_type, $size);
+    }
+
+    public function readSetEnd()
+    {
+        return $this->readCollectionEnd();
+    }
+
+    public function readBool(&$value)
+    {
+        if ($this->state == TCompactProtocol::STATE_BOOL_READ) {
+            $value = $this->boolValue;
+
+            return 0;
+        } elseif ($this->state == TCompactProtocol::STATE_CONTAINER_READ) {
+            return $this->readByte($value);
+        } else {
+            throw new TProtocolException('Invalid state in compact protocol');
+        }
+    }
+
+    public function readI16(&$value)
+    {
+        return $this->readZigZag($value);
+    }
+
+    public function readI32(&$value)
+    {
+        return $this->readZigZag($value);
+    }
+
+    public function readDouble(&$value)
+    {
+        $data = $this->trans_->readAll(8);
+        $arr = unpack('d', $data);
+        $value = $arr[1];
+
+        return 8;
+    }
+
+    public function readString(&$value)
+    {
+        $result = $this->readVarint($len);
+        if ($len) {
+            $value = $this->trans_->readAll($len);
+        } else {
+            $value = '';
+        }
+
+        return $result + $len;
+    }
+
+    public function getTType($byte)
+    {
+        return self::$ttypes[$byte & 0x0f];
+    }
+
+    // If we are on a 32bit architecture we have to explicitly deal with
+    // 64-bit twos-complement arithmetic since PHP wants to treat all ints
+    // as signed and any int over 2^31 - 1 as a float
+
+    // Read and write I64 as two 32 bit numbers $hi and $lo
+
+    public function readI64(&$value)
+    {
+        // Read varint from wire
+        $hi = 0;
         $lo = 0;
-      } else {
-        $lo++;
-      }
-    }
 
-    // Force 32bit words in excess of 2G to be positive - we deal with sign
-    // explicitly below
+        $idx = 0;
+        $shift = 0;
 
-    if ($hi & (int) 0x80000000) {
-      $hi &= (int) 0x7fffffff;
-      $hi += 0x80000000;
-    }
-
-    if ($lo & (int) 0x80000000) {
-      $lo &= (int) 0x7fffffff;
-      $lo += 0x80000000;
-    }
-
-    // Create as negative value first, since we can store -2^63 but not 2^63
-    $value = -$hi * 4294967296 - $lo;
-
-    if (!$isNeg) {
-      $value = -$value;
-    }
-
-    return $idx;
-  }
-
-  public function writeI64($value)
-  {
-    // If we are in an I32 range, use the easy method below.
-    if (($value > 4294967296) || ($value < -4294967296)) {
-      // Convert $value to $hi and $lo
-      $neg = $value < 0;
-
-      if ($neg) {
-        $value *= -1;
-      }
-
-      $hi = (int) $value >> 32;
-      $lo = (int) $value & 0xffffffff;
-
-      if ($neg) {
-        $hi = ~$hi;
-        $lo = ~$lo;
-        if (($lo & (int) 0xffffffff) == (int) 0xffffffff) {
-          $lo = 0;
-          $hi++;
-        } else {
-          $lo++;
+        while (true) {
+            $x = $this->trans_->readAll(1);
+            $arr = unpack('C', $x);
+            $byte = $arr[1];
+            $idx += 1;
+            // Shift hi and lo together.
+            if ($shift < 28) {
+                $lo |= (($byte & 0x7f) << $shift);
+            } elseif ($shift == 28) {
+                $lo |= (($byte & 0x0f) << 28);
+                $hi |= (($byte & 0x70) >> 4);
+            } else {
+                $hi |= (($byte & 0x7f) << ($shift - 32));
+            }
+            if (($byte >> 7) === 0) {
+                break;
+            }
+            $shift += 7;
         }
-      }
 
-      // Now do the zigging and zagging.
-      $xorer = 0;
-      if ($neg) {
-        $xorer = 0xffffffff;
-      }
-      $lowbit = ($lo >> 31) & 1;
-      $hi = ($hi << 1) | $lowbit;
-      $lo = ($lo << 1);
-      $lo = ($lo ^ $xorer) & 0xffffffff;
-      $hi = ($hi ^ $xorer) & 0xffffffff;
-
-      // now write out the varint, ensuring we shift both hi and lo
-      $out = "";
-      while (true) {
-        if (($lo & ~0x7f) === 0 &&
-           $hi === 0) {
-          $out .= chr($lo);
-          break;
-        } else {
-          $out .= chr(($lo & 0xff) | 0x80);
-          $lo = $lo >> 7;
-          $lo = $lo | ($hi << 25);
-          $hi = $hi >> 7;
-          // Right shift carries sign, but we don't want it to.
-          $hi = $hi & (127 << 25);
+        // Now, unzig it.
+        $xorer = 0;
+        if ($lo & 1) {
+            $xorer = 0xffffffff;
         }
-      }
+        $lo = ($lo >> 1) & 0x7fffffff;
+        $lo = $lo | (($hi & 1) << 31);
+        $hi = ($hi >> 1) ^ $xorer;
+        $lo = $lo ^ $xorer;
 
-      $ret = TStringFuncFactory::create()->strlen($out);
-      $this->trans_->write($out, $ret);
+        // Now put $hi and $lo back together
+        $isNeg = $hi < 0 || $hi & 0x80000000;
 
-      return $ret;
-    } else {
-      return $this->writeVarint($this->toZigZag($value, 64));
+        // Check for a negative
+        if ($isNeg) {
+            $hi = ~$hi & (int)0xffffffff;
+            $lo = ~$lo & (int)0xffffffff;
+
+            if ($lo == (int)0xffffffff) {
+                $hi++;
+                $lo = 0;
+            } else {
+                $lo++;
+            }
+        }
+
+        // Force 32bit words in excess of 2G to be positive - we deal with sign
+        // explicitly below
+
+        if ($hi & (int)0x80000000) {
+            $hi &= (int)0x7fffffff;
+            $hi += 0x80000000;
+        }
+
+        if ($lo & (int)0x80000000) {
+            $lo &= (int)0x7fffffff;
+            $lo += 0x80000000;
+        }
+
+        // Create as negative value first, since we can store -2^63 but not 2^63
+        $value = -$hi * 4294967296 - $lo;
+
+        if (!$isNeg) {
+            $value = -$value;
+        }
+
+        return $idx;
     }
-  }
+
+    public function writeI64($value)
+    {
+        // If we are in an I32 range, use the easy method below.
+        if (($value > 4294967296) || ($value < -4294967296)) {
+            // Convert $value to $hi and $lo
+            $neg = $value < 0;
+
+            if ($neg) {
+                $value *= -1;
+            }
+
+            $hi = (int)$value >> 32;
+            $lo = (int)$value & 0xffffffff;
+
+            if ($neg) {
+                $hi = ~$hi;
+                $lo = ~$lo;
+                if (($lo & (int)0xffffffff) == (int)0xffffffff) {
+                    $lo = 0;
+                    $hi++;
+                } else {
+                    $lo++;
+                }
+            }
+
+            // Now do the zigging and zagging.
+            $xorer = 0;
+            if ($neg) {
+                $xorer = 0xffffffff;
+            }
+            $lowbit = ($lo >> 31) & 1;
+            $hi = ($hi << 1) | $lowbit;
+            $lo = ($lo << 1);
+            $lo = ($lo ^ $xorer) & 0xffffffff;
+            $hi = ($hi ^ $xorer) & 0xffffffff;
+
+            // now write out the varint, ensuring we shift both hi and lo
+            $out = "";
+            while (true) {
+                if (($lo & ~0x7f) === 0 &&
+                    $hi === 0) {
+                    $out .= chr($lo);
+                    break;
+                } else {
+                    $out .= chr(($lo & 0xff) | 0x80);
+                    $lo = $lo >> 7;
+                    $lo = $lo | ($hi << 25);
+                    $hi = $hi >> 7;
+                    // Right shift carries sign, but we don't want it to.
+                    $hi = $hi & (127 << 25);
+                }
+            }
+
+            $ret = TStringFuncFactory::create()->strlen($out);
+            $this->trans_->write($out, $ret);
+
+            return $ret;
+        } else {
+            return $this->writeVarint($this->toZigZag($value, 64));
+        }
+    }
 }
diff --git a/lib/php/lib/Protocol/TJSONProtocol.php b/lib/php/lib/Protocol/TJSONProtocol.php
index 6d8e81f..9144884 100644
--- a/lib/php/lib/Protocol/TJSONProtocol.php
+++ b/lib/php/lib/Protocol/TJSONProtocol.php
@@ -217,9 +217,9 @@
 
     private function hasJSONUnescapedUnicode()
     {
-        if (PHP_MAJOR_VERSION > 5
-            || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 4))
+        if (PHP_MAJOR_VERSION > 5 || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 4)) {
             return true;
+        }
 
         return false;
     }
@@ -237,18 +237,24 @@
          * High surrogate: 0xD800 - 0xDBFF
          * Low surrogate: 0xDC00 - 0xDFFF
          */
-        $json = preg_replace_callback('/\\\\u(d[89ab][0-9a-f]{2})\\\\u(d[cdef][0-9a-f]{2})/i',
+        $json = preg_replace_callback(
+            '/\\\\u(d[89ab][0-9a-f]{2})\\\\u(d[cdef][0-9a-f]{2})/i',
             function ($matches) {
-                return mb_convert_encoding(pack('H*', $matches[1].$matches[2]), 'UTF-8', 'UTF-16BE');
-            }, $json);
+                return mb_convert_encoding(pack('H*', $matches[1] . $matches[2]), 'UTF-8', 'UTF-16BE');
+            },
+            $json
+        );
 
         /*
          * Unescaped characters within the Basic Multilingual Plane
          */
-        $json = preg_replace_callback('/\\\\u([0-9a-f]{4})/i',
+        $json = preg_replace_callback(
+            '/\\\\u([0-9a-f]{4})/i',
             function ($matches) {
                 return mb_convert_encoding(pack('H*', $matches[1]), 'UTF-8', 'UTF-16BE');
-            }, $json);
+            },
+            $json
+        );
 
         return $json;
     }
@@ -308,54 +314,54 @@
 
     private function writeJSONObjectStart()
     {
-      $this->context_->write();
-      $this->trans_->write(self::LBRACE);
-      $this->pushContext(new PairContext($this));
+        $this->context_->write();
+        $this->trans_->write(self::LBRACE);
+        $this->pushContext(new PairContext($this));
     }
 
     private function writeJSONObjectEnd()
     {
-      $this->popContext();
-      $this->trans_->write(self::RBRACE);
+        $this->popContext();
+        $this->trans_->write(self::RBRACE);
     }
 
     private function writeJSONArrayStart()
     {
-      $this->context_->write();
-      $this->trans_->write(self::LBRACKET);
-      $this->pushContext(new ListContext($this));
+        $this->context_->write();
+        $this->trans_->write(self::LBRACKET);
+        $this->pushContext(new ListContext($this));
     }
 
     private function writeJSONArrayEnd()
     {
-      $this->popContext();
-      $this->trans_->write(self::RBRACKET);
+        $this->popContext();
+        $this->trans_->write(self::RBRACKET);
     }
 
     private function readJSONString($skipContext)
     {
-      if (!$skipContext) {
-        $this->context_->read();
-      }
-
-      $jsonString = '';
-      $lastChar = null;
-      while (true) {
-        $ch = $this->reader_->read();
-        $jsonString .= $ch;
-        if ($ch == self::QUOTE &&
-          $lastChar !== NULL &&
-            $lastChar !== self::ESCSEQ) {
-          break;
+        if (!$skipContext) {
+            $this->context_->read();
         }
-        if ($ch == self::ESCSEQ && $lastChar == self::ESCSEQ) {
-          $lastChar = self::DOUBLEESC;
-        } else {
-          $lastChar = $ch;
-        }
-      }
 
-      return json_decode($jsonString);
+        $jsonString = '';
+        $lastChar = null;
+        while (true) {
+            $ch = $this->reader_->read();
+            $jsonString .= $ch;
+            if ($ch == self::QUOTE &&
+                $lastChar !== null &&
+                $lastChar !== self::ESCSEQ) {
+                break;
+            }
+            if ($ch == self::ESCSEQ && $lastChar == self::ESCSEQ) {
+                $lastChar = self::DOUBLEESC;
+            } else {
+                $lastChar = $ch;
+            }
+        }
+
+        return json_decode($jsonString);
     }
 
     private function isJSONNumeric($b)
@@ -376,8 +382,8 @@
             case '9':
             case 'E':
             case 'e':
-              return true;
-            }
+                return true;
+        }
 
         return false;
     }
@@ -459,8 +465,10 @@
             } elseif ($arr == "Infinity") {
                 return INF;
             } elseif (!$this->context_->escapeNum()) {
-                throw new TProtocolException("Numeric data unexpectedly quoted " . $arr,
-                                              TProtocolException::INVALID_DATA);
+                throw new TProtocolException(
+                    "Numeric data unexpectedly quoted " . $arr,
+                    TProtocolException::INVALID_DATA
+                );
             }
 
             return floatval($arr);
@@ -514,9 +522,9 @@
     /**
      * Writes the message header
      *
-     * @param string $name  Function name
-     * @param int    $type  message type TMessageType::CALL or TMessageType::REPLY
-     * @param int    $seqid The sequence id of this message
+     * @param string $name Function name
+     * @param int $type message type TMessageType::CALL or TMessageType::REPLY
+     * @param int $seqid The sequence id of this message
      */
     public function writeMessageBegin($name, $type, $seqid)
     {
@@ -538,7 +546,7 @@
     /**
      * Writes a struct header.
      *
-     * @param  string     $name Struct name
+     * @param  string $name Struct name
      * @throws TException on write error
      * @return int        How many bytes written
      */
@@ -652,7 +660,7 @@
      * Reads the message header
      *
      * @param string $name Function name
-     * @param int    $type message type TMessageType::CALL or TMessageType::REPLY
+     * @param int $type message type TMessageType::CALL or TMessageType::REPLY
      * @parem int $seqid The sequence id of this message
      */
     public function readMessageBegin(&$name, &$type, &$seqid)
diff --git a/lib/php/lib/Protocol/TProtocol.php b/lib/php/lib/Protocol/TProtocol.php
index 0e3bc0d..81aceb6 100644
--- a/lib/php/lib/Protocol/TProtocol.php
+++ b/lib/php/lib/Protocol/TProtocol.php
@@ -30,323 +30,321 @@
  */
 abstract class TProtocol
 {
-  /**
-   * Underlying transport
-   *
-   * @var TTransport
-   */
-  protected $trans_;
+    /**
+     * Underlying transport
+     *
+     * @var TTransport
+     */
+    protected $trans_;
 
-  /**
-   * Constructor
-   */
-  protected function __construct($trans)
-  {
-    $this->trans_ = $trans;
-  }
-
-  /**
-   * Accessor for transport
-   *
-   * @return TTransport
-   */
-  public function getTransport()
-  {
-    return $this->trans_;
-  }
-
-  /**
-   * Writes the message header
-   *
-   * @param string $name Function name
-   * @param int $type message type TMessageType::CALL or TMessageType::REPLY
-   * @param int $seqid The sequence id of this message
-   */
-  abstract public function writeMessageBegin($name, $type, $seqid);
-
-  /**
-   * Close the message
-   */
-  abstract public function writeMessageEnd();
-
-  /**
-   * Writes a struct header.
-   *
-   * @param string     $name Struct name
-   * @throws TException on write error
-   * @return int How many bytes written
-   */
-  abstract public function writeStructBegin($name);
-
-  /**
-   * Close a struct.
-   *
-   * @throws TException on write error
-   * @return int How many bytes written
-   */
-  abstract public function writeStructEnd();
-
-  /*
-   * Starts a field.
-   *
-   * @param string     $name Field name
-   * @param int        $type Field type
-   * @param int        $fid  Field id
-   * @throws TException on write error
-   * @return int How many bytes written
-   */
-  abstract public function writeFieldBegin($fieldName, $fieldType, $fieldId);
-
-  abstract public function writeFieldEnd();
-
-  abstract public function writeFieldStop();
-
-  abstract public function writeMapBegin($keyType, $valType, $size);
-
-  abstract public function writeMapEnd();
-
-  abstract public function writeListBegin($elemType, $size);
-
-  abstract public function writeListEnd();
-
-  abstract public function writeSetBegin($elemType, $size);
-
-  abstract public function writeSetEnd();
-
-  abstract public function writeBool($bool);
-
-  abstract public function writeByte($byte);
-
-  abstract public function writeI16($i16);
-
-  abstract public function writeI32($i32);
-
-  abstract public function writeI64($i64);
-
-  abstract public function writeDouble($dub);
-
-  abstract public function writeString($str);
-
-  /**
-   * Reads the message header
-   *
-   * @param string $name Function name
-   * @param int $type message type TMessageType::CALL or TMessageType::REPLY
-   * @parem int $seqid The sequence id of this message
-   */
-  abstract public function readMessageBegin(&$name, &$type, &$seqid);
-
-  /**
-   * Read the close of message
-   */
-  abstract public function readMessageEnd();
-
-  abstract public function readStructBegin(&$name);
-
-  abstract public function readStructEnd();
-
-  abstract public function readFieldBegin(&$name, &$fieldType, &$fieldId);
-
-  abstract public function readFieldEnd();
-
-  abstract public function readMapBegin(&$keyType, &$valType, &$size);
-
-  abstract public function readMapEnd();
-
-  abstract public function readListBegin(&$elemType, &$size);
-
-  abstract public function readListEnd();
-
-  abstract public function readSetBegin(&$elemType, &$size);
-
-  abstract public function readSetEnd();
-
-  abstract public function readBool(&$bool);
-
-  abstract public function readByte(&$byte);
-
-  abstract public function readI16(&$i16);
-
-  abstract public function readI32(&$i32);
-
-  abstract public function readI64(&$i64);
-
-  abstract public function readDouble(&$dub);
-
-  abstract public function readString(&$str);
-
-  /**
-   * The skip function is a utility to parse over unrecognized date without
-   * causing corruption.
-   *
-   * @param TType $type What type is it
-   */
-  public function skip($type)
-  {
-    switch ($type) {
-    case TType::BOOL:
-      return $this->readBool($bool);
-    case TType::BYTE:
-      return $this->readByte($byte);
-    case TType::I16:
-      return $this->readI16($i16);
-    case TType::I32:
-      return $this->readI32($i32);
-    case TType::I64:
-      return $this->readI64($i64);
-    case TType::DOUBLE:
-      return $this->readDouble($dub);
-    case TType::STRING:
-      return $this->readString($str);
-    case TType::STRUCT:
-      {
-        $result = $this->readStructBegin($name);
-        while (true) {
-          $result += $this->readFieldBegin($name, $ftype, $fid);
-          if ($ftype == TType::STOP) {
-            break;
-          }
-          $result += $this->skip($ftype);
-          $result += $this->readFieldEnd();
-        }
-        $result += $this->readStructEnd();
-
-        return $result;
-      }
-    case TType::MAP:
-      {
-        $result = $this->readMapBegin($keyType, $valType, $size);
-        for ($i = 0; $i < $size; $i++) {
-          $result += $this->skip($keyType);
-          $result += $this->skip($valType);
-        }
-        $result += $this->readMapEnd();
-
-        return $result;
-      }
-    case TType::SET:
-      {
-        $result = $this->readSetBegin($elemType, $size);
-        for ($i = 0; $i < $size; $i++) {
-          $result += $this->skip($elemType);
-        }
-        $result += $this->readSetEnd();
-
-        return $result;
-      }
-    case TType::LST:
-      {
-        $result = $this->readListBegin($elemType, $size);
-        for ($i = 0; $i < $size; $i++) {
-          $result += $this->skip($elemType);
-        }
-        $result += $this->readListEnd();
-
-        return $result;
-      }
-    default:
-      throw new TProtocolException('Unknown field type: '.$type,
-                                   TProtocolException::INVALID_DATA);
+    /**
+     * Constructor
+     */
+    protected function __construct($trans)
+    {
+        $this->trans_ = $trans;
     }
-  }
 
-  /**
-   * Utility for skipping binary data
-   *
-   * @param TTransport $itrans TTransport object
-   * @param int        $type   Field type
-   */
-  public static function skipBinary($itrans, $type)
-  {
-    switch ($type) {
-    case TType::BOOL:
-      return $itrans->readAll(1);
-    case TType::BYTE:
-      return $itrans->readAll(1);
-    case TType::I16:
-      return $itrans->readAll(2);
-    case TType::I32:
-      return $itrans->readAll(4);
-    case TType::I64:
-      return $itrans->readAll(8);
-    case TType::DOUBLE:
-      return $itrans->readAll(8);
-    case TType::STRING:
-      $len = unpack('N', $itrans->readAll(4));
-      $len = $len[1];
-      if ($len > 0x7fffffff) {
-        $len = 0 - (($len - 1) ^ 0xffffffff);
-      }
-
-      return 4 + $itrans->readAll($len);
-    case TType::STRUCT:
-      {
-        $result = 0;
-        while (true) {
-          $ftype = 0;
-          $fid = 0;
-          $data = $itrans->readAll(1);
-          $arr = unpack('c', $data);
-          $ftype = $arr[1];
-          if ($ftype == TType::STOP) {
-            break;
-          }
-          // I16 field id
-          $result += $itrans->readAll(2);
-          $result += self::skipBinary($itrans, $ftype);
-        }
-
-        return $result;
-      }
-    case TType::MAP:
-      {
-        // Ktype
-        $data = $itrans->readAll(1);
-        $arr = unpack('c', $data);
-        $ktype = $arr[1];
-        // Vtype
-        $data = $itrans->readAll(1);
-        $arr = unpack('c', $data);
-        $vtype = $arr[1];
-        // Size
-        $data = $itrans->readAll(4);
-        $arr = unpack('N', $data);
-        $size = $arr[1];
-        if ($size > 0x7fffffff) {
-          $size = 0 - (($size - 1) ^ 0xffffffff);
-        }
-        $result = 6;
-        for ($i = 0; $i < $size; $i++) {
-          $result += self::skipBinary($itrans, $ktype);
-          $result += self::skipBinary($itrans, $vtype);
-        }
-
-        return $result;
-      }
-    case TType::SET:
-    case TType::LST:
-      {
-        // Vtype
-        $data = $itrans->readAll(1);
-        $arr = unpack('c', $data);
-        $vtype = $arr[1];
-        // Size
-        $data = $itrans->readAll(4);
-        $arr = unpack('N', $data);
-        $size = $arr[1];
-        if ($size > 0x7fffffff) {
-          $size = 0 - (($size - 1) ^ 0xffffffff);
-        }
-        $result = 5;
-        for ($i = 0; $i < $size; $i++) {
-          $result += self::skipBinary($itrans, $vtype);
-        }
-
-        return $result;
-      }
-    default:
-      throw new TProtocolException('Unknown field type: '.$type,
-                                   TProtocolException::INVALID_DATA);
+    /**
+     * Accessor for transport
+     *
+     * @return TTransport
+     */
+    public function getTransport()
+    {
+        return $this->trans_;
     }
-  }
+
+    /**
+     * Writes the message header
+     *
+     * @param string $name Function name
+     * @param int $type message type TMessageType::CALL or TMessageType::REPLY
+     * @param int $seqid The sequence id of this message
+     */
+    abstract public function writeMessageBegin($name, $type, $seqid);
+
+    /**
+     * Close the message
+     */
+    abstract public function writeMessageEnd();
+
+    /**
+     * Writes a struct header.
+     *
+     * @param string $name Struct name
+     * @throws TException on write error
+     * @return int How many bytes written
+     */
+    abstract public function writeStructBegin($name);
+
+    /**
+     * Close a struct.
+     *
+     * @throws TException on write error
+     * @return int How many bytes written
+     */
+    abstract public function writeStructEnd();
+
+    /*
+     * Starts a field.
+     *
+     * @param string     $name Field name
+     * @param int        $type Field type
+     * @param int        $fid  Field id
+     * @throws TException on write error
+     * @return int How many bytes written
+     */
+    abstract public function writeFieldBegin($fieldName, $fieldType, $fieldId);
+
+    abstract public function writeFieldEnd();
+
+    abstract public function writeFieldStop();
+
+    abstract public function writeMapBegin($keyType, $valType, $size);
+
+    abstract public function writeMapEnd();
+
+    abstract public function writeListBegin($elemType, $size);
+
+    abstract public function writeListEnd();
+
+    abstract public function writeSetBegin($elemType, $size);
+
+    abstract public function writeSetEnd();
+
+    abstract public function writeBool($bool);
+
+    abstract public function writeByte($byte);
+
+    abstract public function writeI16($i16);
+
+    abstract public function writeI32($i32);
+
+    abstract public function writeI64($i64);
+
+    abstract public function writeDouble($dub);
+
+    abstract public function writeString($str);
+
+    /**
+     * Reads the message header
+     *
+     * @param string $name Function name
+     * @param int $type message type TMessageType::CALL or TMessageType::REPLY
+     * @parem int $seqid The sequence id of this message
+     */
+    abstract public function readMessageBegin(&$name, &$type, &$seqid);
+
+    /**
+     * Read the close of message
+     */
+    abstract public function readMessageEnd();
+
+    abstract public function readStructBegin(&$name);
+
+    abstract public function readStructEnd();
+
+    abstract public function readFieldBegin(&$name, &$fieldType, &$fieldId);
+
+    abstract public function readFieldEnd();
+
+    abstract public function readMapBegin(&$keyType, &$valType, &$size);
+
+    abstract public function readMapEnd();
+
+    abstract public function readListBegin(&$elemType, &$size);
+
+    abstract public function readListEnd();
+
+    abstract public function readSetBegin(&$elemType, &$size);
+
+    abstract public function readSetEnd();
+
+    abstract public function readBool(&$bool);
+
+    abstract public function readByte(&$byte);
+
+    abstract public function readI16(&$i16);
+
+    abstract public function readI32(&$i32);
+
+    abstract public function readI64(&$i64);
+
+    abstract public function readDouble(&$dub);
+
+    abstract public function readString(&$str);
+
+    /**
+     * The skip function is a utility to parse over unrecognized date without
+     * causing corruption.
+     *
+     * @param TType $type What type is it
+     */
+    public function skip($type)
+    {
+        switch ($type) {
+            case TType::BOOL:
+                return $this->readBool($bool);
+            case TType::BYTE:
+                return $this->readByte($byte);
+            case TType::I16:
+                return $this->readI16($i16);
+            case TType::I32:
+                return $this->readI32($i32);
+            case TType::I64:
+                return $this->readI64($i64);
+            case TType::DOUBLE:
+                return $this->readDouble($dub);
+            case TType::STRING:
+                return $this->readString($str);
+            case TType::STRUCT:
+                $result = $this->readStructBegin($name);
+                while (true) {
+                    $result += $this->readFieldBegin($name, $ftype, $fid);
+                    if ($ftype == TType::STOP) {
+                        break;
+                    }
+                    $result += $this->skip($ftype);
+                    $result += $this->readFieldEnd();
+                }
+                $result += $this->readStructEnd();
+
+                return $result;
+
+            case TType::MAP:
+                $result = $this->readMapBegin($keyType, $valType, $size);
+                for ($i = 0; $i < $size; $i++) {
+                    $result += $this->skip($keyType);
+                    $result += $this->skip($valType);
+                }
+                $result += $this->readMapEnd();
+
+                return $result;
+
+            case TType::SET:
+                $result = $this->readSetBegin($elemType, $size);
+                for ($i = 0; $i < $size; $i++) {
+                    $result += $this->skip($elemType);
+                }
+                $result += $this->readSetEnd();
+
+                return $result;
+
+            case TType::LST:
+                $result = $this->readListBegin($elemType, $size);
+                for ($i = 0; $i < $size; $i++) {
+                    $result += $this->skip($elemType);
+                }
+                $result += $this->readListEnd();
+
+                return $result;
+
+            default:
+                throw new TProtocolException(
+                    'Unknown field type: ' . $type,
+                    TProtocolException::INVALID_DATA
+                );
+        }
+    }
+
+    /**
+     * Utility for skipping binary data
+     *
+     * @param TTransport $itrans TTransport object
+     * @param int $type Field type
+     */
+    public static function skipBinary($itrans, $type)
+    {
+        switch ($type) {
+            case TType::BOOL:
+                return $itrans->readAll(1);
+            case TType::BYTE:
+                return $itrans->readAll(1);
+            case TType::I16:
+                return $itrans->readAll(2);
+            case TType::I32:
+                return $itrans->readAll(4);
+            case TType::I64:
+                return $itrans->readAll(8);
+            case TType::DOUBLE:
+                return $itrans->readAll(8);
+            case TType::STRING:
+                $len = unpack('N', $itrans->readAll(4));
+                $len = $len[1];
+                if ($len > 0x7fffffff) {
+                    $len = 0 - (($len - 1) ^ 0xffffffff);
+                }
+
+                return 4 + $itrans->readAll($len);
+
+            case TType::STRUCT:
+                $result = 0;
+                while (true) {
+                    $ftype = 0;
+                    $fid = 0;
+                    $data = $itrans->readAll(1);
+                    $arr = unpack('c', $data);
+                    $ftype = $arr[1];
+                    if ($ftype == TType::STOP) {
+                        break;
+                    }
+                    // I16 field id
+                    $result += $itrans->readAll(2);
+                    $result += self::skipBinary($itrans, $ftype);
+                }
+
+                return $result;
+
+            case TType::MAP:
+                // Ktype
+                $data = $itrans->readAll(1);
+                $arr = unpack('c', $data);
+                $ktype = $arr[1];
+                // Vtype
+                $data = $itrans->readAll(1);
+                $arr = unpack('c', $data);
+                $vtype = $arr[1];
+                // Size
+                $data = $itrans->readAll(4);
+                $arr = unpack('N', $data);
+                $size = $arr[1];
+                if ($size > 0x7fffffff) {
+                    $size = 0 - (($size - 1) ^ 0xffffffff);
+                }
+                $result = 6;
+                for ($i = 0; $i < $size; $i++) {
+                    $result += self::skipBinary($itrans, $ktype);
+                    $result += self::skipBinary($itrans, $vtype);
+                }
+
+                return $result;
+
+            case TType::SET:
+            case TType::LST:
+                // Vtype
+                $data = $itrans->readAll(1);
+                $arr = unpack('c', $data);
+                $vtype = $arr[1];
+                // Size
+                $data = $itrans->readAll(4);
+                $arr = unpack('N', $data);
+                $size = $arr[1];
+                if ($size > 0x7fffffff) {
+                    $size = 0 - (($size - 1) ^ 0xffffffff);
+                }
+                $result = 5;
+                for ($i = 0; $i < $size; $i++) {
+                    $result += self::skipBinary($itrans, $vtype);
+                }
+
+                return $result;
+
+            default:
+                throw new TProtocolException(
+                    'Unknown field type: ' . $type,
+                    TProtocolException::INVALID_DATA
+                );
+        }
+    }
 }
diff --git a/lib/php/lib/Protocol/TProtocolDecorator.php b/lib/php/lib/Protocol/TProtocolDecorator.php
index c08c4d5..a85e0b8 100644
--- a/lib/php/lib/Protocol/TProtocolDecorator.php
+++ b/lib/php/lib/Protocol/TProtocolDecorator.php
@@ -21,6 +21,7 @@
  */
 
 namespace Thrift\Protocol;
+
 use Thrift\Exception\TException;
 
 /**
diff --git a/lib/php/lib/Protocol/TSimpleJSONProtocol.php b/lib/php/lib/Protocol/TSimpleJSONProtocol.php
index 9cf90bd..1cf1f64 100644
--- a/lib/php/lib/Protocol/TSimpleJSONProtocol.php
+++ b/lib/php/lib/Protocol/TSimpleJSONProtocol.php
@@ -54,7 +54,8 @@
     /**
      * Push a new write context onto the stack.
      */
-    protected function pushWriteContext(Context $c) {
+    protected function pushWriteContext(Context $c)
+    {
         $this->writeContextStack_[] = $this->writeContext_;
         $this->writeContext_ = $c;
     }
@@ -62,14 +63,16 @@
     /**
      * Pop the last write context off the stack
      */
-    protected function popWriteContext() {
+    protected function popWriteContext()
+    {
         $this->writeContext_ = array_pop($this->writeContextStack_);
     }
 
     /**
      * Used to make sure that we are not encountering a map whose keys are containers
      */
-    protected function assertContextIsNotMapKey($invalidKeyType) {
+    protected function assertContextIsNotMapKey($invalidKeyType)
+    {
         if ($this->writeContext_->isMapKey()) {
             throw new CollectionMapKeyException(
                 "Cannot serialize a map with keys that are of type " .
diff --git a/lib/php/lib/Serializer/TBinarySerializer.php b/lib/php/lib/Serializer/TBinarySerializer.php
index aa2f71b..9d2b147 100644
--- a/lib/php/lib/Serializer/TBinarySerializer.php
+++ b/lib/php/lib/Serializer/TBinarySerializer.php
@@ -33,53 +33,55 @@
  */
 class TBinarySerializer
 {
-  // NOTE(rmarin): Because thrift_protocol_write_binary
-  // adds a begin message prefix, you cannot specify
-  // a transport in which to serialize an object. It has to
-  // be a string. Otherwise we will break the compatibility with
-  // normal deserialization.
-  public static function serialize($object)
-  {
-    $transport = new TMemoryBuffer();
-    $protocol = new TBinaryProtocolAccelerated($transport);
-    if (function_exists('thrift_protocol_write_binary')) {
-      thrift_protocol_write_binary($protocol, $object->getName(),
-                                   TMessageType::REPLY, $object,
-                                   0, $protocol->isStrictWrite());
+    // NOTE(rmarin): Because thrift_protocol_write_binary
+    // adds a begin message prefix, you cannot specify
+    // a transport in which to serialize an object. It has to
+    // be a string. Otherwise we will break the compatibility with
+    // normal deserialization.
+    public static function serialize($object)
+    {
+        $transport = new TMemoryBuffer();
+        $protocol = new TBinaryProtocolAccelerated($transport);
+        if (function_exists('thrift_protocol_write_binary')) {
+            thrift_protocol_write_binary(
+                $protocol,
+                $object->getName(),
+                TMessageType::REPLY,
+                $object,
+                0,
+                $protocol->isStrictWrite()
+            );
 
-      $protocol->readMessageBegin($unused_name, $unused_type,
-                                  $unused_seqid);
-    } else {
-      $object->write($protocol);
+            $protocol->readMessageBegin($unused_name, $unused_type, $unused_seqid);
+        } else {
+            $object->write($protocol);
+        }
+        $protocol->getTransport()->flush();
+
+        return $transport->getBuffer();
     }
-    $protocol->getTransport()->flush();
 
-    return $transport->getBuffer();
-  }
+    public static function deserialize($string_object, $class_name, $buffer_size = 8192)
+    {
+        $transport = new TMemoryBuffer();
+        $protocol = new TBinaryProtocolAccelerated($transport);
+        if (function_exists('thrift_protocol_read_binary')) {
+            // NOTE (t.heintz) TBinaryProtocolAccelerated internally wraps our TMemoryBuffer in a
+            // TBufferedTransport, so we have to retrieve it again or risk losing data when writing
+            // less than 512 bytes to the transport (see the comment there as well).
+            // @see THRIFT-1579
+            $protocol->writeMessageBegin('', TMessageType::REPLY, 0);
+            $protocolTransport = $protocol->getTransport();
+            $protocolTransport->write($string_object);
+            $protocolTransport->flush();
 
-  public static function deserialize($string_object, $class_name, $buffer_size  = 8192)
-  {
-     $transport = new TMemoryBuffer();
-     $protocol = new TBinaryProtocolAccelerated($transport);
-     if (function_exists('thrift_protocol_read_binary')) {
-       // NOTE (t.heintz) TBinaryProtocolAccelerated internally wraps our TMemoryBuffer in a
-       // TBufferedTransport, so we have to retrieve it again or risk losing data when writing
-       // less than 512 bytes to the transport (see the comment there as well).
-       // @see THRIFT-1579
-       $protocol->writeMessageBegin('', TMessageType::REPLY, 0);
-       $protocolTransport = $protocol->getTransport();
-       $protocolTransport->write($string_object);
-       $protocolTransport->flush();
+            return thrift_protocol_read_binary($protocol, $class_name, $protocol->isStrictRead(), $buffer_size);
+        } else {
+            $transport->write($string_object);
+            $object = new $class_name();
+            $object->read($protocol);
 
-       return thrift_protocol_read_binary($protocol, $class_name,
-                                          $protocol->isStrictRead(),
-                                          $buffer_size);
-     } else {
-       $transport->write($string_object);
-       $object = new $class_name();
-       $object->read($protocol);
-
-       return $object;
-     }
-  }
+            return $object;
+        }
+    }
 }
diff --git a/lib/php/lib/Server/TForkingServer.php b/lib/php/lib/Server/TForkingServer.php
index 7f6e541..0bb6e91 100644
--- a/lib/php/lib/Server/TForkingServer.php
+++ b/lib/php/lib/Server/TForkingServer.php
@@ -13,108 +13,113 @@
  */
 class TForkingServer extends TServer
 {
-  /**
-   * Flag for the main serving loop
-   *
-   * @var bool
-   */
-  private $stop_ = false;
+    /**
+     * Flag for the main serving loop
+     *
+     * @var bool
+     */
+    private $stop_ = false;
 
-  /**
-   * List of children.
-   *
-   * @var array
-   */
-  protected $children_ = array();
+    /**
+     * List of children.
+     *
+     * @var array
+     */
+    protected $children_ = array();
 
-  /**
-   * Listens for new client using the supplied
-   * transport. We fork when a new connection
-   * arrives.
-   *
-   * @return void
-   */
-  public function serve()
-  {
-    $this->transport_->listen();
+    /**
+     * Listens for new client using the supplied
+     * transport. We fork when a new connection
+     * arrives.
+     *
+     * @return void
+     */
+    public function serve()
+    {
+        $this->transport_->listen();
 
-    while (!$this->stop_) {
-      try {
-        $transport = $this->transport_->accept();
+        while (!$this->stop_) {
+            try {
+                $transport = $this->transport_->accept();
 
-        if ($transport != null) {
-          $pid = pcntl_fork();
+                if ($transport != null) {
+                    $pid = pcntl_fork();
 
-          if ($pid > 0) {
-            $this->handleParent($transport, $pid);
-          } elseif ($pid === 0) {
-            $this->handleChild($transport);
-          } else {
-            throw new TException('Failed to fork');
-          }
+                    if ($pid > 0) {
+                        $this->handleParent($transport, $pid);
+                    } elseif ($pid === 0) {
+                        $this->handleChild($transport);
+                    } else {
+                        throw new TException('Failed to fork');
+                    }
+                }
+            } catch (TTransportException $e) {
+            }
+
+            $this->collectChildren();
         }
-      } catch (TTransportException $e) { }
-
-      $this->collectChildren();
     }
-  }
 
-  /**
-   * Code run by the parent
-   *
-   * @param TTransport $transport
-   * @param int $pid
-   * @return void
-   */
-  private function handleParent(TTransport $transport, $pid)
-  {
-    $this->children_[$pid] = $transport;
-  }
-
-  /**
-   * Code run by the child.
-   *
-   * @param TTransport $transport
-   * @return void
-   */
-  private function handleChild(TTransport $transport)
-  {
-    try {
-      $inputTransport = $this->inputTransportFactory_->getTransport($transport);
-      $outputTransport = $this->outputTransportFactory_->getTransport($transport);
-      $inputProtocol = $this->inputProtocolFactory_->getProtocol($inputTransport);
-      $outputProtocol = $this->outputProtocolFactory_->getProtocol($outputTransport);
-      while ($this->processor_->process($inputProtocol, $outputProtocol)) { }
-      @$transport->close();
-    } catch (TTransportException $e) { }
-
-    exit(0);
-  }
-
-  /**
-   * Collects any children we may have
-   *
-   * @return void
-   */
-  private function collectChildren()
-  {
-    foreach ($this->children_ as $pid => $transport) {
-      if (pcntl_waitpid($pid, $status, WNOHANG) > 0) {
-        unset($this->children_[$pid]);
-        if ($transport) @$transport->close();
-      }
+    /**
+     * Code run by the parent
+     *
+     * @param TTransport $transport
+     * @param int $pid
+     * @return void
+     */
+    private function handleParent(TTransport $transport, $pid)
+    {
+        $this->children_[$pid] = $transport;
     }
-  }
 
-  /**
-   * Stops the server running. Kills the transport
-   * and then stops the main serving loop
-   *
-   * @return void
-   */
-  public function stop()
-  {
-    $this->transport_->close();
-    $this->stop_ = true;
-  }
+    /**
+     * Code run by the child.
+     *
+     * @param TTransport $transport
+     * @return void
+     */
+    private function handleChild(TTransport $transport)
+    {
+        try {
+            $inputTransport = $this->inputTransportFactory_->getTransport($transport);
+            $outputTransport = $this->outputTransportFactory_->getTransport($transport);
+            $inputProtocol = $this->inputProtocolFactory_->getProtocol($inputTransport);
+            $outputProtocol = $this->outputProtocolFactory_->getProtocol($outputTransport);
+            while ($this->processor_->process($inputProtocol, $outputProtocol)) {
+            }
+            @$transport->close();
+        } catch (TTransportException $e) {
+        }
+
+        exit(0);
+    }
+
+    /**
+     * Collects any children we may have
+     *
+     * @return void
+     */
+    private function collectChildren()
+    {
+        foreach ($this->children_ as $pid => $transport) {
+            if (pcntl_waitpid($pid, $status, WNOHANG) > 0) {
+                unset($this->children_[$pid]);
+                if ($transport) {
+                    @$transport->close();
+                }
+            }
+        }
+    }
+
+    /**
+     * Stops the server running. Kills the transport
+     * and then stops the main serving loop
+     *
+     * @return void
+     */
+    public function stop()
+    {
+        $this->transport_->close();
+        $this->stop_ = true;
+    }
 }
diff --git a/lib/php/lib/Server/TSSLServerSocket.php b/lib/php/lib/Server/TSSLServerSocket.php
index dfc4704..ac589b7 100644
--- a/lib/php/lib/Server/TSSLServerSocket.php
+++ b/lib/php/lib/Server/TSSLServerSocket.php
@@ -30,65 +30,68 @@
  */
 class TSSLServerSocket extends TServerSocket
 {
-  /**
-   * Remote port
-   *
-   * @var resource
-   */
-  protected $context_ = null;
+    /**
+     * Remote port
+     *
+     * @var resource
+     */
+    protected $context_ = null;
 
-  /**
-   * ServerSocket constructor
-   *
-   * @param string $host        Host to listen on
-   * @param int $port           Port to listen on
-   * @param resource   $context      Stream context
-   * @return void
-   */
-  public function __construct($host = 'localhost', $port = 9090, $context = null)
-  {
-    $ssl_host = $this->getSSLHost($host);
-    parent::__construct($ssl_host, $port);
-    $this->context_ = $context;
-  }
-
-  public function getSSLHost($host)
-  {
-    $transport_protocol_loc = strpos($host, "://");
-    if ($transport_protocol_loc === false) {
-      $host = 'ssl://'.$host;
+    /**
+     * ServerSocket constructor
+     *
+     * @param string $host Host to listen on
+     * @param int $port Port to listen on
+     * @param resource $context Stream context
+     * @return void
+     */
+    public function __construct($host = 'localhost', $port = 9090, $context = null)
+    {
+        $ssl_host = $this->getSSLHost($host);
+        parent::__construct($ssl_host, $port);
+        $this->context_ = $context;
     }
-    return $host;
-  }
 
-  /**
-   * Opens a new socket server handle
-   *
-   * @return void
-   */
-  public function listen()
-  {
-    $this->listener_ = @stream_socket_server(
-      $this->host_ . ':' . $this->port_,
-      $errno,
-      $errstr,
-      STREAM_SERVER_BIND|STREAM_SERVER_LISTEN,
-      $this->context_);
-  }
+    public function getSSLHost($host)
+    {
+        $transport_protocol_loc = strpos($host, "://");
+        if ($transport_protocol_loc === false) {
+            $host = 'ssl://' . $host;
+        }
+        return $host;
+    }
 
-  /**
-   * Implementation of accept. If not client is accepted in the given time
-   *
-   * @return TSocket
-   */
-  protected function acceptImpl()
-  {
-    $handle = @stream_socket_accept($this->listener_, $this->acceptTimeout_ / 1000.0);
-    if(!$handle) return null;
+    /**
+     * Opens a new socket server handle
+     *
+     * @return void
+     */
+    public function listen()
+    {
+        $this->listener_ = @stream_socket_server(
+            $this->host_ . ':' . $this->port_,
+            $errno,
+            $errstr,
+            STREAM_SERVER_BIND | STREAM_SERVER_LISTEN,
+            $this->context_
+        );
+    }
 
-    $socket = new TSSLSocket();
-    $socket->setHandle($handle);
+    /**
+     * Implementation of accept. If not client is accepted in the given time
+     *
+     * @return TSocket
+     */
+    protected function acceptImpl()
+    {
+        $handle = @stream_socket_accept($this->listener_, $this->acceptTimeout_ / 1000.0);
+        if (!$handle) {
+            return null;
+        }
 
-    return $socket;
-  }
+        $socket = new TSSLSocket();
+        $socket->setHandle($handle);
+
+        return $socket;
+    }
 }
diff --git a/lib/php/lib/Server/TServer.php b/lib/php/lib/Server/TServer.php
index f4d76cc..268c378 100644
--- a/lib/php/lib/Server/TServer.php
+++ b/lib/php/lib/Server/TServer.php
@@ -12,89 +12,91 @@
  */
 abstract class TServer
 {
-  /**
-   * Processor to handle new clients
-   *
-   * @var TProcessor
-   */
-  protected $processor_;
+    /**
+     * Processor to handle new clients
+     *
+     * @var TProcessor
+     */
+    protected $processor_;
 
-  /**
-   * Server transport to be used for listening
-   * and accepting new clients
-   *
-   * @var TServerTransport
-   */
-  protected $transport_;
+    /**
+     * Server transport to be used for listening
+     * and accepting new clients
+     *
+     * @var TServerTransport
+     */
+    protected $transport_;
 
-  /**
-   * Input transport factory
-   *
-   * @var TTransportFactory
-   */
-  protected $inputTransportFactory_;
+    /**
+     * Input transport factory
+     *
+     * @var TTransportFactory
+     */
+    protected $inputTransportFactory_;
 
-  /**
-   * Output transport factory
-   *
-   * @var TTransportFactory
-   */
-  protected $outputTransportFactory_;
+    /**
+     * Output transport factory
+     *
+     * @var TTransportFactory
+     */
+    protected $outputTransportFactory_;
 
-  /**
-   * Input protocol factory
-   *
-   * @var TProtocolFactory
-   */
-  protected $inputProtocolFactory_;
+    /**
+     * Input protocol factory
+     *
+     * @var TProtocolFactory
+     */
+    protected $inputProtocolFactory_;
 
-  /**
-   * Output protocol factory
-   *
-   * @var TProtocolFactory
-   */
-  protected $outputProtocolFactory_;
+    /**
+     * Output protocol factory
+     *
+     * @var TProtocolFactory
+     */
+    protected $outputProtocolFactory_;
 
-  /**
-   * Sets up all the factories, etc
-   *
-   * @param object $processor
-   * @param TServerTransport $transport
-   * @param TTransportFactory $inputTransportFactory
-   * @param TTransportFactory $outputTransportFactory
-   * @param TProtocolFactory $inputProtocolFactory
-   * @param TProtocolFactory $outputProtocolFactory
-   * @return void
-   */
-  public function __construct($processor,
-                              TServerTransport $transport,
-                              TTransportFactory $inputTransportFactory,
-                              TTransportFactory $outputTransportFactory,
-                              TProtocolFactory $inputProtocolFactory,
-                              TProtocolFactory $outputProtocolFactory) {
-    $this->processor_ = $processor;
-    $this->transport_ = $transport;
-    $this->inputTransportFactory_ = $inputTransportFactory;
-    $this->outputTransportFactory_ = $outputTransportFactory;
-    $this->inputProtocolFactory_ = $inputProtocolFactory;
-    $this->outputProtocolFactory_ = $outputProtocolFactory;
-  }
+    /**
+     * Sets up all the factories, etc
+     *
+     * @param object $processor
+     * @param TServerTransport $transport
+     * @param TTransportFactory $inputTransportFactory
+     * @param TTransportFactory $outputTransportFactory
+     * @param TProtocolFactory $inputProtocolFactory
+     * @param TProtocolFactory $outputProtocolFactory
+     * @return void
+     */
+    public function __construct(
+        $processor,
+        TServerTransport $transport,
+        TTransportFactory $inputTransportFactory,
+        TTransportFactory $outputTransportFactory,
+        TProtocolFactory $inputProtocolFactory,
+        TProtocolFactory $outputProtocolFactory
+    ) {
+        $this->processor_ = $processor;
+        $this->transport_ = $transport;
+        $this->inputTransportFactory_ = $inputTransportFactory;
+        $this->outputTransportFactory_ = $outputTransportFactory;
+        $this->inputProtocolFactory_ = $inputProtocolFactory;
+        $this->outputProtocolFactory_ = $outputProtocolFactory;
+    }
 
-  /**
-   * Serves the server. This should never return
-   * unless a problem permits it to do so or it
-   * is interrupted intentionally
-   *
-   * @abstract
-   * @return void
-   */
-  abstract public function serve();
+    /**
+     * Serves the server. This should never return
+     * unless a problem permits it to do so or it
+     * is interrupted intentionally
+     *
+     * @abstract
+     * @return void
+     */
+    abstract public function serve();
 
-  /**
-   * Stops the server serving
-   *
-   * @abstract
-   * @return void
-   */
-  abstract public function stop();
+    /**
+     * Stops the server serving
+     *
+     * @abstract
+     * @return void
+     */
+    abstract public function stop();
 }
diff --git a/lib/php/lib/Server/TServerSocket.php b/lib/php/lib/Server/TServerSocket.php
index da8e226..8f38fb2 100644
--- a/lib/php/lib/Server/TServerSocket.php
+++ b/lib/php/lib/Server/TServerSocket.php
@@ -31,92 +31,94 @@
  */
 class TServerSocket extends TServerTransport
 {
-  /**
-   * Handle for the listener socket
-   *
-   * @var resource
-   */
-  protected $listener_;
+    /**
+     * Handle for the listener socket
+     *
+     * @var resource
+     */
+    protected $listener_;
 
-  /**
-   * Port for the listener to listen on
-   *
-   * @var int
-   */
-  protected $port_;
+    /**
+     * Port for the listener to listen on
+     *
+     * @var int
+     */
+    protected $port_;
 
-  /**
-   * Timeout when listening for a new client
-   *
-   * @var int
-   */
-  protected $acceptTimeout_ = 30000;
+    /**
+     * Timeout when listening for a new client
+     *
+     * @var int
+     */
+    protected $acceptTimeout_ = 30000;
 
-  /**
-   * Host to listen on
-   *
-   * @var string
-   */
-  protected $host_;
+    /**
+     * Host to listen on
+     *
+     * @var string
+     */
+    protected $host_;
 
-  /**
-   * ServerSocket constructor
-   *
-   * @param string $host        Host to listen on
-   * @param int $port           Port to listen on
-   * @return void
-   */
-  public function __construct($host = 'localhost', $port = 9090)
-  {
-    $this->host_ = $host;
-    $this->port_ = $port;
-  }
+    /**
+     * ServerSocket constructor
+     *
+     * @param string $host Host to listen on
+     * @param int $port Port to listen on
+     * @return void
+     */
+    public function __construct($host = 'localhost', $port = 9090)
+    {
+        $this->host_ = $host;
+        $this->port_ = $port;
+    }
 
-  /**
-   * Sets the accept timeout
-   *
-   * @param int $acceptTimeout
-   * @return void
-   */
-  public function setAcceptTimeout($acceptTimeout)
-  {
-    $this->acceptTimeout_ = $acceptTimeout;
-  }
+    /**
+     * Sets the accept timeout
+     *
+     * @param int $acceptTimeout
+     * @return void
+     */
+    public function setAcceptTimeout($acceptTimeout)
+    {
+        $this->acceptTimeout_ = $acceptTimeout;
+    }
 
-  /**
-   * Opens a new socket server handle
-   *
-   * @return void
-   */
-  public function listen()
-  {
-    $this->listener_ = stream_socket_server('tcp://' . $this->host_ . ':' . $this->port_);
-  }
+    /**
+     * Opens a new socket server handle
+     *
+     * @return void
+     */
+    public function listen()
+    {
+        $this->listener_ = stream_socket_server('tcp://' . $this->host_ . ':' . $this->port_);
+    }
 
-  /**
-   * Closes the socket server handle
-   *
-   * @return void
-   */
-  public function close()
-  {
-    @fclose($this->listener_);
-    $this->listener_ = null;
-  }
+    /**
+     * Closes the socket server handle
+     *
+     * @return void
+     */
+    public function close()
+    {
+        @fclose($this->listener_);
+        $this->listener_ = null;
+    }
 
-  /**
-   * Implementation of accept. If not client is accepted in the given time
-   *
-   * @return TSocket
-   */
-  protected function acceptImpl()
-  {
-    $handle = @stream_socket_accept($this->listener_, $this->acceptTimeout_ / 1000.0);
-    if(!$handle) return null;
+    /**
+     * Implementation of accept. If not client is accepted in the given time
+     *
+     * @return TSocket
+     */
+    protected function acceptImpl()
+    {
+        $handle = @stream_socket_accept($this->listener_, $this->acceptTimeout_ / 1000.0);
+        if (!$handle) {
+            return null;
+        }
 
-    $socket = new TSocket();
-    $socket->setHandle($handle);
+        $socket = new TSocket();
+        $socket->setHandle($handle);
 
-    return $socket;
-  }
+        return $socket;
+    }
 }
diff --git a/lib/php/lib/Server/TServerTransport.php b/lib/php/lib/Server/TServerTransport.php
index f82d06d..15a27af 100644
--- a/lib/php/lib/Server/TServerTransport.php
+++ b/lib/php/lib/Server/TServerTransport.php
@@ -11,46 +11,46 @@
  */
 abstract class TServerTransport
 {
-  /**
-   * List for new clients
-   *
-   * @abstract
-   * @return void
-   */
-  abstract public function listen();
+    /**
+     * List for new clients
+     *
+     * @abstract
+     * @return void
+     */
+    abstract public function listen();
 
-  /**
-   * Close the server
-   *
-   * @abstract
-   * @return void
-   */
-  abstract public function close();
+    /**
+     * Close the server
+     *
+     * @abstract
+     * @return void
+     */
+    abstract public function close();
 
-  /**
-   * Subclasses should use this to implement
-   * accept.
-   *
-   * @abstract
-   * @return TTransport
-   */
-  abstract protected function acceptImpl();
+    /**
+     * Subclasses should use this to implement
+     * accept.
+     *
+     * @abstract
+     * @return TTransport
+     */
+    abstract protected function acceptImpl();
 
-  /**
-   * Uses the accept implemtation. If null is returned, an
-   * exception is thrown.
-   *
-   * @throws TTransportException
-   * @return TTransport
-   */
-  public function accept()
-  {
-    $transport = $this->acceptImpl();
+    /**
+     * Uses the accept implemtation. If null is returned, an
+     * exception is thrown.
+     *
+     * @throws TTransportException
+     * @return TTransport
+     */
+    public function accept()
+    {
+        $transport = $this->acceptImpl();
 
-    if ($transport == null) {
-      throw new TTransportException("accept() may not return NULL");
+        if ($transport == null) {
+            throw new TTransportException("accept() may not return NULL");
+        }
+
+        return $transport;
     }
-
-    return $transport;
-  }
 }
diff --git a/lib/php/lib/Server/TSimpleServer.php b/lib/php/lib/Server/TSimpleServer.php
index e277700..4c1dda5 100644
--- a/lib/php/lib/Server/TSimpleServer.php
+++ b/lib/php/lib/Server/TSimpleServer.php
@@ -11,48 +11,50 @@
  */
 class TSimpleServer extends TServer
 {
-  /**
-   * Flag for the main serving loop
-   *
-   * @var bool
-   */
-  private $stop_ = false;
+    /**
+     * Flag for the main serving loop
+     *
+     * @var bool
+     */
+    private $stop_ = false;
 
-  /**
-   * Listens for new client using the supplied
-   * transport. It handles TTransportExceptions
-   * to avoid timeouts etc killing it
-   *
-   * @return void
-   */
-  public function serve()
-  {
-    $this->transport_->listen();
+    /**
+     * Listens for new client using the supplied
+     * transport. It handles TTransportExceptions
+     * to avoid timeouts etc killing it
+     *
+     * @return void
+     */
+    public function serve()
+    {
+        $this->transport_->listen();
 
-    while (!$this->stop_) {
-      try {
-        $transport = $this->transport_->accept();
+        while (!$this->stop_) {
+            try {
+                $transport = $this->transport_->accept();
 
-        if ($transport != null) {
-          $inputTransport = $this->inputTransportFactory_->getTransport($transport);
-          $outputTransport = $this->outputTransportFactory_->getTransport($transport);
-          $inputProtocol = $this->inputProtocolFactory_->getProtocol($inputTransport);
-          $outputProtocol = $this->outputProtocolFactory_->getProtocol($outputTransport);
-          while ($this->processor_->process($inputProtocol, $outputProtocol)) { }
+                if ($transport != null) {
+                    $inputTransport = $this->inputTransportFactory_->getTransport($transport);
+                    $outputTransport = $this->outputTransportFactory_->getTransport($transport);
+                    $inputProtocol = $this->inputProtocolFactory_->getProtocol($inputTransport);
+                    $outputProtocol = $this->outputProtocolFactory_->getProtocol($outputTransport);
+                    while ($this->processor_->process($inputProtocol, $outputProtocol)) {
+                    }
+                }
+            } catch (TTransportException $e) {
+            }
         }
-      } catch (TTransportException $e) { }
     }
-  }
 
-  /**
-   * Stops the server running. Kills the transport
-   * and then stops the main serving loop
-   *
-   * @return void
-   */
-  public function stop()
-  {
-    $this->transport_->close();
-    $this->stop_ = true;
-  }
+    /**
+     * Stops the server running. Kills the transport
+     * and then stops the main serving loop
+     *
+     * @return void
+     */
+    public function stop()
+    {
+        $this->transport_->close();
+        $this->stop_ = true;
+    }
 }
diff --git a/lib/php/lib/StoredMessageProtocol.php b/lib/php/lib/StoredMessageProtocol.php
index 476d9a6..c4aaaa9 100644
--- a/lib/php/lib/StoredMessageProtocol.php
+++ b/lib/php/lib/StoredMessageProtocol.php
@@ -32,7 +32,9 @@
  */
 class StoredMessageProtocol extends TProtocolDecorator
 {
-    private $fname_, $mtype_, $rseqid_;
+    private $fname_;
+    private $mtype_;
+    private $rseqid_;
 
     public function __construct(TProtocol $protocol, $fname, $mtype, $rseqid)
     {
diff --git a/lib/php/lib/TMultiplexedProcessor.php b/lib/php/lib/TMultiplexedProcessor.php
index 0c2094d..a64a968 100644
--- a/lib/php/lib/TMultiplexedProcessor.php
+++ b/lib/php/lib/TMultiplexedProcessor.php
@@ -111,7 +111,8 @@
         $processor = $this->serviceProcessorMap_[$serviceName];
 
         return $processor->process(
-            new StoredMessageProtocol($input, $messageName, $mtype, $rseqid), $output
+            new StoredMessageProtocol($input, $messageName, $mtype, $rseqid),
+            $output
         );
     }
 }
diff --git a/lib/php/lib/Transport/TBufferedTransport.php b/lib/php/lib/Transport/TBufferedTransport.php
index f654ad3..a541cbb 100644
--- a/lib/php/lib/Transport/TBufferedTransport.php
+++ b/lib/php/lib/Transport/TBufferedTransport.php
@@ -33,149 +33,148 @@
  */
 class TBufferedTransport extends TTransport
 {
-  /**
-   * Constructor. Creates a buffered transport around an underlying transport
-   */
-  public function __construct($transport=null, $rBufSize=512, $wBufSize=512)
-  {
-    $this->transport_ = $transport;
-    $this->rBufSize_ = $rBufSize;
-    $this->wBufSize_ = $wBufSize;
-  }
-
-  /**
-   * The underlying transport
-   *
-   * @var TTransport
-   */
-  protected $transport_ = null;
-
-  /**
-   * The receive buffer size
-   *
-   * @var int
-   */
-  protected $rBufSize_ = 512;
-
-  /**
-   * The write buffer size
-   *
-   * @var int
-   */
-  protected $wBufSize_ = 512;
-
-  /**
-   * The write buffer.
-   *
-   * @var string
-   */
-  protected $wBuf_ = '';
-
-  /**
-   * The read buffer.
-   *
-   * @var string
-   */
-  protected $rBuf_ = '';
-
-  public function isOpen()
-  {
-    return $this->transport_->isOpen();
-  }
-
-  public function open()
-  {
-    $this->transport_->open();
-  }
-
-  public function close()
-  {
-    $this->transport_->close();
-  }
-
-  public function putBack($data)
-  {
-    if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
-      $this->rBuf_ = $data;
-    } else {
-      $this->rBuf_ = ($data . $this->rBuf_);
-    }
-  }
-
-  /**
-   * The reason that we customize readAll here is that the majority of PHP
-   * streams are already internally buffered by PHP. The socket stream, for
-   * example, buffers internally and blocks if you call read with $len greater
-   * than the amount of data available, unlike recv() in C.
-   *
-   * Therefore, use the readAll method of the wrapped transport inside
-   * the buffered readAll.
-   */
-  public function readAll($len)
-  {
-    $have = TStringFuncFactory::create()->strlen($this->rBuf_);
-    if ($have == 0) {
-      $data = $this->transport_->readAll($len);
-    } elseif ($have < $len) {
-      $data = $this->rBuf_;
-      $this->rBuf_ = '';
-      $data .= $this->transport_->readAll($len - $have);
-    } elseif ($have == $len) {
-      $data = $this->rBuf_;
-      $this->rBuf_ = '';
-    } elseif ($have > $len) {
-      $data = TStringFuncFactory::create()->substr($this->rBuf_, 0, $len);
-      $this->rBuf_ = TStringFuncFactory::create()->substr($this->rBuf_, $len);
+    /**
+     * Constructor. Creates a buffered transport around an underlying transport
+     */
+    public function __construct($transport = null, $rBufSize = 512, $wBufSize = 512)
+    {
+        $this->transport_ = $transport;
+        $this->rBufSize_ = $rBufSize;
+        $this->wBufSize_ = $wBufSize;
     }
 
-    return $data;
-  }
+    /**
+     * The underlying transport
+     *
+     * @var TTransport
+     */
+    protected $transport_ = null;
 
-  public function read($len)
-  {
-    if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
-      $this->rBuf_ = $this->transport_->read($this->rBufSize_);
+    /**
+     * The receive buffer size
+     *
+     * @var int
+     */
+    protected $rBufSize_ = 512;
+
+    /**
+     * The write buffer size
+     *
+     * @var int
+     */
+    protected $wBufSize_ = 512;
+
+    /**
+     * The write buffer.
+     *
+     * @var string
+     */
+    protected $wBuf_ = '';
+
+    /**
+     * The read buffer.
+     *
+     * @var string
+     */
+    protected $rBuf_ = '';
+
+    public function isOpen()
+    {
+        return $this->transport_->isOpen();
     }
 
-    if (TStringFuncFactory::create()->strlen($this->rBuf_) <= $len) {
-      $ret = $this->rBuf_;
-      $this->rBuf_ = '';
-
-      return $ret;
+    public function open()
+    {
+        $this->transport_->open();
     }
 
-    $ret = TStringFuncFactory::create()->substr($this->rBuf_, 0, $len);
-    $this->rBuf_ = TStringFuncFactory::create()->substr($this->rBuf_, $len);
-
-    return $ret;
-  }
-
-  public function write($buf)
-  {
-    $this->wBuf_ .= $buf;
-    if (TStringFuncFactory::create()->strlen($this->wBuf_) >= $this->wBufSize_) {
-      $out = $this->wBuf_;
-
-      // Note that we clear the internal wBuf_ prior to the underlying write
-      // to ensure we're in a sane state (i.e. internal buffer cleaned)
-      // if the underlying write throws up an exception
-      $this->wBuf_ = '';
-      $this->transport_->write($out);
+    public function close()
+    {
+        $this->transport_->close();
     }
-  }
 
-  public function flush()
-  {
-    if (TStringFuncFactory::create()->strlen($this->wBuf_) > 0) {
-      $out = $this->wBuf_;
-
-      // Note that we clear the internal wBuf_ prior to the underlying write
-      // to ensure we're in a sane state (i.e. internal buffer cleaned)
-      // if the underlying write throws up an exception
-      $this->wBuf_ = '';
-      $this->transport_->write($out);
+    public function putBack($data)
+    {
+        if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
+            $this->rBuf_ = $data;
+        } else {
+            $this->rBuf_ = ($data . $this->rBuf_);
+        }
     }
-    $this->transport_->flush();
-  }
 
+    /**
+     * The reason that we customize readAll here is that the majority of PHP
+     * streams are already internally buffered by PHP. The socket stream, for
+     * example, buffers internally and blocks if you call read with $len greater
+     * than the amount of data available, unlike recv() in C.
+     *
+     * Therefore, use the readAll method of the wrapped transport inside
+     * the buffered readAll.
+     */
+    public function readAll($len)
+    {
+        $have = TStringFuncFactory::create()->strlen($this->rBuf_);
+        if ($have == 0) {
+            $data = $this->transport_->readAll($len);
+        } elseif ($have < $len) {
+            $data = $this->rBuf_;
+            $this->rBuf_ = '';
+            $data .= $this->transport_->readAll($len - $have);
+        } elseif ($have == $len) {
+            $data = $this->rBuf_;
+            $this->rBuf_ = '';
+        } elseif ($have > $len) {
+            $data = TStringFuncFactory::create()->substr($this->rBuf_, 0, $len);
+            $this->rBuf_ = TStringFuncFactory::create()->substr($this->rBuf_, $len);
+        }
+
+        return $data;
+    }
+
+    public function read($len)
+    {
+        if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
+            $this->rBuf_ = $this->transport_->read($this->rBufSize_);
+        }
+
+        if (TStringFuncFactory::create()->strlen($this->rBuf_) <= $len) {
+            $ret = $this->rBuf_;
+            $this->rBuf_ = '';
+
+            return $ret;
+        }
+
+        $ret = TStringFuncFactory::create()->substr($this->rBuf_, 0, $len);
+        $this->rBuf_ = TStringFuncFactory::create()->substr($this->rBuf_, $len);
+
+        return $ret;
+    }
+
+    public function write($buf)
+    {
+        $this->wBuf_ .= $buf;
+        if (TStringFuncFactory::create()->strlen($this->wBuf_) >= $this->wBufSize_) {
+            $out = $this->wBuf_;
+
+            // Note that we clear the internal wBuf_ prior to the underlying write
+            // to ensure we're in a sane state (i.e. internal buffer cleaned)
+            // if the underlying write throws up an exception
+            $this->wBuf_ = '';
+            $this->transport_->write($out);
+        }
+    }
+
+    public function flush()
+    {
+        if (TStringFuncFactory::create()->strlen($this->wBuf_) > 0) {
+            $out = $this->wBuf_;
+
+            // Note that we clear the internal wBuf_ prior to the underlying write
+            // to ensure we're in a sane state (i.e. internal buffer cleaned)
+            // if the underlying write throws up an exception
+            $this->wBuf_ = '';
+            $this->transport_->write($out);
+        }
+        $this->transport_->flush();
+    }
 }
diff --git a/lib/php/lib/Transport/TCurlClient.php b/lib/php/lib/Transport/TCurlClient.php
index c761cd0..f51fa88 100644
--- a/lib/php/lib/Transport/TCurlClient.php
+++ b/lib/php/lib/Transport/TCurlClient.php
@@ -32,218 +32,217 @@
  */
 class TCurlClient extends TTransport
 {
-  private static $curlHandle;
+    private static $curlHandle;
 
-  /**
-   * The host to connect to
-   *
-   * @var string
-   */
-  protected $host_;
+    /**
+     * The host to connect to
+     *
+     * @var string
+     */
+    protected $host_;
 
-  /**
-   * The port to connect on
-   *
-   * @var int
-   */
-  protected $port_;
+    /**
+     * The port to connect on
+     *
+     * @var int
+     */
+    protected $port_;
 
-  /**
-   * The URI to request
-   *
-   * @var string
-   */
-  protected $uri_;
+    /**
+     * The URI to request
+     *
+     * @var string
+     */
+    protected $uri_;
 
-  /**
-   * The scheme to use for the request, i.e. http, https
-   *
-   * @var string
-   */
-  protected $scheme_;
+    /**
+     * The scheme to use for the request, i.e. http, https
+     *
+     * @var string
+     */
+    protected $scheme_;
 
-  /**
-   * Buffer for the HTTP request data
-   *
-   * @var string
-   */
-  protected $request_;
+    /**
+     * Buffer for the HTTP request data
+     *
+     * @var string
+     */
+    protected $request_;
 
-  /**
-   * Buffer for the HTTP response data.
-   *
-   * @var binary string
-   */
-  protected $response_;
+    /**
+     * Buffer for the HTTP response data.
+     *
+     * @var binary string
+     */
+    protected $response_;
 
-  /**
-   * Read timeout
-   *
-   * @var float
-   */
-  protected $timeout_;
+    /**
+     * Read timeout
+     *
+     * @var float
+     */
+    protected $timeout_;
 
-  /**
-   * http headers
-   *
-   * @var array
-   */
-  protected $headers_;
+    /**
+     * http headers
+     *
+     * @var array
+     */
+    protected $headers_;
 
-  /**
-   * Make a new HTTP client.
-   *
-   * @param string $host
-   * @param int    $port
-   * @param string $uri
-   */
-  public function __construct($host, $port=80, $uri='', $scheme = 'http')
-  {
-    if ((TStringFuncFactory::create()->strlen($uri) > 0) && ($uri{0} != '/')) {
-      $uri = '/'.$uri;
-    }
-    $this->scheme_ = $scheme;
-    $this->host_ = $host;
-    $this->port_ = $port;
-    $this->uri_ = $uri;
-    $this->request_ = '';
-    $this->response_ = null;
-    $this->timeout_ = null;
-    $this->headers_ = array();
-  }
-
-  /**
-   * Set read timeout
-   *
-   * @param float $timeout
-   */
-  public function setTimeoutSecs($timeout)
-  {
-    $this->timeout_ = $timeout;
-  }
-
-  /**
-   * Whether this transport is open.
-   *
-   * @return boolean true if open
-   */
-  public function isOpen()
-  {
-    return true;
-  }
-
-  /**
-   * Open the transport for reading/writing
-   *
-   * @throws TTransportException if cannot open
-   */
-  public function open()
-  {
-  }
-
-  /**
-   * Close the transport.
-   */
-  public function close()
-  {
-    $this->request_ = '';
-    $this->response_ = null;
-  }
-
-  /**
-   * Read some data into the array.
-   *
-   * @param int    $len How much to read
-   * @return string The data that has been read
-   * @throws TTransportException if cannot read any more data
-   */
-  public function read($len)
-  {
-    if ($len >= strlen($this->response_)) {
-      return $this->response_;
-    } else {
-      $ret = substr($this->response_, 0, $len);
-      $this->response_ = substr($this->response_, $len);
-
-      return $ret;
-    }
-  }
-
-  /**
-   * Writes some data into the pending buffer
-   *
-   * @param string $buf  The data to write
-   * @throws TTransportException if writing fails
-   */
-  public function write($buf)
-  {
-    $this->request_ .= $buf;
-  }
-
-  /**
-   * Opens and sends the actual request over the HTTP connection
-   *
-   * @throws TTransportException if a writing error occurs
-   */
-  public function flush()
-  {
-    if (!self::$curlHandle) {
-      register_shutdown_function(array('Thrift\\Transport\\TCurlClient', 'closeCurlHandle'));
-      self::$curlHandle = curl_init();
-      curl_setopt(self::$curlHandle, CURLOPT_RETURNTRANSFER, true);
-      curl_setopt(self::$curlHandle, CURLOPT_BINARYTRANSFER, true);
-      curl_setopt(self::$curlHandle, CURLOPT_USERAGENT, 'PHP/TCurlClient');
-      curl_setopt(self::$curlHandle, CURLOPT_CUSTOMREQUEST, 'POST');
-      curl_setopt(self::$curlHandle, CURLOPT_FOLLOWLOCATION, true);
-      curl_setopt(self::$curlHandle, CURLOPT_MAXREDIRS, 1);
-    }
-    // God, PHP really has some esoteric ways of doing simple things.
-    $host = $this->host_.($this->port_ != 80 ? ':'.$this->port_ : '');
-    $fullUrl = $this->scheme_."://".$host.$this->uri_;
-
-    $headers = array();
-    $defaultHeaders = array('Accept' => 'application/x-thrift',
-                     'Content-Type' => 'application/x-thrift',
-                     'Content-Length' => TStringFuncFactory::create()->strlen($this->request_));
-    foreach (array_merge($defaultHeaders, $this->headers_) as $key => $value) {
-      $headers[] = "$key: $value";
+    /**
+     * Make a new HTTP client.
+     *
+     * @param string $host
+     * @param int $port
+     * @param string $uri
+     */
+    public function __construct($host, $port = 80, $uri = '', $scheme = 'http')
+    {
+        if ((TStringFuncFactory::create()->strlen($uri) > 0) && ($uri{0} != '/')) {
+            $uri = '/' . $uri;
+        }
+        $this->scheme_ = $scheme;
+        $this->host_ = $host;
+        $this->port_ = $port;
+        $this->uri_ = $uri;
+        $this->request_ = '';
+        $this->response_ = null;
+        $this->timeout_ = null;
+        $this->headers_ = array();
     }
 
-    curl_setopt(self::$curlHandle, CURLOPT_HTTPHEADER, $headers);
-
-    if ($this->timeout_ > 0) {
-      curl_setopt(self::$curlHandle, CURLOPT_TIMEOUT, $this->timeout_);
+    /**
+     * Set read timeout
+     *
+     * @param float $timeout
+     */
+    public function setTimeoutSecs($timeout)
+    {
+        $this->timeout_ = $timeout;
     }
-    curl_setopt(self::$curlHandle, CURLOPT_POSTFIELDS, $this->request_);
-    $this->request_ = '';
 
-    curl_setopt(self::$curlHandle, CURLOPT_URL, $fullUrl);
-    $this->response_ = curl_exec(self::$curlHandle);
-
-    // Connect failed?
-    if (!$this->response_) {
-      curl_close(self::$curlHandle);
-      self::$curlHandle = null;
-      $error = 'TCurlClient: Could not connect to '.$fullUrl;
-      throw new TTransportException($error, TTransportException::NOT_OPEN);
+    /**
+     * Whether this transport is open.
+     *
+     * @return boolean true if open
+     */
+    public function isOpen()
+    {
+        return true;
     }
-  }
 
-  public static function closeCurlHandle()
-  {
-    try {
-      if (self::$curlHandle) {
-        curl_close(self::$curlHandle);
-        self::$curlHandle = null;
-      }
-    } catch (\Exception $x) {
-      error_log('There was an error closing the curl handle: ' . $x->getMessage());
+    /**
+     * Open the transport for reading/writing
+     *
+     * @throws TTransportException if cannot open
+     */
+    public function open()
+    {
     }
-  }
 
-  public function addHeaders($headers)
-  {
-    $this->headers_ = array_merge($this->headers_, $headers);
-  }
+    /**
+     * Close the transport.
+     */
+    public function close()
+    {
+        $this->request_ = '';
+        $this->response_ = null;
+    }
 
+    /**
+     * Read some data into the array.
+     *
+     * @param int $len How much to read
+     * @return string The data that has been read
+     * @throws TTransportException if cannot read any more data
+     */
+    public function read($len)
+    {
+        if ($len >= strlen($this->response_)) {
+            return $this->response_;
+        } else {
+            $ret = substr($this->response_, 0, $len);
+            $this->response_ = substr($this->response_, $len);
+
+            return $ret;
+        }
+    }
+
+    /**
+     * Writes some data into the pending buffer
+     *
+     * @param string $buf The data to write
+     * @throws TTransportException if writing fails
+     */
+    public function write($buf)
+    {
+        $this->request_ .= $buf;
+    }
+
+    /**
+     * Opens and sends the actual request over the HTTP connection
+     *
+     * @throws TTransportException if a writing error occurs
+     */
+    public function flush()
+    {
+        if (!self::$curlHandle) {
+            register_shutdown_function(array('Thrift\\Transport\\TCurlClient', 'closeCurlHandle'));
+            self::$curlHandle = curl_init();
+            curl_setopt(self::$curlHandle, CURLOPT_RETURNTRANSFER, true);
+            curl_setopt(self::$curlHandle, CURLOPT_BINARYTRANSFER, true);
+            curl_setopt(self::$curlHandle, CURLOPT_USERAGENT, 'PHP/TCurlClient');
+            curl_setopt(self::$curlHandle, CURLOPT_CUSTOMREQUEST, 'POST');
+            curl_setopt(self::$curlHandle, CURLOPT_FOLLOWLOCATION, true);
+            curl_setopt(self::$curlHandle, CURLOPT_MAXREDIRS, 1);
+        }
+        // God, PHP really has some esoteric ways of doing simple things.
+        $host = $this->host_ . ($this->port_ != 80 ? ':' . $this->port_ : '');
+        $fullUrl = $this->scheme_ . "://" . $host . $this->uri_;
+
+        $headers = array();
+        $defaultHeaders = array('Accept' => 'application/x-thrift',
+            'Content-Type' => 'application/x-thrift',
+            'Content-Length' => TStringFuncFactory::create()->strlen($this->request_));
+        foreach (array_merge($defaultHeaders, $this->headers_) as $key => $value) {
+            $headers[] = "$key: $value";
+        }
+
+        curl_setopt(self::$curlHandle, CURLOPT_HTTPHEADER, $headers);
+
+        if ($this->timeout_ > 0) {
+            curl_setopt(self::$curlHandle, CURLOPT_TIMEOUT, $this->timeout_);
+        }
+        curl_setopt(self::$curlHandle, CURLOPT_POSTFIELDS, $this->request_);
+        $this->request_ = '';
+
+        curl_setopt(self::$curlHandle, CURLOPT_URL, $fullUrl);
+        $this->response_ = curl_exec(self::$curlHandle);
+
+        // Connect failed?
+        if (!$this->response_) {
+            curl_close(self::$curlHandle);
+            self::$curlHandle = null;
+            $error = 'TCurlClient: Could not connect to ' . $fullUrl;
+            throw new TTransportException($error, TTransportException::NOT_OPEN);
+        }
+    }
+
+    public static function closeCurlHandle()
+    {
+        try {
+            if (self::$curlHandle) {
+                curl_close(self::$curlHandle);
+                self::$curlHandle = null;
+            }
+        } catch (\Exception $x) {
+            error_log('There was an error closing the curl handle: ' . $x->getMessage());
+        }
+    }
+
+    public function addHeaders($headers)
+    {
+        $this->headers_ = array_merge($this->headers_, $headers);
+    }
 }
diff --git a/lib/php/lib/Transport/TFramedTransport.php b/lib/php/lib/Transport/TFramedTransport.php
index b8a64a9..39d1869 100644
--- a/lib/php/lib/Transport/TFramedTransport.php
+++ b/lib/php/lib/Transport/TFramedTransport.php
@@ -32,162 +32,161 @@
  */
 class TFramedTransport extends TTransport
 {
-  /**
-   * Underlying transport object.
-   *
-   * @var TTransport
-   */
-  private $transport_;
+    /**
+     * Underlying transport object.
+     *
+     * @var TTransport
+     */
+    private $transport_;
 
-  /**
-   * Buffer for read data.
-   *
-   * @var string
-   */
-  private $rBuf_;
+    /**
+     * Buffer for read data.
+     *
+     * @var string
+     */
+    private $rBuf_;
 
-  /**
-   * Buffer for queued output data
-   *
-   * @var string
-   */
-  private $wBuf_;
+    /**
+     * Buffer for queued output data
+     *
+     * @var string
+     */
+    private $wBuf_;
 
-  /**
-   * Whether to frame reads
-   *
-   * @var bool
-   */
-  private $read_;
+    /**
+     * Whether to frame reads
+     *
+     * @var bool
+     */
+    private $read_;
 
-  /**
-   * Whether to frame writes
-   *
-   * @var bool
-   */
-  private $write_;
+    /**
+     * Whether to frame writes
+     *
+     * @var bool
+     */
+    private $write_;
 
-  /**
-   * Constructor.
-   *
-   * @param TTransport $transport Underlying transport
-   */
-  public function __construct($transport=null, $read=true, $write=true)
-  {
-    $this->transport_ = $transport;
-    $this->read_ = $read;
-    $this->write_ = $write;
-  }
-
-  public function isOpen()
-  {
-    return $this->transport_->isOpen();
-  }
-
-  public function open()
-  {
-    $this->transport_->open();
-  }
-
-  public function close()
-  {
-    $this->transport_->close();
-  }
-
-  /**
-   * Reads from the buffer. When more data is required reads another entire
-   * chunk and serves future reads out of that.
-   *
-   * @param int $len How much data
-   */
-  public function read($len)
-  {
-    if (!$this->read_) {
-      return $this->transport_->read($len);
+    /**
+     * Constructor.
+     *
+     * @param TTransport $transport Underlying transport
+     */
+    public function __construct($transport = null, $read = true, $write = true)
+    {
+        $this->transport_ = $transport;
+        $this->read_ = $read;
+        $this->write_ = $write;
     }
 
-    if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
-      $this->readFrame();
+    public function isOpen()
+    {
+        return $this->transport_->isOpen();
     }
 
-    // Just return full buff
-    if ($len >= TStringFuncFactory::create()->strlen($this->rBuf_)) {
-      $out = $this->rBuf_;
-      $this->rBuf_ = null;
-
-      return $out;
+    public function open()
+    {
+        $this->transport_->open();
     }
 
-    // Return TStringFuncFactory::create()->substr
-    $out = TStringFuncFactory::create()->substr($this->rBuf_, 0, $len);
-    $this->rBuf_ = TStringFuncFactory::create()->substr($this->rBuf_, $len);
-
-    return $out;
-  }
-
-  /**
-   * Put previously read data back into the buffer
-   *
-   * @param string $data data to return
-   */
-  public function putBack($data)
-  {
-    if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
-      $this->rBuf_ = $data;
-    } else {
-      $this->rBuf_ = ($data . $this->rBuf_);
-    }
-  }
-
-  /**
-   * Reads a chunk of data into the internal read buffer.
-   */
-  private function readFrame()
-  {
-    $buf = $this->transport_->readAll(4);
-    $val = unpack('N', $buf);
-    $sz = $val[1];
-
-    $this->rBuf_ = $this->transport_->readAll($sz);
-  }
-
-  /**
-   * Writes some data to the pending output buffer.
-   *
-   * @param string $buf The data
-   * @param int    $len Limit of bytes to write
-   */
-  public function write($buf, $len=null)
-  {
-    if (!$this->write_) {
-      return $this->transport_->write($buf, $len);
+    public function close()
+    {
+        $this->transport_->close();
     }
 
-    if ($len !== null && $len < TStringFuncFactory::create()->strlen($buf)) {
-      $buf = TStringFuncFactory::create()->substr($buf, 0, $len);
-    }
-    $this->wBuf_ .= $buf;
-  }
+    /**
+     * Reads from the buffer. When more data is required reads another entire
+     * chunk and serves future reads out of that.
+     *
+     * @param int $len How much data
+     */
+    public function read($len)
+    {
+        if (!$this->read_) {
+            return $this->transport_->read($len);
+        }
 
-  /**
-   * Writes the output buffer to the stream in the format of a 4-byte length
-   * followed by the actual data.
-   */
-  public function flush()
-  {
-    if (!$this->write_ || TStringFuncFactory::create()->strlen($this->wBuf_) == 0) {
-      return $this->transport_->flush();
+        if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
+            $this->readFrame();
+        }
+
+        // Just return full buff
+        if ($len >= TStringFuncFactory::create()->strlen($this->rBuf_)) {
+            $out = $this->rBuf_;
+            $this->rBuf_ = null;
+
+            return $out;
+        }
+
+        // Return TStringFuncFactory::create()->substr
+        $out = TStringFuncFactory::create()->substr($this->rBuf_, 0, $len);
+        $this->rBuf_ = TStringFuncFactory::create()->substr($this->rBuf_, $len);
+
+        return $out;
     }
 
-    $out = pack('N', TStringFuncFactory::create()->strlen($this->wBuf_));
-    $out .= $this->wBuf_;
+    /**
+     * Put previously read data back into the buffer
+     *
+     * @param string $data data to return
+     */
+    public function putBack($data)
+    {
+        if (TStringFuncFactory::create()->strlen($this->rBuf_) === 0) {
+            $this->rBuf_ = $data;
+        } else {
+            $this->rBuf_ = ($data . $this->rBuf_);
+        }
+    }
 
-    // Note that we clear the internal wBuf_ prior to the underlying write
-    // to ensure we're in a sane state (i.e. internal buffer cleaned)
-    // if the underlying write throws up an exception
-    $this->wBuf_ = '';
-    $this->transport_->write($out);
-    $this->transport_->flush();
-  }
+    /**
+     * Reads a chunk of data into the internal read buffer.
+     */
+    private function readFrame()
+    {
+        $buf = $this->transport_->readAll(4);
+        $val = unpack('N', $buf);
+        $sz = $val[1];
 
+        $this->rBuf_ = $this->transport_->readAll($sz);
+    }
+
+    /**
+     * Writes some data to the pending output buffer.
+     *
+     * @param string $buf The data
+     * @param int $len Limit of bytes to write
+     */
+    public function write($buf, $len = null)
+    {
+        if (!$this->write_) {
+            return $this->transport_->write($buf, $len);
+        }
+
+        if ($len !== null && $len < TStringFuncFactory::create()->strlen($buf)) {
+            $buf = TStringFuncFactory::create()->substr($buf, 0, $len);
+        }
+        $this->wBuf_ .= $buf;
+    }
+
+    /**
+     * Writes the output buffer to the stream in the format of a 4-byte length
+     * followed by the actual data.
+     */
+    public function flush()
+    {
+        if (!$this->write_ || TStringFuncFactory::create()->strlen($this->wBuf_) == 0) {
+            return $this->transport_->flush();
+        }
+
+        $out = pack('N', TStringFuncFactory::create()->strlen($this->wBuf_));
+        $out .= $this->wBuf_;
+
+        // Note that we clear the internal wBuf_ prior to the underlying write
+        // to ensure we're in a sane state (i.e. internal buffer cleaned)
+        // if the underlying write throws up an exception
+        $this->wBuf_ = '';
+        $this->transport_->write($out);
+        $this->transport_->flush();
+    }
 }
diff --git a/lib/php/lib/Transport/THttpClient.php b/lib/php/lib/Transport/THttpClient.php
index b372ab7..a89794b 100644
--- a/lib/php/lib/Transport/THttpClient.php
+++ b/lib/php/lib/Transport/THttpClient.php
@@ -32,198 +32,212 @@
  */
 class THttpClient extends TTransport
 {
-  /**
-   * The host to connect to
-   *
-   * @var string
-   */
-  protected $host_;
+    /**
+     * The host to connect to
+     *
+     * @var string
+     */
+    protected $host_;
 
-  /**
-   * The port to connect on
-   *
-   * @var int
-   */
-  protected $port_;
+    /**
+     * The port to connect on
+     *
+     * @var int
+     */
+    protected $port_;
 
-  /**
-   * The URI to request
-   *
-   * @var string
-   */
-  protected $uri_;
+    /**
+     * The URI to request
+     *
+     * @var string
+     */
+    protected $uri_;
 
-  /**
-   * The scheme to use for the request, i.e. http, https
-   *
-   * @var string
-   */
-  protected $scheme_;
+    /**
+     * The scheme to use for the request, i.e. http, https
+     *
+     * @var string
+     */
+    protected $scheme_;
 
-  /**
-   * Buffer for the HTTP request data
-   *
-   * @var string
-   */
-  protected $buf_;
+    /**
+     * Buffer for the HTTP request data
+     *
+     * @var string
+     */
+    protected $buf_;
 
-  /**
-   * Input socket stream.
-   *
-   * @var resource
-   */
-  protected $handle_;
+    /**
+     * Input socket stream.
+     *
+     * @var resource
+     */
+    protected $handle_;
 
-  /**
-   * Read timeout
-   *
-   * @var float
-   */
-  protected $timeout_;
+    /**
+     * Read timeout
+     *
+     * @var float
+     */
+    protected $timeout_;
 
-  /**
-   * http headers
-   *
-   * @var array
-   */
-  protected $headers_;
+    /**
+     * http headers
+     *
+     * @var array
+     */
+    protected $headers_;
 
-  /**
-   * Make a new HTTP client.
-   *
-   * @param string $host
-   * @param int    $port
-   * @param string $uri
-   */
-  public function __construct($host, $port=80, $uri='', $scheme = 'http')
-  {
-    if ((TStringFuncFactory::create()->strlen($uri) > 0) && ($uri{0} != '/')) {
-      $uri = '/'.$uri;
-    }
-    $this->scheme_ = $scheme;
-    $this->host_ = $host;
-    $this->port_ = $port;
-    $this->uri_ = $uri;
-    $this->buf_ = '';
-    $this->handle_ = null;
-    $this->timeout_ = null;
-    $this->headers_ = array();
-  }
-
-  /**
-   * Set read timeout
-   *
-   * @param float $timeout
-   */
-  public function setTimeoutSecs($timeout)
-  {
-    $this->timeout_ = $timeout;
-  }
-
-  /**
-   * Whether this transport is open.
-   *
-   * @return boolean true if open
-   */
-  public function isOpen()
-  {
-    return true;
-  }
-
-  /**
-   * Open the transport for reading/writing
-   *
-   * @throws TTransportException if cannot open
-   */
-  public function open() {}
-
-  /**
-   * Close the transport.
-   */
-  public function close()
-  {
-    if ($this->handle_) {
-      @fclose($this->handle_);
-      $this->handle_ = null;
-    }
-  }
-
-  /**
-   * Read some data into the array.
-   *
-   * @param int    $len How much to read
-   * @return string The data that has been read
-   * @throws TTransportException if cannot read any more data
-   */
-  public function read($len)
-  {
-    $data = @fread($this->handle_, $len);
-    if ($data === FALSE || $data === '') {
-      $md = stream_get_meta_data($this->handle_);
-      if ($md['timed_out']) {
-        throw new TTransportException('THttpClient: timed out reading '.$len.' bytes from '.$this->host_.':'.$this->port_.$this->uri_, TTransportException::TIMED_OUT);
-      } else {
-        throw new TTransportException('THttpClient: Could not read '.$len.' bytes from '.$this->host_.':'.$this->port_.$this->uri_, TTransportException::UNKNOWN);
-      }
+    /**
+     * Make a new HTTP client.
+     *
+     * @param string $host
+     * @param int $port
+     * @param string $uri
+     */
+    public function __construct($host, $port = 80, $uri = '', $scheme = 'http')
+    {
+        if ((TStringFuncFactory::create()->strlen($uri) > 0) && ($uri{0} != '/')) {
+            $uri = '/' . $uri;
+        }
+        $this->scheme_ = $scheme;
+        $this->host_ = $host;
+        $this->port_ = $port;
+        $this->uri_ = $uri;
+        $this->buf_ = '';
+        $this->handle_ = null;
+        $this->timeout_ = null;
+        $this->headers_ = array();
     }
 
-    return $data;
-  }
-
-  /**
-   * Writes some data into the pending buffer
-   *
-   * @param string $buf  The data to write
-   * @throws TTransportException if writing fails
-   */
-  public function write($buf)
-  {
-    $this->buf_ .= $buf;
-  }
-
-  /**
-   * Opens and sends the actual request over the HTTP connection
-   *
-   * @throws TTransportException if a writing error occurs
-   */
-  public function flush()
-  {
-    // God, PHP really has some esoteric ways of doing simple things.
-    $host = $this->host_.($this->port_ != 80 ? ':'.$this->port_ : '');
-
-    $headers = array();
-    $defaultHeaders = array('Host' => $host,
-                            'Accept' => 'application/x-thrift',
-                            'User-Agent' => 'PHP/THttpClient',
-                            'Content-Type' => 'application/x-thrift',
-                            'Content-Length' => TStringFuncFactory::create()->strlen($this->buf_));
-    foreach (array_merge($defaultHeaders, $this->headers_) as $key => $value) {
-        $headers[] = "$key: $value";
+    /**
+     * Set read timeout
+     *
+     * @param float $timeout
+     */
+    public function setTimeoutSecs($timeout)
+    {
+        $this->timeout_ = $timeout;
     }
 
-    $options = array('method' => 'POST',
-                     'header' => implode("\r\n", $headers),
-                     'max_redirects' => 1,
-                     'content' => $this->buf_);
-    if ($this->timeout_ > 0) {
-      $options['timeout'] = $this->timeout_;
+    /**
+     * Whether this transport is open.
+     *
+     * @return boolean true if open
+     */
+    public function isOpen()
+    {
+        return true;
     }
-    $this->buf_ = '';
 
-    $contextid = stream_context_create(array('http' => $options));
-    $this->handle_ = @fopen($this->scheme_.'://'.$host.$this->uri_, 'r', false, $contextid);
-
-    // Connect failed?
-    if ($this->handle_ === FALSE) {
-      $this->handle_ = null;
-      $error = 'THttpClient: Could not connect to '.$host.$this->uri_;
-      throw new TTransportException($error, TTransportException::NOT_OPEN);
+    /**
+     * Open the transport for reading/writing
+     *
+     * @throws TTransportException if cannot open
+     */
+    public function open()
+    {
     }
-  }
 
-  public function addHeaders($headers)
-  {
-    $this->headers_ = array_merge($this->headers_, $headers);
-  }
+    /**
+     * Close the transport.
+     */
+    public function close()
+    {
+        if ($this->handle_) {
+            @fclose($this->handle_);
+            $this->handle_ = null;
+        }
+    }
 
+    /**
+     * Read some data into the array.
+     *
+     * @param int $len How much to read
+     * @return string The data that has been read
+     * @throws TTransportException if cannot read any more data
+     */
+    public function read($len)
+    {
+        $data = @fread($this->handle_, $len);
+        if ($data === false || $data === '') {
+            $md = stream_get_meta_data($this->handle_);
+            if ($md['timed_out']) {
+                throw new TTransportException(
+                    'THttpClient: timed out reading ' . $len . ' bytes from ' .
+                    $this->host_ . ':' . $this->port_ . $this->uri_,
+                    TTransportException::TIMED_OUT
+                );
+            } else {
+                throw new TTransportException(
+                    'THttpClient: Could not read ' . $len . ' bytes from ' .
+                    $this->host_ . ':' . $this->port_ . $this->uri_,
+                    TTransportException::UNKNOWN
+                );
+            }
+        }
+
+        return $data;
+    }
+
+    /**
+     * Writes some data into the pending buffer
+     *
+     * @param string $buf The data to write
+     * @throws TTransportException if writing fails
+     */
+    public function write($buf)
+    {
+        $this->buf_ .= $buf;
+    }
+
+    /**
+     * Opens and sends the actual request over the HTTP connection
+     *
+     * @throws TTransportException if a writing error occurs
+     */
+    public function flush()
+    {
+        // God, PHP really has some esoteric ways of doing simple things.
+        $host = $this->host_ . ($this->port_ != 80 ? ':' . $this->port_ : '');
+
+        $headers = array();
+        $defaultHeaders = array('Host' => $host,
+            'Accept' => 'application/x-thrift',
+            'User-Agent' => 'PHP/THttpClient',
+            'Content-Type' => 'application/x-thrift',
+            'Content-Length' => TStringFuncFactory::create()->strlen($this->buf_));
+        foreach (array_merge($defaultHeaders, $this->headers_) as $key => $value) {
+            $headers[] = "$key: $value";
+        }
+
+        $options = array('method' => 'POST',
+            'header' => implode("\r\n", $headers),
+            'max_redirects' => 1,
+            'content' => $this->buf_);
+        if ($this->timeout_ > 0) {
+            $options['timeout'] = $this->timeout_;
+        }
+        $this->buf_ = '';
+
+        $contextid = stream_context_create(array('http' => $options));
+        $this->handle_ = @fopen(
+            $this->scheme_ . '://' . $host . $this->uri_,
+            'r',
+            false,
+            $contextid
+        );
+
+        // Connect failed?
+        if ($this->handle_ === false) {
+            $this->handle_ = null;
+            $error = 'THttpClient: Could not connect to ' . $host . $this->uri_;
+            throw new TTransportException($error, TTransportException::NOT_OPEN);
+        }
+    }
+
+    public function addHeaders($headers)
+    {
+        $this->headers_ = array_merge($this->headers_, $headers);
+    }
 }
diff --git a/lib/php/lib/Transport/TMemoryBuffer.php b/lib/php/lib/Transport/TMemoryBuffer.php
index ca31c57..fee03a2 100644
--- a/lib/php/lib/Transport/TMemoryBuffer.php
+++ b/lib/php/lib/Transport/TMemoryBuffer.php
@@ -35,66 +35,72 @@
  */
 class TMemoryBuffer extends TTransport
 {
-  /**
-   * Constructor. Optionally pass an initial value
-   * for the buffer.
-   */
-  public function __construct($buf = '')
-  {
-    $this->buf_ = $buf;
-  }
-
-  protected $buf_ = '';
-
-  public function isOpen()
-  {
-    return true;
-  }
-
-  public function open() {}
-
-  public function close() {}
-
-  public function write($buf)
-  {
-    $this->buf_ .= $buf;
-  }
-
-  public function read($len)
-  {
-    $bufLength = TStringFuncFactory::create()->strlen($this->buf_);
-
-    if ($bufLength === 0) {
-      throw new TTransportException('TMemoryBuffer: Could not read ' .
-                                    $len . ' bytes from buffer.',
-                                    TTransportException::UNKNOWN);
+    /**
+     * Constructor. Optionally pass an initial value
+     * for the buffer.
+     */
+    public function __construct($buf = '')
+    {
+        $this->buf_ = $buf;
     }
 
-    if ($bufLength <= $len) {
-      $ret = $this->buf_;
-      $this->buf_ = '';
+    protected $buf_ = '';
 
-      return $ret;
+    public function isOpen()
+    {
+        return true;
     }
 
-    $ret = TStringFuncFactory::create()->substr($this->buf_, 0, $len);
-    $this->buf_ = TStringFuncFactory::create()->substr($this->buf_, $len);
+    public function open()
+    {
+    }
 
-    return $ret;
-  }
+    public function close()
+    {
+    }
 
-  public function getBuffer()
-  {
-    return $this->buf_;
-  }
+    public function write($buf)
+    {
+        $this->buf_ .= $buf;
+    }
 
-  public function available()
-  {
-    return TStringFuncFactory::create()->strlen($this->buf_);
-  }
+    public function read($len)
+    {
+        $bufLength = TStringFuncFactory::create()->strlen($this->buf_);
 
-  public function putBack($data)
-  {
-    $this->buf_ = $data.$this->buf_;
-  }
+        if ($bufLength === 0) {
+            throw new TTransportException(
+                'TMemoryBuffer: Could not read ' .
+                $len . ' bytes from buffer.',
+                TTransportException::UNKNOWN
+            );
+        }
+
+        if ($bufLength <= $len) {
+            $ret = $this->buf_;
+            $this->buf_ = '';
+
+            return $ret;
+        }
+
+        $ret = TStringFuncFactory::create()->substr($this->buf_, 0, $len);
+        $this->buf_ = TStringFuncFactory::create()->substr($this->buf_, $len);
+
+        return $ret;
+    }
+
+    public function getBuffer()
+    {
+        return $this->buf_;
+    }
+
+    public function available()
+    {
+        return TStringFuncFactory::create()->strlen($this->buf_);
+    }
+
+    public function putBack($data)
+    {
+        $this->buf_ = $data . $this->buf_;
+    }
 }
diff --git a/lib/php/lib/Transport/TNullTransport.php b/lib/php/lib/Transport/TNullTransport.php
index feeb7a4..7e086b6 100644
--- a/lib/php/lib/Transport/TNullTransport.php
+++ b/lib/php/lib/Transport/TNullTransport.php
@@ -32,20 +32,25 @@
  */
 class TNullTransport extends TTransport
 {
-  public function isOpen()
-  {
-    return true;
-  }
+    public function isOpen()
+    {
+        return true;
+    }
 
-  public function open() {}
+    public function open()
+    {
+    }
 
-  public function close() {}
+    public function close()
+    {
+    }
 
-  public function read($len)
-  {
-    throw new TTransportException("Can't read from TNullTransport.");
-  }
+    public function read($len)
+    {
+        throw new TTransportException("Can't read from TNullTransport.");
+    }
 
-  public function write($buf) {}
-
+    public function write($buf)
+    {
+    }
 }
diff --git a/lib/php/lib/Transport/TPhpStream.php b/lib/php/lib/Transport/TPhpStream.php
index 4c14cdf..42823ff 100644
--- a/lib/php/lib/Transport/TPhpStream.php
+++ b/lib/php/lib/Transport/TPhpStream.php
@@ -33,91 +33,92 @@
  */
 class TPhpStream extends TTransport
 {
-  const MODE_R = 1;
-  const MODE_W = 2;
+    const MODE_R = 1;
+    const MODE_W = 2;
 
-  private $inStream_ = null;
+    private $inStream_ = null;
 
-  private $outStream_ = null;
+    private $outStream_ = null;
 
-  private $read_ = false;
+    private $read_ = false;
 
-  private $write_ = false;
+    private $write_ = false;
 
-  public function __construct($mode)
-  {
-    $this->read_ = $mode & self::MODE_R;
-    $this->write_ = $mode & self::MODE_W;
-  }
-
-  public function open()
-  {
-    if ($this->read_) {
-      $this->inStream_ = @fopen(self::inStreamName(), 'r');
-      if (!is_resource($this->inStream_)) {
-        throw new TException('TPhpStream: Could not open php://input');
-      }
-    }
-    if ($this->write_) {
-      $this->outStream_ = @fopen('php://output', 'w');
-      if (!is_resource($this->outStream_)) {
-        throw new TException('TPhpStream: Could not open php://output');
-      }
-    }
-  }
-
-  public function close()
-  {
-    if ($this->read_) {
-      @fclose($this->inStream_);
-      $this->inStream_ = null;
-    }
-    if ($this->write_) {
-      @fclose($this->outStream_);
-      $this->outStream_ = null;
-    }
-  }
-
-  public function isOpen()
-  {
-    return
-      (!$this->read_ || is_resource($this->inStream_)) &&
-      (!$this->write_ || is_resource($this->outStream_));
-  }
-
-  public function read($len)
-  {
-    $data = @fread($this->inStream_, $len);
-    if ($data === FALSE || $data === '') {
-      throw new TException('TPhpStream: Could not read '.$len.' bytes');
+    public function __construct($mode)
+    {
+        $this->read_ = $mode & self::MODE_R;
+        $this->write_ = $mode & self::MODE_W;
     }
 
-    return $data;
-  }
-
-  public function write($buf)
-  {
-    while (TStringFuncFactory::create()->strlen($buf) > 0) {
-      $got = @fwrite($this->outStream_, $buf);
-      if ($got === 0 || $got === FALSE) {
-        throw new TException('TPhpStream: Could not write '.TStringFuncFactory::create()->strlen($buf).' bytes');
-      }
-      $buf = TStringFuncFactory::create()->substr($buf, $got);
-    }
-  }
-
-  public function flush()
-  {
-    @fflush($this->outStream_);
-  }
-
-  private static function inStreamName()
-  {
-    if (php_sapi_name() == 'cli') {
-      return 'php://stdin';
+    public function open()
+    {
+        if ($this->read_) {
+            $this->inStream_ = @fopen(self::inStreamName(), 'r');
+            if (!is_resource($this->inStream_)) {
+                throw new TException('TPhpStream: Could not open php://input');
+            }
+        }
+        if ($this->write_) {
+            $this->outStream_ = @fopen('php://output', 'w');
+            if (!is_resource($this->outStream_)) {
+                throw new TException('TPhpStream: Could not open php://output');
+            }
+        }
     }
 
-    return 'php://input';
-  }
+    public function close()
+    {
+        if ($this->read_) {
+            @fclose($this->inStream_);
+            $this->inStream_ = null;
+        }
+        if ($this->write_) {
+            @fclose($this->outStream_);
+            $this->outStream_ = null;
+        }
+    }
 
+    public function isOpen()
+    {
+        return
+            (!$this->read_ || is_resource($this->inStream_)) &&
+            (!$this->write_ || is_resource($this->outStream_));
+    }
+
+    public function read($len)
+    {
+        $data = @fread($this->inStream_, $len);
+        if ($data === false || $data === '') {
+            throw new TException('TPhpStream: Could not read ' . $len . ' bytes');
+        }
+
+        return $data;
+    }
+
+    public function write($buf)
+    {
+        while (TStringFuncFactory::create()->strlen($buf) > 0) {
+            $got = @fwrite($this->outStream_, $buf);
+            if ($got === 0 || $got === false) {
+                throw new TException(
+                    'TPhpStream: Could not write ' . TStringFuncFactory::create()->strlen($buf) . ' bytes'
+                );
+            }
+            $buf = TStringFuncFactory::create()->substr($buf, $got);
+        }
+    }
+
+    public function flush()
+    {
+        @fflush($this->outStream_);
+    }
+
+    private static function inStreamName()
+    {
+        if (php_sapi_name() == 'cli') {
+            return 'php://stdin';
+        }
+
+        return 'php://input';
+    }
 }
diff --git a/lib/php/lib/Transport/TSSLSocket.php b/lib/php/lib/Transport/TSSLSocket.php
index 533b7bb..b4a0adb 100644
--- a/lib/php/lib/Transport/TSSLSocket.php
+++ b/lib/php/lib/Transport/TSSLSocket.php
@@ -33,80 +33,85 @@
  */
 class TSSLSocket extends TSocket
 {
-  /**
-   * Remote port
-   *
-   * @var resource
-   */
-  protected $context_ = null;
+    /**
+     * Remote port
+     *
+     * @var resource
+     */
+    protected $context_ = null;
 
-  /**
-   * Socket constructor
-   *
-   * @param string     $host         Remote hostname
-   * @param int        $port         Remote port
-   * @param resource   $context      Stream context
-   * @param bool       $persist      Whether to use a persistent socket
-   * @param string     $debugHandler Function to call for error logging
-   */
-  public function __construct($host='localhost',
-                              $port=9090,
-                              $context=null,
-                              $debugHandler=null) {
-    $this->host_ = $this->getSSLHost($host);
-    $this->port_ = $port;
-    $this->context_ = $context;
-    $this->debugHandler_ = $debugHandler ? $debugHandler : 'error_log';
-  }
-
-  /**
-   * Creates a host name with SSL transport protocol
-   * if no transport protocol already specified in
-   * the host name.
-   *
-   * @param string $host    Host to listen on
-   * @return string $host   Host name with transport protocol
-   */
-  private function getSSLHost($host)
-  {
-    $transport_protocol_loc = strpos($host, "://");
-    if ($transport_protocol_loc === false) {
-      $host = 'ssl://'.$host;
-    }
-    return $host;
-  }
-
-  /**
-   * Connects the socket.
-   */
-  public function open()
-  {
-    if ($this->isOpen()) {
-      throw new TTransportException('Socket already connected', TTransportException::ALREADY_OPEN);
+    /**
+     * Socket constructor
+     *
+     * @param string $host Remote hostname
+     * @param int $port Remote port
+     * @param resource $context Stream context
+     * @param bool $persist Whether to use a persistent socket
+     * @param string $debugHandler Function to call for error logging
+     */
+    public function __construct(
+        $host = 'localhost',
+        $port = 9090,
+        $context = null,
+        $debugHandler = null
+    ) {
+        $this->host_ = $this->getSSLHost($host);
+        $this->port_ = $port;
+        $this->context_ = $context;
+        $this->debugHandler_ = $debugHandler ? $debugHandler : 'error_log';
     }
 
-    if (empty($this->host_)) {
-      throw new TTransportException('Cannot open null host', TTransportException::NOT_OPEN);
+    /**
+     * Creates a host name with SSL transport protocol
+     * if no transport protocol already specified in
+     * the host name.
+     *
+     * @param string $host Host to listen on
+     * @return string $host   Host name with transport protocol
+     */
+    private function getSSLHost($host)
+    {
+        $transport_protocol_loc = strpos($host, "://");
+        if ($transport_protocol_loc === false) {
+            $host = 'ssl://' . $host;
+        }
+        return $host;
     }
 
-    if ($this->port_ <= 0) {
-      throw new TTransportException('Cannot open without port', TTransportException::NOT_OPEN);
-    }
+    /**
+     * Connects the socket.
+     */
+    public function open()
+    {
+        if ($this->isOpen()) {
+            throw new TTransportException('Socket already connected', TTransportException::ALREADY_OPEN);
+        }
 
-    $this->handle_ = @stream_socket_client($this->host_.':'.$this->port_,
-                                          $errno,
-                                          $errstr,
-                                          $this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000),
-                                          STREAM_CLIENT_CONNECT,
-                                          $this->context_);
+        if (empty($this->host_)) {
+            throw new TTransportException('Cannot open null host', TTransportException::NOT_OPEN);
+        }
 
-    // Connect failed?
-    if ($this->handle_ === FALSE) {
-      $error = 'TSocket: Could not connect to '.$this->host_.':'.$this->port_.' ('.$errstr.' ['.$errno.'])';
-      if ($this->debug_) {
-        call_user_func($this->debugHandler_, $error);
-      }
-      throw new TException($error);
+        if ($this->port_ <= 0) {
+            throw new TTransportException('Cannot open without port', TTransportException::NOT_OPEN);
+        }
+
+        $this->handle_ = @stream_socket_client(
+            $this->host_ . ':' . $this->port_,
+            $errno,
+            $errstr,
+            $this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000),
+            STREAM_CLIENT_CONNECT,
+            $this->context_
+        );
+
+        // Connect failed?
+        if ($this->handle_ === false) {
+            $error = 'TSocket: Could not connect to ' .
+                $this->host_ . ':' . $this->port_ . ' (' . $errstr . ' [' . $errno . '])';
+            if ($this->debug_) {
+                call_user_func($this->debugHandler_, $error);
+            }
+            throw new TException($error);
+        }
     }
-  }
 }
diff --git a/lib/php/lib/Transport/TSocket.php b/lib/php/lib/Transport/TSocket.php
index a1872b9..93bd1cf 100644
--- a/lib/php/lib/Transport/TSocket.php
+++ b/lib/php/lib/Transport/TSocket.php
@@ -33,308 +33,333 @@
  */
 class TSocket extends TTransport
 {
-  /**
-   * Handle to PHP socket
-   *
-   * @var resource
-   */
-  protected $handle_ = null;
+    /**
+     * Handle to PHP socket
+     *
+     * @var resource
+     */
+    protected $handle_ = null;
 
-  /**
-   * Remote hostname
-   *
-   * @var string
-   */
-  protected $host_ = 'localhost';
+    /**
+     * Remote hostname
+     *
+     * @var string
+     */
+    protected $host_ = 'localhost';
 
-  /**
-   * Remote port
-   *
-   * @var int
-   */
-  protected $port_ = '9090';
+    /**
+     * Remote port
+     *
+     * @var int
+     */
+    protected $port_ = '9090';
 
-  /**
-   * Send timeout in seconds.
-   *
-   * Combined with sendTimeoutUsec this is used for send timeouts.
-   *
-   * @var int
-   */
-  protected $sendTimeoutSec_ = 0;
+    /**
+     * Send timeout in seconds.
+     *
+     * Combined with sendTimeoutUsec this is used for send timeouts.
+     *
+     * @var int
+     */
+    protected $sendTimeoutSec_ = 0;
 
-  /**
-   * Send timeout in microseconds.
-   *
-   * Combined with sendTimeoutSec this is used for send timeouts.
-   *
-   * @var int
-   */
-  protected $sendTimeoutUsec_ = 100000;
+    /**
+     * Send timeout in microseconds.
+     *
+     * Combined with sendTimeoutSec this is used for send timeouts.
+     *
+     * @var int
+     */
+    protected $sendTimeoutUsec_ = 100000;
 
-  /**
-   * Recv timeout in seconds
-   *
-   * Combined with recvTimeoutUsec this is used for recv timeouts.
-   *
-   * @var int
-   */
-  protected $recvTimeoutSec_ = 0;
+    /**
+     * Recv timeout in seconds
+     *
+     * Combined with recvTimeoutUsec this is used for recv timeouts.
+     *
+     * @var int
+     */
+    protected $recvTimeoutSec_ = 0;
 
-  /**
-   * Recv timeout in microseconds
-   *
-   * Combined with recvTimeoutSec this is used for recv timeouts.
-   *
-   * @var int
-   */
-  protected $recvTimeoutUsec_ = 750000;
+    /**
+     * Recv timeout in microseconds
+     *
+     * Combined with recvTimeoutSec this is used for recv timeouts.
+     *
+     * @var int
+     */
+    protected $recvTimeoutUsec_ = 750000;
 
-  /**
-   * Persistent socket or plain?
-   *
-   * @var bool
-   */
-  protected $persist_ = false;
+    /**
+     * Persistent socket or plain?
+     *
+     * @var bool
+     */
+    protected $persist_ = false;
 
-  /**
-   * Debugging on?
-   *
-   * @var bool
-   */
-  protected $debug_ = false;
+    /**
+     * Debugging on?
+     *
+     * @var bool
+     */
+    protected $debug_ = false;
 
-  /**
-   * Debug handler
-   *
-   * @var mixed
-   */
-  protected $debugHandler_ = null;
+    /**
+     * Debug handler
+     *
+     * @var mixed
+     */
+    protected $debugHandler_ = null;
 
-  /**
-   * Socket constructor
-   *
-   * @param string $host         Remote hostname
-   * @param int    $port         Remote port
-   * @param bool   $persist      Whether to use a persistent socket
-   * @param string $debugHandler Function to call for error logging
-   */
-  public function __construct($host='localhost',
-                              $port=9090,
-                              $persist=false,
-                              $debugHandler=null) {
-    $this->host_ = $host;
-    $this->port_ = $port;
-    $this->persist_ = $persist;
-    $this->debugHandler_ = $debugHandler ? $debugHandler : 'error_log';
-  }
+    /**
+     * Socket constructor
+     *
+     * @param string $host Remote hostname
+     * @param int $port Remote port
+     * @param bool $persist Whether to use a persistent socket
+     * @param string $debugHandler Function to call for error logging
+     */
+    public function __construct(
+        $host = 'localhost',
+        $port = 9090,
+        $persist = false,
+        $debugHandler = null
+    ) {
+        $this->host_ = $host;
+        $this->port_ = $port;
+        $this->persist_ = $persist;
+        $this->debugHandler_ = $debugHandler ? $debugHandler : 'error_log';
+    }
 
-  /**
-   * @param resource $handle
-   * @return void
-   */
-  public function setHandle($handle)
-  {
-    $this->handle_ = $handle;
-  }
+    /**
+     * @param resource $handle
+     * @return void
+     */
+    public function setHandle($handle)
+    {
+        $this->handle_ = $handle;
+    }
 
-  /**
-   * Sets the send timeout.
-   *
-   * @param int $timeout  Timeout in milliseconds.
-   */
-  public function setSendTimeout($timeout)
-  {
-    $this->sendTimeoutSec_ = floor($timeout / 1000);
-    $this->sendTimeoutUsec_ =
+    /**
+     * Sets the send timeout.
+     *
+     * @param int $timeout Timeout in milliseconds.
+     */
+    public function setSendTimeout($timeout)
+    {
+        $this->sendTimeoutSec_ = floor($timeout / 1000);
+        $this->sendTimeoutUsec_ =
             ($timeout - ($this->sendTimeoutSec_ * 1000)) * 1000;
-  }
+    }
 
-  /**
-   * Sets the receive timeout.
-   *
-   * @param int $timeout  Timeout in milliseconds.
-   */
-  public function setRecvTimeout($timeout)
-  {
-    $this->recvTimeoutSec_ = floor($timeout / 1000);
-    $this->recvTimeoutUsec_ =
+    /**
+     * Sets the receive timeout.
+     *
+     * @param int $timeout Timeout in milliseconds.
+     */
+    public function setRecvTimeout($timeout)
+    {
+        $this->recvTimeoutSec_ = floor($timeout / 1000);
+        $this->recvTimeoutUsec_ =
             ($timeout - ($this->recvTimeoutSec_ * 1000)) * 1000;
-  }
-
-  /**
-   * Sets debugging output on or off
-   *
-   * @param bool $debug
-   */
-  public function setDebug($debug)
-  {
-    $this->debug_ = $debug;
-  }
-
-  /**
-   * Get the host that this socket is connected to
-   *
-   * @return string host
-   */
-  public function getHost()
-  {
-    return $this->host_;
-  }
-
-  /**
-   * Get the remote port that this socket is connected to
-   *
-   * @return int port
-   */
-  public function getPort()
-  {
-    return $this->port_;
-  }
-
-  /**
-   * Tests whether this is open
-   *
-   * @return bool true if the socket is open
-   */
-  public function isOpen()
-  {
-    return is_resource($this->handle_);
-  }
-
-  /**
-   * Connects the socket.
-   */
-  public function open()
-  {
-    if ($this->isOpen()) {
-      throw new TTransportException('Socket already connected', TTransportException::ALREADY_OPEN);
     }
 
-    if (empty($this->host_)) {
-      throw new TTransportException('Cannot open null host', TTransportException::NOT_OPEN);
+    /**
+     * Sets debugging output on or off
+     *
+     * @param bool $debug
+     */
+    public function setDebug($debug)
+    {
+        $this->debug_ = $debug;
     }
 
-    if ($this->port_ <= 0) {
-      throw new TTransportException('Cannot open without port', TTransportException::NOT_OPEN);
+    /**
+     * Get the host that this socket is connected to
+     *
+     * @return string host
+     */
+    public function getHost()
+    {
+        return $this->host_;
     }
 
-    if ($this->persist_) {
-      $this->handle_ = @pfsockopen($this->host_,
-                                   $this->port_,
-                                   $errno,
-                                   $errstr,
-                                   $this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000));
-    } else {
-      $this->handle_ = @fsockopen($this->host_,
-                                  $this->port_,
-                                  $errno,
-                                  $errstr,
-                                  $this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000));
+    /**
+     * Get the remote port that this socket is connected to
+     *
+     * @return int port
+     */
+    public function getPort()
+    {
+        return $this->port_;
     }
 
-    // Connect failed?
-    if ($this->handle_ === FALSE) {
-      $error = 'TSocket: Could not connect to '.$this->host_.':'.$this->port_.' ('.$errstr.' ['.$errno.'])';
-      if ($this->debug_) {
-        call_user_func($this->debugHandler_, $error);
-      }
-      throw new TException($error);
+    /**
+     * Tests whether this is open
+     *
+     * @return bool true if the socket is open
+     */
+    public function isOpen()
+    {
+        return is_resource($this->handle_);
     }
 
-    if (function_exists('socket_import_stream') && function_exists('socket_set_option')) {
-      $socket = socket_import_stream($this->handle_);
-      socket_set_option($socket, SOL_TCP, TCP_NODELAY, 1);
-    }
-  }
-
-  /**
-   * Closes the socket.
-   */
-  public function close()
-  {
-    @fclose($this->handle_);
-    $this->handle_ = null;
-  }
-
-  /**
-   * Read from the socket at most $len bytes.
-   *
-   * This method will not wait for all the requested data, it will return as
-   * soon as any data is received.
-   *
-   * @param int $len Maximum number of bytes to read.
-   * @return string Binary data
-   */
-  public function read($len)
-  {
-    $null = null;
-    $read = array($this->handle_);
-    $readable = @stream_select($read, $null, $null, $this->recvTimeoutSec_, $this->recvTimeoutUsec_);
-
-    if ($readable > 0) {
-      $data = fread($this->handle_, $len);
-      if ($data === false) {
-          throw new TTransportException('TSocket: Could not read '.$len.' bytes from '.
-                               $this->host_.':'.$this->port_);
-      } elseif ($data == '' && feof($this->handle_)) {
-          throw new TTransportException('TSocket read 0 bytes');
+    /**
+     * Connects the socket.
+     */
+    public function open()
+    {
+        if ($this->isOpen()) {
+            throw new TTransportException('Socket already connected', TTransportException::ALREADY_OPEN);
         }
 
-      return $data;
-    } elseif ($readable === 0) {
-        throw new TTransportException('TSocket: timed out reading '.$len.' bytes from '.
-                             $this->host_.':'.$this->port_);
-      } else {
-        throw new TTransportException('TSocket: Could not read '.$len.' bytes from '.
-                             $this->host_.':'.$this->port_);
-      }
-    }
-
-  /**
-   * Write to the socket.
-   *
-   * @param string $buf The data to write
-   */
-  public function write($buf)
-  {
-    $null = null;
-    $write = array($this->handle_);
-
-    // keep writing until all the data has been written
-    while (TStringFuncFactory::create()->strlen($buf) > 0) {
-      // wait for stream to become available for writing
-      $writable = @stream_select($null, $write, $null, $this->sendTimeoutSec_, $this->sendTimeoutUsec_);
-      if ($writable > 0) {
-        // write buffer to stream
-        $written = fwrite($this->handle_, $buf);
-        if ($written === -1 || $written === false) {
-          throw new TTransportException('TSocket: Could not write '.TStringFuncFactory::create()->strlen($buf).' bytes '.
-                                   $this->host_.':'.$this->port_);
+        if (empty($this->host_)) {
+            throw new TTransportException('Cannot open null host', TTransportException::NOT_OPEN);
         }
-        // determine how much of the buffer is left to write
-        $buf = TStringFuncFactory::create()->substr($buf, $written);
-      } elseif ($writable === 0) {
-          throw new TTransportException('TSocket: timed out writing '.TStringFuncFactory::create()->strlen($buf).' bytes from '.
-                               $this->host_.':'.$this->port_);
+
+        if ($this->port_ <= 0) {
+            throw new TTransportException('Cannot open without port', TTransportException::NOT_OPEN);
+        }
+
+        if ($this->persist_) {
+            $this->handle_ = @pfsockopen(
+                $this->host_,
+                $this->port_,
+                $errno,
+                $errstr,
+                $this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000)
+            );
         } else {
-            throw new TTransportException('TSocket: Could not write '.TStringFuncFactory::create()->strlen($buf).' bytes '.
-                                 $this->host_.':'.$this->port_);
+            $this->handle_ = @fsockopen(
+                $this->host_,
+                $this->port_,
+                $errno,
+                $errstr,
+                $this->sendTimeoutSec_ + ($this->sendTimeoutUsec_ / 1000000)
+            );
         }
-      }
+
+        // Connect failed?
+        if ($this->handle_ === false) {
+            $error = 'TSocket: Could not connect to ' .
+                $this->host_ . ':' . $this->port_ . ' (' . $errstr . ' [' . $errno . '])';
+            if ($this->debug_) {
+                call_user_func($this->debugHandler_, $error);
+            }
+            throw new TException($error);
+        }
+
+        if (function_exists('socket_import_stream') && function_exists('socket_set_option')) {
+            $socket = socket_import_stream($this->handle_);
+            socket_set_option($socket, SOL_TCP, TCP_NODELAY, 1);
+        }
     }
 
-  /**
-   * Flush output to the socket.
-   *
-   * Since read(), readAll() and write() operate on the sockets directly,
-   * this is a no-op
-   *
-   * If you wish to have flushable buffering behaviour, wrap this TSocket
-   * in a TBufferedTransport.
-   */
-  public function flush()
-  {
-    // no-op
+    /**
+     * Closes the socket.
+     */
+    public function close()
+    {
+        @fclose($this->handle_);
+        $this->handle_ = null;
     }
-  }
+
+    /**
+     * Read from the socket at most $len bytes.
+     *
+     * This method will not wait for all the requested data, it will return as
+     * soon as any data is received.
+     *
+     * @param int $len Maximum number of bytes to read.
+     * @return string Binary data
+     */
+    public function read($len)
+    {
+        $null = null;
+        $read = array($this->handle_);
+        $readable = @stream_select(
+            $read,
+            $null,
+            $null,
+            $this->recvTimeoutSec_,
+            $this->recvTimeoutUsec_
+        );
+
+        if ($readable > 0) {
+            $data = fread($this->handle_, $len);
+            if ($data === false) {
+                throw new TTransportException('TSocket: Could not read ' . $len . ' bytes from ' .
+                    $this->host_ . ':' . $this->port_);
+            } elseif ($data == '' && feof($this->handle_)) {
+                throw new TTransportException('TSocket read 0 bytes');
+            }
+
+            return $data;
+        } elseif ($readable === 0) {
+            throw new TTransportException('TSocket: timed out reading ' . $len . ' bytes from ' .
+                $this->host_ . ':' . $this->port_);
+        } else {
+            throw new TTransportException('TSocket: Could not read ' . $len . ' bytes from ' .
+                $this->host_ . ':' . $this->port_);
+        }
+    }
+
+    /**
+     * Write to the socket.
+     *
+     * @param string $buf The data to write
+     */
+    public function write($buf)
+    {
+        $null = null;
+        $write = array($this->handle_);
+
+        // keep writing until all the data has been written
+        while (TStringFuncFactory::create()->strlen($buf) > 0) {
+            // wait for stream to become available for writing
+            $writable = @stream_select(
+                $null,
+                $write,
+                $null,
+                $this->sendTimeoutSec_,
+                $this->sendTimeoutUsec_
+            );
+            if ($writable > 0) {
+                // write buffer to stream
+                $written = fwrite($this->handle_, $buf);
+                if ($written === -1 || $written === false) {
+                    throw new TTransportException(
+                        'TSocket: Could not write ' . TStringFuncFactory::create()->strlen($buf) . ' bytes ' .
+                        $this->host_ . ':' . $this->port_
+                    );
+                }
+                // determine how much of the buffer is left to write
+                $buf = TStringFuncFactory::create()->substr($buf, $written);
+            } elseif ($writable === 0) {
+                throw new TTransportException(
+                    'TSocket: timed out writing ' . TStringFuncFactory::create()->strlen($buf) . ' bytes from ' .
+                    $this->host_ . ':' . $this->port_
+                );
+            } else {
+                throw new TTransportException(
+                    'TSocket: Could not write ' . TStringFuncFactory::create()->strlen($buf) . ' bytes ' .
+                    $this->host_ . ':' . $this->port_
+                );
+            }
+        }
+    }
+
+    /**
+     * Flush output to the socket.
+     *
+     * Since read(), readAll() and write() operate on the sockets directly,
+     * this is a no-op
+     *
+     * If you wish to have flushable buffering behaviour, wrap this TSocket
+     * in a TBufferedTransport.
+     */
+    public function flush()
+    {
+        // no-op
+    }
+}
diff --git a/lib/php/lib/Transport/TSocketPool.php b/lib/php/lib/Transport/TSocketPool.php
index 18ffd8d..cb9e8dd 100644
--- a/lib/php/lib/Transport/TSocketPool.php
+++ b/lib/php/lib/Transport/TSocketPool.php
@@ -31,8 +31,15 @@
  * misses.
  */
 if (!function_exists('apc_fetch')) {
-  function apc_fetch($key) { return FALSE; }
-  function apc_store($key, $var, $ttl=0) { return FALSE; }
+    function apc_fetch($key)
+    {
+        return false;
+    }
+
+    function apc_store($key, $var, $ttl = 0)
+    {
+        return false;
+    }
 }
 
 /**
@@ -43,258 +50,261 @@
  */
 class TSocketPool extends TSocket
 {
-  /**
-   * Remote servers. Array of associative arrays with 'host' and 'port' keys
-   */
-  private $servers_ = array();
+    /**
+     * Remote servers. Array of associative arrays with 'host' and 'port' keys
+     */
+    private $servers_ = array();
 
-  /**
-   * How many times to retry each host in connect
-   *
-   * @var int
-   */
-  private $numRetries_ = 1;
+    /**
+     * How many times to retry each host in connect
+     *
+     * @var int
+     */
+    private $numRetries_ = 1;
 
-  /**
-   * Retry interval in seconds, how long to not try a host if it has been
-   * marked as down.
-   *
-   * @var int
-   */
-  private $retryInterval_ = 60;
+    /**
+     * Retry interval in seconds, how long to not try a host if it has been
+     * marked as down.
+     *
+     * @var int
+     */
+    private $retryInterval_ = 60;
 
-  /**
-   * Max consecutive failures before marking a host down.
-   *
-   * @var int
-   */
-  private $maxConsecutiveFailures_ = 1;
+    /**
+     * Max consecutive failures before marking a host down.
+     *
+     * @var int
+     */
+    private $maxConsecutiveFailures_ = 1;
 
-  /**
-   * Try hosts in order? or Randomized?
-   *
-   * @var bool
-   */
-  private $randomize_ = true;
+    /**
+     * Try hosts in order? or Randomized?
+     *
+     * @var bool
+     */
+    private $randomize_ = true;
 
-  /**
-   * Always try last host, even if marked down?
-   *
-   * @var bool
-   */
-  private $alwaysTryLast_ = true;
+    /**
+     * Always try last host, even if marked down?
+     *
+     * @var bool
+     */
+    private $alwaysTryLast_ = true;
 
-  /**
-   * Socket pool constructor
-   *
-   * @param array  $hosts        List of remote hostnames
-   * @param mixed  $ports        Array of remote ports, or a single common port
-   * @param bool   $persist      Whether to use a persistent socket
-   * @param mixed  $debugHandler Function for error logging
-   */
-  public function __construct($hosts=array('localhost'),
-                              $ports=array(9090),
-                              $persist=false,
-                              $debugHandler=null) {
-    parent::__construct(null, 0, $persist, $debugHandler);
+    /**
+     * Socket pool constructor
+     *
+     * @param array $hosts List of remote hostnames
+     * @param mixed $ports Array of remote ports, or a single common port
+     * @param bool $persist Whether to use a persistent socket
+     * @param mixed $debugHandler Function for error logging
+     */
+    public function __construct(
+        $hosts = array('localhost'),
+        $ports = array(9090),
+        $persist = false,
+        $debugHandler = null
+    ) {
+        parent::__construct(null, 0, $persist, $debugHandler);
 
-    if (!is_array($ports)) {
-      $port = $ports;
-      $ports = array();
-      foreach ($hosts as $key => $val) {
-        $ports[$key] = $port;
-      }
-    }
-
-    foreach ($hosts as $key => $host) {
-      $this->servers_ []= array('host' => $host,
-                                'port' => $ports[$key]);
-    }
-  }
-
-  /**
-   * Add a server to the pool
-   *
-   * This function does not prevent you from adding a duplicate server entry.
-   *
-   * @param string $host hostname or IP
-   * @param int $port port
-   */
-  public function addServer($host, $port)
-  {
-    $this->servers_[] = array('host' => $host, 'port' => $port);
-  }
-
-  /**
-   * Sets how many time to keep retrying a host in the connect function.
-   *
-   * @param int $numRetries
-   */
-  public function setNumRetries($numRetries)
-  {
-    $this->numRetries_ = $numRetries;
-  }
-
-  /**
-   * Sets how long to wait until retrying a host if it was marked down
-   *
-   * @param int $numRetries
-   */
-  public function setRetryInterval($retryInterval)
-  {
-    $this->retryInterval_ = $retryInterval;
-  }
-
-  /**
-   * Sets how many time to keep retrying a host before marking it as down.
-   *
-   * @param int $numRetries
-   */
-  public function setMaxConsecutiveFailures($maxConsecutiveFailures)
-  {
-    $this->maxConsecutiveFailures_ = $maxConsecutiveFailures;
-  }
-
-  /**
-   * Turns randomization in connect order on or off.
-   *
-   * @param bool $randomize
-   */
-  public function setRandomize($randomize)
-  {
-    $this->randomize_ = $randomize;
-  }
-
-  /**
-   * Whether to always try the last server.
-   *
-   * @param bool $alwaysTryLast
-   */
-  public function setAlwaysTryLast($alwaysTryLast)
-  {
-    $this->alwaysTryLast_ = $alwaysTryLast;
-  }
-
-  /**
-   * Connects the socket by iterating through all the servers in the pool
-   * and trying to find one that works.
-   */
-  public function open()
-  {
-    // Check if we want order randomization
-    if ($this->randomize_) {
-      shuffle($this->servers_);
-    }
-
-    // Count servers to identify the "last" one
-    $numServers = count($this->servers_);
-
-    for ($i = 0; $i < $numServers; ++$i) {
-
-      // This extracts the $host and $port variables
-      extract($this->servers_[$i]);
-
-      // Check APC cache for a record of this server being down
-      $failtimeKey = 'thrift_failtime:'.$host.':'.$port.'~';
-
-      // Cache miss? Assume it's OK
-      $lastFailtime = apc_fetch($failtimeKey);
-      if ($lastFailtime === FALSE) {
-        $lastFailtime = 0;
-      }
-
-      $retryIntervalPassed = false;
-
-      // Cache hit...make sure enough the retry interval has elapsed
-      if ($lastFailtime > 0) {
-        $elapsed = time() - $lastFailtime;
-        if ($elapsed > $this->retryInterval_) {
-          $retryIntervalPassed = true;
-          if ($this->debug_) {
-            call_user_func($this->debugHandler_,
-                           'TSocketPool: retryInterval '.
-                           '('.$this->retryInterval_.') '.
-                           'has passed for host '.$host.':'.$port);
-          }
+        if (!is_array($ports)) {
+            $port = $ports;
+            $ports = array();
+            foreach ($hosts as $key => $val) {
+                $ports[$key] = $port;
+            }
         }
-      }
 
-      // Only connect if not in the middle of a fail interval, OR if this
-      // is the LAST server we are trying, just hammer away on it
-      $isLastServer = false;
-      if ($this->alwaysTryLast_) {
-        $isLastServer = ($i == ($numServers - 1));
-      }
+        foreach ($hosts as $key => $host) {
+            $this->servers_ [] = array('host' => $host,
+                'port' => $ports[$key]);
+        }
+    }
 
-      if (($lastFailtime === 0) ||
-          ($isLastServer) ||
-          ($lastFailtime > 0 && $retryIntervalPassed)) {
+    /**
+     * Add a server to the pool
+     *
+     * This function does not prevent you from adding a duplicate server entry.
+     *
+     * @param string $host hostname or IP
+     * @param int $port port
+     */
+    public function addServer($host, $port)
+    {
+        $this->servers_[] = array('host' => $host, 'port' => $port);
+    }
 
-        // Set underlying TSocket params to this one
-        $this->host_ = $host;
-        $this->port_ = $port;
+    /**
+     * Sets how many time to keep retrying a host in the connect function.
+     *
+     * @param int $numRetries
+     */
+    public function setNumRetries($numRetries)
+    {
+        $this->numRetries_ = $numRetries;
+    }
 
-        // Try up to numRetries_ connections per server
-        for ($attempt = 0; $attempt < $this->numRetries_; $attempt++) {
-          try {
-            // Use the underlying TSocket open function
-            parent::open();
+    /**
+     * Sets how long to wait until retrying a host if it was marked down
+     *
+     * @param int $numRetries
+     */
+    public function setRetryInterval($retryInterval)
+    {
+        $this->retryInterval_ = $retryInterval;
+    }
 
-            // Only clear the failure counts if required to do so
-            if ($lastFailtime > 0) {
-              apc_store($failtimeKey, 0);
+    /**
+     * Sets how many time to keep retrying a host before marking it as down.
+     *
+     * @param int $numRetries
+     */
+    public function setMaxConsecutiveFailures($maxConsecutiveFailures)
+    {
+        $this->maxConsecutiveFailures_ = $maxConsecutiveFailures;
+    }
+
+    /**
+     * Turns randomization in connect order on or off.
+     *
+     * @param bool $randomize
+     */
+    public function setRandomize($randomize)
+    {
+        $this->randomize_ = $randomize;
+    }
+
+    /**
+     * Whether to always try the last server.
+     *
+     * @param bool $alwaysTryLast
+     */
+    public function setAlwaysTryLast($alwaysTryLast)
+    {
+        $this->alwaysTryLast_ = $alwaysTryLast;
+    }
+
+    /**
+     * Connects the socket by iterating through all the servers in the pool
+     * and trying to find one that works.
+     */
+    public function open()
+    {
+        // Check if we want order randomization
+        if ($this->randomize_) {
+            shuffle($this->servers_);
+        }
+
+        // Count servers to identify the "last" one
+        $numServers = count($this->servers_);
+
+        for ($i = 0; $i < $numServers; ++$i) {
+            // This extracts the $host and $port variables
+            extract($this->servers_[$i]);
+
+            // Check APC cache for a record of this server being down
+            $failtimeKey = 'thrift_failtime:' . $host . ':' . $port . '~';
+
+            // Cache miss? Assume it's OK
+            $lastFailtime = apc_fetch($failtimeKey);
+            if ($lastFailtime === false) {
+                $lastFailtime = 0;
             }
 
-            // Successful connection, return now
-            return;
+            $retryIntervalPassed = false;
 
-          } catch (TException $tx) {
-            // Connection failed
-          }
+            // Cache hit...make sure enough the retry interval has elapsed
+            if ($lastFailtime > 0) {
+                $elapsed = time() - $lastFailtime;
+                if ($elapsed > $this->retryInterval_) {
+                    $retryIntervalPassed = true;
+                    if ($this->debug_) {
+                        call_user_func(
+                            $this->debugHandler_,
+                            'TSocketPool: retryInterval ' .
+                            '(' . $this->retryInterval_ . ') ' .
+                            'has passed for host ' . $host . ':' . $port
+                        );
+                    }
+                }
+            }
+
+            // Only connect if not in the middle of a fail interval, OR if this
+            // is the LAST server we are trying, just hammer away on it
+            $isLastServer = false;
+            if ($this->alwaysTryLast_) {
+                $isLastServer = ($i == ($numServers - 1));
+            }
+
+            if (($lastFailtime === 0) ||
+                ($isLastServer) ||
+                ($lastFailtime > 0 && $retryIntervalPassed)) {
+                // Set underlying TSocket params to this one
+                $this->host_ = $host;
+                $this->port_ = $port;
+
+                // Try up to numRetries_ connections per server
+                for ($attempt = 0; $attempt < $this->numRetries_; $attempt++) {
+                    try {
+                        // Use the underlying TSocket open function
+                        parent::open();
+
+                        // Only clear the failure counts if required to do so
+                        if ($lastFailtime > 0) {
+                            apc_store($failtimeKey, 0);
+                        }
+
+                        // Successful connection, return now
+                        return;
+                    } catch (TException $tx) {
+                        // Connection failed
+                    }
+                }
+
+                // Mark failure of this host in the cache
+                $consecfailsKey = 'thrift_consecfails:' . $host . ':' . $port . '~';
+
+                // Ignore cache misses
+                $consecfails = apc_fetch($consecfailsKey);
+                if ($consecfails === false) {
+                    $consecfails = 0;
+                }
+
+                // Increment by one
+                $consecfails++;
+
+                // Log and cache this failure
+                if ($consecfails >= $this->maxConsecutiveFailures_) {
+                    if ($this->debug_) {
+                        call_user_func(
+                            $this->debugHandler_,
+                            'TSocketPool: marking ' . $host . ':' . $port .
+                            ' as down for ' . $this->retryInterval_ . ' secs ' .
+                            'after ' . $consecfails . ' failed attempts.'
+                        );
+                    }
+                    // Store the failure time
+                    apc_store($failtimeKey, time());
+
+                    // Clear the count of consecutive failures
+                    apc_store($consecfailsKey, 0);
+                } else {
+                    apc_store($consecfailsKey, $consecfails);
+                }
+            }
         }
 
-        // Mark failure of this host in the cache
-        $consecfailsKey = 'thrift_consecfails:'.$host.':'.$port.'~';
-
-        // Ignore cache misses
-        $consecfails = apc_fetch($consecfailsKey);
-        if ($consecfails === FALSE) {
-          $consecfails = 0;
+        // Oh no; we failed them all. The system is totally ill!
+        $error = 'TSocketPool: All hosts in pool are down. ';
+        $hosts = array();
+        foreach ($this->servers_ as $server) {
+            $hosts [] = $server['host'] . ':' . $server['port'];
         }
-
-        // Increment by one
-        $consecfails++;
-
-        // Log and cache this failure
-        if ($consecfails >= $this->maxConsecutiveFailures_) {
-          if ($this->debug_) {
-            call_user_func($this->debugHandler_,
-                           'TSocketPool: marking '.$host.':'.$port.
-                           ' as down for '.$this->retryInterval_.' secs '.
-                           'after '.$consecfails.' failed attempts.');
-          }
-          // Store the failure time
-          apc_store($failtimeKey, time());
-
-          // Clear the count of consecutive failures
-          apc_store($consecfailsKey, 0);
-        } else {
-          apc_store($consecfailsKey, $consecfails);
+        $hostlist = implode(',', $hosts);
+        $error .= '(' . $hostlist . ')';
+        if ($this->debug_) {
+            call_user_func($this->debugHandler_, $error);
         }
-      }
+        throw new TException($error);
     }
-
-    // Oh no; we failed them all. The system is totally ill!
-    $error = 'TSocketPool: All hosts in pool are down. ';
-    $hosts = array();
-    foreach ($this->servers_ as $server) {
-      $hosts []= $server['host'].':'.$server['port'];
-    }
-    $hostlist = implode(',', $hosts);
-    $error .= '('.$hostlist.')';
-    if ($this->debug_) {
-      call_user_func($this->debugHandler_, $error);
-    }
-    throw new TException($error);
-  }
 }
diff --git a/lib/php/lib/Transport/TTransport.php b/lib/php/lib/Transport/TTransport.php
index 99c39ff..df248f2 100644
--- a/lib/php/lib/Transport/TTransport.php
+++ b/lib/php/lib/Transport/TTransport.php
@@ -31,65 +31,67 @@
  */
 abstract class TTransport
 {
-  /**
-   * Whether this transport is open.
-   *
-   * @return boolean true if open
-   */
-  abstract public function isOpen();
+    /**
+     * Whether this transport is open.
+     *
+     * @return boolean true if open
+     */
+    abstract public function isOpen();
 
-  /**
-   * Open the transport for reading/writing
-   *
-   * @throws TTransportException if cannot open
-   */
-  abstract public function open();
+    /**
+     * Open the transport for reading/writing
+     *
+     * @throws TTransportException if cannot open
+     */
+    abstract public function open();
 
-  /**
-   * Close the transport.
-   */
-  abstract public function close();
+    /**
+     * Close the transport.
+     */
+    abstract public function close();
 
-  /**
-   * Read some data into the array.
-   *
-   * @param int    $len How much to read
-   * @return string The data that has been read
-   * @throws TTransportException if cannot read any more data
-   */
-  abstract public function read($len);
+    /**
+     * Read some data into the array.
+     *
+     * @param int $len How much to read
+     * @return string The data that has been read
+     * @throws TTransportException if cannot read any more data
+     */
+    abstract public function read($len);
 
-  /**
-   * Guarantees that the full amount of data is read.
-   *
-   * @return string The data, of exact length
-   * @throws TTransportException if cannot read data
-   */
-  public function readAll($len)
-  {
-    // return $this->read($len);
+    /**
+     * Guarantees that the full amount of data is read.
+     *
+     * @return string The data, of exact length
+     * @throws TTransportException if cannot read data
+     */
+    public function readAll($len)
+    {
+        // return $this->read($len);
 
-    $data = '';
-    $got = 0;
-    while (($got = TStringFuncFactory::create()->strlen($data)) < $len) {
-      $data .= $this->read($len - $got);
+        $data = '';
+        $got = 0;
+        while (($got = TStringFuncFactory::create()->strlen($data)) < $len) {
+            $data .= $this->read($len - $got);
+        }
+
+        return $data;
     }
 
-    return $data;
-  }
+    /**
+     * Writes the given data out.
+     *
+     * @param string $buf The data to write
+     * @throws TTransportException if writing fails
+     */
+    abstract public function write($buf);
 
-  /**
-   * Writes the given data out.
-   *
-   * @param string $buf  The data to write
-   * @throws TTransportException if writing fails
-   */
-  abstract public function write($buf);
-
-  /**
-   * Flushes any pending data out of a buffer
-   *
-   * @throws TTransportException if a writing error occurs
-   */
-  public function flush() {}
+    /**
+     * Flushes any pending data out of a buffer
+     *
+     * @throws TTransportException if a writing error occurs
+     */
+    public function flush()
+    {
+    }
 }
diff --git a/lib/php/lib/Type/TConstant.php b/lib/php/lib/Type/TConstant.php
index 7c8eceb..215da4a 100644
--- a/lib/php/lib/Type/TConstant.php
+++ b/lib/php/lib/Type/TConstant.php
@@ -30,7 +30,9 @@
     /**
      * Don't instanciate this class
      */
-    protected function __construct() {}
+    protected function __construct()
+    {
+    }
 
     /**
      * Get a constant value
@@ -41,8 +43,8 @@
     {
         if (is_null(static::$$constant)) {
             static::$$constant = call_user_func(
-                    sprintf('static::init_%s', $constant)
-                );
+                sprintf('static::init_%s', $constant)
+            );
         }
 
         return static::$$constant;
diff --git a/lib/php/lib/Type/TMessageType.php b/lib/php/lib/Type/TMessageType.php
index bff224f..dc9ae62 100644
--- a/lib/php/lib/Type/TMessageType.php
+++ b/lib/php/lib/Type/TMessageType.php
@@ -27,8 +27,8 @@
  */
 class TMessageType
 {
-  const CALL  = 1;
-  const REPLY = 2;
-  const EXCEPTION = 3;
-  const ONEWAY = 4;
+    const CALL  = 1;
+    const REPLY = 2;
+    const EXCEPTION = 3;
+    const ONEWAY = 4;
 }
diff --git a/lib/php/lib/Type/TType.php b/lib/php/lib/Type/TType.php
index 71219c2..3fdb15f 100644
--- a/lib/php/lib/Type/TType.php
+++ b/lib/php/lib/Type/TType.php
@@ -27,21 +27,21 @@
  */
 class TType
 {
-  const STOP   = 0;
-  const VOID   = 1;
-  const BOOL   = 2;
-  const BYTE   = 3;
-  const I08    = 3;
-  const DOUBLE = 4;
-  const I16    = 6;
-  const I32    = 8;
-  const I64    = 10;
-  const STRING = 11;
-  const UTF7   = 11;
-  const STRUCT = 12;
-  const MAP    = 13;
-  const SET    = 14;
-  const LST    = 15;    // N.B. cannot use LIST keyword in PHP!
-  const UTF8   = 16;
-  const UTF16  = 17;
+    const STOP   = 0;
+    const VOID   = 1;
+    const BOOL   = 2;
+    const BYTE   = 3;
+    const I08    = 3;
+    const DOUBLE = 4;
+    const I16    = 6;
+    const I32    = 8;
+    const I64    = 10;
+    const STRING = 11;
+    const UTF7   = 11;
+    const STRUCT = 12;
+    const MAP    = 13;
+    const SET    = 14;
+    const LST    = 15;    // N.B. cannot use LIST keyword in PHP!
+    const UTF8   = 16;
+    const UTF16  = 17;
 }