Namespaces

  • Latte
    • Loaders
    • Macros
    • Runtime
  • Nette
    • Application
      • Responses
      • Routers
      • UI
    • Bridges
      • ApplicationLatte
      • ApplicationTracy
      • CacheLatte
      • DatabaseDI
      • DatabaseTracy
      • DITracy
      • FormsLatte
      • Framework
      • HttpTracy
      • SecurityTracy
    • Caching
      • Storages
    • ComponentModel
    • Database
      • Drivers
      • Reflection
      • Table
    • DI
      • Config
        • Adapters
      • Extensions
    • Diagnostics
    • Forms
      • Controls
      • Rendering
    • Http
    • Iterators
    • Latte
    • Loaders
    • Localization
    • Mail
    • Neon
    • PhpGenerator
    • Reflection
    • Security
    • Templating
    • Utils
  • NetteModule
  • none
  • Tracy

Classes

  • ClassType
  • Helpers
  • Method
  • Parameter
  • PhpLiteral
  • Property
  • Overview
  • Namespace
  • Class
  • Tree
  • Deprecated
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (http://nette.org)
  5:  * Copyright (c) 2004 David Grudl (http://davidgrudl.com)
  6:  */
  7: 
  8: namespace Nette\PhpGenerator;
  9: 
 10: use Nette;
 11: 
 12: 
 13: /**
 14:  * PHP code generator utils.
 15:  *
 16:  * @author     David Grudl
 17:  */
 18: class Helpers
 19: {
 20:     const PHP_IDENT = '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*';
 21: 
 22: 
 23:     /**
 24:      * Returns a PHP representation of a variable.
 25:      * @return string
 26:      */
 27:     public static function dump($var)
 28:     {
 29:         return self::_dump($var);
 30:     }
 31: 
 32: 
 33:     private static function _dump(& $var, $level = 0)
 34:     {
 35:         if ($var instanceof PhpLiteral) {
 36:             return (string) $var;
 37: 
 38:         } elseif (is_float($var)) {
 39:             $var = var_export($var, TRUE);
 40:             return strpos($var, '.') === FALSE ? $var . '.0' : $var;
 41: 
 42:         } elseif (is_bool($var)) {
 43:             return $var ? 'TRUE' : 'FALSE';
 44: 
 45:         } elseif (is_string($var) && (preg_match('#[^\x09\x20-\x7E\xA0-\x{10FFFF}]#u', $var) || preg_last_error())) {
 46:             static $table;
 47:             if ($table === NULL) {
 48:                 foreach (array_merge(range("\x00", "\x1F"), range("\x7F", "\xFF")) as $ch) {
 49:                     $table[$ch] = '\x' . str_pad(dechex(ord($ch)), 2, '0', STR_PAD_LEFT);
 50:                 }
 51:                 $table['\\'] = '\\\\';
 52:                 $table["\r"] = '\r';
 53:                 $table["\n"] = '\n';
 54:                 $table["\t"] = '\t';
 55:                 $table['$'] = '\$';
 56:                 $table['"'] = '\"';
 57:             }
 58:             return '"' . strtr($var, $table) . '"';
 59: 
 60:         } elseif (is_array($var)) {
 61:             $space = str_repeat("\t", $level);
 62: 
 63:             static $marker;
 64:             if ($marker === NULL) {
 65:                 $marker = uniqid("\x00", TRUE);
 66:             }
 67:             if (empty($var)) {
 68:                 $out = '';
 69: 
 70:             } elseif ($level > 50 || isset($var[$marker])) {
 71:                 throw new Nette\InvalidArgumentException('Nesting level too deep or recursive dependency.');
 72: 
 73:             } else {
 74:                 $out = '';
 75:                 $outAlt = "\n$space";
 76:                 $var[$marker] = TRUE;
 77:                 $counter = 0;
 78:                 foreach ($var as $k => & $v) {
 79:                     if ($k !== $marker) {
 80:                         $item = ($k === $counter ? '' : self::_dump($k, $level + 1) . ' => ') . self::_dump($v, $level + 1);
 81:                         $counter = is_int($k) ? max($k + 1, $counter) : $counter;
 82:                         $out .= ($out === '' ? '' : ', ') . $item;
 83:                         $outAlt .= "\t$item,\n$space";
 84:                     }
 85:                 }
 86:                 unset($var[$marker]);
 87:             }
 88:             return 'array(' . (strpos($out, "\n") === FALSE && strlen($out) < 40 ? $out : $outAlt) . ')';
 89: 
 90:         } elseif (is_object($var)) {
 91:             $arr = (array) $var;
 92:             $space = str_repeat("\t", $level);
 93: 
 94:             static $list = array();
 95:             if (empty($arr)) {
 96:                 $out = '';
 97: 
 98:             } elseif ($level > 50 || in_array($var, $list, TRUE)) {
 99:                 throw new Nette\InvalidArgumentException('Nesting level too deep or recursive dependency.');
100: 
101:             } else {
102:                 $out = "\n";
103:                 $list[] = $var;
104:                 foreach ($arr as $k => & $v) {
105:                     if ($k[0] === "\x00") {
106:                         $k = substr($k, strrpos($k, "\x00") + 1);
107:                     }
108:                     $out .= "$space\t" . self::_dump($k, $level + 1) . " => " . self::_dump($v, $level + 1) . ",\n";
109:                 }
110:                 array_pop($list);
111:                 $out .= $space;
112:             }
113:             return get_class($var) === 'stdClass'
114:                 ? "(object) array($out)"
115:                 : __CLASS__ . "::createObject('" . get_class($var) . "', array($out))";
116: 
117:         } elseif (is_resource($var)) {
118:             throw new Nette\InvalidArgumentException('Cannot dump resource.');
119: 
120:         } else {
121:             return var_export($var, TRUE);
122:         }
123:     }
124: 
125: 
126:     /**
127:      * Generates PHP statement.
128:      * @return string
129:      */
130:     public static function format($statement)
131:     {
132:         $args = func_get_args();
133:         return self::formatArgs(array_shift($args), $args);
134:     }
135: 
136: 
137:     /**
138:      * Generates PHP statement.
139:      * @return string
140:      */
141:     public static function formatArgs($statement, array $args)
142:     {
143:         $a = strpos($statement, '?');
144:         while ($a !== FALSE) {
145:             if (!$args) {
146:                 throw new Nette\InvalidArgumentException('Insufficient number of arguments.');
147:             }
148:             $arg = array_shift($args);
149:             if (substr($statement, $a + 1, 1) === '*') { // ?*
150:                 if (!is_array($arg)) {
151:                     throw new Nette\InvalidArgumentException('Argument must be an array.');
152:                 }
153:                 $arg = implode(', ', array_map(array(__CLASS__, 'dump'), $arg));
154:                 $statement = substr_replace($statement, $arg, $a, 2);
155: 
156:             } else {
157:                 $arg = substr($statement, $a - 1, 1) === '$' || in_array(substr($statement, $a - 2, 2), array('->', '::'))
158:                     ? self::formatMember($arg) : self::_dump($arg);
159:                 $statement = substr_replace($statement, $arg, $a, 1);
160:             }
161:             $a = strpos($statement, '?', $a + strlen($arg));
162:         }
163:         return $statement;
164:     }
165: 
166: 
167:     /**
168:      * Returns a PHP representation of a object member.
169:      * @return string
170:      */
171:     public static function formatMember($name)
172:     {
173:         return $name instanceof PhpLiteral || !self::isIdentifier($name)
174:             ? '{' . self::_dump($name) . '}'
175:             : $name ;
176:     }
177: 
178: 
179:     /**
180:      * @return bool
181:      */
182:     public static function isIdentifier($value)
183:     {
184:         return is_string($value) && preg_match('#^' . self::PHP_IDENT . '\z#', $value);
185:     }
186: 
187: 
188:     public static function createObject($class, array $props)
189:     {
190:         return unserialize('O' . substr(serialize((string) $class), 1, -1) . substr(serialize($props), 1));
191:     }
192: 
193: }
194: 
Nette 2.2.2 API API documentation generated by ApiGen 2.8.0