Unexpected '"', expecting end of HTML tag (in '.../Articles/2009-07-23.latte' on line 39 at column 213) search►

67:    
68:        /**
69:         * Consumes the current token (if is of given kind) or throws exception on end.
70:         * @throws CompileException
71:         */
72:        public function consume(int|string ...$kind): Token
73:        {
74:            $token = $this->peek();
75:            if ($kind && !$token->is(...$kind)) {
76:                $kind = array_map(fn($item) => is_string($item) ? "'$item'" : Token::Names[$item], $kind);
77:                $this->throwUnexpectedException($kind);
78:            } elseif (!$token->isEnd()) {
79:                $this->index++;
80:            }
81:            return $token;

214:            );
215:            $this->elementData[$elem] = (object) [
216:                'tag' => $this->parser->peekTag(),
217:                'textualName' => $textual,
218:            ];
219:            $elem->attributes = $this->parser->parseFragment($this->inTagResolve(...));
220:            $elem->selfClosing = (bool) $stream->tryConsume(Token::Slash);
221:            if ($variable) {
222:                $elem->dynamicTag = new Nodes\Html\TagNode($elem, $variable);
223:            }
224:            $stream->consume(Token::Html_TagClose);
225:            $lexer->popState();
226:            return $elem;
227:        }
228:    

10021

105:                $stream->throwUnexpectedException(excerpt: '/');
106:            }
107:            return $this->parseBogusEndTag();
108:        }
109:    
110:    
111:        private function parseElement(): Node
112:        {
113:            $res = new FragmentNode;
114:            $res->append($this->extractIndentation());
115:            $res->append($this->parseStartTag($this->element));
116:            $elem = $this->element;
117:    
118:            $stream = $this->parser->getStream();
119:            $void = $this->resolveVoidness($elem);

77:    
78:    
79:        private function parseTag(): ?Node
80:        {
81:            $stream = $this->parser->getStream();
82:            $lexer = $this->parser->getLexer();
83:            $lexer->pushState(TemplateLexer::StateHtmlTag);
84:            $closing = $stream->tryPeek(1)?->is(Token::Slash);
85:            $lexer->popState();
86:            if (!$closing) {
87:                return $this->parseElement();
88:            }
89:    
90:            if ($this->element
91:                && $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element

45:        {
46:            return $this->element;
47:        }
48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };

 92:         * @param  \Closure(FragmentNode): ?Node  $resolver
 93:         * @param  ?(\Closure(FragmentNode): void)  $after
 94:         */
 95:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
 96:        {
 97:            $res = new FragmentNode;
 98:            $save = [$this->lastResolver, $this->tag];
 99:            $this->lastResolver = $resolver;
100:            try {
101:                while (!$this->stream->peek()->isEnd()) {
102:                    if ($node = $resolver($res)) {
103:                        assert($node instanceof Nodes\AreaNode);
104:                        $res->append($node);
105:                        $after && $after($res);
106:                    } else {

128:                if ($elem->isRawText()) {
129:                    $this->parser->getLexer()->pushState(TemplateLexer::StateHtmlRawText, $elem->name);
130:                }
131:                $content = new FragmentNode;
132:                if ($token = $stream->tryConsume(Token::Newline)) {
133:                    $content->append(new Nodes\TextNode($token->text, $token->position));
134:                }
135:    
136:                $innerNodes = $this->openNAttrNodes($attrs[Tag::PrefixInner] ?? []);
137:                $this->elementData[$elem]->tag = $this->parser->peekTag();
138:                $frag = $this->parser->parseFragment($this->inTextResolve(...));
139:                $content->append($this->finishNAttrNodes($frag, $innerNodes));
140:                if ($elem->isRawText()) {
141:                    $this->parser->getLexer()->popState();
142:                }

77:    
78:    
79:        private function parseTag(): ?Node
80:        {
81:            $stream = $this->parser->getStream();
82:            $lexer = $this->parser->getLexer();
83:            $lexer->pushState(TemplateLexer::StateHtmlTag);
84:            $closing = $stream->tryPeek(1)?->is(Token::Slash);
85:            $lexer->popState();
86:            if (!$closing) {
87:                return $this->parseElement();
88:            }
89:    
90:            if ($this->element
91:                && $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element

45:        {
46:            return $this->element;
47:        }
48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };

 92:         * @param  \Closure(FragmentNode): ?Node  $resolver
 93:         * @param  ?(\Closure(FragmentNode): void)  $after
 94:         */
 95:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
 96:        {
 97:            $res = new FragmentNode;
 98:            $save = [$this->lastResolver, $this->tag];
 99:            $this->lastResolver = $resolver;
100:            try {
101:                while (!$this->stream->peek()->isEnd()) {
102:                    if ($node = $resolver($res)) {
103:                        assert($node instanceof Nodes\AreaNode);
104:                        $res->append($node);
105:                        $after && $after($res);
106:                    } else {

205:                $this->ensureIsConsumed($startTag);
206:                if ($startTag->outputMode === $startTag::OutputKeepIndentation) {
207:                    $this->lastIndentation = null;
208:                }
209:    
210:                if ($startTag->void) {
211:                    $res->send([new FragmentNode, $startTag]);
212:                } else {
213:                    while ($res->valid()) {
214:                        $this->lookFor[$startTag] = $res->current() ?: null;
215:                        $content = $this->parseFragment($resolver ?? $this->lastResolver);
216:                        if ($this->dedent) {
217:                            $this->applyDedent($content);
218:                        }
219:    

118:        /**
119:         * Resolves the next node in plain text context (text, indentation, Latte tag, or comment).
120:         */
121:        public function inTextResolve(): ?Node
122:        {
123:            $token = $this->stream->peek();
124:            return match ($token->type) {
125:                Token::Text => $this->parseText(),
126:                Token::Indentation => $this->parseIndentation(),
127:                Token::Newline => $this->parseNewline(),
128:                Token::Latte_TagOpen => $this->parseLatteStatement(),
129:                Token::Latte_CommentOpen => $this->parseLatteComment(),
130:                default => null,
131:            };
132:        }

48:    
49:    
50:        public function inTextResolve(): ?Node
51:        {
52:            $stream = $this->parser->getStream();
53:            $token = $stream->peek();
54:            return match ($token->type) {
55:                Token::Html_TagOpen => $this->parseTag(),
56:                Token::Html_CommentOpen => $this->parseComment(),
57:                Token::Html_BogusOpen => $this->parseBogusTag(),
58:                default => $this->parser->inTextResolve(),
59:            };
60:        }
61:    
62:    

 92:         * @param  \Closure(FragmentNode): ?Node  $resolver
 93:         * @param  ?(\Closure(FragmentNode): void)  $after
 94:         */
 95:        public function parseFragment(\Closure $resolver, ?\Closure $after = null): FragmentNode
 96:        {
 97:            $res = new FragmentNode;
 98:            $save = [$this->lastResolver, $this->tag];
 99:            $this->lastResolver = $resolver;
100:            try {
101:                while (!$this->stream->peek()->isEnd()) {
102:                    if ($node = $resolver($res)) {
103:                        assert($node instanceof Nodes\AreaNode);
104:                        $res->append($node);
105:                        $after && $after($res);
106:                    } else {

69:            $this->lookFor = new \WeakMap;
70:    
71:            $headLength = 0;
72:            $findLength = function (FragmentNode $fragment) use (&$headLength) {
73:                if ($this->inHead && !end($fragment->children) instanceof Nodes\TextNode) {
74:                    $headLength = count($fragment->children);
75:                }
76:            };
77:    
78:            $node = new Nodes\TemplateNode;
79:            $node->main = $this->parseFragment($this->html->inTextResolve(...), $findLength);
80:            $node->head = new FragmentNode(array_splice($node->main->children, 0, $headLength));
81:            $node->contentType = $this->contentType;
82:    
83:            if (!$this->stream->peek()->isEnd()) {

161:            $parser->dedent = $this->hasFeature(Feature::Dedent);
162:    
163:            foreach ($this->extensions as $extension) {
164:                $extension->beforeCompile($this);
165:                $parser->addTags($extension->getTags());
166:            }
167:    
168:            return $parser
169:                ->setContentType($this->contentType)
170:                ->setPolicy($this->getPolicy(effective: true))
171:                ->parse($template);
172:        }
173:    
174:    
175:        /**

123:         */
124:        public function compile(string $name): string
125:        {
126:            if ($this->sandboxed && !$this->policy) {
127:                throw new \LogicException('In sandboxed mode you need to set a security policy.');
128:            }
129:    
130:            $template = $this->getLoader()->getContent($name);
131:    
132:            try {
133:                $node = $this->parse($template);
134:                $this->applyPasses($node);
135:                $compiled = $this->generate($node, $name);
136:    
137:            } catch (\Throwable $e) {

50:    
51:            if ($lock) {
52:                flock($lock, LOCK_UN); // release shared lock so we can get exclusive
53:                fseek($lock, 0);
54:            }
55:    
56:            $lock = $this->acquireLock("$file.lock", LOCK_EX);
57:    
58:            // while waiting for exclusive lock, someone might have already created the cache
59:            if (!is_file($file) || ($signature && $signature !== stream_get_contents($lock))) {
60:                $compiled = $engine->compile($name);
61:                if (
62:                    file_put_contents("$file.tmp", $compiled) !== strlen($compiled)
63:                    || !rename("$file.tmp", $file)
64:                ) {

'/data/www/www.24usoftware.com/app/presenters/templates/Press/Articles/2009-07-23.latte'

215:        }
216:    
217:    
218:        /** @return class-string<Runtime\Template> */
219:        private function loadTemplate(string $name): string
220:        {
221:            $class = $this->getTemplateClass($name);
222:            if (class_exists($class, autoload: false)) {
223:                // nothing
224:            } elseif ($this->cache->directory) {
225:                $this->cache->loadOrCreate($this, $name);
226:            } else {
227:                $compiled = $this->compile($name);
228:                if (@eval(substr($compiled, 5)) === false) { // @ is escalated to exception, substr removes <?php
229:                    throw (new CompileException('Error in template: ' . (error_get_last()['message'] ?? '')))

'/data/www/www.24usoftware.com/app/presenters/templates/Press/Articles/2009-07-23.latte'

 99:        }
100:    
101:    
102:        /**
103:         * Creates template object.
104:         * @param  mixed[]  $params
105:         */
106:        public function createTemplate(string $name, array $params = [], bool $clearCache = true): Runtime\Template
107:        {
108:            $this->configurationHash = $clearCache ? null : $this->configurationHash;
109:            $class = $this->loadTemplate($name);
110:            $this->providers->fn = $this->functions;
111:            return new $class(
112:                $this,
113:                $params,

'/data/www/www.24usoftware.com/app/presenters/templates/Press/Articles/2009-07-23.latte'

160:        /**
161:         * Renders template.
162:         * @param  mixed[]  $params
163:         * @internal
164:         */
165:        public function createTemplate(string $name, array $params, string $relation): self
166:        {
167:            $name = $this->engine->getLoader()->getReferredName($name, $this->name);
168:            $child = $relation === 'sandbox'
169:                ? (clone $this->engine)->setSandboxMode()->createTemplate($name, $params)
170:                : $this->engine->createTemplate($name, $params, clearCache: false);
171:    
172:            $child->referringTemplate = $this;
173:            $child->referenceType = $relation;
174:            $child->global = $this->global;

'/data/www/www.24usoftware.com/app/presenters/templates/Press/Articles/2009-07-23.latte'

false

111:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
112:                    ? ", did you mean '$t'?"
113:                    : '.';
114:                $name = $layer ? "$layer $name" : $name;
115:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
116:            }
117:    
118:            $fn = reset($block->functions);
119:            assert($fn !== false);
120:            $this->filter(
121:                fn() => $fn($params),
122:                $mod,
123:                $block->contentType ?? static::ContentType,
124:                "block $name",
125:            );

null

187:            return $child;
188:        }
189:    
190:    
191:        /**
192:         * @param  string|\Closure|null  $targetType  content-type name or modifier closure
193:         */
194:        private function filter(callable $producer, string|\Closure|null $targetType, string $contentType, string $name): void
195:        {
196:            if ($targetType === null || $targetType === $contentType) {
197:                $producer();
198:    
199:            } elseif ($targetType instanceof \Closure) {
200:                echo $targetType($this->capture($producer), $contentType);
201:    

110:            if (!$block) {
111:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
112:                    ? ", did you mean '$t'?"
113:                    : '.';
114:                $name = $layer ? "$layer $name" : $name;
115:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
116:            }
117:    
118:            $fn = reset($block->functions);
119:            assert($fn !== false);
120:            $this->filter(
121:                fn() => $fn($params),
122:                $mod,
123:                $block->contentType ?? static::ContentType,
124:                "block $name",

'html'

'html'

'block content'

78:                }
79:    
80:            } elseif ($this->parentName) { // extends
81:                $this->params = $params;
82:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
83:    
84:            } elseif ($block !== null) { // single block rendering
85:                $this->renderBlock($block, $this->params);
86:    
87:            } else {
88:                $this->main($params);
89:            }
90:        }
91:    
92:    

null

72:                $this->parentName = ($this->global->coreParentFinder)($this);
73:            }
74:    
75:            if ($this->referenceType === 'import') {
76:                if ($this->parentName) {
77:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
78:                }
79:    
80:            } elseif ($this->parentName) { // extends
81:                $this->params = $params;
82:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
83:    
84:            } elseif ($block !== null) { // single block rendering
85:                $this->renderBlock($block, $this->params);
86:    

null

76:    
77:    
78:        /**
79:         * Renders template to output.
80:         * @param  object|mixed[]  $params
81:         */
82:        public function render(string $name, object|array $params = [], ?string $block = null): void
83:        {
84:            $template = $this->createTemplate($name, Helpers::resolveParams($this, $params));
85:            $template->global->coreCaptured = false;
86:            $template->render($block);
87:        }
88:    
89:    
90:        /**

null

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

'/data/www/www.24usoftware.com/app/presenters/templates/Press/detail.latte'

31:            return $this->source;
32:        }
33:    
34:    
35:        /**
36:         * Sends response to output.
37:         */
38:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
39:        {
40:            if ($this->source instanceof Nette\Application\UI\Template) {
41:                $this->source->render();
42:    
43:            } else {
44:                echo $this->source;
45:            }

149:    
150:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
151:            $response = $this->presenter->run(clone $request);
152:    
153:            if ($response instanceof Responses\ForwardResponse) {
154:                $request = $response->getRequest();
155:                goto process;
156:            }
157:    
158:            Arrays::invoke($this->onResponse, $this, $response);
159:            $response->send($this->httpRequest, $this->httpResponse);
160:        }
161:    
162:    
163:        public function createErrorRequest(\Throwable $e): ?Request

67:        }
68:    
69:    
70:        /**
71:         * Dispatch a HTTP request to a front controller.
72:         */
73:        public function run(): void
74:        {
75:            try {
76:                Arrays::invoke($this->onStartup, $this);
77:                $this->processRequest($this->createInitialRequest());
78:                Arrays::invoke($this->onShutdown, $this);
79:    
80:            } catch (\Throwable $e) {
81:                $this->sendHttpCode($e);

1460:        $new[$number["code"]] = $number["dial_code"] . " (".$number['code'].")";
1461:    }
1462:    var_dump(json_encode($new));
1463:    exit();
1464:    
1465:    exit(); */
1466:    
1467:    $container = require __DIR__ . '/../app/bootstrap.php';
1468:    
1469:    $container->getByType(Nette\Application\Application::class)
1470:        ->run();