Transform.class.php

Go to the documentation of this file.

<?php
final class Transform
{
  const MACHINE_ENDIAN_ORDER = 0;
  const LITTLE_ENDIAN_ORDER  = 1;
  const BIG_ENDIAN_ORDER     = 2;
 
  private function __construct() {}
  
  public static function isLittleEndian()
  {
    return self::fromInt32("\x01\x00\x00\x00") == 1;
  }
  
  public static function isBigEndian()
  {
    return self::fromInt32("\x00\x00\x00\x01") == 1;
  }
  
  public static function toInt64LE($value)
  {
    return pack("V*", $value & 0xffffffff, $value / (0xffffffff+1));
  }
 
  public static function fromInt64LE($value)
  {
    list(, $lolo, $lohi, $hilo, $hihi) = unpack("v*", $value);
    return ($hihi * (0xffff+1) + $hilo) * (0xffffffff+1) +
      ($lohi * (0xffff+1) + $lolo);
  }
 
  public static function toInt64BE($value)
  {
    return pack("N*", $value / (0xffffffff+1), $value & 0xffffffff);
  }
 
  public static function fromInt64BE($value)
  {
    list(, $hihi, $hilo, $lohi, $lolo) = unpack("n*", $value);
    return ($hihi * (0xffff+1) + $hilo) * (0xffffffff+1) +
      ($lohi * (0xffff+1) + $lolo);
  }
 
  public static function toInt32($value)
  {
    return pack("l*", $value);
  }
 
  public static function fromInt32($value)
  {
    list(, $int) = unpack("l*", $value);
    return $int;
  }
 
  public static function toInt32LE($value)
  {
    if (self::isBigEndian())
      return strrev(self::toInt32($value));
    else
      return self::toInt32($value);
  }
 
  public static function fromInt32LE($value)
  {
    if (self::isBigEndian())
      return self::fromInt32(strrev($value));
    else
      return self::fromInt32($value);
  }
 
  public static function toInt32BE($value)
  {
    if (self::isBigEndian())
      return self::toInt32($value);
    else
      return strrev(self::toInt32($value));
  }
 
  public static function fromInt32BE($value)
  {
    if (self::isBigEndian())
      return self::fromInt32($value);
    else
      return self::fromInt32(strrev($value));
  }
 
  public static function toUInt32LE($value)
  {
    return pack("V*", $value);
  }
 
  public static function fromUInt32LE($value)
  {
    if (PHP_INT_SIZE < 8) {
      list(, $lo, $hi) = unpack("v*", $value);
      return $hi * (0xffff+1) + $lo; // eq $hi << 16 | $lo
    } else {
      list(, $int) = unpack("V*", $value);
      return $int;
    }
  }
 
  public static function toUInt32BE($value)
  {
    return pack("N*", $value);
  }
 
  public static function fromUInt32BE($value)
  {
    if (PHP_INT_SIZE < 8) {
      list(, $hi, $lo) = unpack("n*", $value);
      return $hi * (0xffff+1) + $lo; // eq $hi << 16 | $lo
    } else {
      list(, $int) = unpack("N*", $value);
      return $int;
    }
  }
 
  public static function toInt16($value)
  {
    return pack("s*", $value);
  }
 
  public static function fromInt16($value)
  {
    list(, $int) = unpack("s*", $value);
    return $int;
  }
 
  public static function toInt16LE($value)
  {
    if (self::isBigEndian())
      return strrev(self::toInt16($value));
    else
      return self::toInt16($value);
  }
 
  public static function fromInt16LE($value)
  {
    if (self::isBigEndian())
      return self::fromInt16(strrev($value));
    else
      return self::fromInt16($value);
  }
 
  public static function toInt16BE($value)
  {
    if (self::isBigEndian())
      return self::toInt16($value);
    else
      return strrev(self::toInt16($value));
  }
 
  public static function fromInt16BE($value)
  {
    if (self::isBigEndian())
      return self::fromInt16($value);
    else
      return self::fromInt16(strrev($value));
  }
 
  private static function fromUInt16($value, $order = self::MACHINE_ENDIAN_ORDER)
  {
    list(, $int) = unpack
      (($order == self::BIG_ENDIAN_ORDER ? "n" :
        ($order == self::LITTLE_ENDIAN_ORDER ? "v" : "S")) . "*", $value);
    return $int;
  }
 
  public static function toUInt16LE($value)
  {
    return pack("v*", $value);
  }
 
  public static function fromUInt16LE($value)
  {
    return self::fromUInt16($value, self::LITTLE_ENDIAN_ORDER);
  }
 
  public static function toUInt16BE($value)
  {
    return pack("n*", $value);
  }
 
  public static function fromUInt16BE($value)
  {
    return self::fromUInt16($value, self::BIG_ENDIAN_ORDER);
  }
 
  public static function toInt8($value)
  {
    return pack("c*", $value);
  }
 
  public static function fromInt8($value)
  {
    list(, $int) = unpack("c*", $value);
    return $int;
  }
 
  public static function toUInt8($value)
  {
    return pack("C*", $value);
  }
 
  public static function fromUInt8($value)
  {
    list(, $int) = unpack("C*", $value);
    return $int;
  }
 
  public static function toFloat($value)
  {
    return pack("f*", $value);
  }
 
  public static function fromFloat($value)
  {
    list(, $float) = unpack("f*", $value);
    return $float;
  }
 
  public static function toFloatLE($value)
  {
    if (self::isBigEndian())
      return strrev(self::toFloat($value));
    else
      return self::toFloat($value);
  }
 
  public static function fromFloatLE($value)
  {
    if (self::isBigEndian())
      return self::fromFloat(strrev($value));
    else
      return self::fromFloat($value);
  }
 
  public static function toFloatBE($value)
  {
    if (self::isBigEndian())
      return self::toFloat($value);
    else
      return strrev(self::toFloat($value));
  }
 
  public static function fromFloatBE($value)
  {
    if (self::isBigEndian())
      return self::fromFloat($value);
    else
      return self::fromFloat(strrev($value));
  }
 
  public static function toString8($value, $length = false, $padding = "\0")
  {
    if ($length === false)
      $length = strlen($value);
    if ($length < ($tmp = strlen($value)))
      $length = $tmp + $length;
    return str_pad($value, $length, $padding);
  }
 
  public static function fromString8($value)
  {
    return rtrim($value, "\0");
  }
 
  public static function toString16
    ($value, $order = false, $length = false, $padding = "\0")
  {
    if ($length === false)
      $length = (int)(strlen($value) / 2);
    if ($length < ($tmp = strlen($value) / 2))
      $length = $tmp + $length;
    if ($order == self::BIG_ENDIAN_ORDER &&
        !(ord($value[0]) == 0xfe && ord($value[1]) == 0xff)) {
      $value = 0xfeff . $value;
      $length++;
    }
    if ($order == self::LITTLE_ENDIAN_ORDER &&
        !(ord($value[0]) == 0xff && ord($value[1]) == 0xfe)) {
      $value = 0xfffe . $value;
      $length++;
    }
    return str_pad($value, $length * 2, $padding);
  }
 
  public static function fromString16
    ($value, &$order = false, $trimOrder = false)
  {
    if (strlen($value) < 2)
      return "";
    
    if (ord($value[0]) == 0xfe && ord($value[1]) == 0xff) {
      $order = self::BIG_ENDIAN_ORDER;
      if ($trimOrder)
        $value = substr($value, 2);
    }
    if (ord($value[0]) == 0xff && ord($value[1]) == 0xfe) {
      $order = self::LITTLE_ENDIAN_ORDER;
      if ($trimOrder)
        $value = substr($value, 2);
    }
    
    return substr($value, -2) == "\0\0" ? substr($value, 0, -2) : $value;
  }
 
  public static function toHHex($value)
  {
    return pack("H*", $value);
  }
 
  public static function fromHHex($value)
  {
    list($hex) = unpack("H*0", $value);
    return $hex;
  }
 
  public static function toLHex($value)
  {
    return pack("h*", $value);
  }
 
  public static function fromLHex($value)
  {
    list($hex) = unpack("h*0", $value);
    return $hex;
  }
 
  public static function toGUID($value)
  {
    $string = ""; $C = preg_split("/-/", $value);
    return pack
      ("V1v2N2", hexdec($C[0]), hexdec($C[1]), hexdec($C[2]),
       hexdec($C[3] . substr($C[4], 0, 4)), hexdec(substr($C[4], 4)));
  }
 
  public static function fromGUID($value)
  {
    $C = @unpack("V1V/v2v/N2N", $value);
    list($hex) = @unpack("H*0", pack
      ("NnnNN", $C["V"], $C["v1"], $C["v2"], $C["N1"], $C["N2"]));
 
    /* Fixes a bug in PHP versions earlier than Jan 25 2006 */
    if (implode("", unpack("H*", pack("H*", "a"))) == "a00")
      $hex = substr($hex, 0, -1);
 
    return preg_replace
      ("/^(.{8})(.{4})(.{4})(.{4})/", "\\1-\\2-\\3-\\4-", $hex);
  }
}