Upload files to 'classes'

classes/badges.class.php

@@ -1,145 +1,136 @@
-<?php
-class Badges
-{
-    /**
-     * Given a UserID, returns that user's badges
-     *
-     * @param int $UserID
-     * @return array of BadgeIDs
-     */
-    public static function get_badges($UserID)
-    {
-        return Users::user_info($UserID)['Badges'];
-    }
-
-    /**
-     * Awards UserID the given BadgeID
-     *
-     * @param int $UserID
-     * @param int $BadgeID
-     * @return bool success?
-     */
-    public static function award_badge($UserID, $BadgeID)
-    {
-        if (self::has_badge($UserID, $BadgeID)) {
-            return false;
-        } else {
-            $QueryID = G::$DB->get_query_id();
-            G::$DB->query("
+<?
+class Badges {
+  /**
+   * Given a UserID, returns that user's badges
+   *
+   * @param int $UserID
+   * @return array of BadgeIDs
+   */
+  public static function get_badges($UserID) {
+    return Users::user_info($UserID)['Badges'];
+  }
+
+  /**
+   * Awards UserID the given BadgeID
+   *
+   * @param int $UserID
+   * @param int $BadgeID
+   * @return bool success?
+   */
+  public static function award_badge($UserID, $BadgeID) {
+    if (self::has_badge($UserID, $BadgeID)) {
+      return false;
+    } else {
+      $QueryID = G::$DB->get_query_id();
+      G::$DB->query("
         INSERT INTO users_badges
           (UserID, BadgeID)
         VALUES
           ($UserID, $BadgeID)");
-            G::$DB->set_query_id($QueryID);
+      G::$DB->set_query_id($QueryID);
 
-            G::$Cache->delete_value('user_info_'.$UserID);
+      G::$Cache->delete_value('user_info_'.$UserID);
 
-            return true;
-        }
+      return true;
     }
-
-    /**
-     * Given a UserID, return that user's displayed badges
-     *
-     * @param int $UserID
-     * @return array of BadgeIDs
-     */
-    public static function get_displayed_badges($UserID)
-    {
-        $Result = [];
-
-        $Badges = self::get_badges($UserID);
-
-        foreach ($Badges as $Badge => $Displayed) {
-            if ($Displayed) {
-                $Result[] = $Badge;
-            }
-        }
-        return $Result;
+  }
+
+  /**
+   * Given a UserID, return that user's displayed badges
+   *
+   * @param int $UserID
+   * @return array of BadgeIDs
+   */
+  public static function get_displayed_badges($UserID) {
+    $Result = [];
+
+    $Badges = self::get_badges($UserID);
+
+    foreach ($Badges as $Badge => $Displayed) {
+      if ($Displayed)
+        $Result[] = $Badge;
     }
-
-    /**
-     * Returns true if the given user owns the given badge
-     *
-     * @param int $UserID
-     * @param int $BadgeID
-     * @return bool
-     */
-    public static function has_badge($UserID, $BadgeID)
-    {
-        $Badges = self::get_badges($UserID);
-
-        return array_key_exists($BadgeID, $Badges);
+    return $Result;
+  }
+
+  /**
+   * Returns true if the given user owns the given badge
+   *
+   * @param int $UserID
+   * @param int $BadgeID
+   * @return bool
+   */
+  public static function has_badge($UserID, $BadgeID) {
+    $Badges = self::get_badges($UserID);
+
+    return array_key_exists($BadgeID, $Badges);
+  }
+
+  /**
+   * Creates HTML for displaying a badge.
+   *
+   * @param int $BadgeID
+   * @param bool $Tooltip Should HTML contain a tooltip?
+   * @return string HTML
+   */
+  public static function display_badge($BadgeID, $Tooltip = false) {
+    $html = "";
+
+    if (($Badges = G::$Cache->get_value('badges')) && array_key_exists($BadgeID, $Badges)) {
+      extract($Badges[$BadgeID]);
+    } else {
+      self::update_badge_cache();
+      if (($Badges = G::$Cache->get_value('badges')) && array_key_exists($BadgeID, $Badges)) {
+        extract($Badges[$BadgeID]);
+      } else {
+        global $Debug;
+        $Debug->analysis('Invalid BadgeID ' . $BadgeID . ' requested.');
+      }
     }
 
-    /**
-     * Creates HTML for displaying a badge.
-     *
-     * @param int $BadgeID
-     * @param bool $Tooltip Should HTML contain a tooltip?
-     * @return string HTML
-     */
-    public static function display_badge($BadgeID, $Tooltip = false)
-    {
-        $html = "";
-
-        if (($Badges = G::$Cache->get_value('badges')) && array_key_exists($BadgeID, $Badges)) {
-            extract($Badges[$BadgeID]);
-        } else {
-            self::update_badge_cache();
-            if (($Badges = G::$Cache->get_value('badges')) && array_key_exists($BadgeID, $Badges)) {
-                extract($Badges[$BadgeID]);
-            } else {
-                global $Debug;
-                $Debug->analysis('Invalid BadgeID ' . $BadgeID . ' requested.');
-            }
-        }
-
-        if ($Tooltip) {
-            $html .= '<a class="badge_icon"><img class="tooltip" alt="'.$Name.'" title="'.$Name.'</br>'.$Description.'" src="'.$Icon.'" /></a>';
-        } else {
-            $html .= '<a class="badge_icon"><img alt="'.$Name.'" title="'.$Name.'" src="'.$Icon.'" /></a>';
-        }
-
-        return $html;
+    if ($Tooltip) {
+      $html .= '<a class="badge_icon"><img class="tooltip" alt="'.$Name.'" title="'.$Name.'</br>'.$Description.'" src="'.$Icon.'" /></a>';
+    } else {
+      $html .= '<a class="badge_icon"><img alt="'.$Name.'" title="'.$Name.'" src="'.$Icon.'" /></a>';
     }
 
-    public static function display_badges($BadgeIDs, $Tooltip = false)
-    {
-        $html = "";
-        foreach ($BadgeIDs as $BadgeID) {
-            $html .= self::display_badge($BadgeID, $Tooltip);
-        }
-        return $html;
+    return $html;
+  }
+
+  public static function display_badges($BadgeIDs, $Tooltip = false) {
+    $html = "";
+    foreach ($BadgeIDs as $BadgeID) {
+      $html .= self::display_badge($BadgeID, $Tooltip);
     }
+    return $html;
+  }
 
-    private static function update_badge_cache()
-    {
-        $QueryID = G::$DB->get_query_id();
+  private static function update_badge_cache() {
+      $QueryID = G::$DB->get_query_id();
 
-        G::$DB->query("
+      G::$DB->query("
         SELECT
         ID, Icon, Name, Description
         FROM badges");
 
-        $badges = [];
-        if (G::$DB->has_results()) {
-            while (list($id, $icon, $name, $description) = G::$DB->next_record()) {
-                $badges[$id] = array('Icon' => $icon, 'Name' => $name, 'Description' => $Description);
-            }
-            G::$Cache->cache_value('badges', $badges);
-        }
-
-        G::$DB->set_query_id($QueryID);
-    }
-
-    public static function get_all_badges()
-    {
-        if (($Badges = G::$Cache->get_value('badges'))) {
-            return $Badges;
-        } else {
-            self::update_badge_cache();
-            return G::$Cache->get_value('badges');
+      $badges = [];
+      if (G::$DB->has_results()) {
+        while(list($id, $icon, $name, $description) = G::$DB->next_record()) {
+          $badges[$id] = array('Icon' => $icon, 'Name' => $name, 'Description' => $Description);
         }
+        G::$Cache->cache_value('badges', $badges);
+      }
+
+      G::$DB->set_query_id($QueryID);
+  }
+
+  public static function get_all_badges() {
+    if (($Badges = G::$Cache->get_value('badges'))) {
+      return $Badges;
+    } else {
+      self::update_badge_cache();
+      return G::$Cache->get_value('badges');
     }
+  }
 }
+?>

classes/bencode.class.php

@@ -1,104 +1,96 @@
-<?php
+<?
 /**
  * If we're running a 32bit PHP version, we use small objects to store ints.
  * Overhead from the function calls is small enough to not worry about
  */
-class Int64
-{
-    private $Num;
+class Int64 {
+  private $Num;
 
-    public function __construct($Val)
-    {
-        $this->Num = $Val;
-    }
+  public function __construct($Val) {
+    $this->Num = $Val;
+  }
 
-    public static function make($Val)
-    {
-        return PHP_INT_SIZE === 4 ? new Int64($Val) : (int)$Val;
-    }
+  public static function make($Val) {
+    return PHP_INT_SIZE === 4 ? new Int64($Val) : (int)$Val;
+  }
 
-    public static function get($Val)
-    {
-        return PHP_INT_SIZE === 4 ? $Val->Num : $Val;
-    }
+  public static function get($Val) {
+    return PHP_INT_SIZE === 4 ? $Val->Num : $Val;
+  }
 
-    public static function is_int($Val)
-    {
-        return is_int($Val) || (is_object($Val) && get_class($Val) === 'Int64');
-    }
+  public static function is_int($Val) {
+    return is_int($Val) || (is_object($Val) && get_class($Val) === 'Int64');
+  }
 }
 
 /**
  * The encode class is simple and straightforward. The only thing to
  * note is that empty dictionaries are represented by boolean trues
  */
-class Bencode
-{
-    private $DefaultKeys = array( // Get rid of everything except these keys to save some space
+class Bencode {
+  private $DefaultKeys = array( // Get rid of everything except these keys to save some space
       'created by', 'creation date', 'encoding', 'info', 'comment');
-    private $Data;
-    public $Enc;
+  private $Data;
+  public $Enc;
 
-    /**
-     * Encode an arbitrary array (usually one that's just been decoded)
-     *
-     * @param array $Arg the thing to encode
-     * @param mixed $Keys string or array with keys in the input array to encode or true to encode everything
-     * @return bencoded string representing the content of the input array
-     */
-    public function encode($Arg = false, $Keys = false)
-    {
-        if ($Arg === false) {
-            $Data =& $this->Dec;
-        } else {
-            $Data =& $Arg;
-        }
-        if ($Keys === true) {
-            $this->Data = $Data;
-        } elseif ($Keys === false) {
-            $this->Data = array_intersect_key($Data, array_flip($this->DefaultKeys));
-        } elseif (is_array($Keys)) {
-            $this->Data = array_intersect_key($Data, array_flip($Keys));
-        } else {
-            $this->Data = isset($Data[$Keys]) ? $Data[$Keys] : false;
-        }
-        if (!$this->Data) {
-            return false;
-        }
-        $this->Enc = $this->_benc();
-        return $this->Enc;
+  /**
+   * Encode an arbitrary array (usually one that's just been decoded)
+   *
+   * @param array $Arg the thing to encode
+   * @param mixed $Keys string or array with keys in the input array to encode or true to encode everything
+   * @return bencoded string representing the content of the input array
+   */
+  public function encode($Arg = false, $Keys = false) {
+    if ($Arg === false) {
+      $Data =& $this->Dec;
+    } else {
+      $Data =& $Arg;
     }
+    if ($Keys === true) {
+      $this->Data = $Data;
+    } elseif ($Keys === false) {
+      $this->Data = array_intersect_key($Data, array_flip($this->DefaultKeys));
+    } elseif (is_array($Keys)) {
+      $this->Data = array_intersect_key($Data, array_flip($Keys));
+    } else {
+      $this->Data = isset($Data[$Keys]) ? $Data[$Keys] : false;
+    }
+    if (!$this->Data) {
+      return false;
+    }
+    $this->Enc = $this->_benc();
+    return $this->Enc;
+  }
 
-    /**
-     * Internal encoding function that does the actual job
-     *
-     * @return bencoded string
-     */
-    private function _benc()
-    {
-        if (!is_array($this->Data)) {
-            if (Int64::is_int($this->Data)) { // Integer
-                return 'i'.Int64::get($this->Data).'e';
-            }
-            if ($this->Data === true) { // Empty dictionary
-                return 'de';
-            }
-            return strlen($this->Data).':'.$this->Data; // String
-        }
-        if (empty($this->Data) || Int64::is_int(key($this->Data))) {
-            $IsDict = false;
-        } else {
-            $IsDict = true;
-            ksort($this->Data); // Dictionaries must be sorted
-        }
-        $Ret = $IsDict ? 'd' : 'l';
-        foreach ($this->Data as $Key => $Value) {
-            if ($IsDict) {
-                $Ret .= strlen($Key).':'.$Key;
-            }
-            $this->Data = $Value;
-            $Ret .= $this->_benc();
-        }
-        return $Ret.'e';
+  /**
+   * Internal encoding function that does the actual job
+   *
+   * @return bencoded string
+   */
+  private function _benc() {
+    if (!is_array($this->Data)) {
+      if (Int64::is_int($this->Data)) { // Integer
+        return 'i'.Int64::get($this->Data).'e';
+      }
+      if ($this->Data === true) { // Empty dictionary
+        return 'de';
+      }
+      return strlen($this->Data).':'.$this->Data; // String
+    }
+    if (empty($this->Data) || Int64::is_int(key($this->Data))) {
+      $IsDict = false;
+    } else {
+      $IsDict = true;
+      ksort($this->Data); // Dictionaries must be sorted
+    }
+    $Ret = $IsDict ? 'd' : 'l';
+    foreach ($this->Data as $Key => $Value) {
+      if ($IsDict) {
+        $Ret .= strlen($Key).':'.$Key;
+      }
+      $this->Data = $Value;
+      $Ret .= $this->_benc();
     }
+    return $Ret.'e';
+  }
 }

classes/bencodedecode.class.php

@@ -1,196 +1,187 @@
-<?php
+<?
 /**
  * The decode class is simple and straightforward. The only thing to
  * note is that empty dictionaries are represented by boolean trues
  */
-class BencodeDecode extends Bencode
-{
-    private $Data;
-    private $Length;
-    private $Pos = 0;
-    public $Dec = [];
-    public $ExitOnError = true;
-    const SnipLength = 40;
+class BencodeDecode extends Bencode {
+  private $Data;
+  private $Length;
+  private $Pos = 0;
+  public $Dec = [];
+  public $ExitOnError = true;
+  const SnipLength = 40;
 
-    /**
-     * Decode prepararations
-     *
-     * @param string $Arg bencoded string or path to bencoded file to decode
-     * @param bool $IsPath needs to be true if $Arg is a path
-     * @return decoded data with a suitable structure
-     */
-    public function __construct($Arg = false, $IsPath = false, $Strict = true)
-    {
-        if (!$Strict) {
-            $this->ExitOnError = false;
-        }
-        if ($Arg === false) {
-            if (empty($this->Enc)) {
-                return false;
-            }
-        } else {
-            if ($IsPath === true) {
-                return $this->bdec_file($Arg);
-            }
-            $this->Data = $Arg;
-        }
-        return $this->decode();
+  /**
+   * Decode prepararations
+   *
+   * @param string $Arg bencoded string or path to bencoded file to decode
+   * @param bool $IsPath needs to be true if $Arg is a path
+   * @return decoded data with a suitable structure
+   */
+  function __construct($Arg = false, $IsPath = false, $Strict = true) {
+    if (!$Strict) {
+      $this->ExitOnError = false;
     }
-
-    /**
-     * Decodes a bencoded file
-     *
-     * @param $Path path to bencoded file to decode
-     * @return decoded data with a suitable structure
-     */
-    public function bdec_file($Path = false)
-    {
-        if (empty($Path)) {
-            return false;
-        }
-        if (!$this->Data = @file_get_contents($Path, FILE_BINARY)) {
-            return $this->error("Error: file '$Path' could not be opened.\n");
-        }
-        return $this->decode();
+    if ($Arg === false) {
+      if (empty($this->Enc)) {
+        return false;
+      }
+    } else {
+      if ($IsPath === true) {
+        return $this->bdec_file($Arg);
+      }
+      $this->Data = $Arg;
     }
+    return $this->decode();
+  }
 
-    /**
-     * Decodes a string with bencoded data
-     *
-     * @param mixed $Arg bencoded data or false to decode the content of $this->Data
-     * @return decoded data with a suitable structure
-     */
-    public function decode($Arg = false)
-    {
-        if ($Arg !== false) {
-            $this->Data = $Arg;
-        } elseif (!$this->Data) {
-            $this->Data = $this->Enc;
-        }
-        if (!$this->Data) {
-            return false;
-        }
-        $this->Length = strlen($this->Data);
-        $this->Pos = 0;
-        $this->Dec = $this->_bdec();
-        if ($this->Pos < $this->Length) {
-            // Not really necessary, but if the torrent is invalid, it's better to warn than to silently truncate it
-            return $this->error();
-        }
-        return $this->Dec;
+  /**
+   * Decodes a bencoded file
+   *
+   * @param $Path path to bencoded file to decode
+   * @return decoded data with a suitable structure
+   */
+  public function bdec_file($Path = false) {
+    if (empty($Path)) {
+      return false;
     }
+    if (!$this->Data = @file_get_contents($Path, FILE_BINARY)) {
+      return $this->error("Error: file '$Path' could not be opened.\n");
+    }
+    return $this->decode();
+  }
 
-    /**
-     * Internal decoding function that does the actual job
-     *
-     * @return decoded data with a suitable structure
-     */
-    private function _bdec()
-    {
-        switch ($this->Data[$this->Pos]) {
-            case 'i':
-                $this->Pos++;
-                $Value = substr($this->Data, $this->Pos, strpos($this->Data, 'e', $this->Pos) - $this->Pos);
-                if (!ctype_digit($Value) && !($Value[0] == '-' && ctype_digit(substr($Value, 1)))) {
-                    return $this->error();
-                }
-                $this->Pos += strlen($Value) + 1;
-                return Int64::make($Value);
-
-            case 'l':
-                $Value = [];
-                $this->Pos++;
-                while ($this->Data[$this->Pos] != 'e') {
-                    if ($this->Pos >= $this->Length) {
-                        return $this->error();
-                    }
-                    $Value[] = $this->_bdec();
-                }
-                $this->Pos++;
-                return $Value;
+  /**
+   * Decodes a string with bencoded data
+   *
+   * @param mixed $Arg bencoded data or false to decode the content of $this->Data
+   * @return decoded data with a suitable structure
+   */
+  public function decode($Arg = false) {
+    if ($Arg !== false) {
+      $this->Data = $Arg;
+    } elseif (!$this->Data) {
+      $this->Data = $this->Enc;
+    }
+    if (!$this->Data) {
+      return false;
+    }
+    $this->Length = strlen($this->Data);
+    $this->Pos = 0;
+    $this->Dec = $this->_bdec();
+    if ($this->Pos < $this->Length) {
+      // Not really necessary, but if the torrent is invalid, it's better to warn than to silently truncate it
+      return $this->error();
+    }
+    return $this->Dec;
+  }
 
-            case 'd':
-                $Value = [];
-                $this->Pos++;
-                while ($this->Data[$this->Pos] != 'e') {
-                    $Length = substr($this->Data, $this->Pos, strpos($this->Data, ':', $this->Pos) - $this->Pos);
-                    if (!ctype_digit($Length)) {
-                        return $this->error();
-                    }
-                    $this->Pos += strlen($Length) + $Length + 1;
-                    $Key = substr($this->Data, $this->Pos - $Length, $Length);
-                    if ($this->Pos >= $this->Length) {
-                        return $this->error();
-                    }
-                    $Value[$Key] = $this->_bdec();
-                }
-                $this->Pos++;
-              // Use boolean true to keep track of empty dictionaries
-                return empty($Value) ? true : $Value;
+  /**
+   * Internal decoding function that does the actual job
+   *
+   * @return decoded data with a suitable structure
+   */
+  private function _bdec() {
+    switch ($this->Data[$this->Pos]) {
 
-            default:
-                $Length = substr($this->Data, $this->Pos, strpos($this->Data, ':', $this->Pos) - $this->Pos);
-                if (!ctype_digit($Length)) {
-                    return $this->error(); // Even if the string is likely to be decoded correctly without this check, it's malformed
-                }
-                $this->Pos += strlen($Length) + $Length + 1;
-                return substr($this->Data, $this->Pos - $Length, $Length);
+      case 'i':
+        $this->Pos++;
+        $Value = substr($this->Data, $this->Pos, strpos($this->Data, 'e', $this->Pos) - $this->Pos);
+        if (!ctype_digit($Value) && !($Value[0] == '-' && ctype_digit(substr($Value, 1)))) {
+          return $this->error();
         }
-    }
+        $this->Pos += strlen($Value) + 1;
+        return Int64::make($Value);
 
-    /**
-     * Convert everything to the correct data types and optionally escape strings
-     *
-     * @param bool $Escape whether to escape the textual data
-     * @param mixed $Data decoded data or false to use the $Dec property
-     * @return decoded data with more useful data types
-     */
-    public function dump($Escape = true, $Data = false)
-    {
-        if ($Data === false) {
-            $Data = $this->Dec;
-        }
-        if (Int64::is_int($Data)) {
-            return Int64::get($Data);
+      case 'l':
+        $Value = [];
+        $this->Pos++;
+        while ($this->Data[$this->Pos] != 'e') {
+          if ($this->Pos >= $this->Length) {
+            return $this->error();
+          }
+          $Value[] = $this->_bdec();
         }
-        if (is_bool($Data)) {
-            return [];
+        $this->Pos++;
+        return $Value;
+
+      case 'd':
+        $Value = [];
+        $this->Pos++;
+        while ($this->Data[$this->Pos] != 'e') {
+          $Length = substr($this->Data, $this->Pos, strpos($this->Data, ':', $this->Pos) - $this->Pos);
+          if (!ctype_digit($Length)) {
+            return $this->error();
+          }
+          $this->Pos += strlen($Length) + $Length + 1;
+          $Key = substr($this->Data, $this->Pos - $Length, $Length);
+          if ($this->Pos >= $this->Length) {
+            return $this->error();
+          }
+          $Value[$Key] = $this->_bdec();
         }
-        if (is_array($Data)) {
-            $Output = [];
-            foreach ($Data as $Key => $Val) {
-                $Output[$Key] = $this->dump($Escape, $Val);
-            }
-            return $Output;
+        $this->Pos++;
+        // Use boolean true to keep track of empty dictionaries
+        return empty($Value) ? true : $Value;
+
+      default:
+        $Length = substr($this->Data, $this->Pos, strpos($this->Data, ':', $this->Pos) - $this->Pos);
+        if (!ctype_digit($Length)) {
+          return $this->error(); // Even if the string is likely to be decoded correctly without this check, it's malformed
         }
-        return $Escape ? htmlentities($Data) : $Data;
+        $this->Pos += strlen($Length) + $Length + 1;
+        return substr($this->Data, $this->Pos - $Length, $Length);
     }
+  }
 
-    /**
-     * Display an error and halt the operation unless the $ExitOnError property is false
-     *
-     * @param string $ErrMsg the error message to display
-     */
-    private function error($ErrMsg = false)
-    {
-        static $ErrorPos;
-        if ($this->Pos === $ErrorPos) {
-            // The recursive nature of the class requires this to avoid duplicate error messages
-            return false;
-        }
-        if ($this->ExitOnError) {
-            if ($ErrMsg === false) {
-                printf(
-                    "Malformed string. Invalid character at pos 0x%X: %s\n",
-                    $this->Pos,
-                    str_replace(array("\r","\n"), array('',' '), htmlentities(substr($this->Data, $this->Pos, self::SnipLength)))
-                );
-            } else {
-                echo $ErrMsg;
-            }
-            exit();
-        }
-        $ErrorPos = $this->Pos;
-        return false;
+  /**
+   * Convert everything to the correct data types and optionally escape strings
+   *
+   * @param bool $Escape whether to escape the textual data
+   * @param mixed $Data decoded data or false to use the $Dec property
+   * @return decoded data with more useful data types
+   */
+  public function dump($Escape = true, $Data = false) {
+    if ($Data === false) {
+      $Data = $this->Dec;
+    }
+    if (Int64::is_int($Data)) {
+      return Int64::get($Data);
+    }
+    if (is_bool($Data)) {
+      return [];
+    }
+    if (is_array($Data)) {
+      $Output = [];
+      foreach ($Data as $Key => $Val) {
+        $Output[$Key] = $this->dump($Escape, $Val);
+      }
+      return $Output;
+    }
+    return $Escape ? htmlentities($Data) : $Data;
+  }
+
+  /**
+   * Display an error and halt the operation unless the $ExitOnError property is false
+   *
+   * @param string $ErrMsg the error message to display
+   */
+  private function error($ErrMsg = false) {
+    static $ErrorPos;
+    if ($this->Pos === $ErrorPos) {
+      // The recursive nature of the class requires this to avoid duplicate error messages
+      return false;
+    }
+    if ($this->ExitOnError) {
+      if ($ErrMsg === false) {
+        printf("Malformed string. Invalid character at pos 0x%X: %s\n",
+            $this->Pos, str_replace(array("\r","\n"), array('',' '), htmlentities(substr($this->Data, $this->Pos, self::SnipLength))));
+      } else {
+        echo $ErrMsg;
+      }
+      exit();
     }
+    $ErrorPos = $this->Pos;
+    return false;
+  }
 }