ini_set(): Headers already sent. You cannot change the session module's ini settings at this time search► skip error►

452:    
453:                } else {
454:                    if (session_status() === PHP_SESSION_ACTIVE) {
455:                        throw new Nette\InvalidStateException("Unable to set 'session.$key' to value '$value' when session has been started" . ($this->started ? '.' : ' by session.auto_start or session_start().'));
456:                    }
457:    
458:                    if (isset($special[$key])) {
459:                        ("session_$key")($value);
460:    
461:                    } elseif (function_exists('ini_set')) {
462:                        ini_set("session.$key", (string) $value);
463:    
464:                    } else {
465:                        throw new Nette\NotSupportedException("Unable to set 'session.$key' to '$value' because function ini_set() is disabled.");
466:                    }

'session.use_strict_mode'

'1'

 93:        {
 94:            if (session_status() === PHP_SESSION_ACTIVE) { // adapt an existing session
 95:                if (!$this->started) {
 96:                    $this->configure(self::SecurityOptions);
 97:                    $this->initialize();
 98:                }
 99:    
100:                return;
101:            }
102:    
103:            $this->configure(self::SecurityOptions + $this->options);
104:    
105:            if (!session_id()) { // session is started for first time
106:                $id = $this->request->getCookie(session_name());
107:                $id = is_string($id) && preg_match('#^[0-9a-zA-Z,-]{22,256}$#Di', $id)

78:            $this->options['cookie_secure'] = &$this->response->cookieSecure;
79:        }
80:    
81:    
82:        /**
83:         * Starts and initializes session data.
84:         * @throws Nette\InvalidStateException
85:         */
86:        public function start(): void
87:        {
88:            $this->doStart();
89:        }
90:    
91:    
92:        private function doStart($mustExists = false): void

30:        public function __construct($errorMessage)
31:        {
32:            parent::__construct();
33:            $this->setOmitted()
34:                ->setRequired()
35:                ->addRule(self::PROTECTION, $errorMessage);
36:    
37:            $this->monitor(Presenter::class, function (Presenter $presenter): void {
38:                if (!$this->session) {
39:                    $this->session = $presenter->getSession();
40:                    $this->session->start();
41:                }
42:            });
43:    
44:            $this->monitor(Nette\Forms\Form::class, function (Nette\Forms\Form $form): void {

256:                        }
257:                        $this->monitors[$type][3] = $rec[3]; // mark as monitored
258:                    }
259:                }
260:            }
261:    
262:            if ($depth === 0) { // call listeners
263:                $prev = [];
264:                foreach ($listeners as $item) {
265:                    if ($item[0] && !in_array($item, $prev, true)) {
266:                        $item[0]($item[1]);
267:                        $prev[] = $item;
268:                    }
269:                }
270:            }

182:                $this->parent = null;
183:    
184:            } else { // add to parent
185:                $this->validateParent($parent);
186:                $this->parent = $parent;
187:                if ($name !== null) {
188:                    $this->name = $name;
189:                }
190:    
191:                $tmp = [];
192:                $this->refreshMonitors(0, $tmp);
193:            }
194:            return $this;
195:        }
196:    

0

72:                        $tmp[$name] = $component;
73:                    }
74:                    $tmp[$k] = $v;
75:                }
76:                $this->components = $tmp;
77:            } else {
78:                $this->components[$name] = $component;
79:            }
80:    
81:            try {
82:                $component->setParent($this, $name);
83:            } catch (\Throwable $e) {
84:                unset($this->components[$name]); // undo
85:                throw $e;
86:            }

'loginForm'

114:            if (!isset($this->components[$name])) {
115:                if (!preg_match(self::NAME_REGEXP, $name)) {
116:                    if ($throw) {
117:                        throw new Nette\InvalidArgumentException("Component name must be non-empty alphanumeric string, '$name' given.");
118:                    }
119:                    return null;
120:                }
121:    
122:                $component = $this->createComponent($name);
123:                if ($component && !isset($this->components[$name])) {
124:                    $this->addComponent($component, $name);
125:                }
126:            }
127:    
128:            $component = $this->components[$name] ?? null;

'loginForm'

30:    
31:    
32:        /**
33:         * Returns component specified by name. Throws exception if component doesn't exist.
34:         * @param  string|int  $name
35:         * @throws Nette\InvalidArgumentException
36:         */
37:        public function offsetGet($name): IComponent
38:        {
39:            $name = is_int($name) ? (string) $name : $name;
40:            return $this->getComponent($name);
41:        }
42:    
43:    
44:        /**

'loginForm'

303:    
304:            if (!$block) {
305:                $hint = ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
306:                    ? ", did you mean '$t'?"
307:                    : '.';
308:                $name = $layer ? "$layer $name" : $name;
309:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
310:            }
311:    
312:            $this->filter(
313:                function () use ($block, $params): void { reset($block->functions)($params); },
314:                $mod,
315:                $block->contentType,
316:                "block $name"
317:            );

null

358:            $block->functions = array_merge($block->functions, $functions);
359:        }
360:    
361:    
362:        /**
363:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
364:         */
365:        private function filter(callable $function, $mod, string $contentType, string $name): void
366:        {
367:            if ($mod === null || $mod === $contentType) {
368:                $function();
369:    
370:            } elseif ($mod instanceof \Closure) {
371:                echo $mod($this->capture($function), $contentType);
372:    

306:                    ? ", did you mean '$t'?"
307:                    : '.';
308:                $name = $layer ? "$layer $name" : $name;
309:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
310:            }
311:    
312:            $this->filter(
313:                function () use ($block, $params): void { reset($block->functions)($params); },
314:                $mod,
315:                $block->contentType,
316:                "block $name"
317:            );
318:        }
319:    
320:    

'html'

'html'

'block content'

165:        /**
166:         * Renders template.
167:         * @internal
168:         */
169:        public function render(?string $block = null): void
170:        {
171:            $level = ob_get_level();
172:            try {
173:                $this->prepare();
174:                if (!$this->doRender($block)) {
175:                    $this->main();
176:                }
177:    
178:            } catch (\Throwable $e) {
179:                while (ob_get_level() > $level) {

197:    
198:            if ($this->referenceType === 'import') {
199:                if ($this->parentName) {
200:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
201:                }
202:    
203:            } elseif ($this->parentName) { // extends
204:                ob_start(function () {});
205:                $this->params = $this->main();
206:                ob_end_clean();
207:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
208:    
209:            } elseif ($block !== null) { // single block rendering
210:                $this->renderBlock($block, $this->params);
211:    

null

164:    
165:        /**
166:         * Renders template.
167:         * @internal
168:         */
169:        public function render(?string $block = null): void
170:        {
171:            $level = ob_get_level();
172:            try {
173:                $this->prepare();
174:                if (!$this->doRender($block)) {
175:                    $this->main();
176:                }
177:    
178:            } catch (\Throwable $e) {

null

 92:    
 93:        /**
 94:         * Renders template to output.
 95:         * @param  object|mixed[]  $params
 96:         */
 97:        public function render(string $name, $params = [], ?string $block = null): void
 98:        {
 99:            $template = $this->createTemplate($name, $this->processParams($params));
100:            $template->global->coreCaptured = false;
101:            ($this->probe)($template);
102:            $template->render($block);
103:        }
104:    
105:    
106:        /**

null

36:            return $this->latte;
37:        }
38:    
39:    
40:        /**
41:         * Renders template to output.
42:         */
43:        public function render(?string $file = null, array $params = []): void
44:        {
45:            Nette\Utils\Arrays::toObject($params, $this);
46:            $this->latte->render($file ?: $this->file, $this);
47:        }
48:    
49:    
50:        /**

'/var/www/zakaznik/app/templates/Login/auth.latte'

40:            return $this->source;
41:        }
42:    
43:    
44:        /**
45:         * Sends response to output.
46:         */
47:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
48:        {
49:            if ($this->source instanceof Nette\Application\UI\Template) {
50:                $this->source->render();
51:    
52:            } else {
53:                echo $this->source;
54:            }

161:    
162:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
163:            $response = $this->presenter->run(clone $request);
164:    
165:            if ($response instanceof Responses\ForwardResponse) {
166:                $request = $response->getRequest();
167:                goto process;
168:            }
169:    
170:            Arrays::invoke($this->onResponse, $this, $response);
171:            $response->send($this->httpRequest, $this->httpResponse);
172:        }
173:    
174:    
175:        public function processException(\Throwable $e): void

80:        }
81:    
82:    
83:        /**
84:         * Dispatch a HTTP request to a front controller.
85:         */
86:        public function run(): void
87:        {
88:            try {
89:                Arrays::invoke($this->onStartup, $this);
90:                $this->processRequest($this->createInitialRequest());
91:                Arrays::invoke($this->onShutdown, $this);
92:    
93:            } catch (\Throwable $e) {
94:                Arrays::invoke($this->onError, $this, $e);

1:    <?php
2:    
3:    $container = require __DIR__ . '/../app/bootstrap.php';
4:    
5:    $container->getByType(Nette\Application\Application::class)
6:        ->run();
7: