.
*
* @param array unicode code points representing a string
* @return string utf8 string of characters
* @return boolean FALSE if a code point cannot be found
*/
public static function from_unicode($arr)
{
if ( ! isset(self::$called[__FUNCTION__]))
{
require SYSPATH.'core/utf8/'.__FUNCTION__.EXT;
// Function has been called
self::$called[__FUNCTION__] = TRUE;
}
return _from_unicode($arr);
}
} // End utf8 ./kohana/system/core/Benchmark.php 0000644 0001750 0001750 00000005337 11164666402 016677 0 ustar tokkee tokkee microtime(TRUE),
'stop' => FALSE,
'memory_start' => self::memory_usage(),
'memory_stop' => FALSE
);
array_unshift(self::$marks[$name], $mark);
}
/**
* Set a benchmark stop point.
*
* @param string benchmark name
* @return void
*/
public static function stop($name)
{
if (isset(self::$marks[$name]) AND self::$marks[$name][0]['stop'] === FALSE)
{
self::$marks[$name][0]['stop'] = microtime(TRUE);
self::$marks[$name][0]['memory_stop'] = self::memory_usage();
}
}
/**
* Get the elapsed time between a start and stop.
*
* @param string benchmark name, TRUE for all
* @param integer number of decimal places to count to
* @return array
*/
public static function get($name, $decimals = 4)
{
if ($name === TRUE)
{
$times = array();
$names = array_keys(self::$marks);
foreach ($names as $name)
{
// Get each mark recursively
$times[$name] = self::get($name, $decimals);
}
// Return the array
return $times;
}
if ( ! isset(self::$marks[$name]))
return FALSE;
if (self::$marks[$name][0]['stop'] === FALSE)
{
// Stop the benchmark to prevent mis-matched results
self::stop($name);
}
// Return a string version of the time between the start and stop points
// Properly reading a float requires using number_format or sprintf
$time = $memory = 0;
for ($i = 0; $i < count(self::$marks[$name]); $i++)
{
$time += self::$marks[$name][$i]['stop'] - self::$marks[$name][$i]['start'];
$memory += self::$marks[$name][$i]['memory_stop'] - self::$marks[$name][$i]['memory_start'];
}
return array
(
'time' => number_format($time, $decimals),
'memory' => $memory,
'count' => count(self::$marks[$name])
);
}
/**
* Returns the current memory usage. This is only possible if the
* memory_get_usage function is supported in PHP.
*
* @return integer
*/
private static function memory_usage()
{
static $func;
if ($func === NULL)
{
// Test if memory usage can be seen
$func = function_exists('memory_get_usage');
}
return $func ? memory_get_usage() : 0;
}
} // End Benchmark
./kohana/system/core/utf8/ 0000755 0001750 0001750 00000000000 11263472437 015155 5 ustar tokkee tokkee ./kohana/system/core/utf8/ltrim.php 0000644 0001750 0001750 00000001057 11121324570 017003 0 ustar tokkee tokkee 0x0041, 0x03C6=>0x03A6, 0x0163=>0x0162, 0x00E5=>0x00C5, 0x0062=>0x0042,
0x013A=>0x0139, 0x00E1=>0x00C1, 0x0142=>0x0141, 0x03CD=>0x038E, 0x0101=>0x0100,
0x0491=>0x0490, 0x03B4=>0x0394, 0x015B=>0x015A, 0x0064=>0x0044, 0x03B3=>0x0393,
0x00F4=>0x00D4, 0x044A=>0x042A, 0x0439=>0x0419, 0x0113=>0x0112, 0x043C=>0x041C,
0x015F=>0x015E, 0x0144=>0x0143, 0x00EE=>0x00CE, 0x045E=>0x040E, 0x044F=>0x042F,
0x03BA=>0x039A, 0x0155=>0x0154, 0x0069=>0x0049, 0x0073=>0x0053, 0x1E1F=>0x1E1E,
0x0135=>0x0134, 0x0447=>0x0427, 0x03C0=>0x03A0, 0x0438=>0x0418, 0x00F3=>0x00D3,
0x0440=>0x0420, 0x0454=>0x0404, 0x0435=>0x0415, 0x0449=>0x0429, 0x014B=>0x014A,
0x0431=>0x0411, 0x0459=>0x0409, 0x1E03=>0x1E02, 0x00F6=>0x00D6, 0x00F9=>0x00D9,
0x006E=>0x004E, 0x0451=>0x0401, 0x03C4=>0x03A4, 0x0443=>0x0423, 0x015D=>0x015C,
0x0453=>0x0403, 0x03C8=>0x03A8, 0x0159=>0x0158, 0x0067=>0x0047, 0x00E4=>0x00C4,
0x03AC=>0x0386, 0x03AE=>0x0389, 0x0167=>0x0166, 0x03BE=>0x039E, 0x0165=>0x0164,
0x0117=>0x0116, 0x0109=>0x0108, 0x0076=>0x0056, 0x00FE=>0x00DE, 0x0157=>0x0156,
0x00FA=>0x00DA, 0x1E61=>0x1E60, 0x1E83=>0x1E82, 0x00E2=>0x00C2, 0x0119=>0x0118,
0x0146=>0x0145, 0x0070=>0x0050, 0x0151=>0x0150, 0x044E=>0x042E, 0x0129=>0x0128,
0x03C7=>0x03A7, 0x013E=>0x013D, 0x0442=>0x0422, 0x007A=>0x005A, 0x0448=>0x0428,
0x03C1=>0x03A1, 0x1E81=>0x1E80, 0x016D=>0x016C, 0x00F5=>0x00D5, 0x0075=>0x0055,
0x0177=>0x0176, 0x00FC=>0x00DC, 0x1E57=>0x1E56, 0x03C3=>0x03A3, 0x043A=>0x041A,
0x006D=>0x004D, 0x016B=>0x016A, 0x0171=>0x0170, 0x0444=>0x0424, 0x00EC=>0x00CC,
0x0169=>0x0168, 0x03BF=>0x039F, 0x006B=>0x004B, 0x00F2=>0x00D2, 0x00E0=>0x00C0,
0x0434=>0x0414, 0x03C9=>0x03A9, 0x1E6B=>0x1E6A, 0x00E3=>0x00C3, 0x044D=>0x042D,
0x0436=>0x0416, 0x01A1=>0x01A0, 0x010D=>0x010C, 0x011D=>0x011C, 0x00F0=>0x00D0,
0x013C=>0x013B, 0x045F=>0x040F, 0x045A=>0x040A, 0x00E8=>0x00C8, 0x03C5=>0x03A5,
0x0066=>0x0046, 0x00FD=>0x00DD, 0x0063=>0x0043, 0x021B=>0x021A, 0x00EA=>0x00CA,
0x03B9=>0x0399, 0x017A=>0x0179, 0x00EF=>0x00CF, 0x01B0=>0x01AF, 0x0065=>0x0045,
0x03BB=>0x039B, 0x03B8=>0x0398, 0x03BC=>0x039C, 0x045C=>0x040C, 0x043F=>0x041F,
0x044C=>0x042C, 0x00FE=>0x00DE, 0x00F0=>0x00D0, 0x1EF3=>0x1EF2, 0x0068=>0x0048,
0x00EB=>0x00CB, 0x0111=>0x0110, 0x0433=>0x0413, 0x012F=>0x012E, 0x00E6=>0x00C6,
0x0078=>0x0058, 0x0161=>0x0160, 0x016F=>0x016E, 0x03B1=>0x0391, 0x0457=>0x0407,
0x0173=>0x0172, 0x00FF=>0x0178, 0x006F=>0x004F, 0x043B=>0x041B, 0x03B5=>0x0395,
0x0445=>0x0425, 0x0121=>0x0120, 0x017E=>0x017D, 0x017C=>0x017B, 0x03B6=>0x0396,
0x03B2=>0x0392, 0x03AD=>0x0388, 0x1E85=>0x1E84, 0x0175=>0x0174, 0x0071=>0x0051,
0x0437=>0x0417, 0x1E0B=>0x1E0A, 0x0148=>0x0147, 0x0105=>0x0104, 0x0458=>0x0408,
0x014D=>0x014C, 0x00ED=>0x00CD, 0x0079=>0x0059, 0x010B=>0x010A, 0x03CE=>0x038F,
0x0072=>0x0052, 0x0430=>0x0410, 0x0455=>0x0405, 0x0452=>0x0402, 0x0127=>0x0126,
0x0137=>0x0136, 0x012B=>0x012A, 0x03AF=>0x038A, 0x044B=>0x042B, 0x006C=>0x004C,
0x03B7=>0x0397, 0x0125=>0x0124, 0x0219=>0x0218, 0x00FB=>0x00DB, 0x011F=>0x011E,
0x043E=>0x041E, 0x1E41=>0x1E40, 0x03BD=>0x039D, 0x0107=>0x0106, 0x03CB=>0x03AB,
0x0446=>0x0426, 0x00FE=>0x00DE, 0x00E7=>0x00C7, 0x03CA=>0x03AA, 0x0441=>0x0421,
0x0432=>0x0412, 0x010F=>0x010E, 0x00F8=>0x00D8, 0x0077=>0x0057, 0x011B=>0x011A,
0x0074=>0x0054, 0x006A=>0x004A, 0x045B=>0x040B, 0x0456=>0x0406, 0x0103=>0x0102,
0x03BB=>0x039B, 0x00F1=>0x00D1, 0x043D=>0x041D, 0x03CC=>0x038C, 0x00E9=>0x00C9,
0x00F0=>0x00D0, 0x0457=>0x0407, 0x0123=>0x0122,
);
}
$uni = utf8::to_unicode($str);
if ($uni === FALSE)
return FALSE;
for ($i = 0, $c = count($uni); $i < $c; $i++)
{
if (isset($UTF8_LOWER_TO_UPPER[$uni[$i]]))
{
$uni[$i] = $UTF8_LOWER_TO_UPPER[$uni[$i]];
}
}
return utf8::from_unicode($uni);
} ./kohana/system/core/utf8/str_pad.php 0000644 0001750 0001750 00000003111 11151055263 017304 0 ustar tokkee tokkee = 0) AND ($arr[$k] <= 0x007f))
{
echo chr($arr[$k]);
}
// 2 byte sequence
elseif ($arr[$k] <= 0x07ff)
{
echo chr(0xc0 | ($arr[$k] >> 6));
echo chr(0x80 | ($arr[$k] & 0x003f));
}
// Byte order mark (skip)
elseif ($arr[$k] == 0xFEFF)
{
// nop -- zap the BOM
}
// Test for illegal surrogates
elseif ($arr[$k] >= 0xD800 AND $arr[$k] <= 0xDFFF)
{
// Found a surrogate
trigger_error('utf8::from_unicode: Illegal surrogate at index: '.$k.', value: '.$arr[$k], E_USER_WARNING);
return FALSE;
}
// 3 byte sequence
elseif ($arr[$k] <= 0xffff)
{
echo chr(0xe0 | ($arr[$k] >> 12));
echo chr(0x80 | (($arr[$k] >> 6) & 0x003f));
echo chr(0x80 | ($arr[$k] & 0x003f));
}
// 4 byte sequence
elseif ($arr[$k] <= 0x10ffff)
{
echo chr(0xf0 | ($arr[$k] >> 18));
echo chr(0x80 | (($arr[$k] >> 12) & 0x3f));
echo chr(0x80 | (($arr[$k] >> 6) & 0x3f));
echo chr(0x80 | ($arr[$k] & 0x3f));
}
// Out of range
else
{
trigger_error('utf8::from_unicode: Codepoint out of Unicode range at index: '.$k.', value: '.$arr[$k], E_USER_WARNING);
return FALSE;
}
}
$result = ob_get_contents();
ob_end_clean();
return $result;
}
./kohana/system/core/utf8/transliterate_to_ascii.php 0000644 0001750 0001750 00000007427 11121324570 022416 0 ustar tokkee tokkee 'a', 'ô' => 'o', 'ď' => 'd', 'ḟ' => 'f', 'ë' => 'e', 'š' => 's', 'ơ' => 'o',
'ß' => 'ss', 'ă' => 'a', 'ř' => 'r', 'ț' => 't', 'ň' => 'n', 'ā' => 'a', 'ķ' => 'k',
'ŝ' => 's', 'ỳ' => 'y', 'ņ' => 'n', 'ĺ' => 'l', 'ħ' => 'h', 'ṗ' => 'p', 'ó' => 'o',
'ú' => 'u', 'ě' => 'e', 'é' => 'e', 'ç' => 'c', 'ẁ' => 'w', 'ċ' => 'c', 'õ' => 'o',
'ṡ' => 's', 'ø' => 'o', 'ģ' => 'g', 'ŧ' => 't', 'ș' => 's', 'ė' => 'e', 'ĉ' => 'c',
'ś' => 's', 'î' => 'i', 'ű' => 'u', 'ć' => 'c', 'ę' => 'e', 'ŵ' => 'w', 'ṫ' => 't',
'ū' => 'u', 'č' => 'c', 'ö' => 'o', 'è' => 'e', 'ŷ' => 'y', 'ą' => 'a', 'ł' => 'l',
'ų' => 'u', 'ů' => 'u', 'ş' => 's', 'ğ' => 'g', 'ļ' => 'l', 'ƒ' => 'f', 'ž' => 'z',
'ẃ' => 'w', 'ḃ' => 'b', 'å' => 'a', 'ì' => 'i', 'ï' => 'i', 'ḋ' => 'd', 'ť' => 't',
'ŗ' => 'r', 'ä' => 'a', 'í' => 'i', 'ŕ' => 'r', 'ê' => 'e', 'ü' => 'u', 'ò' => 'o',
'ē' => 'e', 'ñ' => 'n', 'ń' => 'n', 'ĥ' => 'h', 'ĝ' => 'g', 'đ' => 'd', 'ĵ' => 'j',
'ÿ' => 'y', 'ũ' => 'u', 'ŭ' => 'u', 'ư' => 'u', 'ţ' => 't', 'ý' => 'y', 'ő' => 'o',
'â' => 'a', 'ľ' => 'l', 'ẅ' => 'w', 'ż' => 'z', 'ī' => 'i', 'ã' => 'a', 'ġ' => 'g',
'ṁ' => 'm', 'ō' => 'o', 'ĩ' => 'i', 'ù' => 'u', 'į' => 'i', 'ź' => 'z', 'á' => 'a',
'û' => 'u', 'þ' => 'th', 'ð' => 'dh', 'æ' => 'ae', 'µ' => 'u', 'ĕ' => 'e',
);
}
$str = str_replace(
array_keys($UTF8_LOWER_ACCENTS),
array_values($UTF8_LOWER_ACCENTS),
$str
);
}
if ($case >= 0)
{
if ($UTF8_UPPER_ACCENTS === NULL)
{
$UTF8_UPPER_ACCENTS = array(
'À' => 'A', 'Ô' => 'O', 'Ď' => 'D', 'Ḟ' => 'F', 'Ë' => 'E', 'Š' => 'S', 'Ơ' => 'O',
'Ă' => 'A', 'Ř' => 'R', 'Ț' => 'T', 'Ň' => 'N', 'Ā' => 'A', 'Ķ' => 'K', 'Ĕ' => 'E',
'Ŝ' => 'S', 'Ỳ' => 'Y', 'Ņ' => 'N', 'Ĺ' => 'L', 'Ħ' => 'H', 'Ṗ' => 'P', 'Ó' => 'O',
'Ú' => 'U', 'Ě' => 'E', 'É' => 'E', 'Ç' => 'C', 'Ẁ' => 'W', 'Ċ' => 'C', 'Õ' => 'O',
'Ṡ' => 'S', 'Ø' => 'O', 'Ģ' => 'G', 'Ŧ' => 'T', 'Ș' => 'S', 'Ė' => 'E', 'Ĉ' => 'C',
'Ś' => 'S', 'Î' => 'I', 'Ű' => 'U', 'Ć' => 'C', 'Ę' => 'E', 'Ŵ' => 'W', 'Ṫ' => 'T',
'Ū' => 'U', 'Č' => 'C', 'Ö' => 'O', 'È' => 'E', 'Ŷ' => 'Y', 'Ą' => 'A', 'Ł' => 'L',
'Ų' => 'U', 'Ů' => 'U', 'Ş' => 'S', 'Ğ' => 'G', 'Ļ' => 'L', 'Ƒ' => 'F', 'Ž' => 'Z',
'Ẃ' => 'W', 'Ḃ' => 'B', 'Å' => 'A', 'Ì' => 'I', 'Ï' => 'I', 'Ḋ' => 'D', 'Ť' => 'T',
'Ŗ' => 'R', 'Ä' => 'A', 'Í' => 'I', 'Ŕ' => 'R', 'Ê' => 'E', 'Ü' => 'U', 'Ò' => 'O',
'Ē' => 'E', 'Ñ' => 'N', 'Ń' => 'N', 'Ĥ' => 'H', 'Ĝ' => 'G', 'Đ' => 'D', 'Ĵ' => 'J',
'Ÿ' => 'Y', 'Ũ' => 'U', 'Ŭ' => 'U', 'Ư' => 'U', 'Ţ' => 'T', 'Ý' => 'Y', 'Ő' => 'O',
'Â' => 'A', 'Ľ' => 'L', 'Ẅ' => 'W', 'Ż' => 'Z', 'Ī' => 'I', 'Ã' => 'A', 'Ġ' => 'G',
'Ṁ' => 'M', 'Ō' => 'O', 'Ĩ' => 'I', 'Ù' => 'U', 'Į' => 'I', 'Ź' => 'Z', 'Á' => 'A',
'Û' => 'U', 'Þ' => 'Th', 'Ð' => 'Dh', 'Æ' => 'Ae',
);
}
$str = str_replace(
array_keys($UTF8_UPPER_ACCENTS),
array_values($UTF8_UPPER_ACCENTS),
$str
);
}
return $str;
} ./kohana/system/core/utf8/strtolower.php 0000644 0001750 0001750 00000010351 11121324570 020075 0 ustar tokkee tokkee 0x0061, 0x03A6=>0x03C6, 0x0162=>0x0163, 0x00C5=>0x00E5, 0x0042=>0x0062,
0x0139=>0x013A, 0x00C1=>0x00E1, 0x0141=>0x0142, 0x038E=>0x03CD, 0x0100=>0x0101,
0x0490=>0x0491, 0x0394=>0x03B4, 0x015A=>0x015B, 0x0044=>0x0064, 0x0393=>0x03B3,
0x00D4=>0x00F4, 0x042A=>0x044A, 0x0419=>0x0439, 0x0112=>0x0113, 0x041C=>0x043C,
0x015E=>0x015F, 0x0143=>0x0144, 0x00CE=>0x00EE, 0x040E=>0x045E, 0x042F=>0x044F,
0x039A=>0x03BA, 0x0154=>0x0155, 0x0049=>0x0069, 0x0053=>0x0073, 0x1E1E=>0x1E1F,
0x0134=>0x0135, 0x0427=>0x0447, 0x03A0=>0x03C0, 0x0418=>0x0438, 0x00D3=>0x00F3,
0x0420=>0x0440, 0x0404=>0x0454, 0x0415=>0x0435, 0x0429=>0x0449, 0x014A=>0x014B,
0x0411=>0x0431, 0x0409=>0x0459, 0x1E02=>0x1E03, 0x00D6=>0x00F6, 0x00D9=>0x00F9,
0x004E=>0x006E, 0x0401=>0x0451, 0x03A4=>0x03C4, 0x0423=>0x0443, 0x015C=>0x015D,
0x0403=>0x0453, 0x03A8=>0x03C8, 0x0158=>0x0159, 0x0047=>0x0067, 0x00C4=>0x00E4,
0x0386=>0x03AC, 0x0389=>0x03AE, 0x0166=>0x0167, 0x039E=>0x03BE, 0x0164=>0x0165,
0x0116=>0x0117, 0x0108=>0x0109, 0x0056=>0x0076, 0x00DE=>0x00FE, 0x0156=>0x0157,
0x00DA=>0x00FA, 0x1E60=>0x1E61, 0x1E82=>0x1E83, 0x00C2=>0x00E2, 0x0118=>0x0119,
0x0145=>0x0146, 0x0050=>0x0070, 0x0150=>0x0151, 0x042E=>0x044E, 0x0128=>0x0129,
0x03A7=>0x03C7, 0x013D=>0x013E, 0x0422=>0x0442, 0x005A=>0x007A, 0x0428=>0x0448,
0x03A1=>0x03C1, 0x1E80=>0x1E81, 0x016C=>0x016D, 0x00D5=>0x00F5, 0x0055=>0x0075,
0x0176=>0x0177, 0x00DC=>0x00FC, 0x1E56=>0x1E57, 0x03A3=>0x03C3, 0x041A=>0x043A,
0x004D=>0x006D, 0x016A=>0x016B, 0x0170=>0x0171, 0x0424=>0x0444, 0x00CC=>0x00EC,
0x0168=>0x0169, 0x039F=>0x03BF, 0x004B=>0x006B, 0x00D2=>0x00F2, 0x00C0=>0x00E0,
0x0414=>0x0434, 0x03A9=>0x03C9, 0x1E6A=>0x1E6B, 0x00C3=>0x00E3, 0x042D=>0x044D,
0x0416=>0x0436, 0x01A0=>0x01A1, 0x010C=>0x010D, 0x011C=>0x011D, 0x00D0=>0x00F0,
0x013B=>0x013C, 0x040F=>0x045F, 0x040A=>0x045A, 0x00C8=>0x00E8, 0x03A5=>0x03C5,
0x0046=>0x0066, 0x00DD=>0x00FD, 0x0043=>0x0063, 0x021A=>0x021B, 0x00CA=>0x00EA,
0x0399=>0x03B9, 0x0179=>0x017A, 0x00CF=>0x00EF, 0x01AF=>0x01B0, 0x0045=>0x0065,
0x039B=>0x03BB, 0x0398=>0x03B8, 0x039C=>0x03BC, 0x040C=>0x045C, 0x041F=>0x043F,
0x042C=>0x044C, 0x00DE=>0x00FE, 0x00D0=>0x00F0, 0x1EF2=>0x1EF3, 0x0048=>0x0068,
0x00CB=>0x00EB, 0x0110=>0x0111, 0x0413=>0x0433, 0x012E=>0x012F, 0x00C6=>0x00E6,
0x0058=>0x0078, 0x0160=>0x0161, 0x016E=>0x016F, 0x0391=>0x03B1, 0x0407=>0x0457,
0x0172=>0x0173, 0x0178=>0x00FF, 0x004F=>0x006F, 0x041B=>0x043B, 0x0395=>0x03B5,
0x0425=>0x0445, 0x0120=>0x0121, 0x017D=>0x017E, 0x017B=>0x017C, 0x0396=>0x03B6,
0x0392=>0x03B2, 0x0388=>0x03AD, 0x1E84=>0x1E85, 0x0174=>0x0175, 0x0051=>0x0071,
0x0417=>0x0437, 0x1E0A=>0x1E0B, 0x0147=>0x0148, 0x0104=>0x0105, 0x0408=>0x0458,
0x014C=>0x014D, 0x00CD=>0x00ED, 0x0059=>0x0079, 0x010A=>0x010B, 0x038F=>0x03CE,
0x0052=>0x0072, 0x0410=>0x0430, 0x0405=>0x0455, 0x0402=>0x0452, 0x0126=>0x0127,
0x0136=>0x0137, 0x012A=>0x012B, 0x038A=>0x03AF, 0x042B=>0x044B, 0x004C=>0x006C,
0x0397=>0x03B7, 0x0124=>0x0125, 0x0218=>0x0219, 0x00DB=>0x00FB, 0x011E=>0x011F,
0x041E=>0x043E, 0x1E40=>0x1E41, 0x039D=>0x03BD, 0x0106=>0x0107, 0x03AB=>0x03CB,
0x0426=>0x0446, 0x00DE=>0x00FE, 0x00C7=>0x00E7, 0x03AA=>0x03CA, 0x0421=>0x0441,
0x0412=>0x0432, 0x010E=>0x010F, 0x00D8=>0x00F8, 0x0057=>0x0077, 0x011A=>0x011B,
0x0054=>0x0074, 0x004A=>0x006A, 0x040B=>0x045B, 0x0406=>0x0456, 0x0102=>0x0103,
0x039B=>0x03BB, 0x00D1=>0x00F1, 0x041D=>0x043D, 0x038C=>0x03CC, 0x00C9=>0x00E9,
0x00D0=>0x00F0, 0x0407=>0x0457, 0x0122=>0x0123,
);
}
$uni = utf8::to_unicode($str);
if ($uni === FALSE)
return FALSE;
for ($i = 0, $c = count($uni); $i < $c; $i++)
{
if (isset($UTF8_UPPER_TO_LOWER[$uni[$i]]))
{
$uni[$i] = $UTF8_UPPER_TO_LOWER[$uni[$i]];
}
}
return utf8::from_unicode($uni);
} ./kohana/system/core/utf8/strrpos.php 0000644 0001750 0001750 00000001420 11121324570 017362 0 ustar tokkee tokkee $val)
{
$str[$key] = utf8::str_ireplace($search, $replace, $val, $count);
}
return $str;
}
if (is_array($search))
{
$keys = array_keys($search);
foreach ($keys as $k)
{
if (is_array($replace))
{
if (array_key_exists($k, $replace))
{
$str = utf8::str_ireplace($search[$k], $replace[$k], $str, $count);
}
else
{
$str = utf8::str_ireplace($search[$k], '', $str, $count);
}
}
else
{
$str = utf8::str_ireplace($search[$k], $replace, $str, $count);
}
}
return $str;
}
$search = utf8::strtolower($search);
$str_lower = utf8::strtolower($str);
$total_matched_strlen = 0;
$i = 0;
while (preg_match('/(.*?)'.preg_quote($search, '/').'/s', $str_lower, $matches))
{
$matched_strlen = strlen($matches[0]);
$str_lower = substr($str_lower, $matched_strlen);
$offset = $total_matched_strlen + strlen($matches[1]) + ($i * (strlen($replace) - 1));
$str = substr_replace($str, $replace, $offset, strlen($search));
$total_matched_strlen += $matched_strlen;
$i++;
}
$count += $i;
return $str;
}
./kohana/system/core/utf8/strlen.php 0000644 0001750 0001750 00000001015 11121324570 017155 0 ustar tokkee tokkee = 0 AND $ord0 <= 127)
{
return $ord0;
}
if ( ! isset($chr[1]))
{
trigger_error('Short sequence - at least 2 bytes expected, only 1 seen', E_USER_WARNING);
return FALSE;
}
$ord1 = ord($chr[1]);
if ($ord0 >= 192 AND $ord0 <= 223)
{
return ($ord0 - 192) * 64 + ($ord1 - 128);
}
if ( ! isset($chr[2]))
{
trigger_error('Short sequence - at least 3 bytes expected, only 2 seen', E_USER_WARNING);
return FALSE;
}
$ord2 = ord($chr[2]);
if ($ord0 >= 224 AND $ord0 <= 239)
{
return ($ord0 - 224) * 4096 + ($ord1 - 128) * 64 + ($ord2 - 128);
}
if ( ! isset($chr[3]))
{
trigger_error('Short sequence - at least 4 bytes expected, only 3 seen', E_USER_WARNING);
return FALSE;
}
$ord3 = ord($chr[3]);
if ($ord0 >= 240 AND $ord0 <= 247)
{
return ($ord0 - 240) * 262144 + ($ord1 - 128) * 4096 + ($ord2-128) * 64 + ($ord3 - 128);
}
if ( ! isset($chr[4]))
{
trigger_error('Short sequence - at least 5 bytes expected, only 4 seen', E_USER_WARNING);
return FALSE;
}
$ord4 = ord($chr[4]);
if ($ord0 >= 248 AND $ord0 <= 251)
{
return ($ord0 - 248) * 16777216 + ($ord1-128) * 262144 + ($ord2 - 128) * 4096 + ($ord3 - 128) * 64 + ($ord4 - 128);
}
if ( ! isset($chr[5]))
{
trigger_error('Short sequence - at least 6 bytes expected, only 5 seen', E_USER_WARNING);
return FALSE;
}
if ($ord0 >= 252 AND $ord0 <= 253)
{
return ($ord0 - 252) * 1073741824 + ($ord1 - 128) * 16777216 + ($ord2 - 128) * 262144 + ($ord3 - 128) * 4096 + ($ord4 - 128) * 64 + (ord($chr[5]) - 128);
}
if ($ord0 >= 254 AND $ord0 <= 255)
{
trigger_error('Invalid UTF-8 with surrogate ordinal '.$ord0, E_USER_WARNING);
return FALSE;
}
} ./kohana/system/core/utf8/ucfirst.php 0000644 0001750 0001750 00000000710 11121324570 017326 0 ustar tokkee tokkee = $strlen OR ($length < 0 AND $length <= $offset - $strlen))
return '';
// Whole string
if ($offset == 0 AND ($length === NULL OR $length >= $strlen))
return $str;
// Build regex
$regex = '^';
// Create an offset expression
if ($offset > 0)
{
// PCRE repeating quantifiers must be less than 65536, so repeat when necessary
$x = (int) ($offset / 65535);
$y = (int) ($offset % 65535);
$regex .= ($x == 0) ? '' : '(?:.{65535}){'.$x.'}';
$regex .= ($y == 0) ? '' : '.{'.$y.'}';
}
// Create a length expression
if ($length === NULL)
{
$regex .= '(.*)'; // No length set, grab it all
}
// Find length from the left (positive length)
elseif ($length > 0)
{
// Reduce length so that it can't go beyond the end of the string
$length = min($strlen - $offset, $length);
$x = (int) ($length / 65535);
$y = (int) ($length % 65535);
$regex .= '(';
$regex .= ($x == 0) ? '' : '(?:.{65535}){'.$x.'}';
$regex .= '.{'.$y.'})';
}
// Find length from the right (negative length)
else
{
$x = (int) (-$length / 65535);
$y = (int) (-$length % 65535);
$regex .= '(.*)';
$regex .= ($x == 0) ? '' : '(?:.{65535}){'.$x.'}';
$regex .= '.{'.$y.'}';
}
preg_match('/'.$regex.'/us', $str, $matches);
return $matches[1];
} ./kohana/system/core/utf8/to_unicode.php 0000644 0001750 0001750 00000007340 11121324570 020005 0 ustar tokkee tokkee 0x10FFFF))
{
trigger_error('utf8::to_unicode: Illegal sequence or codepoint in UTF-8 at byte '.$i, E_USER_WARNING);
return FALSE;
}
if (0xFEFF != $mUcs4)
{
// BOM is legal but we don't want to output it
$out[] = $mUcs4;
}
// Initialize UTF-8 cache
$mState = 0;
$mUcs4 = 0;
$mBytes = 1;
}
}
else
{
// ((0xC0 & (*in) != 0x80) AND (mState != 0))
// Incomplete multi-octet sequence
trigger_error('utf8::to_unicode: Incomplete multi-octet sequence in UTF-8 at byte '.$i, E_USER_WARNING);
return FALSE;
}
}
}
return $out;
} ./kohana/system/core/Kohana.php 0000644 0001750 0001750 00000122371 11207541462 016200 0 ustar tokkee tokkee 1,
'alert' => 2,
'info' => 3,
'debug' => 4,
);
// Internal caches and write status
private static $internal_cache = array();
private static $write_cache;
private static $internal_cache_path;
private static $internal_cache_key;
private static $internal_cache_encrypt;
/**
* Sets up the PHP environment. Adds error/exception handling, output
* buffering, and adds an auto-loading method for loading classes.
*
* This method is run immediately when this file is loaded, and is
* benchmarked as environment_setup.
*
* For security, this function also destroys the $_REQUEST global variable.
* Using the proper global (GET, POST, COOKIE, etc) is inherently more secure.
* The recommended way to fetch a global variable is using the Input library.
* @see http://www.php.net/globals
*
* @return void
*/
public static function setup()
{
static $run;
// This function can only be run once
if ($run === TRUE)
return;
// Start the environment setup benchmark
Benchmark::start(SYSTEM_BENCHMARK.'_environment_setup');
// Define Kohana error constant
define('E_KOHANA', 42);
// Define 404 error constant
define('E_PAGE_NOT_FOUND', 43);
// Define database error constant
define('E_DATABASE_ERROR', 44);
if (self::$cache_lifetime = self::config('core.internal_cache'))
{
// Are we using encryption for caches?
self::$internal_cache_encrypt = self::config('core.internal_cache_encrypt');
if(self::$internal_cache_encrypt===TRUE)
{
self::$internal_cache_key = self::config('core.internal_cache_key');
// Be sure the key is of acceptable length for the mcrypt algorithm used
self::$internal_cache_key = substr(self::$internal_cache_key, 0, 24);
}
// Set the directory to be used for the internal cache
if ( ! self::$internal_cache_path = self::config('core.internal_cache_path'))
{
self::$internal_cache_path = APPPATH.'cache/';
}
// Load cached configuration and language files
self::$internal_cache['configuration'] = self::cache('configuration', self::$cache_lifetime);
self::$internal_cache['language'] = self::cache('language', self::$cache_lifetime);
// Load cached file paths
self::$internal_cache['find_file_paths'] = self::cache('find_file_paths', self::$cache_lifetime);
// Enable cache saving
Event::add('system.shutdown', array(__CLASS__, 'internal_cache_save'));
}
// Disable notices and "strict" errors
$ER = error_reporting(~E_NOTICE & ~E_STRICT);
// Set the user agent
self::$user_agent = ( ! empty($_SERVER['HTTP_USER_AGENT']) ? trim($_SERVER['HTTP_USER_AGENT']) : '');
if (function_exists('date_default_timezone_set'))
{
$timezone = self::config('locale.timezone');
// Set default timezone, due to increased validation of date settings
// which cause massive amounts of E_NOTICEs to be generated in PHP 5.2+
date_default_timezone_set(empty($timezone) ? date_default_timezone_get() : $timezone);
}
// Restore error reporting
error_reporting($ER);
// Start output buffering
ob_start(array(__CLASS__, 'output_buffer'));
// Save buffering level
self::$buffer_level = ob_get_level();
// Set autoloader
spl_autoload_register(array('Kohana', 'auto_load'));
// Set error handler
set_error_handler(array('Kohana', 'exception_handler'));
// Set exception handler
set_exception_handler(array('Kohana', 'exception_handler'));
// Send default text/html UTF-8 header
header('Content-Type: text/html; charset=UTF-8');
// Load locales
$locales = self::config('locale.language');
// Make first locale UTF-8
$locales[0] .= '.UTF-8';
// Set locale information
self::$locale = setlocale(LC_ALL, $locales);
if (self::$configuration['core']['log_threshold'] > 0)
{
// Set the log directory
self::log_directory(self::$configuration['core']['log_directory']);
// Enable log writing at shutdown
register_shutdown_function(array(__CLASS__, 'log_save'));
}
// Enable Kohana routing
Event::add('system.routing', array('Router', 'find_uri'));
Event::add('system.routing', array('Router', 'setup'));
// Enable Kohana controller initialization
Event::add('system.execute', array('Kohana', 'instance'));
// Enable Kohana 404 pages
Event::add('system.404', array('Kohana', 'show_404'));
// Enable Kohana output handling
Event::add('system.shutdown', array('Kohana', 'shutdown'));
if (self::config('core.enable_hooks') === TRUE)
{
// Find all the hook files
$hooks = self::list_files('hooks', TRUE);
foreach ($hooks as $file)
{
// Load the hook
include $file;
}
}
// Setup is complete, prevent it from being run again
$run = TRUE;
// Stop the environment setup routine
Benchmark::stop(SYSTEM_BENCHMARK.'_environment_setup');
}
/**
* Loads the controller and initializes it. Runs the pre_controller,
* post_controller_constructor, and post_controller events. Triggers
* a system.404 event when the route cannot be mapped to a controller.
*
* This method is benchmarked as controller_setup and controller_execution.
*
* @return object instance of controller
*/
public static function & instance()
{
if (self::$instance === NULL)
{
Benchmark::start(SYSTEM_BENCHMARK.'_controller_setup');
// Include the Controller file
require Router::$controller_path;
try
{
// Start validation of the controller
$class = new ReflectionClass(ucfirst(Router::$controller).'_Controller');
}
catch (ReflectionException $e)
{
// Controller does not exist
Event::run('system.404');
}
if ($class->isAbstract() OR (IN_PRODUCTION AND $class->getConstant('ALLOW_PRODUCTION') == FALSE))
{
// Controller is not allowed to run in production
Event::run('system.404');
}
// Run system.pre_controller
Event::run('system.pre_controller');
// Create a new controller instance
$controller = $class->newInstance();
// Controller constructor has been executed
Event::run('system.post_controller_constructor');
try
{
// Load the controller method
$method = $class->getMethod(Router::$method);
// Method exists
if (Router::$method[0] === '_')
{
// Do not allow access to hidden methods
Event::run('system.404');
}
if ($method->isProtected() or $method->isPrivate())
{
// Do not attempt to invoke protected methods
throw new ReflectionException('protected controller method');
}
// Default arguments
$arguments = Router::$arguments;
}
catch (ReflectionException $e)
{
// Use __call instead
$method = $class->getMethod('__call');
// Use arguments in __call format
$arguments = array(Router::$method, Router::$arguments);
}
// Stop the controller setup benchmark
Benchmark::stop(SYSTEM_BENCHMARK.'_controller_setup');
// Start the controller execution benchmark
Benchmark::start(SYSTEM_BENCHMARK.'_controller_execution');
// Execute the controller method
$method->invokeArgs($controller, $arguments);
// Controller method has been executed
Event::run('system.post_controller');
// Stop the controller execution benchmark
Benchmark::stop(SYSTEM_BENCHMARK.'_controller_execution');
}
return self::$instance;
}
/**
* Get all include paths. APPPATH is the first path, followed by module
* paths in the order they are configured, follow by the SYSPATH.
*
* @param boolean re-process the include paths
* @return array
*/
public static function include_paths($process = FALSE)
{
if ($process === TRUE)
{
// Add APPPATH as the first path
self::$include_paths = array(APPPATH);
foreach (self::$configuration['core']['modules'] as $path)
{
if ($path = str_replace('\\', '/', realpath($path)))
{
// Add a valid path
self::$include_paths[] = $path.'/';
}
}
// Add SYSPATH as the last path
self::$include_paths[] = SYSPATH;
}
return self::$include_paths;
}
/**
* Get a config item or group.
*
* @param string item name
* @param boolean force a forward slash (/) at the end of the item
* @param boolean is the item required?
* @return mixed
*/
public static function config($key, $slash = FALSE, $required = TRUE)
{
if (self::$configuration === NULL)
{
// Load core configuration
self::$configuration['core'] = self::config_load('core');
// Re-parse the include paths
self::include_paths(TRUE);
}
// Get the group name from the key
$group = explode('.', $key, 2);
$group = $group[0];
if ( ! isset(self::$configuration[$group]))
{
// Load the configuration group
self::$configuration[$group] = self::config_load($group, $required);
}
// Get the value of the key string
$value = self::key_string(self::$configuration, $key);
if ($slash === TRUE AND is_string($value) AND $value !== '')
{
// Force the value to end with "/"
$value = rtrim($value, '/').'/';
}
return $value;
}
/**
* Sets a configuration item, if allowed.
*
* @param string config key string
* @param string config value
* @return boolean
*/
public static function config_set($key, $value)
{
// Do this to make sure that the config array is already loaded
self::config($key);
if (substr($key, 0, 7) === 'routes.')
{
// Routes cannot contain sub keys due to possible dots in regex
$keys = explode('.', $key, 2);
}
else
{
// Convert dot-noted key string to an array
$keys = explode('.', $key);
}
// Used for recursion
$conf =& self::$configuration;
$last = count($keys) - 1;
foreach ($keys as $i => $k)
{
if ($i === $last)
{
$conf[$k] = $value;
}
else
{
$conf =& $conf[$k];
}
}
if ($key === 'core.modules')
{
// Reprocess the include paths
self::include_paths(TRUE);
}
return TRUE;
}
/**
* Load a config file.
*
* @param string config filename, without extension
* @param boolean is the file required?
* @return array
*/
public static function config_load($name, $required = TRUE)
{
if ($name === 'core')
{
// Load the application configuration file
require APPPATH.'config/config'.EXT;
if ( ! isset($config['site_domain']))
{
// Invalid config file
die('Your Kohana application configuration file is not valid.');
}
return $config;
}
if (isset(self::$internal_cache['configuration'][$name]))
return self::$internal_cache['configuration'][$name];
// Load matching configs
$configuration = array();
if ($files = self::find_file('config', $name, $required))
{
foreach ($files as $file)
{
require $file;
if (isset($config) AND is_array($config))
{
// Merge in configuration
$configuration = array_merge($configuration, $config);
}
}
}
if ( ! isset(self::$write_cache['configuration']))
{
// Cache has changed
self::$write_cache['configuration'] = TRUE;
}
return self::$internal_cache['configuration'][$name] = $configuration;
}
/**
* Clears a config group from the cached configuration.
*
* @param string config group
* @return void
*/
public static function config_clear($group)
{
// Remove the group from config
unset(self::$configuration[$group], self::$internal_cache['configuration'][$group]);
if ( ! isset(self::$write_cache['configuration']))
{
// Cache has changed
self::$write_cache['configuration'] = TRUE;
}
}
/**
* Add a new message to the log.
*
* @param string type of message
* @param string message text
* @return void
*/
public static function log($type, $message)
{
if (self::$log_levels[$type] <= self::$configuration['core']['log_threshold'])
{
$message = array(date('Y-m-d H:i:s P'), $type, $message);
// Run the system.log event
Event::run('system.log', $message);
self::$log[] = $message;
}
}
/**
* Save all currently logged messages.
*
* @return void
*/
public static function log_save()
{
if (empty(self::$log) OR self::$configuration['core']['log_threshold'] < 1)
return;
// Filename of the log
$filename = self::log_directory().date('Y-m-d').'.log'.EXT;
if ( ! is_file($filename))
{
// Write the SYSPATH checking header
file_put_contents($filename,
''.PHP_EOL.PHP_EOL);
// Prevent external writes
chmod($filename, 0644);
}
// Messages to write
$messages = array();
do
{
// Load the next mess
list ($date, $type, $text) = array_shift(self::$log);
// Add a new message line
$messages[] = $date.' --- '.$type.': '.$text;
}
while ( ! empty(self::$log));
// Write messages to log file
file_put_contents($filename, implode(PHP_EOL, $messages).PHP_EOL, FILE_APPEND);
}
/**
* Get or set the logging directory.
*
* @param string new log directory
* @return string
*/
public static function log_directory($dir = NULL)
{
static $directory;
if ( ! empty($dir))
{
// Get the directory path
$dir = realpath($dir);
if (is_dir($dir) AND is_writable($dir))
{
// Change the log directory
$directory = str_replace('\\', '/', $dir).'/';
}
else
{
// Log directory is invalid
throw new Kohana_Exception('core.log_dir_unwritable', $dir);
}
}
return $directory;
}
/**
* Load data from a simple cache file. This should only be used internally,
* and is NOT a replacement for the Cache library.
*
* @param string unique name of cache
* @param integer expiration in seconds
* @return mixed
*/
public static function cache($name, $lifetime)
{
if ($lifetime > 0)
{
$path = self::$internal_cache_path.'kohana_'.$name;
if (is_file($path))
{
// Check the file modification time
if ((time() - filemtime($path)) < $lifetime)
{
// Cache is valid! Now, do we need to decrypt it?
if(self::$internal_cache_encrypt===TRUE)
{
$data = file_get_contents($path);
$iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
$iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
$decrypted_text = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, self::$internal_cache_key, $data, MCRYPT_MODE_ECB, $iv);
$cache = unserialize($decrypted_text);
// If the key changed, delete the cache file
if(!$cache)
unlink($path);
// If cache is false (as above) return NULL, otherwise, return the cache
return ($cache ? $cache : NULL);
}
else
{
return unserialize(file_get_contents($path));
}
}
else
{
// Cache is invalid, delete it
unlink($path);
}
}
}
// No cache found
return NULL;
}
/**
* Save data to a simple cache file. This should only be used internally, and
* is NOT a replacement for the Cache library.
*
* @param string cache name
* @param mixed data to cache
* @param integer expiration in seconds
* @return boolean
*/
public static function cache_save($name, $data, $lifetime)
{
if ($lifetime < 1)
return FALSE;
$path = self::$internal_cache_path.'kohana_'.$name;
if ($data === NULL)
{
// Delete cache
return (is_file($path) and unlink($path));
}
else
{
// Using encryption? Encrypt the data when we write it
if(self::$internal_cache_encrypt===TRUE)
{
// Encrypt and write data to cache file
$iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
$iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
// Serialize and encrypt!
$encrypted_text = mcrypt_encrypt(MCRYPT_RIJNDAEL_256, self::$internal_cache_key, serialize($data), MCRYPT_MODE_ECB, $iv);
return (bool) file_put_contents($path, $encrypted_text);
}
else
{
// Write data to cache file
return (bool) file_put_contents($path, serialize($data));
}
}
}
/**
* Kohana output handler. Called during ob_clean, ob_flush, and their variants.
*
* @param string current output buffer
* @return string
*/
public static function output_buffer($output)
{
// Could be flushing, so send headers first
if ( ! Event::has_run('system.send_headers'))
{
// Run the send_headers event
Event::run('system.send_headers');
}
self::$output = $output;
// Set and return the final output
return self::$output;
}
/**
* Closes all open output buffers, either by flushing or cleaning, and stores the Kohana
* output buffer for display during shutdown.
*
* @param boolean disable to clear buffers, rather than flushing
* @return void
*/
public static function close_buffers($flush = TRUE)
{
if (ob_get_level() >= self::$buffer_level)
{
// Set the close function
$close = ($flush === TRUE) ? 'ob_end_flush' : 'ob_end_clean';
while (ob_get_level() > self::$buffer_level)
{
// Flush or clean the buffer
$close();
}
// Store the Kohana output buffer
ob_end_clean();
}
}
/**
* Triggers the shutdown of Kohana by closing the output buffer, runs the system.display event.
*
* @return void
*/
public static function shutdown()
{
// Close output buffers
self::close_buffers(TRUE);
// Run the output event
Event::run('system.display', self::$output);
// Render the final output
self::render(self::$output);
}
/**
* Inserts global Kohana variables into the generated output and prints it.
*
* @param string final output that will displayed
* @return void
*/
public static function render($output)
{
if (self::config('core.render_stats') === TRUE)
{
// Fetch memory usage in MB
$memory = function_exists('memory_get_usage') ? (memory_get_usage() / 1024 / 1024) : 0;
// Fetch benchmark for page execution time
$benchmark = Benchmark::get(SYSTEM_BENCHMARK.'_total_execution');
// Replace the global template variables
$output = str_replace(
array
(
'{kohana_version}',
'{kohana_codename}',
'{execution_time}',
'{memory_usage}',
'{included_files}',
),
array
(
KOHANA_VERSION,
KOHANA_CODENAME,
$benchmark['time'],
number_format($memory, 2).'MB',
count(get_included_files()),
),
$output
);
}
if ($level = self::config('core.output_compression') AND ini_get('output_handler') !== 'ob_gzhandler' AND (int) ini_get('zlib.output_compression') === 0)
{
if ($level < 1 OR $level > 9)
{
// Normalize the level to be an integer between 1 and 9. This
// step must be done to prevent gzencode from triggering an error
$level = max(1, min($level, 9));
}
if (stripos(@$_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip') !== FALSE)
{
$compress = 'gzip';
}
elseif (stripos(@$_SERVER['HTTP_ACCEPT_ENCODING'], 'deflate') !== FALSE)
{
$compress = 'deflate';
}
}
if (isset($compress) AND $level > 0)
{
switch ($compress)
{
case 'gzip':
// Compress output using gzip
$output = gzencode($output, $level);
break;
case 'deflate':
// Compress output using zlib (HTTP deflate)
$output = gzdeflate($output, $level);
break;
}
// This header must be sent with compressed content to prevent
// browser caches from breaking
header('Vary: Accept-Encoding');
// Send the content encoding header
header('Content-Encoding: '.$compress);
// Sending Content-Length in CGI can result in unexpected behavior
if (stripos(PHP_SAPI, 'cgi') === FALSE)
{
header('Content-Length: '.strlen($output));
}
}
echo $output;
}
/**
* Displays a 404 page.
*
* @throws Kohana_404_Exception
* @param string URI of page
* @param string custom template
* @return void
*/
public static function show_404($page = FALSE, $template = FALSE)
{
throw new Kohana_404_Exception($page, $template);
}
/**
* Dual-purpose PHP error and exception handler. Uses the kohana_error_page
* view to display the message.
*
* @param integer|object exception object or error code
* @param string error message
* @param string filename
* @param integer line number
* @return void
*/
public static function exception_handler($exception, $message = NULL, $file = NULL, $line = NULL)
{
try
{
// PHP errors have 5 args, always
$PHP_ERROR = (func_num_args() === 5);
// Test to see if errors should be displayed
if ($PHP_ERROR AND (error_reporting() & $exception) === 0)
return;
// This is useful for hooks to determine if a page has an error
self::$has_error = TRUE;
// Error handling will use exactly 5 args, every time
if ($PHP_ERROR)
{
$code = $exception;
$type = 'PHP Error';
$template = 'kohana_error_page';
}
else
{
$code = $exception->getCode();
$type = get_class($exception);
$message = $exception->getMessage();
$file = $exception->getFile();
$line = $exception->getLine();
$template = ($exception instanceof Kohana_Exception) ? $exception->getTemplate() : 'kohana_error_page';
}
if (is_numeric($code))
{
$codes = self::lang('errors');
if ( ! empty($codes[$code]))
{
list($level, $error, $description) = $codes[$code];
}
else
{
$level = 1;
$error = $PHP_ERROR ? 'Unknown Error' : get_class($exception);
$description = '';
}
}
else
{
// Custom error message, this will never be logged
$level = 5;
$error = $code;
$description = '';
}
// Remove the DOCROOT from the path, as a security precaution
$file = str_replace('\\', '/', realpath($file));
$file = preg_replace('|^'.preg_quote(DOCROOT).'|', '', $file);
if ($level <= self::$configuration['core']['log_threshold'])
{
// Log the error
self::log('error', self::lang('core.uncaught_exception', $type, $message, $file, $line));
}
if ($PHP_ERROR)
{
$description = self::lang('errors.'.E_RECOVERABLE_ERROR);
$description = is_array($description) ? $description[2] : '';
if ( ! headers_sent())
{
// Send the 500 header
header('HTTP/1.1 500 Internal Server Error');
}
}
else
{
if (method_exists($exception, 'sendHeaders') AND ! headers_sent())
{
// Send the headers if they have not already been sent
$exception->sendHeaders();
}
}
// Close all output buffers except for Kohana
while (ob_get_level() > self::$buffer_level)
{
ob_end_clean();
}
// Test if display_errors is on
if (self::$configuration['core']['display_errors'] === TRUE)
{
if ( ! IN_PRODUCTION AND $line != FALSE)
{
// Remove the first entry of debug_backtrace(), it is the exception_handler call
$trace = $PHP_ERROR ? array_slice(debug_backtrace(), 1) : $exception->getTrace();
// Beautify backtrace
$trace = self::backtrace($trace);
}
// Load the error
require self::find_file('views', empty($template) ? 'kohana_error_page' : $template);
}
else
{
// Get the i18n messages
$error = self::lang('core.generic_error');
$message = self::lang('core.errors_disabled', url::site(), url::site(Router::$current_uri));
// Load the errors_disabled view
require self::find_file('views', 'kohana_error_disabled');
}
if ( ! Event::has_run('system.shutdown'))
{
// Run the shutdown even to ensure a clean exit
Event::run('system.shutdown');
}
// Turn off error reporting
error_reporting(0);
exit;
}
catch (Exception $e)
{
if (IN_PRODUCTION)
{
die('Fatal Error');
}
else
{
die('Fatal Error: '.$e->getMessage().' File: '.$e->getFile().' Line: '.$e->getLine());
}
}
}
/**
* Provides class auto-loading.
*
* @throws Kohana_Exception
* @param string name of class
* @return bool
*/
public static function auto_load($class)
{
if (class_exists($class, FALSE))
return TRUE;
if (($suffix = strrpos($class, '_')) > 0)
{
// Find the class suffix
$suffix = substr($class, $suffix + 1);
}
else
{
// No suffix
$suffix = FALSE;
}
if ($suffix === 'Core')
{
$type = 'libraries';
$file = substr($class, 0, -5);
}
elseif ($suffix === 'Controller')
{
$type = 'controllers';
// Lowercase filename
$file = strtolower(substr($class, 0, -11));
}
elseif ($suffix === 'Model')
{
$type = 'models';
// Lowercase filename
$file = strtolower(substr($class, 0, -6));
}
elseif ($suffix === 'Driver')
{
$type = 'libraries/drivers';
$file = str_replace('_', '/', substr($class, 0, -7));
}
else
{
// This could be either a library or a helper, but libraries must
// always be capitalized, so we check if the first character is
// uppercase. If it is, we are loading a library, not a helper.
$type = ($class[0] < 'a') ? 'libraries' : 'helpers';
$file = $class;
}
if ($filename = self::find_file($type, $file))
{
// Load the class
require $filename;
}
else
{
// The class could not be found
return FALSE;
}
if ($filename = self::find_file($type, self::$configuration['core']['extension_prefix'].$class))
{
// Load the class extension
require $filename;
}
elseif ($suffix !== 'Core' AND class_exists($class.'_Core', FALSE))
{
// Class extension to be evaluated
$extension = 'class '.$class.' extends '.$class.'_Core { }';
// Start class analysis
$core = new ReflectionClass($class.'_Core');
if ($core->isAbstract())
{
// Make the extension abstract
$extension = 'abstract '.$extension;
}
// Transparent class extensions are handled using eval. This is
// a disgusting hack, but it gets the job done.
eval($extension);
}
return TRUE;
}
/**
* Find a resource file in a given directory. Files will be located according
* to the order of the include paths. Configuration and i18n files will be
* returned in reverse order.
*
* @throws Kohana_Exception if file is required and not found
* @param string directory to search in
* @param string filename to look for (without extension)
* @param boolean file required
* @param string file extension
* @return array if the type is config, i18n or l10n
* @return string if the file is found
* @return FALSE if the file is not found
*/
public static function find_file($directory, $filename, $required = FALSE, $ext = FALSE)
{
// NOTE: This test MUST be not be a strict comparison (===), or empty
// extensions will be allowed!
if ($ext == '')
{
// Use the default extension
$ext = EXT;
}
else
{
// Add a period before the extension
$ext = '.'.$ext;
}
// Search path
$search = $directory.'/'.$filename.$ext;
if (isset(self::$internal_cache['find_file_paths'][$search]))
return self::$internal_cache['find_file_paths'][$search];
// Load include paths
$paths = self::$include_paths;
// Nothing found, yet
$found = NULL;
if ($directory === 'config' OR $directory === 'i18n')
{
// Search in reverse, for merging
$paths = array_reverse($paths);
foreach ($paths as $path)
{
if (is_file($path.$search))
{
// A matching file has been found
$found[] = $path.$search;
}
}
}
else
{
foreach ($paths as $path)
{
if (is_file($path.$search))
{
// A matching file has been found
$found = $path.$search;
// Stop searching
break;
}
}
}
if ($found === NULL)
{
if ($required === TRUE)
{
// Directory i18n key
$directory = 'core.'.inflector::singular($directory);
// If the file is required, throw an exception
throw new Kohana_Exception('core.resource_not_found', self::lang($directory), $filename);
}
else
{
// Nothing was found, return FALSE
$found = FALSE;
}
}
if ( ! isset(self::$write_cache['find_file_paths']))
{
// Write cache at shutdown
self::$write_cache['find_file_paths'] = TRUE;
}
return self::$internal_cache['find_file_paths'][$search] = $found;
}
/**
* Lists all files and directories in a resource path.
*
* @param string directory to search
* @param boolean list all files to the maximum depth?
* @param string full path to search (used for recursion, *never* set this manually)
* @return array filenames and directories
*/
public static function list_files($directory, $recursive = FALSE, $path = FALSE)
{
$files = array();
if ($path === FALSE)
{
$paths = array_reverse(self::include_paths());
foreach ($paths as $path)
{
// Recursively get and merge all files
$files = array_merge($files, self::list_files($directory, $recursive, $path.$directory));
}
}
else
{
$path = rtrim($path, '/').'/';
if (is_readable($path))
{
$items = (array) glob($path.'*');
if ( ! empty($items))
{
foreach ($items as $index => $item)
{
$files[] = $item = str_replace('\\', '/', $item);
// Handle recursion
if (is_dir($item) AND $recursive == TRUE)
{
// Filename should only be the basename
$item = pathinfo($item, PATHINFO_BASENAME);
// Append sub-directory search
$files = array_merge($files, self::list_files($directory, TRUE, $path.$item));
}
}
}
}
}
return $files;
}
/**
* Fetch an i18n language item.
*
* @param string language key to fetch
* @param array additional information to insert into the line
* @return string i18n language string, or the requested key if the i18n item is not found
*/
public static function lang($key, $args = array())
{
// Extract the main group from the key
$group = explode('.', $key, 2);
$group = $group[0];
// Get locale name
$locale = self::config('locale.language.0');
if ( ! isset(self::$internal_cache['language'][$locale][$group]))
{
// Messages for this group
$messages = array();
if ($files = self::find_file('i18n', $locale.'/'.$group))
{
foreach ($files as $file)
{
include $file;
// Merge in configuration
if ( ! empty($lang) AND is_array($lang))
{
foreach ($lang as $k => $v)
{
$messages[$k] = $v;
}
}
}
}
if ( ! isset(self::$write_cache['language']))
{
// Write language cache
self::$write_cache['language'] = TRUE;
}
self::$internal_cache['language'][$locale][$group] = $messages;
}
// Get the line from cache
$line = self::key_string(self::$internal_cache['language'][$locale], $key);
if ($line === NULL)
{
self::log('error', 'Missing i18n entry '.$key.' for language '.$locale);
// Return the key string as fallback
return $key;
}
if (is_string($line) AND func_num_args() > 1)
{
$args = array_slice(func_get_args(), 1);
// Add the arguments into the line
$line = vsprintf($line, is_array($args[0]) ? $args[0] : $args);
}
return $line;
}
/**
* Returns the value of a key, defined by a 'dot-noted' string, from an array.
*
* @param array array to search
* @param string dot-noted string: foo.bar.baz
* @return string if the key is found
* @return void if the key is not found
*/
public static function key_string($array, $keys)
{
if (empty($array))
return NULL;
// Prepare for loop
$keys = explode('.', $keys);
do
{
// Get the next key
$key = array_shift($keys);
if (isset($array[$key]))
{
if (is_array($array[$key]) AND ! empty($keys))
{
// Dig down to prepare the next loop
$array = $array[$key];
}
else
{
// Requested key was found
return $array[$key];
}
}
else
{
// Requested key is not set
break;
}
}
while ( ! empty($keys));
return NULL;
}
/**
* Sets values in an array by using a 'dot-noted' string.
*
* @param array array to set keys in (reference)
* @param string dot-noted string: foo.bar.baz
* @return mixed fill value for the key
* @return void
*/
public static function key_string_set( & $array, $keys, $fill = NULL)
{
if (is_object($array) AND ($array instanceof ArrayObject))
{
// Copy the array
$array_copy = $array->getArrayCopy();
// Is an object
$array_object = TRUE;
}
else
{
if ( ! is_array($array))
{
// Must always be an array
$array = (array) $array;
}
// Copy is a reference to the array
$array_copy =& $array;
}
if (empty($keys))
return $array;
// Create keys
$keys = explode('.', $keys);
// Create reference to the array
$row =& $array_copy;
for ($i = 0, $end = count($keys) - 1; $i <= $end; $i++)
{
// Get the current key
$key = $keys[$i];
if ( ! isset($row[$key]))
{
if (isset($keys[$i + 1]))
{
// Make the value an array
$row[$key] = array();
}
else
{
// Add the fill key
$row[$key] = $fill;
}
}
elseif (isset($keys[$i + 1]))
{
// Make the value an array
$row[$key] = (array) $row[$key];
}
// Go down a level, creating a new row reference
$row =& $row[$key];
}
if (isset($array_object))
{
// Swap the array back in
$array->exchangeArray($array_copy);
}
}
/**
* Retrieves current user agent information:
* keys: browser, version, platform, mobile, robot, referrer, languages, charsets
* tests: is_browser, is_mobile, is_robot, accept_lang, accept_charset
*
* @param string key or test name
* @param string used with "accept" tests: user_agent(accept_lang, en)
* @return array languages and charsets
* @return string all other keys
* @return boolean all tests
*/
public static function user_agent($key = 'agent', $compare = NULL)
{
static $info;
// Return the raw string
if ($key === 'agent')
return self::$user_agent;
if ($info === NULL)
{
// Parse the user agent and extract basic information
$agents = self::config('user_agents');
foreach ($agents as $type => $data)
{
foreach ($data as $agent => $name)
{
if (stripos(self::$user_agent, $agent) !== FALSE)
{
if ($type === 'browser' AND preg_match('|'.preg_quote($agent).'[^0-9.]*+([0-9.][0-9.a-z]*)|i', self::$user_agent, $match))
{
// Set the browser version
$info['version'] = $match[1];
}
// Set the agent name
$info[$type] = $name;
break;
}
}
}
}
if (empty($info[$key]))
{
switch ($key)
{
case 'is_robot':
case 'is_browser':
case 'is_mobile':
// A boolean result
$return = ! empty($info[substr($key, 3)]);
break;
case 'languages':
$return = array();
if ( ! empty($_SERVER['HTTP_ACCEPT_LANGUAGE']))
{
if (preg_match_all('/[-a-z]{2,}/', strtolower(trim($_SERVER['HTTP_ACCEPT_LANGUAGE'])), $matches))
{
// Found a result
$return = $matches[0];
}
}
break;
case 'charsets':
$return = array();
if ( ! empty($_SERVER['HTTP_ACCEPT_CHARSET']))
{
if (preg_match_all('/[-a-z0-9]{2,}/', strtolower(trim($_SERVER['HTTP_ACCEPT_CHARSET'])), $matches))
{
// Found a result
$return = $matches[0];
}
}
break;
case 'referrer':
if ( ! empty($_SERVER['HTTP_REFERER']))
{
// Found a result
$return = trim($_SERVER['HTTP_REFERER']);
}
break;
}
// Cache the return value
isset($return) and $info[$key] = $return;
}
if ( ! empty($compare))
{
// The comparison must always be lowercase
$compare = strtolower($compare);
switch ($key)
{
case 'accept_lang':
// Check if the lange is accepted
return in_array($compare, self::user_agent('languages'));
break;
case 'accept_charset':
// Check if the charset is accepted
return in_array($compare, self::user_agent('charsets'));
break;
default:
// Invalid comparison
return FALSE;
break;
}
}
// Return the key, if set
return isset($info[$key]) ? $info[$key] : NULL;
}
/**
* Quick debugging of any variable. Any number of parameters can be set.
*
* @return string
*/
public static function debug()
{
if (func_num_args() === 0)
return;
// Get params
$params = func_get_args();
$output = array();
foreach ($params as $var)
{
$output[] = '('.gettype($var).') '.html::specialchars(print_r($var, TRUE)).'
';
}
return implode("\n", $output);
}
/**
* Displays nice backtrace information.
* @see http://php.net/debug_backtrace
*
* @param array backtrace generated by an exception or debug_backtrace
* @return string
*/
public static function backtrace($trace)
{
if ( ! is_array($trace))
return;
// Final output
$output = array();
foreach ($trace as $entry)
{
$temp = '';
if (isset($entry['file']))
{
$temp .= self::lang('core.error_file_line', preg_replace('!^'.preg_quote(DOCROOT).'!', '', $entry['file']), $entry['line']);
}
$temp .= '';
if (isset($entry['class']))
{
// Add class and call type
$temp .= $entry['class'].$entry['type'];
}
// Add function
$temp .= $entry['function'].'( ';
// Add function args
if (isset($entry['args']) AND is_array($entry['args']))
{
// Separator starts as nothing
$sep = '';
while ($arg = array_shift($entry['args']))
{
if (is_string($arg) AND is_file($arg))
{
// Remove docroot from filename
$arg = preg_replace('!^'.preg_quote(DOCROOT).'!', '', $arg);
}
$temp .= $sep.html::specialchars(print_r($arg, TRUE));
// Change separator to a comma
$sep = ', ';
}
}
$temp .= ' )
';
$output[] = $temp;
}
return ''.implode("\n", $output).'
';
}
/**
* Saves the internal caches: configuration, include paths, etc.
*
* @return boolean
*/
public static function internal_cache_save()
{
if ( ! is_array(self::$write_cache))
return FALSE;
// Get internal cache names
$caches = array_keys(self::$write_cache);
// Nothing written
$written = FALSE;
foreach ($caches as $cache)
{
if (isset(self::$internal_cache[$cache]))
{
// Write the cache file
self::cache_save($cache, self::$internal_cache[$cache], self::$configuration['core']['internal_cache']);
// A cache has been written
$written = TRUE;
}
}
return $written;
}
} // End Kohana
/**
* Creates a generic i18n exception.
*/
class Kohana_Exception extends Exception {
// Template file
protected $template = 'kohana_error_page';
// Header
protected $header = FALSE;
// Error code
protected $code = E_KOHANA;
/**
* Set exception message.
*
* @param string i18n language key for the message
* @param array addition line parameters
*/
public function __construct($error)
{
$args = array_slice(func_get_args(), 1);
// Fetch the error message
$message = Kohana::lang($error, $args);
if ($message === $error OR empty($message))
{
// Unable to locate the message for the error
$message = 'Unknown Exception: '.$error;
}
// Sets $this->message the proper way
parent::__construct($message);
}
/**
* Magic method for converting an object to a string.
*
* @return string i18n message
*/
public function __toString()
{
return (string) $this->message;
}
/**
* Fetch the template name.
*
* @return string
*/
public function getTemplate()
{
return $this->template;
}
/**
* Sends an Internal Server Error header.
*
* @return void
*/
public function sendHeaders()
{
// Send the 500 header
header('HTTP/1.1 500 Internal Server Error');
}
} // End Kohana Exception
/**
* Creates a custom exception.
*/
class Kohana_User_Exception extends Kohana_Exception {
/**
* Set exception title and message.
*
* @param string exception title string
* @param string exception message string
* @param string custom error template
*/
public function __construct($title, $message, $template = FALSE)
{
Exception::__construct($message);
$this->code = $title;
if ($template !== FALSE)
{
$this->template = $template;
}
}
} // End Kohana PHP Exception
/**
* Creates a Page Not Found exception.
*/
class Kohana_404_Exception extends Kohana_Exception {
protected $code = E_PAGE_NOT_FOUND;
/**
* Set internal properties.
*
* @param string URL of page
* @param string custom error template
*/
public function __construct($page = FALSE, $template = FALSE)
{
if ($page === FALSE)
{
// Construct the page URI using Router properties
$page = Router::$current_uri.Router::$url_suffix.Router::$query_string;
}
Exception::__construct(Kohana::lang('core.page_not_found', $page));
$this->template = $template;
}
/**
* Sends "File Not Found" headers, to emulate server behavior.
*
* @return void
*/
public function sendHeaders()
{
// Send the 404 header
header('HTTP/1.1 404 File Not Found');
}
} // End Kohana 404 Exception
./kohana/system/fonts/ 0000755 0001750 0001750 00000000000 11263472440 014462 5 ustar tokkee tokkee ./kohana/system/fonts/DejaVuSerif.ttf 0000644 0001750 0001750 00001124740 11036111000 017335 0 ustar tokkee tokkee 0FFTML
<