phpmyadmin/libraries/String.class.php

   1 <?php
   2 /**
   3  * Specialized string class for phpMyAdmin.
   4  * The SQL Parser code relies heavily on these functions.
   5  *
   6  * @package PhpMyAdmin-String
   7  */
   8
   9 /**
  10  * Specialized string class for phpMyAdmin.
  11  * The SQL Parser code relies heavily on these functions.
  12  *
  13  * @package PhpMyAdmin-String
  14  */
  15 class PMA_String
  16 {
  17     /**
  18      * @var PMA_StringType
  19      */
  20     private $_type;
  21     /**
  22      * @var PMA_StringByte
  23      */
  24     private $_byte;
  25
  26     /**
  27      * Constructor
  28      */
  29     public function __construct()
  30     {
  31         if (@function_exists('mb_strlen')) {
  32             mb_internal_encoding('utf-8');
  33             include_once 'libraries/StringMB.class.php';
  34             $this->_byte = new PMA_StringMB();
  35         } else {
  36             include_once 'libraries/StringNative.class.php';
  37             $this->_byte = new PMA_StringNative();
  38         }
  39
  40         if (@extension_loaded('ctype')) {
  41             include_once 'libraries/StringCType.class.php';
  42             $this->_type = new PMA_StringCType();
  43         } else {
  44             include_once 'libraries/StringNativeType.class.php';
  45             $this->_type = new PMA_StringNativeType();
  46         }
  47     }
  48
  49     /**
  50      * Checks if a given character position in the string is escaped or not
  51      *
  52      * @param string  $string string to check for
  53      * @param integer $pos    the character to check for
  54      * @param integer $start  starting position in the string
  55      *
  56      * @return boolean  whether the character is escaped or not
  57      */
  58     public function charIsEscaped($string, $pos, $start = 0)
  59     {
  60         $pos = max(intval($pos), 0);
  61         $start = max(intval($start), 0);
  62         $len = $this->strlen($string);
  63         // Base case:
  64         // Check for string length or invalid input or special case of input
  65         // (pos == $start)
  66         if ($pos <= $start || $len <= max($pos, $start)) {
  67             return false;
  68         }
  69
  70         $pos--;
  71         $escaped     = false;
  72         while ($pos >= $start && $this->substr($string, $pos, 1) == '\\') {
  73             $escaped = !$escaped;
  74             $pos--;
  75         } // end while
  76
  77         return $escaped;
  78     }
  79
  80     /**
  81      * Checks if a character is an SQL identifier
  82      *
  83      * @param string  $c            character to check for
  84      * @param boolean $dot_is_valid whether the dot character is valid or not
  85      *
  86      * @return boolean  whether the character is an SQL identifier or not
  87      */
  88     public function isSqlIdentifier($c, $dot_is_valid = false)
  89     {
  90         return ($this->isAlnum($c)
  91             || ($ord_c = $this->ord($c)) && $ord_c >= 192 && $ord_c != 215 &&
  92             $ord_c != 249
  93             || $c == '_'
  94             || $c == '$'
  95             || ($dot_is_valid != false && $c == '.'));
  96     }
  97
  98     /**
  99      * Returns length of string depending on current charset.
 100      *
 101      * @param string $string string to count
 102      *
 103      * @return int string length
 104      */
 105
 106     public function strlen($string)
 107     {
 108         return $this->_byte->strlen($string);
 109     }
 110
 111     /**
 112      * Returns substring from string, works depending on current charset.
 113      *
 114      * @param string $string string to count
 115      * @param int    $start  start of substring
 116      * @param int    $length length of substring
 117      *
 118      * @return string the sub string
 119      */
 120     public function substr($string, $start, $length = 2147483647)
 121     {
 122         return $this->_byte->substr($string, $start, $length);
 123     }
 124
 125     /**
 126      * Returns postion of $needle in $haystack or false if not found
 127      *
 128      * @param string $haystack the string being checked
 129      * @param string $needle   the string to find in haystack
 130      * @param int    $offset   the search offset
 131      *
 132      * @return integer position of $needle in $haystack or false
 133      */
 134     public function strpos($haystack, $needle, $offset = 0)
 135     {
 136         return $this->_byte->strpos($haystack, $needle, $offset);
 137     }
 138
 139     /**
 140      * Make a string lowercase
 141      *
 142      * @param string $string the string being lowercased
 143      *
 144      * @return string the lower case string
 145      */
 146     public function strtolower($string)
 147     {
 148         return $this->_byte->strtolower($string);
 149     }
 150
 151     /**
 152      * Get the ordinal value of a string
 153      *
 154      * @param string $string the string for which ord is required
 155      *
 156      * @return string the ord value
 157      */
 158     public function ord($string)
 159     {
 160         return $this->_byte->ord($string);
 161     }
 162
 163     /**
 164      * Checks if a character is an alphanumeric one
 165      *
 166      * @param string $c character to check for
 167      *
 168      * @return boolean whether the character is an alphanumeric one or not
 169      */
 170     public function isAlnum($c)
 171     {
 172         return $this->_type->isAlnum($c);
 173     }
 174
 175     /**
 176      * Checks if a character is an alphabetic one
 177      *
 178      * @param string $c character to check for
 179      *
 180      * @return boolean whether the character is an alphabetic one or not
 181      */
 182     public function isAlpha($c)
 183     {
 184         return $this->_type->isAlpha($c);
 185     }
 186
 187     /**
 188      * Checks if a character is a digit
 189      *
 190      * @param string $c character to check for
 191      *
 192      * @return boolean whether the character is a digit or not
 193      */
 194     public function isDigit($c)
 195     {
 196         return $this->_type->isDigit($c);
 197     }
 198
 199     /**
 200      * Checks if a character is an upper alphabetic one
 201      *
 202      * @param string $c character to check for
 203      *
 204      * @return boolean whether the character is an upper alphabetic one or not
 205      */
 206     public function isUpper($c)
 207     {
 208         return $this->_type->isUpper($c);
 209     }
 210
 211     /**
 212      * Checks if a character is a lower alphabetic one
 213      *
 214      * @param string $c character to check for
 215      *
 216      * @return boolean whether the character is a lower alphabetic one or not
 217      */
 218     public function isLower($c)
 219     {
 220         return $this->_type->isLower($c);
 221     }
 222
 223     /**
 224      * Checks if a character is a space one
 225      *
 226      * @param string $c character to check for
 227      *
 228      * @return boolean whether the character is a space one or not
 229      */
 230     public function isSpace($c)
 231     {
 232         return $this->_type->isSpace($c);
 233     }
 234
 235     /**
 236      * Checks if a character is an hexadecimal digit
 237      *
 238      * @param string $c character to check for
 239      *
 240      * @return boolean whether the character is an hexadecimal digit or not
 241      */
 242     public function isHexDigit($c)
 243     {
 244         return $this->_type->isHexDigit($c);
 245     }
 246
 247     /**
 248      * Checks if a number is in a range
 249      *
 250      * @param integer $num   number to check for
 251      * @param integer $lower lower bound
 252      * @param integer $upper upper bound
 253      *
 254      * @return boolean  whether the number is in the range or not
 255      */
 256     public function numberInRangeInclusive($num, $lower, $upper)
 257     {
 258         return $this->_type->numberInRangeInclusive($num, $lower, $upper);
 259     }
 260 }
 261 ?>