├── .gitattributes
├── .travis.yml
├── .gitignore
├── composer.json
├── LICENSE
├── symbolclass.php
├── CHANGELOG.md
├── README.md
├── DOCUMENTATION.md
├── test.php
└── qevix.php


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | # list any PHP version you want to test against
 4 | php:
 5 |   - 5.4
 6 |   - 5.5
 7 |   - 5.6
 8 |   - 7.0
 9 |   - hhvm
10 | 
11 | script: phpunit test
12 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Build results
 2 | bin/
 3 | pkg/
 4 | 
 5 | #Bat
 6 | *.bat
 7 | 
 8 | # Log
 9 | *.log
10 | 
11 | # Windows image file caches
12 | Thumbs.db
13 | 
14 | # Folder config file
15 | Desktop.ini
16 | 
17 | # Mac crap
18 | .DS_Store
19 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "qevix/qevix",
 3 | 	"description": "Automatic filter HTML/XHTML",
 4 | 	"keywords": ["qevix", "html", "xhtml"],
 5 | 	"homepage": "https://github.com/AlexanderGrom/php-qevix",
 6 | 	"type": "library",
 7 | 	"license": "MIT",
 8 | 	"require": {
 9 | 		"php": ">=5.0.0",
10 | 		"ext-mbstring": "*"
11 | 	},
12 | 	"autoload": {
13 | 		"classmap": ["qevix.php"]
14 |   	}
15 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | The MIT License (MIT)
 3 | 
 4 | Copyright (c) 2014 Alexander Gromov <grom@dighub.ru >
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/symbolclass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Генератор классов символов символов для Qevix
 4 |  */
 5 | 
 6 | require 'qevix.php';
 7 | 
 8 | function addChClass(&$table, $chars, $class) {
 9 | 	foreach($chars as $ch) {
10 | 		$ord = Qevix::ord($ch);
11 | 		$table[$ord] = (isset($table[$ord]) ? $table[$ord] : 0) | $class;
12 | 	}
13 | }
14 | 
15 | function addChRangeClass(&$table, $from, $to, $class) {
16 | 	for($i = $from; $i <= $to; $i++) {
17 | 		$table[$i] = (isset($table[$i]) ? $table[$i] : 0) | $class;
18 | 	}
19 | }
20 | 
21 | $table = array();
22 | 
23 | addChRangeClass($table, 0, 0x20, Qevix::NOPRINT);
24 | addChRangeClass($table, Qevix::ord('a'), Qevix::ord('z'), Qevix::ALPHA | Qevix::PRINATABLE | Qevix::TAG_NAME | Qevix::TAG_PARAM_NAME);
25 | addChRangeClass($table, Qevix::ord('A'), Qevix::ord('Z'), Qevix::ALPHA |  Qevix::PRINATABLE | Qevix::TAG_NAME | Qevix::TAG_PARAM_NAME);
26 | addChRangeClass($table, Qevix::ord('0'), Qevix::ord('9'), Qevix::NUMERIC | Qevix::PRINATABLE | Qevix::TAG_NAME | Qevix::TAG_PARAM_NAME);
27 | 
28 | addChClass($table, array('-'), Qevix::TAG_PARAM_NAME | Qevix::PRINATABLE);
29 | 
30 | addChClass($table, array(' ', "\t"), Qevix::SPACE);
31 | addChClass($table, array("\r", "\n"), Qevix::NL);
32 | addChClass($table, array('"'), Qevix::TAG_QUOTE | Qevix::TEXT_QUOTE | Qevix::PRINATABLE);
33 | addChClass($table, array("'"), Qevix::TAG_QUOTE | Qevix::PRINATABLE);
34 | addChClass($table, array('.', ',', '!', '?', ':', ';'), Qevix::PUNCTUATUON | Qevix::PRINATABLE);
35 | 
36 | addChClass($table, array('<', '>', '[', ']', '{', '}', '(', ')'),  Qevix::TEXT_BRACKET | Qevix::PRINATABLE);
37 | 
38 | addChClass($table, array('@', '#', '$'),  Qevix::SPECIAL_CHAR | Qevix::PRINATABLE);
39 | 
40 | ob_start();
41 | var_export($table);
42 | $res = ob_get_clean();
43 | echo str_replace(array("\n", ' '), '', $res).';';
44 | ?>
45 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | ### v0.4.3 — [19.11.2016]
 2 | * Исправлена ошибка с указанием атрибутов без значения.
 3 | * Добавлен шаблон #bool, для валидного отображения атрибутов без значения.
 4 | 
 5 | ### v0.4 — [15.01.2016]
 6 | * Добавлено новое правило задания шаблона #link. Шаблон может быть указана ввиде строки или ввиде массива с указанием разрешенных доменов. Например, `'src' => array('#link' => ['youtube.com', 'vimeo.com'])`
 7 | 
 8 | ### v0.3.1 — [15.09.2015]
 9 | * В классы символов добавлен символ дефиса для имен атрибутов тега. Другими словами имена атрибутов теперь могут быть с дефисом.
10 | * Добавлен механизм чистки пробельных символов и символов перевода строки после удаленных парсером тегов
11 | 
12 | ### v0.3 — [07.09.2015]
13 | * New
14 |   * Новый конфиг cfgSetEOL($nl), позволяет задать символ/символы перевода строки для текста на выходе. По умолчанию в Qevix используется только символ перевода строки (LF) "\n", теперь можно задать (CR+LF) "\r\n".
15 |   * Новый шаблон #regexp(...) для значений параметров тега. Позволяет сверять значение параметра с регулярным выражением. Например, "#regexp(\d+(%|px))".
16 | * Bug Fixes
17 |   * Исправлена ошибка в определение чисел шаблона #int
18 | * Other
19 |   * Чистка и мелкие исправления
20 | 
21 | ### v0.2.3 — [01.07.2015]
22 | * XHTML ShortTag Fix
23 |   * Поправлено распознавание коротких тегов в стиле XHTML
24 | * AutoLink Fix
25 |   * Поправлено распознавание текстовой ссылки обернутой тегом
26 | * Other BugFixes
27 |   * Поправлена печать "бесхозной" открывающей угловой скобки "<"
28 | 
29 | ### v0.2.2 — [23.03.2015]
30 | * Добавлен Composer
31 | 
32 | ### v0.2.1 — [22.01.2015]
33 | * Улучшена производительность
34 |   * Замена методов ord и chr основанных на mb_* функциях на их более быстрые эквиваленты
35 | 
36 | ### v0.2 — [20.01.2015]
37 | * AutoLink Fix
38 |   * Теперь распознаются ссылки заключенные в двойные кавычки
39 |   * Старается полностью распазнать ссылки с параметрами оформленными в виде массива (?param[0]=nil&param[1]=one)
40 | 
41 | ### v0.1 — [02.12.2014]
42 | * Первый публичный выпуск
43 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | ## Qevix  [![Build Status](https://travis-ci.org/AlexanderGrom/php-qevix.svg?branch=master)](https://travis-ci.org/AlexanderGrom/php-qevix)
  3 | 
  4 | **Qevix** — Jevix-подобный автоматический фильтр HTML/XHTML разметки в текстах.
  5 | Применяя наборы правил, контролирует перечень допустимых тегов и атрибутов, предотвращает возможные XSS-атаки.
  6 | 
  7 | Qevix основывается на идеях и исходном коде [PHP версии Jevix](https://github.com/ur001/Jevix/).
  8 | Фильтр полностью переписан, устраняет ряд ошибок и недоработок, а также вводит новые возможности в правила фильтрации.
  9 | 
 10 | ### Возможности
 11 | 
 12 | * Фильтрация текста с HTML/XHTML разметкой на основе заданных правил о разрешённых тегах и атрибутах;
 13 | * Исправление ошибок HTML/XHTML;
 14 | * Обработка строк предваренных специальными символами (#tagname, @username, $keyword);
 15 | * Установка на теги callback-функций для изменения или сбора информации;
 16 | * Предотвращение XSS-атак;
 17 | 
 18 | ### Требования
 19 | 
 20 | * PHP >= 5.0
 21 | * php-mbstring
 22 | * UTF-8
 23 | 
 24 | ### Пример использования
 25 | 
 26 | ```php
 27 | require('qevix.php');
 28 | 
 29 | $qevix = new Qevix();
 30 | 
 31 | // Конфигурация
 32 | 
 33 | // 1. Задает список разрешенных тегов
 34 | $qevix->cfgAllowTags(array('b', 'i', 'u', 'a', 'img', 'ul', 'li', 'ol', 'br', 'code', 'pre', 'div', 'cut'));
 35 | 
 36 | // 2. Указывает, какие теги считать короткими (<br>, <img>)
 37 | $qevix->cfgSetTagShort(array('br','img','cut'));
 38 | 
 39 | // 3. Указывает преформатированные теги, в которых нужно всё заменять на HTML сущности
 40 | $qevix->cfgSetTagPreformatted(array('code'));
 41 | 
 42 | // 4. Указывает не короткие теги, которые могут быть пустыми и их не нужно из-за этого удалять
 43 | $qevix->cfgSetTagIsEmpty(array('div'));
 44 | 
 45 | // 5. Указывает теги, внутри которых не нужна авто-расстановка тегов перевода на новую строку
 46 | $qevix->cfgSetTagNoAutoBr(array('ul', 'ol'));
 47 | 
 48 | // 6. Указывает теги, которые необходимо вырезать вместе с содержимым
 49 | $qevix->cfgSetTagCutWithContent(array('script', 'object', 'iframe', 'style'));
 50 | 
 51 | // 7. Указывает теги, после которых не нужно добавлять дополнительный перевод строки. Например, блочные теги
 52 | $qevix->cfgSetTagBlockType(array('ol','ul','code'));
 53 | 
 54 | // 8. Добавляет разрешенные параметры для тегов. Значение по умолчанию - шаблон #text. Разрешенные шаблоны #text, #int, #link, #regexp(...) (Например: "#regexp(\d+(%|px))")
 55 | $qevix->cfgAllowTagParams('a', array('title', 'href' => '#link', 'rel' => '#text', 'target' => array('_blank'), 'download' => '#bool'));
 56 | $qevix->cfgAllowTagParams('img', array('src' => '#text', 'alt' => '#text', 'title', 'align' => array('right', 'left', 'center'), 'width' => '#int', 'height' => '#int'));
 57 | 
 58 | // 9. Добавляет обязательные параметры для тега
 59 | $qevix->cfgSetTagParamsRequired('img', 'src');
 60 | $qevix->cfgSetTagParamsRequired('a', 'href');
 61 | 
 62 | // 10. Указывает, какие теги являются контейнерами для других тегов
 63 | $qevix->cfgSetTagChilds('ul', 'li', true, true);
 64 | $qevix->cfgSetTagChilds('ol', 'li', true, true);
 65 | 
 66 | // 11. Указывает, какие теги не должны быть дочерними к другим тегам
 67 | $qevix->cfgSetTagGlobal('cut');
 68 | 
 69 | // 12. Устанавливаем атрибуты тегов, которые будут добавляться автоматически
 70 | $qevix->cfgSetTagParamDefault('a', 'rel', 'nofollow', true);
 71 | $qevix->cfgSetTagParamDefault('img', 'alt', '');
 72 | 
 73 | // 13. Указывает теги, в которых нужно отключить типографирование текста
 74 | $qevix->cfgSetTagNoTypography(array('code', 'pre'));
 75 | 
 76 | // 14. Устанавливает список разрешенных протоколов для ссылок (https, http, ftp)
 77 | $qevix->cfgSetLinkProtocolAllow(array('http','https'));
 78 | 
 79 | // 15. Включает или выключает режим XHTML
 80 | $qevix->cfgSetXHTMLMode(false);
 81 | 
 82 | // 16. Включает или выключает режим автозамены символов переводов строк на тег br
 83 | $qevix->cfgSetAutoBrMode(true);
 84 | 
 85 | // 17. Включает или выключает режим автоматического определения ссылок
 86 | $qevix->cfgSetAutoLinkMode(true);
 87 | 
 88 | // 18. Задает символ/символы перевода строки. По умполчанию "\n". Разрешено "\n" или "\r\n"
 89 | $qevix->cfgSetEOL("\n");
 90 | 
 91 | // 19. Устанавливает на тег callback-функцию
 92 | $qevix->cfgSetTagBuildCallback('code', 'tag_code_build');
 93 | 
 94 | // 20. Устанавливает на строку предворенную спецсимволом (@|#|$) callback-функцию
 95 | $qevix->cfgSetSpecialCharCallback('#', 'tag_sharp_build');
 96 | $qevix->cfgSetSpecialCharCallback('@', 'tag_at_build');
 97 | 
 98 | // 21. Устанавливает на тег callback-функцию, которая сохраняет URL изображений для meta-описания
 99 | $qevix->cfgSetTagEventCallback('img', 'tag_img_event');
100 | 
101 | //-----
102 | 
103 | function tag_code_build($tag, $params, $content)
104 | {
105 | 	return '<pre><code>'.$content.'<code><pre>'."\n";
106 | }
107 | 
108 | //-----
109 | 
110 | $meta_img_src = array();
111 | 
112 | function tag_img_event($tag, $params, $content)
113 | {
114 | 	global $meta_img_src;
115 | 
116 | 	$meta_img_src[] = $params['src'];
117 | }
118 | 
119 | //-----
120 | 
121 | function tag_sharp_build($string)
122 | {
123 | 	if(!preg_match('#^[\w\_\-\ ]{1,32}$#isu', $string)) {
124 | 		return false;
125 | 	}
126 | 
127 | 	return '<a href="/tag/'.rawurlencode($string).'/">#'.$string.'</a>';
128 | }
129 | 
130 | //-----
131 | 
132 | function tag_at_build($string)
133 | {
134 | 	if(!preg_match('#^[\w\_\-\ ]{1,32}$#isu', $string)) {
135 | 		return false;
136 | 	}
137 | 
138 | 	return '<a href="/user/'.$string.'/">@'.$string.'</a>';
139 | }
140 | 
141 | //-----
142 | 
143 | //Фильтр
144 | 
145 | $text = <<<EOD
146 | Привет я <b>Qevix</b> и я много чего могу...
147 | <!-- Могу удалить тег <h1>, впрочем, как и этот комментарий -->
148 | <h1>Этого тега нет в разрешенных</h1>
149 | 
150 | <!-- Это пустой тег, его тоже не должно быть, хотя <div> мог бы быть -->
151 | <p></p>
152 | <div></div>
153 | 
154 | Отмечать метки #qevix, #php, #[mysql], #{mariaDB}, #[два слова].
155 | Людей @Alexander @Андрей @[Илья Андреевич Ростов]
156 | 
157 | (Вы можете запретить определение меток из нескольких слов, просто проверяя это в callback функции)
158 | 
159 | Работать с разными тегами <s>Но не с этим ... <u>зачеркивать нельзя</u></s>,
160 | <script type="text/javascript">alert('И скрипты писать нельзя')</script>
161 | Так же я запрещаю iframe, style и object... но это согласно текущим правилам.
162 | 
163 | А такие теги сейчас разрешены: <b>Куда же без выделения жирным</b> или <i>курсива</i>...
164 | <b>И <b>вложенность</b> не помеха</b>
165 | 
166 | Могу выделить код используя callback функцию:
167 | 
168 | <code>
169 | 	<body>
170 | 		<b>JavaScript:</b>
171 | 		<script>alert('Hello World')</script>
172 | 	</body>
173 | </code>
174 | 
175 | Могу подсвечивать ссылки так https://github.com или так www.yandex.ru или в скобках (http://webonrails.ru)!
176 | Могу найти ссылку в теге <b>http://webonrails.ru</b>.
177 | Или ссылка может быть более сложной http://yandex.ru/yandsearch?lr=2&text=qevix!..
178 | А также традиционная <a href="https://ru.wikipedia.org">Википедия</a>
179 | Но только не опасная <a href="javascript:alert('Hi!')" title="Нажми на меня">Hello World!</a>
180 | И без ненужных атрибутов <a href="https://github.com" name="top" hreflang="ru">GitHub</a>
181 | Или вот такая <a href=http://php.net title = text target=_blank>Я могу определить атрибуты без кавычек!</a>
182 | 
183 | Использовать изображения <img src="http://php.net/images/news/phpday2012.png" alt="Image">
184 | 
185 | Могу менять "кавычки" на елочки и "соблюдать "вложенность" кавычек"...
186 | 
187 | Использовать преформатирование <pre>Могу менять "кавычки" на елочки и "соблюдать "вложенность" кавычек"</pre>
188 | 
189 | Убирать такой код:
190 | <li>Пункт 1</li>
191 | <li>Пункт 2</li>
192 | 
193 | И оставлять такой:
194 | 
195 | <ul>
196 |   <li>Пункт 1</li>
197 |   <li>Пункт 2</li>
198 | </ul>
199 | 
200 | Могу удалить это верхний перевод строки, что бы текст под блочными элементами нормально отображался.
201 | 
202 | Преобразовывать коды символов &#40; &#41; &#42; &#43; &#44; обратно в символы.
203 | 
204 | Преобразовывать в тексте короткое тире - в длинное, но не в таком (2-2=0) и не в таком (веб-программирование)
205 | Зато могу работать с пунктами (диалогами):
206 | - Пункт 1
207 | - Пункт 2
208 | - Пункт 3
209 | 
210 | Могу делать правильный CUT: <b>Краткая часть</b> <cut> <b>Тег <cut> не может быть вложенным</b>
211 | 
212 | Могу    убирать    лишние пробелы и сам <b>закрывать <u>теги
213 | EOD;
214 | 
215 | $result = $qevix->parse($text, $errors);
216 | 
217 | echo $result;
218 | ```
219 | 
220 | ### Документация по конфигурации
221 | 
222 | * [DOCUMENTATION](DOCUMENTATION.md)
223 | 
224 | ### Поддержка
225 | 
226 | * **Александр Громов** - пишите в [Issues](https://github.com/AlexanderGrom/php-qevix/issues)
227 | 
228 | ------
229 | 
230 | Дайте мне знать, если вы нашли проблему в **Qevix** или вас не устраивает его работа.
231 | Спасибо!
232 | 


--------------------------------------------------------------------------------
/DOCUMENTATION.md:
--------------------------------------------------------------------------------
  1 | 
  2 | ## Документации по конфигурации
  3 | 
  4 | ### cfgAllowTags
  5 | 
  6 | cfgAllowTags — Задает список разрешенных тегов
  7 | 
  8 | `cfgAllowTags($tags);`
  9 | 
 10 | **Параметры**
 11 | * $tags — (array|string) список разрешенных тегов
 12 | 
 13 | **Пример использования**
 14 | ```php
 15 | $qevix->cfgAllowTags(array('b', 'i', 'u', 'a', 'img', 'ul', 'li', 'ol', 'br', 'code'));
 16 | ```
 17 | 
 18 | ### cfgSetTagShort
 19 | 
 20 | cfgSetTagShort — Указывает какие теги считать короткими
 21 | 
 22 | `$qevix->cfgSetTagShort($tags)`
 23 | 
 24 | **Параметры**
 25 | * $tags — (array|string) тег(и)
 26 | 
 27 | **Пример использования**
 28 | ```php
 29 | $qevix->cfgSetTagShort(array('br','img'));
 30 | ```
 31 | 
 32 | ### cfgSetTagPreformatted
 33 | 
 34 | cfgSetTagPreformatted — Указывает преформатированные теги, в которых нужно всё заменять на HTML сущности
 35 | 
 36 | `$qevix->cfgSetTagPreformatted($tags)`
 37 | 
 38 | **Параметры**
 39 | * $tags — (array|string) тег(и)  
 40 | 
 41 | **Пример использования**
 42 | ```php
 43 | $qevix->cfgSetTagPreformatted(array('code'));
 44 | ```
 45 | 
 46 | ### cfgSetTagNoTypography
 47 | 
 48 | cfgSetTagNoTypography — Указывает теги в которых нужно отключить типографирование текста
 49 | 
 50 | `$qevix->cfgSetTagNoTypography($tags)`
 51 | 
 52 | **Параметры**
 53 | * $tags — (array|string) тег(и)
 54 | 
 55 | **Пример использования**
 56 | ```php
 57 | $qevix->cfgSetTagNoTypography(array('code'));
 58 | ```
 59 | 
 60 | ### cfgSetTagIsEmpty
 61 | 
 62 | cfgSetTagIsEmpty — Указывает не короткие теги, которые могут быть пустыми и их не нужно из-за этого удалять
 63 | 
 64 | `$qevix->cfgSetTagIsEmpty($tags)`
 65 | 
 66 | **Параметры**
 67 | * $tags — (array|string) тег(и)
 68 | 
 69 | **Пример использования**
 70 | ```php
 71 | $qevix->cfgSetTagIsEmpty(array('div'));
 72 | ```
 73 | 
 74 | ### cfgSetTagNoAutoBr
 75 | 
 76 | cfgSetTagNoAutoBr — Указывает теги внутри, которых не нужна авто-расстановка тегов перевода на новую строку
 77 | 
 78 | `$qevix->cfgSetTagNoAutoBr($tags)`
 79 | 
 80 | **Параметры**
 81 | * $tags — (array|string) тег(и)
 82 | 
 83 | **Пример использования**
 84 | ```php
 85 | $qevix->cfgSetTagNoAutoBr(array('ul', 'ol'));
 86 | ```
 87 | 
 88 | ### cfgSetTagCutWithContent
 89 | 
 90 | cfgSetTagCutWithContent — Указывает теги, которые необходимо вырезать вместе с содержимым
 91 | 
 92 | `$qevix->cfgSetTagCutWithContent($tags)`
 93 | 
 94 | **Параметры**
 95 | * $tags — (array|string) тег(и)
 96 | 
 97 | **Пример использования**
 98 | ```php
 99 | $qevix->cfgSetTagCutWithContent(array('script', 'object', 'iframe', 'style'));
100 | ```
101 | 
102 | ### cfgSetTagBlockType
103 | 
104 | cfgSetTagBlockType — Указывает теги после, которых не нужно добавлять дополнительный перевод строки, например, блочные теги
105 | 
106 | `$qevix->cfgSetTagBlockType($tags)`
107 | 
108 | **Параметры**
109 | * $tags — (array|string) тег(и)
110 | 
111 | **Пример использования**
112 | ```php
113 | $qevix->cfgSetTagBlockType(array('ol','ul','code'));
114 | ```
115 | 
116 | ### cfgAllowTagParams
117 | 
118 | cfgAllowTagParams — Добавляет разрешенные параметры для тегов. Значение по умолчанию - шаблон #text. Разрешенные шаблоны #text, #bool, #int, #link, #regexp(...).
119 | Шаблон с регулярным выражением может выглядеть так: "#regexp(\d+(%|px))"
120 | Шаблон #link может быть задан строкой или описан массивом с указанием разрешенных доменов: "array('#link' => ['youtube.com', 'video.com'])"
121 | 
122 | `$qevix->cfgAllowTagParams($tag, $params)`
123 | 
124 | **Параметры**
125 | * $tag — (string) тег
126 | * $params — (string|array) разрешённые параметры
127 | 
128 | **Пример использования**
129 | ```php
130 | $qevix->cfgAllowTagParams('a', array('title', 'href' => '#link', 'rel' => '#text', 'target' => array('_blank'), 'download' => '#bool'));
131 | $qevix->cfgAllowTagParams('img', array('src' => '#text', 'alt' => '#text', 'title', 'align' => array('right', 'left', 'center'), 'width' => '#int', 'height' => '#int'));
132 | $qevix->cfgAllowTagParams('video', array('src' => array('#link' => ['youtube.com', 'video.com']));
133 | ```
134 | 
135 | ### cfgSetTagParamsRequired
136 | 
137 | cfgSetTagParamsRequired — Добавляет обязательные параметры для тега
138 | 
139 | `$qevix->cfgSetTagParamsRequired($tag, $params)`
140 | 
141 | **Параметры**
142 | * $tag — (string) тег
143 | * $params — (string|array) разрешённые параметры
144 | 
145 | **Пример использования**
146 | ```php
147 | $qevix->cfgSetTagParamsRequired('img', 'src');
148 | $qevix->cfgSetTagParamsRequired('a', 'href');
149 | ```
150 | 
151 | ### cfgSetTagChilds
152 | 
153 | cfgSetTagChilds — Указывает какие теги являются контейнерами для других тегов
154 | 
155 | `$qevix->cfgSetTagChilds($tag, $childs, $isParentOnly = false, $isChildOnly = false)`
156 | 
157 | **Параметры**
158 | * $tag — (string) тег
159 | * $childs — (string|array) разрешённые дочерние теги
160 | * $isParentOnly — (boolean) тег является только контейнером других тегов и не может содержать текст
161 | * $isChildOnly — (boolean) дочерние теги не могут присутствовать нигде кроме указанного тега
162 | 
163 | **Пример использования**
164 | ```php
165 | $qevix->cfgSetTagChilds('ul', 'li', true, true);
166 | $qevix->cfgSetTagChilds('ol', 'li', true, true);
167 | ```
168 | 
169 | ### cfgSetTagGlobal
170 | 
171 | cfgSetTagGlobal — Указывает какие теги не должны быть дочерними к другим тегам
172 | 
173 | `$qevix->cfgSetTagGlobal($tags)`
174 | 
175 | **Параметры**
176 | * $tags — (string|array) тег(и)
177 | 
178 | **Пример использования**
179 | ```php
180 | $qevix->cfgSetTagGlobal('cut');
181 | ```
182 | 
183 | ### cfgSetTagParamDefault
184 | 
185 | cfgSetTagParamDefault — Указывает значения по умолчанию для параметров тега
186 | 
187 | `$qevix->cfgSetTagParamDefault($tag, $param, $value, $isRewrite = false)`
188 | 
189 | **Параметры**
190 | * $tag — (string) тег
191 | * $param — (string) атрибут тега
192 | * $value — (string) значение арибута
193 | * $isRewrite — (boolean) перезаписывать значение значением по умолчанию
194 | 
195 | **Пример использования**
196 | ```php
197 | $qevix->cfgSetTagParamDefault('a', 'rel', 'nofollow', true);
198 | $qevix->cfgSetTagParamDefault('a', 'download', null);
199 | $qevix->cfgSetTagParamDefault('img', 'alt', '');
200 | ```
201 | 
202 | ### cfgSetTagBuildCallback
203 | 
204 | cfgSetTagBuildCallback — Устанавливает на тег callback-функцию для ручной сборки тега
205 | 
206 | `$qevix->cfgSetTagBuildCallback($tag, $callback)`
207 | 
208 | **Параметры**
209 | * $tag — (string) тег
210 | * $callback — (mixed) функция
211 | 
212 | **Пример использования**
213 | ```php
214 | $qevix->cfgSetTagBuildCallback('code', 'tag_code_build');
215 | 
216 | function tag_code_build($tag, $params, $content)
217 | {
218 | 	return '<pre><code>'.$content.'<code><pre>'."\n";
219 | }
220 | ```
221 | 
222 | ### cfgSetTagEventCallback
223 | 
224 | cfgSetTagEventCallback — Устанавливает на тег callback-функцию для сбора информации. В отличие от callback-функций установленных с помощью cfgSetTagBuildCallback, этот обработчик не вносит изменения в текст, а может быть использован для сбора какой-либо информации об используемых тегах.
225 | Например, можно посчитать, какое количество изображений в тексте и сформировать массив из их URL для последующего использования в meta-описании станицы.
226 | Для сбора информации, теги должны быть разрешены в cfgAllowTags.
227 | 
228 | `$qevix->cfgSetTagEventCallback($tag, $callback)`
229 | 
230 | **Параметры**
231 | * $tag — (string) тег
232 | * $callback — (mixed) функция
233 | 
234 | **Пример использования**
235 | ```php
236 | $qevix->cfgSetTagEventCallback('img', 'tag_img_event');
237 | 
238 | $meta_img_src = array();
239 | 
240 | function tag_img_event($tag, $params, $content)
241 | {
242 | 	global $meta_img_src;
243 | 
244 | 	$meta_img_src[] = $params['src'];
245 | }
246 | ```
247 | 
248 | ### cfgSetSpecialCharCallback
249 | 
250 | cfgSetSpecialCharCallback — Устанавливает на строку предваренную спецсимволом callback-функцию. По умолчанию Qevix работает с тремя спец. символами #, @, $. Но вы можете сгенерировать свой набор, воспользовавшись генератором классов символов symbolclass.php.
251 |  Как можно догадаться, эта настройка позволяет получить хештег (#tagname) или имя пользователя (@username), или ключевое слово ($keyword) и оформить его в виде ссылки или того, что вам нужно.
252 | 
253 | `cfgSetSpecialCharCallback($char, $callback)`
254 | 
255 | **Параметры**
256 | * $char — (string) спецсимвол #, @ или $
257 | * $callback — (mixed) функция
258 | 
259 | **Пример использования**
260 | ```php
261 | $qevix->cfgSetSpecialCharCallback('#', 'tag_sharp_build');
262 | $qevix->cfgSetSpecialCharCallback('@', 'tag_at_build');
263 | 
264 | function tag_sharp_build($string)
265 | {
266 | 	if(!preg_match('#^[\w\_\-\ ]{1,32}$#isu', $string)) {
267 | 		return false;
268 | 	}
269 | 
270 | 	return '<a href="/tag/'.rawurlencode($string).'/">#'.$string.'</a>';
271 | }
272 | 
273 | function tag_at_build($string)
274 | {
275 | 	if(!preg_match('#^[\w\_\-\ ]{1,32}$#isu', $string)) {
276 | 		return false;
277 | 	}
278 | 
279 | 	return '<a href="/user/'.$string.'/">@'.$string.'</a>';
280 | }
281 | ```
282 | 
283 | Вы можете сами отслеживать, какие символы могут входить в строку.
284 | Qevix поддерживает два варианта обработки специальных строк #tag, #[tag] или #{tag string}.
285 | Вариант со скобками может содержать пробелы, но вы можете их запретить в своей callback-функции и такие строки обрабатываться не будут.
286 | 
287 | ### cfgSetLinkProtocolAllow
288 | 
289 | cfgSetLinkProtocolAllow — Устанавливает список разрешенных протоколов для ссылок. По умолчанию разрешены http, https, ftp
290 | 
291 | `cfgSetLinkProtocolAllow($protocols)`
292 | 
293 | **Параметры**
294 | * $protocols — (array) список протоколов
295 | 
296 | **Пример использования**
297 | ```php
298 | $qevix->cfgSetLinkProtocolAllow(array('http','https'));
299 | ```
300 | 
301 | ### cfgSetXHTMLMode
302 | 
303 | cfgSetXHTMLMode — Включает или выключает режим XHTML. По умолчанию выключен.
304 | 
305 | `cfgSetXHTMLMode($isXHTMLMode)`
306 | 
307 | **Параметры**
308 | * $isXHTMLMode — (boolean) Включить XHTML формат тегов установив в True;
309 | 
310 | **Пример использования**
311 | ```php
312 | $qevix->cfgSetXHTMLMode(true);
313 | ```
314 | 
315 | ### cfgSetAutoBrMode
316 | 
317 | cfgSetAutoBrMode — Включает или выключает режим автозамены символов перевода строки на тег br. По умолчанию включен.
318 | 
319 | `cfgSetAutoBrMode($isAutoBrMode)`
320 | 
321 | **Параметры**
322 | * $isAutoBrMode — (boolean) Включить авторасстановку тегов переда строки установив в True;
323 | 
324 | **Пример использования**
325 | ```php
326 | $qevix->cfgSetAutoBrMode(true);
327 | ```
328 | 
329 | ### cfgSetAutoLinkMode
330 | 
331 | cfgSetAutoLinkMode — Включает или выключает режим автоматического определения ссылок. По умолчанию режим включен.
332 | 
333 | `cfgSetAutoLinkMode($isAutoLinkMode)`
334 | 
335 | **Параметры**
336 | * $isAutoLinkMode — (boolean) Включить автоопределение ссылок установив в True;
337 | 
338 | **Пример использования**
339 | ```php
340 | $qevix->cfgSetAutoLinkMode(true);
341 | ```
342 | 
343 | ### cfgSetEOL
344 | 
345 | cfgSetEOL — Задает символ/символы перевода строки для текста на выходе. По умолчанию используется только символ перевода строки (LF) "\n", можно задать (CR+LF) "\r\n".
346 | 
347 | `cfgSetEOL($nl)`
348 | 
349 | **Параметры**
350 | * $nl — "\n" или "\r\n";
351 | 
352 | **Пример использования**
353 | ```php
354 | $qevix->cfgSetEOL("\r\n");
355 | ```
356 | 


--------------------------------------------------------------------------------
/test.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | require 'qevix.php';
  4 | 
  5 | class QevixTests extends \PHPUnit_Framework_TestCase
  6 | {
  7 |     private static $qevix = null;
  8 | 
  9 |     public static function setUpBeforeClass()
 10 |     {
 11 |         $qevix = new Qevix();
 12 | 
 13 |         // 1. Задает список разрешенных тегов
 14 |         $qevix->cfgAllowTags(array('b', 'i', 'u', 'a', 'img', 'ul', 'li', 'ol', 'br', 'code', 'pre', 'div', 'cut', 'video'));
 15 | 
 16 |         // 2. Указавает, какие теги считать короткими (<br>, <img>)
 17 |         $qevix->cfgSetTagShort(array('br','img','cut', 'video'));
 18 | 
 19 |         // 3. Указывает преформатированные теги, в которых нужно всё заменять на HTML сущности
 20 |         $qevix->cfgSetTagPreformatted(array('code'));
 21 | 
 22 |         // 4. Указывает не короткие теги, которые могут быть пустыми и их не нужно из-за этого удалять
 23 |         $qevix->cfgSetTagIsEmpty(array('div'));
 24 | 
 25 |         // 5. Указывает теги внутри которых не нужна авто расстановка тегов перевода на новую строку
 26 |         $qevix->cfgSetTagNoAutoBr(array('ul', 'ol'));
 27 | 
 28 |         // 6. Указывает теги, которые необходимо вырезать вместе с содержимым
 29 |         $qevix->cfgSetTagCutWithContent(array('script', 'object', 'iframe', 'style'));
 30 | 
 31 |         // 7. Указывает теги, после которых не нужно добавлять дополнительный перевод строки, например, блочные теги
 32 |         $qevix->cfgSetTagBlockType(array('ol','ul','code','video','div'));
 33 | 
 34 |         // 8. Добавляет разрешенные параметры для тегов, значение по умолчанию шаблон #text. Разрешенные шаблоны #text, #int, #link, #regexp(...) (Например: "#regexp(\d+(%|px))")
 35 |         $qevix->cfgAllowTagParams('a', array('title', 'href' => '#link', 'rel' => '#text', 'target' => array('_blank')));
 36 |         $qevix->cfgAllowTagParams('img', array('src' => '#text', 'alt' => '#text', 'title', 'align' => array('right', 'left', 'center'), 'width' => '#int', 'height' => '#int'));
 37 |         $qevix->cfgAllowTagParams('video', array('src' => ['#link' => ['youtube.com','vimeo.com']]));
 38 |         $qevix->cfgAllowTagParams('div', array('itemscope' => '#bool', 'itemtype' => '#link', 'class' => '#text'));
 39 | 
 40 |         // 9. Добавляет обязательные параметры для тега
 41 |         $qevix->cfgSetTagParamsRequired('a', 'href');
 42 |         $qevix->cfgSetTagParamsRequired('img', 'src');
 43 |         $qevix->cfgSetTagParamsRequired('video', 'src');
 44 | 
 45 |         // 10. Указывает, какие теги являются контейнерами для других тегов
 46 |         $qevix->cfgSetTagChilds('ul', 'li', true, true);
 47 |         $qevix->cfgSetTagChilds('ol', 'li', true, true);
 48 | 
 49 |         // 11. Указывает, какие теги не должны быть дочерними к другим тегам
 50 |         $qevix->cfgSetTagGlobal('cut');
 51 | 
 52 |         // 12. Устанавливаем атрибуты тегов, которые будут добавлятся автоматически
 53 |         $qevix->cfgSetTagParamDefault('a', 'rel', 'nofollow', true);
 54 |         $qevix->cfgSetTagParamDefault('img', 'alt', '');
 55 | 
 56 |         // 13. Указывает теги, в которых нужно отключить типографирование текста
 57 |         $qevix->cfgSetTagNoTypography(array('code', 'pre'));
 58 | 
 59 |         // 14. Устанавливает список разрешенных протоколов для ссылок (https, http, ftp)
 60 |         $qevix->cfgSetLinkProtocolAllow(array('http','https'));
 61 | 
 62 |         // 15. Включает или выключает режим XHTML
 63 |         $qevix->cfgSetXHTMLMode(false);
 64 | 
 65 |         // 16. Включает или выключает режим автозамены символов переводов строк на тег <br>
 66 |         $qevix->cfgSetAutoBrMode(true);
 67 | 
 68 |         // 17. Включает или выключает режим автоматического определения ссылок
 69 |         $qevix->cfgSetAutoLinkMode(true);
 70 | 
 71 |         // 18. Задает символ/символы перевода строки. По умполчанию "\n". Разрешено "\n" или "\r\n"
 72 |         $qevix->cfgSetEOL("\n");
 73 | 
 74 |         // 19. Устанавливает на тег callback-функцию
 75 |         $qevix->cfgSetTagBuildCallback('code', [__CLASS__, 'tagCodeBuild']);
 76 | 
 77 |         // 20. Устанавливает на строку предварённую спецсимволом (@|#|$) callback-функцию
 78 |         $qevix->cfgSetSpecialCharCallback('#', [__CLASS__, 'tagSharpBuild']);
 79 |         $qevix->cfgSetSpecialCharCallback('@', [__CLASS__, 'tagAtBuild']);
 80 | 
 81 |         static::$qevix = $qevix;
 82 |     }
 83 | 
 84 |     public static function tearDownAfterClass()
 85 |     {
 86 |         static::$qevix = null;
 87 |     }
 88 | 
 89 |     public static function tagCodeBuild($tag, $params, $content)
 90 |     {
 91 |         return '<pre><code>'.$content.'<code><pre>'."\n";
 92 |     }
 93 | 
 94 |     public static function tagSharpBuild($string)
 95 |     {
 96 |         if (!preg_match('#^[\w\_\-\ ]{1,32}$#isu', $string)) {
 97 |             return false;
 98 |         }
 99 | 
100 |         return '<a href="/search/tag/'.rawurlencode($string).'/">#'.$string.'</a>';
101 |     }
102 | 
103 |     public static function tagAtBuild($string)
104 |     {
105 |         if (!preg_match('#^[\w\_\-]{1,32}$#isu', $string)) {
106 |             return false;
107 |         }
108 | 
109 |         return '<a href="/user/'.$string.'/">@'.$string.'</a>';
110 |     }
111 | 
112 |     public function textsDataProvider()
113 |     {
114 |         return array(
115 |             [
116 |                  '<b>текст текст текст</b>',
117 |                  '<b>текст текст текст</b>'
118 |             ], [
119 |                 '<b>текст <b>текст</b> текст</b>',
120 |                 '<b>текст <b>текст</b> текст</b>'
121 |             ], [
122 |                 '<b>текст текст текст',
123 |                 '<b>текст текст текст</b>'
124 |             ], [
125 |                 '<b>текст <u>текст текст',
126 |                 '<b>текст <u>текст текст</u></b>'
127 |             ], [
128 |                 '<u>текст <s>текст</s> текст</u>',
129 |                 '<u>текст текст текст</u>'
130 |             ], [
131 |                 'текст <script>текст</script> текст',
132 |                 'текст текст'
133 |             ], [
134 |                 '<code>текст <script>текст</script> текст</code>',
135 |                 '<pre><code>текст &#60;script&#62;текст&#60;/script&#62; текст<code><pre>'
136 |             ], [
137 |                 'текст <div></div> <b></b> текст',
138 |                 "текст <div></div>\n текст"
139 |             ], [
140 |                 'текст http://yandex.ru текст',
141 |                 'текст <a href="http://yandex.ru" rel="nofollow">http://yandex.ru</a> текст'
142 |             ], [
143 |                 'текст <b>http://yandex.ru</b> текст',
144 |                 'текст <b><a href="http://yandex.ru" rel="nofollow">http://yandex.ru</a></b> текст'
145 |             ], [
146 |                 'текст http://yandex.ru/?a=href&title=test!..',
147 |                 'текст <a href="http://yandex.ru/?a=href&title=test" rel="nofollow">http://yandex.ru/?a=href&title=test</a>!..'
148 |             ], [
149 |                 'текст ftp://yandex.ru!..',
150 |                 'текст ftp://yandex.ru!..'
151 |             ], [
152 |                 'текст <ul><li>текст</li><li>текст</li><b>текст</b><br></ul> текст',
153 |                 "текст <ul>\n<li>текст</li>\n<li>текст</li>\n</ul>\n текст"
154 |             ], [
155 |                 'текст <li>текст</li> <li>текст</li> текст',
156 |                 'текст текст текст текст'
157 |             ], [
158 |                 '<b>"текст" текст "текст "текст" текст" "..."</b>',
159 |                 '<b>«текст» текст «текст „текст“ текст» «...»</b>'
160 |             ], [
161 |                 '<pre>"текст" текст "текст "текст" текст" "..."</pre>',
162 |                 '<pre>&#34;текст&#34; текст &#34;текст &#34;текст&#34; текст&#34; &#34;...&#34;</pre>'
163 |             ], [
164 |                 'текст &#40; &#41; &#42; &#43; &#44; текст',
165 |                 'текст ( ) * + , текст'
166 |             ], [
167 |                 'текст - текст',
168 |                 'текст — текст'
169 |             ], [
170 |                 'текст      текст',
171 |                 'текст текст'
172 |             ], [
173 |                 'текст #hash... #{tag name} текст',
174 |                 'текст <a href="/search/tag/hash/">#hash</a>... <a href="/search/tag/tag%20name/">#tag name</a> текст'
175 |             ], [
176 |                 'текст <b>#hashtag #taghash, #htag</b> текст',
177 |                 'текст <b><a href="/search/tag/hashtag/">#hashtag</a> <a href="/search/tag/taghash/">#taghash</a>, <a href="/search/tag/htag/">#htag</a></b> текст'
178 |             ], [
179 |                 'текст <a href="http://ya.ru">текст</a> текст',
180 |                 'текст <a href="http://ya.ru" rel="nofollow">текст</a> текст'
181 |             ], [
182 |                 'текст <a href="//ya.ru">текст</a> текст',
183 |                 'текст <a href="//ya.ru" rel="nofollow">текст</a> текст'
184 |             ], [
185 |                 'текст <a href = "http://ya.ru" title="text" >текст</a> текст',
186 |                 'текст <a href="http://ya.ru" title="text" rel="nofollow">текст</a> текст'
187 |             ], [
188 |                 'текст <a href = "http://ya.ru" args="test">текст</a> текст',
189 |                 'текст <a href="http://ya.ru" rel="nofollow">текст</a> текст'
190 |             ], [
191 |                 'текст <a href="http://ya.ru" title = text>текст</a> текст',
192 |                 'текст <a href="http://ya.ru" title="text" rel="nofollow">текст</a> текст'
193 |             ], [
194 |                 'текст <a href="http://ya.ru" target=_blank title=/">текст</a> текст',
195 |                 'текст <a href="http://ya.ru" target="_blank" title="/&#34;" rel="nofollow">текст</a> текст'
196 |             ], [
197 |                 'текст <a href="javascript:alert(1)">текст</a> текст',
198 |                 'текст текст текст'
199 |             ], [
200 |                 '<b>текст текст</b> <cut> <b>текст <cut> текст</b>',
201 |                 '<b>текст текст</b> <cut> <b>текст текст</b>'
202 |             ], [
203 |                 'текст <video src="http://vimeo.com/1234567890"> текст',
204 |                 "текст <video src=\"http://vimeo.com/1234567890\">\n текст"
205 |             ], [
206 |                 'текст <video src="http://rutube.ru/1234567890"> текст',
207 |                 'текст текст'
208 |             ], [
209 |                 'текст <video src="http://youtube.com.exploit.net/1234567890"> текст',
210 |                 'текст текст'
211 |             ], [
212 |                 'текст <video src="http://youtube.com.exploit.net"> текст',
213 |                 'текст текст'
214 |             ], [
215 |                 'текст <video src="//youtube.com"> текст',
216 |                 "текст <video src=\"//youtube.com\">\n текст"
217 |             ], [
218 |                 'текст <video src="//youtube.com/"> текст',
219 |                 "текст <video src=\"//youtube.com/\">\n текст"
220 |             ], [
221 |                 '<div itemscope itemtype="http://schema.org/ImageObject"></div>',
222 |                 '<div itemscope itemtype="http://schema.org/ImageObject"></div>'
223 |             ], [
224 |                 '<div itemscope itemtype="http://schema.org/ImageObject" class=""></div>',
225 |                 '<div itemscope itemtype="http://schema.org/ImageObject" class=""></div>'
226 |             ],
227 |         );
228 |     }
229 | 
230 |     /**
231 |      * @dataProvider textsDataProvider
232 |      */
233 |     public function testParse($text, $expected)
234 |     {
235 |         $result = static::$qevix->parse($text, $errors);
236 |         $this->assertEquals($result, $expected);
237 |     }
238 | }
239 | 


--------------------------------------------------------------------------------
/qevix.php:
--------------------------------------------------------------------------------
   1 | <?php
   2 | 
   3 | class Qevix
   4 | {
   5 |     const NIL = 0x0;
   6 |     const PRINATABLE = 0x1;
   7 |     const ALPHA = 0x2;
   8 |     const NUMERIC = 0x4;
   9 |     const PUNCTUATUON = 0x8;
  10 |     const SPACE = 0x10;
  11 |     const NL = 0x20;
  12 |     const TAG_NAME = 0x40;
  13 |     const TAG_PARAM_NAME = 0x80;
  14 |     const TAG_QUOTE = 0x100;
  15 |     const TEXT_QUOTE = 0x200;
  16 |     const TEXT_BRACKET = 0x400;
  17 |     const SPECIAL_CHAR = 0x800;
  18 |     //const = 0x1000;
  19 |     //const = 0x2000;
  20 |     //const = 0x4000;
  21 |     //const = 0x8000;
  22 |     const NOPRINT = 0x10000;
  23 | 
  24 |     public $tagsRules = array();
  25 |     public $entities = array('"'=>'&#34;', "'"=>'&#39;', '<'=>'&#60;', '>'=>'&#62;', '&'=>'&#38;');
  26 |     public $quotes = array(array('«', '»'), array('„', '“'));
  27 |     public $bracketsALL = array('<'=>'>', '['=>']', '{'=>'}', '('=>')');
  28 |     public $bracketsSPC = array('['=>']', '{'=>'}');
  29 |     public $dash = "—";
  30 |     public $nl = "\n";
  31 | 
  32 |     protected $textBuf = array();
  33 |     protected $textLen = 0;
  34 | 
  35 |     protected $prevPos = -1;
  36 |     protected $prevChar = null;
  37 |     protected $prevCharOrd = 0;
  38 |     protected $prevCharClass = self::NIL;
  39 | 
  40 |     protected $curPos = -1;
  41 |     protected $curChar = null;
  42 |     protected $curCharOrd = 0;
  43 |     protected $curCharClass = self::NIL;
  44 | 
  45 |     protected $nextPos = -1;
  46 |     protected $nextChar = null;
  47 |     protected $nextCharOrd = 0;
  48 |     protected $nextCharClass = self::NIL;
  49 | 
  50 |     protected $curTag = null;
  51 |     protected $statesStack = array();
  52 |     protected $quotesOpened = 0;
  53 |     protected $linkProtocolAllow = array('http','https','ftp');
  54 |     protected $specialChars = array();
  55 |     protected $isXHTMLMode = false;
  56 |     protected $isAutoBrMode = true;
  57 |     protected $isAutoLinkMode = true;
  58 |     protected $isSpecialCharMode = false;
  59 |     protected $typoMode = true;
  60 |     protected $br = "<br>";
  61 | 
  62 |     protected $errorsList = array();
  63 | 
  64 | 
  65 |     /**
  66 |      * Классификация тегов
  67 |      */
  68 |     const TAG_ALLOWED = 1; // Тег допустим
  69 |     const TAG_PARAM_ALLOWED = 2; // Параметр тега допустим
  70 |     const TAG_PARAM_REQUIRED = 3; // Параметр тега является необходимым
  71 |     const TAG_SHORT = 4; // Тег короткий
  72 |     const TAG_CUT = 5; // Тег необходимо вырезать вместе с его контентом
  73 |     const TAG_GLOBAL_ONLY = 6; // Тег может находиться только в "глобальной" области видимости (не быть дочерним к другим)
  74 |     const TAG_PARENT_ONLY = 7; // Тег может содержать только другие теги
  75 |     const TAG_CHILD_ONLY = 8; // Тег может находиться только внутри других тегов
  76 |     const TAG_PARENT = 9; // Тег родитель относительно дочернего тега
  77 |     const TAG_CHILD = 10; // Тег дочерний относительно родительского
  78 |     const TAG_PREFORMATTED = 11; // Преформатированные теги
  79 |     const TAG_PARAM_AUTO_ADD = 12; // Автодобавление параметров со значениями по умолчанию
  80 |     const TAG_NO_TYPOGRAPHY = 13; // Тег с отключенным типографированием
  81 |     const TAG_EMPTY = 14; // Пустой не короткий тег
  82 |     const TAG_NO_AUTO_BR = 15; // Тег в котором не нужна авто-расстановка <br>
  83 |     const TAG_BLOCK_TYPE = 16; // Тег после которого нужно удалять один перевод строки
  84 |     const TAG_BUILD_CALLBACK = 17; // Тег обрабатывается и строится callback-функцией
  85 |     const TAG_EVENT_CALLBACK = 18; // Тег обрабатывается callback-функцией для сбора информации
  86 | 
  87 |     /**
  88 |      * Классы символов из symbolclass.php
  89 |      */
  90 |     protected $charClasses = array(0=>65536,1=>65536,2=>65536,3=>65536,4=>65536,5=>65536,6=>65536,7=>65536,8=>65536,9=>65552,10=>65568,
  91 |     11=>65536,12=>65536,13=>65568,14=>65536,15=>65536,16=>65536,17=>65536,18=>65536,19=>65536,20=>65536,21=>65536,22=>65536,23=>65536,
  92 |     24=>65536,25=>65536,26=>65536,27=>65536,28=>65536,29=>65536,30=>65536,31=>65536,32=>65552,97=>195,98=>195,99=>195,100=>195,101=>195,
  93 |     102=>195,103=>195,104=>195,105=>195,106=>195,107=>195,108=>195,109=>195,110=>195,111=>195,112=>195,113=>195,114=>195,115=>195,116=>195,
  94 |     117=>195,118=>195,119=>195,120=>195,121=>195,122=>195,65=>195,66=>195,67=>195,68=>195,69=>195,70=>195,71=>195,72=>195,73=>195,74=>195,
  95 |     75=>195,76=>195,77=>195,78=>195,79=>195,80=>195,81=>195,82=>195,83=>195,84=>195,85=>195,86=>195,87=>195,88=>195,89=>195,90=>195,48=>197,
  96 |     49=>197,50=>197,51=>197,52=>197,53=>197,54=>197,55=>197,56=>197,57=>197,45=>129,34=>769,39=>257,46=>9,44=>9,33=>9,63=>9,58=>9,59=>9,
  97 |     60=>1025,62=>1025,91=>1025,93=>1025,123=>1025,125=>1025,40=>1025,41=>1025,64=>2049,35=>2049,36=>2049);
  98 | 
  99 |     /**
 100 |      * Установка конфигурации для одного или нескольких тегов
 101 |      *
 102 |      * @param array|string $tags тег(и)
 103 |      * @param int $flag флаг конфигурации
 104 |      * @param mixed $value значение флага
 105 |      * @param boolean $createIfNoExists создать запить о теге, если он ещё не определён
 106 |      */
 107 |     protected function _cfgSetTagsFlag($tags, $flag, $value, $createIfNoExists = true)
 108 |     {
 109 |         $tags = (is_array($tags)) ? $tags : array($tags);
 110 | 
 111 |         foreach($tags as $tag)
 112 |         {
 113 |             if(!isset($this->tagsRules[$tag]) AND !$createIfNoExists) {
 114 |                 throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 115 |             }
 116 | 
 117 |             $this->tagsRules[$tag][$flag] = $value;
 118 |         }
 119 |     }
 120 | 
 121 |     /**
 122 |      * КОНФИГУРАЦИЯ: Задает список разрешенных тегов
 123 |      *
 124 |      * @param array|string $tags тег(и)
 125 |      */
 126 |     public function cfgAllowTags($tags) {
 127 |         $this->_cfgSetTagsFlag($tags, self::TAG_ALLOWED, true);
 128 |     }
 129 | 
 130 |     /**
 131 |      * КОНФИГУРАЦИЯ: Указывает, какие теги считать короткими (<br>, <img>)
 132 |      *
 133 |      * @param array|string $tags тег(и)
 134 |      */
 135 |     public function cfgSetTagShort($tags) {
 136 |         $this->_cfgSetTagsFlag($tags, self::TAG_SHORT, true, false);
 137 |     }
 138 | 
 139 |     /**
 140 |      * КОНФИГУРАЦИЯ: Указывает преформатированные теги, в которых нужно всё заменять на HTML сущности
 141 |      *
 142 |      * @param array|string $tags тег(и)
 143 |      */
 144 |     public function cfgSetTagPreformatted($tags) {
 145 |         $this->_cfgSetTagsFlag($tags, self::TAG_PREFORMATTED, true, false);
 146 |     }
 147 | 
 148 |     /**
 149 |      * КОНФИГУРАЦИЯ: Указывает теги в которых нужно отключить типографирование текста
 150 |      *
 151 |      * @param array|string $tags тег(и)
 152 |      */
 153 |     public function cfgSetTagNoTypography($tags) {
 154 |         $this->_cfgSetTagsFlag($tags, self::TAG_NO_TYPOGRAPHY, true, false);
 155 |     }
 156 | 
 157 |     /**
 158 |      * КОНФИГУРАЦИЯ: Указывает не короткие теги, которые могут быть пустыми и их не нужно из-за этого удалять
 159 |      *
 160 |      * @param array|string $tags тег(и)
 161 |      */
 162 |     public function cfgSetTagIsEmpty($tags) {
 163 |         $this->_cfgSetTagsFlag($tags, self::TAG_EMPTY, true, false);
 164 |     }
 165 | 
 166 |     /**
 167 |      * КОНФИГУРАЦИЯ: Указывает теги внутри которых не нужна авторасстановка тегов перевода на новую строку
 168 |      *
 169 |      * @param array|string $tags тег(и)
 170 |      */
 171 |     public function cfgSetTagNoAutoBr($tags) {
 172 |         $this->_cfgSetTagsFlag($tags, self::TAG_NO_AUTO_BR, true, false);
 173 |     }
 174 | 
 175 |     /**
 176 |      * КОНФИГУРАЦИЯ: Указывает теги, которые необходимо вырезать вместе с содержимым (style, script, iframe)
 177 |      *
 178 |      * @param array|string $tags тег(и)
 179 |      */
 180 |     public function cfgSetTagCutWithContent($tags) {
 181 |         $this->_cfgSetTagsFlag($tags, self::TAG_CUT, true);
 182 |     }
 183 | 
 184 |     /**
 185 |      * КОНФИГУРАЦИЯ: Указывает теги после которых не нужно добавлять дополнительный перевод строки, например, блочные теги
 186 |      *
 187 |      * @param array|string $tags тег(и)
 188 |      */
 189 |     public function cfgSetTagBlockType($tags) {
 190 |         $this->_cfgSetTagsFlag($tags, self::TAG_BLOCK_TYPE, true, false);
 191 |     }
 192 | 
 193 |     /**
 194 |      * КОНФИГУРАЦИЯ: Добавляет разрешенные параметры для тегов
 195 |      *
 196 |      * @param string $tag тег
 197 |      * @param string|array $params разрешённые параметры
 198 |      */
 199 |     public function cfgAllowTagParams($tag, $params)
 200 |     {
 201 |         if(!isset($this->tagsRules[$tag])) {
 202 |             throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 203 |         }
 204 | 
 205 |         $params = (is_array($params)) ? $params : array($params);
 206 | 
 207 |         foreach($params as $key => $value)
 208 |         {
 209 |             if(is_string($key)) {
 210 |                 $this->tagsRules[$tag][self::TAG_PARAM_ALLOWED][$key] = $value;
 211 |             } else {
 212 |                 $this->tagsRules[$tag][self::TAG_PARAM_ALLOWED][$value] = '#text';
 213 |             }
 214 |         }
 215 |     }
 216 | 
 217 |     /**
 218 |      * КОНФИГУРАЦИЯ: Добавляет обязательные параметры для тега
 219 |      *
 220 |      * @param string $tag тег
 221 |      * @param string|array $params разрешённые параметры
 222 |      */
 223 |     public function cfgSetTagParamsRequired($tag, $params)
 224 |     {
 225 |         if(!isset($this->tagsRules[$tag])) {
 226 |             throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 227 |         }
 228 | 
 229 |         $params = (is_array($params)) ? $params : array($params);
 230 | 
 231 |         foreach($params as $param)
 232 |         {
 233 |             $this->tagsRules[$tag][self::TAG_PARAM_REQUIRED][$param] = true;
 234 |         }
 235 |     }
 236 | 
 237 |     /**
 238 |      * КОНФИГУРАЦИЯ: Указывает, какие теги являются контейнерами для других тегов
 239 |      *
 240 |      * @param string $tag тег
 241 |      * @param string|array $childs разрешённые дочерние теги
 242 |      * @param boolean $isParentOnly тег является только контейнером других тегов и не может содержать текст
 243 |      * @param boolean $isChildOnly вложенные теги не могут присутствовать нигде кроме указанного тега
 244 |      */
 245 |     public function cfgSetTagChilds($tag, $childs, $isParentOnly = false, $isChildOnly = false)
 246 |     {
 247 |         if(!isset($this->tagsRules[$tag])) {
 248 |             throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 249 |         }
 250 | 
 251 |         $childs = (is_array($childs)) ? $childs : array($childs);
 252 | 
 253 |         if($isParentOnly) {
 254 |             $this->tagsRules[$tag][self::TAG_PARENT_ONLY] = true;
 255 |         }
 256 | 
 257 |         foreach($childs as $child)
 258 |         {
 259 |             if(!isset($this->tagsRules[$child])) {
 260 |                 throw new Exception("Тег ".$child." отсутствует в списке разрешённых тегов");
 261 |             }
 262 | 
 263 |             $this->tagsRules[$tag][self::TAG_CHILD][$child] = true;
 264 |             $this->tagsRules[$child][self::TAG_PARENT][$tag] = true;
 265 | 
 266 |             if($isChildOnly) {
 267 |                 $this->tagsRules[$child][self::TAG_CHILD_ONLY] = true;
 268 |             }
 269 |         }
 270 |     }
 271 | 
 272 |     /**
 273 |      * КОНФИГУРАЦИЯ: Указывает, какие теги не должны быть дочерними к другим тегам
 274 |      *
 275 |      * @param string|array $tag тег
 276 |      */
 277 |     public function cfgSetTagGlobal($tags)
 278 |     {
 279 |         $this->_cfgSetTagsFlag($tags, self::TAG_GLOBAL_ONLY, true, false);
 280 |     }
 281 | 
 282 |     /**
 283 |      * КОНФИГУРАЦИЯ: Указывает значения по умолчанию для параметров тега
 284 |      *
 285 |      * @param string $tag тег
 286 |      * @param string $param атрибут
 287 |      * @param sring $value значение
 288 |      * @param boolean $isRewrite перезаписывать значение значением по умолчанию
 289 |      */
 290 |     public function cfgSetTagParamDefault($tag, $param, $value, $isRewrite = false)
 291 |     {
 292 |         if(!isset($this->tagsRules[$tag])) {
 293 |             throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 294 |         }
 295 | 
 296 |         $this->tagsRules[$tag][self::TAG_PARAM_AUTO_ADD][$param] = array('value'=>$value, 'rewrite'=>$isRewrite);
 297 |     }
 298 | 
 299 |     /**
 300 |      * КОНФИГУРАЦИЯ: Устанавливает на тег callback-функцию для построения тега
 301 |      *
 302 |      * @param string $tag тег
 303 |      * @param mixed $callback функция
 304 |      */
 305 |     public function cfgSetTagBuildCallback($tag, $callback)
 306 |     {
 307 |         if(!isset($this->tagsRules[$tag])) {
 308 |             throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 309 |         }
 310 | 
 311 |         $this->tagsRules[$tag][self::TAG_BUILD_CALLBACK] = $callback;
 312 |     }
 313 | 
 314 |     /**
 315 |      * КОНФИГУРАЦИЯ: Устанавливает на тег callback-функцию для сбора информации
 316 |      *
 317 |      * @param string $tag тег
 318 |      * @param mixed $callback функция
 319 |      */
 320 |     public function cfgSetTagEventCallback($tag, $callback)
 321 |     {
 322 |         if(!isset($this->tagsRules[$tag])) {
 323 |             throw new Exception("Тег ".$tag." отсутствует в списке разрешённых тегов");
 324 |         }
 325 | 
 326 |         $this->tagsRules[$tag][self::TAG_EVENT_CALLBACK] = $callback;
 327 |     }
 328 | 
 329 |     /**
 330 |      * КОНФИГУРАЦИЯ: Устанавливает на строку предварённую спецсимволом callback-функцию
 331 |      *
 332 |      * @param string $char спецсимвол
 333 |      * @param mixed $callback функция
 334 |      */
 335 |     public function cfgSetSpecialCharCallback($char, $callback)
 336 |     {
 337 |         if(!is_string($char)) {
 338 |             throw new Exception("Параметр \$char метода cfgSetSpecialCharCallback должен быть строкой из одного символа");
 339 |         }
 340 | 
 341 |         if(mb_strlen($char) != 1) {
 342 |             throw new Exception("Параметр \$char метода cfgSetSpecialCharCallback должен быть строкой из одного символа");
 343 |         }
 344 | 
 345 |         $charClass = $this->getClassByOrd(static::ord($char));
 346 | 
 347 |         if(($charClass & self::SPECIAL_CHAR) == self::NIL) {
 348 |             throw new Exception("Параметр \$char метода cfgSetSpecialCharCallback отсутствует в списке разрешенных символов");
 349 |         }
 350 | 
 351 |         $this->isSpecialCharMode = true;
 352 | 
 353 |         $this->specialChars[$char] = $callback;
 354 |     }
 355 | 
 356 |     /**
 357 |      * КОНФИГУРАЦИЯ: Устанавливает список разрешенных протоколов для ссылок (https, http, ftp)
 358 |      *
 359 |      *
 360 |      * @param array $protocols Список протоколов
 361 |      */
 362 |     public function cfgSetLinkProtocolAllow($protocols)
 363 |     {
 364 |         $protocols = (is_array($protocols)) ? $protocols : array($protocols);
 365 | 
 366 |         $this->linkProtocolAllow = $protocols;
 367 |     }
 368 | 
 369 |     /**
 370 |      * КОНФИГУРАЦИЯ: Включает или выключает режим XHTML
 371 |      *
 372 |      * @param boolean $isXHTMLMode
 373 |      */
 374 |     public function cfgSetXHTMLMode($isXHTMLMode)
 375 |     {
 376 |         $isXHTMLMode = (bool) $isXHTMLMode;
 377 | 
 378 |         $this->br = ($isXHTMLMode) ? '<br/>' : '<br>';
 379 |         $this->isXHTMLMode = $isXHTMLMode;
 380 |     }
 381 | 
 382 |     /**
 383 |      * КОНФИГУРАЦИЯ: Включает или выключает режим автозамены символов переводов строк на тег <br>
 384 |      *
 385 |      * @param boolean $isAutoBrMode
 386 |      */
 387 |     public function cfgSetAutoBrMode($isAutoBrMode) {
 388 |         $this->isAutoBrMode = (bool) $isAutoBrMode;
 389 |     }
 390 | 
 391 |     /**
 392 |      * КОНФИГУРАЦИЯ: Включает или выключает режим автоматического определения ссылок
 393 |      *
 394 |      * @param boolean $isAutoLinkMode
 395 |      */
 396 |     public function cfgSetAutoLinkMode($isAutoLinkMode) {
 397 |         $this->isAutoLinkMode = (bool) $isAutoLinkMode;
 398 |     }
 399 | 
 400 |     /**
 401 |      * КОНФИГУРАЦИЯ: Задает символ/символы перевода строки в готовом тексте (\n или \r\n)
 402 |      *
 403 |      * @param string $nl - "\n" или "\r\n"
 404 |      */
 405 |     public function cfgSetEOL($nl) {
 406 |         if(in_array($nl, array("\n", "\r\n"))) {
 407 |             $this->nl = $nl;
 408 |         }
 409 |     }
 410 | 
 411 |     /**
 412 |      * Разбивает строку в массив посимвольно
 413 |      *
 414 |      * @param string $string текст
 415 |      */
 416 |     protected function strToArray($str)
 417 |     {
 418 |         preg_match_all('#.#su', $str, $chars); // preg_split работает медленнее
 419 |         return $chars[0];
 420 |     }
 421 | 
 422 |     /**
 423 |      * Запускает парсер
 424 |      *
 425 |      * @param string $text текст
 426 |      * @param array $errors сообщения об ошибках
 427 |      * @return string
 428 |      */
 429 |     public function parse($text, &$errors)
 430 |     {
 431 |         $this->prevPos = -1;
 432 |         $this->prevChar = null;
 433 |         $this->prevCharOrd = 0;
 434 |         $this->prevCharClass = self::NIL;
 435 | 
 436 |         $this->curPos = -1;
 437 |         $this->curChar = null;
 438 |         $this->curCharOrd = 0;
 439 |         $this->curCharClass = self::NIL;
 440 | 
 441 |         $this->nextPos = -1;
 442 |         $this->nextChar = null;
 443 |         $this->nextCharOrd = 0;
 444 |         $this->nextCharClass = self::NIL;
 445 | 
 446 |         $this->curTag = null;
 447 | 
 448 |         $this->statesStack = array();
 449 | 
 450 |         $this->quotesOpened = 0;
 451 | 
 452 |         $text = str_replace("\r", "", $text);
 453 | 
 454 |         $this->textBuf = $this->strToArray($text);
 455 |         $this->textLen = count($this->textBuf);
 456 | 
 457 |         $this->errorsList = array();
 458 | 
 459 |         $this->movePos(0);
 460 | 
 461 |         $content = $this->makeContent();
 462 |         $content = ($this->nl != "\n") ? str_replace("\n", $this->nl, $content) : $content;
 463 |         $content = trim($content);
 464 | 
 465 |         $errors = $this->errorsList;
 466 | 
 467 |         return $content;
 468 |     }
 469 | 
 470 |     /**
 471 |      * Получение следующего символа из входной строки
 472 |      *
 473 |      * @return boolean
 474 |      */
 475 |     protected function moveNextPos()
 476 |     {
 477 |         return $this->movePos($this->curPos+1);
 478 |     }
 479 | 
 480 |     /**
 481 |      * Получение следующего символа из входной строки
 482 |      *
 483 |      * @return boolean
 484 |      */
 485 |     protected function movePrevPos()
 486 |     {
 487 |         return $this->movePos($this->curPos-1);
 488 |     }
 489 | 
 490 |     /**
 491 |      * Перемещает указатель на указанную позицию во входной строке и считывание символа
 492 |      *
 493 |      * @param int $position позиция в тексте
 494 |      * @return boolean
 495 |      */
 496 |     protected function movePos($position)
 497 |     {
 498 |         $prevPos = $position - 1;
 499 |         $curPos = $position;
 500 |         $nextPos = $position + 1;
 501 | 
 502 |         $prevPosStatus = ($prevPos < $this->textLen && $prevPos >= 0) ? true : false;
 503 | 
 504 |         $this->prevPos = $prevPos;
 505 |         $this->prevChar = ($prevPosStatus) ? $this->textBuf[$prevPos] : null;
 506 |         $this->prevCharOrd = ($prevPosStatus) ? static::ord($this->prevChar) : 0;
 507 |         $this->prevCharClass = ($prevPosStatus) ? $this->getClassByOrd($this->prevCharOrd) : self::NIL;
 508 | 
 509 |         $curPosStatus = ($curPos < $this->textLen && $curPos >= 0) ? true : false;
 510 | 
 511 |         $this->curPos = $curPos;
 512 |         $this->curChar = ($curPosStatus) ? $this->textBuf[$curPos] : null;
 513 |         $this->curCharOrd = ($curPosStatus) ? static::ord($this->curChar) : 0;
 514 |         $this->curCharClass = ($curPosStatus) ? $this->getClassByOrd($this->curCharOrd) : self::NIL;
 515 | 
 516 |         $nextPosStatus = ($nextPos < $this->textLen && $nextPos >= 0) ? true : false;
 517 | 
 518 |         $this->nextPos = $nextPos;
 519 |         $this->nextChar = ($nextPosStatus) ? $this->textBuf[$nextPos] : null;
 520 |         $this->nextCharOrd = ($nextPosStatus) ? static::ord($this->nextChar) : 0;
 521 |         $this->nextCharClass = ($nextPosStatus) ? $this->getClassByOrd($this->nextCharOrd) : self::NIL;
 522 | 
 523 |         return (!is_null($this->curChar)) ? true : false;
 524 |     }
 525 | 
 526 |     /**
 527 |      * Сохраняет текущее состояние автомата
 528 |      *
 529 |      */
 530 |     protected function saveState()
 531 |     {
 532 |         $state = array();
 533 | 
 534 |         $state['prevPos'] = $this->prevPos;
 535 |         $state['prevChar'] = $this->prevChar;
 536 |         $state['prevCharOrd'] = $this->prevCharOrd;
 537 |         $state['prevCharClass'] = $this->prevCharClass;
 538 | 
 539 |         $state['curPos'] = $this->curPos;
 540 |         $state['curChar'] = $this->curChar;
 541 |         $state['curCharOrd'] = $this->curCharOrd;
 542 |         $state['curCharClass'] = $this->curCharClass;
 543 | 
 544 |         $state['nextPos'] = $this->nextPos;
 545 |         $state['nextChar'] = $this->nextChar;
 546 |         $state['nextCharOrd'] = $this->nextCharOrd;
 547 |         $state['nextCharClass'] = $this->nextCharClass;
 548 | 
 549 |         $this->statesStack[] = $state;
 550 |     }
 551 | 
 552 |     /**
 553 |      * Восстанавливает последнее сохраненное состояние автомата
 554 |      *
 555 |      */
 556 |     protected function restoreState()
 557 |     {
 558 |         $state = array_pop($this->statesStack);
 559 | 
 560 |         $this->prevPos = $state['prevPos'];
 561 |         $this->prevChar = $state['prevChar'];
 562 |         $this->prevCharOrd = $state['prevCharOrd'];
 563 |         $this->prevCharClass = $state['prevCharClass'];
 564 | 
 565 |         $this->curPos = $state['curPos'];
 566 |         $this->curChar = $state['curChar'];
 567 |         $this->curCharOrd = $state['curCharOrd'];
 568 |         $this->curCharClass = $state['curCharClass'];
 569 | 
 570 |         $this->nextPos = $state['nextPos'];
 571 |         $this->nextChar = $state['nextChar'];
 572 |         $this->nextCharOrd = $state['nextCharOrd'];
 573 |         $this->nextCharClass = $state['nextCharClass'];
 574 |     }
 575 | 
 576 |     /**
 577 |      * Удаляет последнее сохраненное состояние
 578 |      *
 579 |      */
 580 |     protected function removeState()
 581 |     {
 582 |         $state = array_pop($this->statesStack);
 583 |     }
 584 | 
 585 |     /**
 586 |      * Проверяет допустимость тега, классификатора тега и других параметров тега
 587 |      *
 588 |      */
 589 |     protected function tagsRules()
 590 |     {
 591 |         $args_list = func_get_args();
 592 | 
 593 |         if(count($args_list) == 0) {
 594 |             return false;
 595 |         }
 596 | 
 597 |         $tagsRules =& $this->tagsRules;
 598 |         foreach($args_list as $value)
 599 |         {
 600 |             if(is_null($value) || !isset($tagsRules[$value])) {
 601 |                 return false;
 602 |             }
 603 | 
 604 |             $tagsRules =& $tagsRules[$value];
 605 |         }
 606 | 
 607 |         return true;
 608 |     }
 609 | 
 610 |     /**
 611 |      * Проверяет точное вхождение символа в текущей позиции
 612 |      *
 613 |      * @param string $char символ
 614 |      * @return boolean
 615 |      */
 616 |     protected function matchChar($char)
 617 |     {
 618 |         return ($this->curChar == $char) ? true : false;
 619 |     }
 620 | 
 621 |     /**
 622 |      * Проверяет вхождение символа указанного класса в текущей позиции
 623 |      *
 624 |      * @param int $charClass класс символа
 625 |      * @return boolean
 626 |      */
 627 |     protected function matchCharClass($charClass)
 628 |     {
 629 |         return ($this->curCharClass & $charClass) ? true : false;
 630 |     }
 631 | 
 632 |     /**
 633 |      * Проверяет точное вхождение кода символа в текущей позиции
 634 |      *
 635 |      * @param int $charOrd код символа
 636 |      * @return boolean
 637 |      */
 638 |     protected function matchCharOrd($charOrd)
 639 |     {
 640 |         return ($this->curCharOrd == $charOrd) ? true : false;
 641 |     }
 642 | 
 643 |     /**
 644 |      * Проверяет точное совпадение строки в текущей позиции
 645 |      *
 646 |      * @param string $str
 647 |      * @return boolean
 648 |      */
 649 |     protected function matchStr($str)
 650 |     {
 651 |         $this->saveState();
 652 |         $lenght = mb_strlen($str, 'UTF-8');
 653 |         $buffer = '';
 654 | 
 655 |         while($lenght-- && $this->curCharClass)
 656 |         {
 657 |             $buffer .= $this->curChar;
 658 |             $this->moveNextPos();
 659 |         }
 660 | 
 661 |         $this->restoreState();
 662 | 
 663 |         return ($buffer == $str) ? true : false;
 664 |     }
 665 | 
 666 |     /**
 667 |      * Пропускает текст до нахождения указанного символа
 668 |      *
 669 |      * @param string $char символ для поиска
 670 |      * @return boolean
 671 |      */
 672 |     protected function skipTextToChar($char)
 673 |     {
 674 |         while($this->curChar != $char && $this->curCharClass)
 675 |         {
 676 |             $this->moveNextPos();
 677 |         }
 678 | 
 679 |         return ($this->curCharClass) ? true : false;
 680 |     }
 681 | 
 682 |     /**
 683 |      * Пропускает текст до нахождения указанной строки
 684 |      *
 685 |      * @param string $str строка или символ для поиска
 686 |      * @return boolean
 687 |      */
 688 |     protected function skipTextToStr($str)
 689 |     {
 690 |         $chars = $this->strToArray($str);
 691 | 
 692 |         while($this->curCharClass)
 693 |         {
 694 |             if($this->curChar == $chars[0])
 695 |             {
 696 |                 $this->saveState();
 697 | 
 698 |                 $state = true;
 699 |                 foreach($chars as $char)
 700 |                 {
 701 |                     if($this->curCharClass == self::NIL) {
 702 |                         $this->removeState();
 703 |                         return false;
 704 |                     }
 705 | 
 706 |                     if($this->curChar != $char) {
 707 |                         $state = false;
 708 |                         break;
 709 |                     }
 710 | 
 711 |                     $this->moveNextPos();
 712 |                 }
 713 | 
 714 |                 $this->restoreState();
 715 | 
 716 |                 if($state) {
 717 |                     return true;
 718 |                 }
 719 |             }
 720 | 
 721 |             $this->moveNextPos();
 722 |         }
 723 | 
 724 |         return false;
 725 |     }
 726 | 
 727 |     /**
 728 |      * Пропускает строку если она начинается с текущей позиции
 729 |      *
 730 |      * $this->skipTextToStr('-->') && $this->skipStr('-->');
 731 |      *
 732 |      * @param string $str строка для пропуска
 733 |      * @return boolean
 734 |      */
 735 |     protected function skipStr($str)
 736 |     {
 737 |         $chars = $this->strToArray($str);
 738 | 
 739 |         $this->saveState();
 740 | 
 741 |         $state = true;
 742 |         foreach($chars as $char)
 743 |         {
 744 |             if($this->curCharClass == self::NIL) {
 745 |                 $state = false; break;
 746 |             }
 747 | 
 748 |             if($this->curChar != $char) {
 749 |                 $state = false; break;
 750 |             }
 751 | 
 752 |             $this->moveNextPos();
 753 |         }
 754 | 
 755 |         if($state) $this->removeState();
 756 |         else $this->restoreState();
 757 | 
 758 |         return ($state) ? true : false;
 759 |     }
 760 | 
 761 |     /**
 762 |      * Возвращает класс символа по его коду
 763 |      *
 764 |      * @param int $ord код символа
 765 |      * @return int класс символа
 766 |      */
 767 |     protected function getClassByOrd($ord)
 768 |     {
 769 |         return isset($this->charClasses[$ord]) ? $this->charClasses[$ord] : self::PRINATABLE;
 770 |     }
 771 | 
 772 |     /**
 773 |      * Пропускает пробелы
 774 |      *
 775 |      * @return int количество пропусков
 776 |      */
 777 |     protected function skipSpaces()
 778 |     {
 779 |         $count = 0;
 780 |         while($this->curCharClass & self::SPACE)
 781 |         {
 782 |             $this->moveNextPos();
 783 |             $count++;
 784 |         }
 785 |         return $count;
 786 |     }
 787 | 
 788 |     /**
 789 |      * Пропускает символы перевода строк
 790 |      *
 791 |      * @param int $limit лимит пропусков символов перевода строк, при установке в 0 - не лимитируется
 792 |      * @return boolean
 793 |      */
 794 |     protected function skipNL($limit=0)
 795 |     {
 796 |         $count = 0;
 797 |         while($this->curCharClass & self::NL)
 798 |         {
 799 |             if($limit > 0 && $count >= $limit) {
 800 |                 break;
 801 |             }
 802 | 
 803 |             $this->moveNextPos();
 804 |             $this->skipSpaces();
 805 | 
 806 |             $count++;
 807 |         }
 808 | 
 809 |         return $count;
 810 |     }
 811 | 
 812 |     /**
 813 |      * Пропускает символы относящиеся к классу и возвращает кол-во пропущенных символов
 814 |      *
 815 |      * @param int $class класс для пропуска
 816 |      * @return string
 817 |     */
 818 |     protected function skipClass($class)
 819 |     {
 820 |         $count = 0;
 821 |         while($this->curCharClass & $class)
 822 |         {
 823 |             $this->moveNextPos();
 824 |             $count++;
 825 |         }
 826 | 
 827 |         return $count;
 828 |     }
 829 | 
 830 |     /**
 831 |      * Захватывает все последующие символы относящиеся к классу и возвращает их
 832 |      *
 833 |      * @param int $class класс для захвата
 834 |      * @return string
 835 |      */
 836 |     protected function grabCharClass($class)
 837 |     {
 838 |         $result = "";
 839 |         while($this->curCharClass & $class)
 840 |         {
 841 |             $result .= $this->curChar;
 842 |             $this->moveNextPos();
 843 |         }
 844 | 
 845 |         return $result;
 846 |     }
 847 | 
 848 |     /**
 849 |      * Захватывает все последующие символы НЕ относящиеся к классу и возвращает их
 850 |      *
 851 |      * @param int $class класс для остановки захвата
 852 |      * @return string
 853 |      */
 854 |     protected function grabNotCharClass($class)
 855 |     {
 856 |         $result = "";
 857 |         while($this->curCharClass && ($this->curCharClass & $class) == self::NIL)
 858 |         {
 859 |             $result .= $this->curChar;
 860 |             $this->moveNextPos();
 861 |         }
 862 | 
 863 |         return $result;
 864 |     }
 865 | 
 866 |     /**
 867 |      * Готовит контент
 868 |      *
 869 |      * @param string|null $parentTag имя родительского тега
 870 |      * @return string
 871 |      */
 872 |     protected function makeContent($parentTag = null)
 873 |     {
 874 |         $content = "";
 875 | 
 876 |         $this->skipSpaces();
 877 |         $this->skipNL();
 878 | 
 879 |         while($this->curCharClass)
 880 |         {
 881 |             $tagName = null;
 882 |             $tagParams = array();
 883 |             $tagContent = null;
 884 |             $shortTag = false;
 885 | 
 886 |             // Если текущий тег это тег без текста - пропускаем символы до "<"
 887 |             if($this->tagsRules($this->curTag, self::TAG_PARENT_ONLY) && $this->curChar != '<')
 888 |             {
 889 |                 $this->skipTextToChar('<');
 890 |             }
 891 | 
 892 |             $this->saveState();
 893 | 
 894 |             // Тег в котором есть текст
 895 |             if($this->curChar == '<' && $this->matchTag($tagName, $tagParams, $tagContent, $shortTag))
 896 |             {
 897 |                 $tagBuilt = $this->makeTag($tagName, $tagParams, $tagContent, $shortTag, $parentTag);
 898 |                 $content .= $tagBuilt;
 899 | 
 900 |                 if(($this->tagsRules($tagName, self::TAG_BLOCK_TYPE) || $tagName == 'br') && $tagBuilt != "") {
 901 |                     $this->skipNL(1);
 902 |                 }
 903 | 
 904 |                 if($tagBuilt == "") {
 905 |                     $this->skipClass(self::SPACE | self::NL);
 906 |                 }
 907 |             }
 908 |             // Комментарий <!-- -->
 909 |             else if($this->curChar == '<' && $this->matchStr('<!--'))
 910 |             {
 911 |                 $this->skipTextToStr('-->') && $this->skipStr('-->');
 912 |                 $this->skipClass(self::SPACE | self::NL);
 913 |             }
 914 |             // Конец тега
 915 |             else if($this->curChar == '<' && $this->matchTagClose($tagName))
 916 |             {
 917 |                 if(!is_null($this->curTag))
 918 |                 {
 919 |                     $this->restoreState();
 920 |                     return $content;
 921 |                 }
 922 |                 else {
 923 |                     $this->setError('Не ожидалось закрывающего тега '.$tagName);
 924 |                 }
 925 |             }
 926 |             // Просто символ "<"
 927 |             else if($this->curChar == '<')
 928 |             {
 929 |                 if(!$this->tagsRules($this->curTag, self::TAG_PARENT_ONLY)) {
 930 |                     $content .= $this->entities['<'];
 931 |                 }
 932 | 
 933 |                 $this->moveNextPos();
 934 |             }
 935 |             // Наверно тут просто текст, формируем его
 936 |             else
 937 |             {
 938 |                 $content .= $this->makeText();
 939 |             }
 940 | 
 941 |             $this->removeState();
 942 |         }
 943 | 
 944 |         return $content;
 945 |     }
 946 | 
 947 |     /**
 948 |      * Обработка тега полностью
 949 |      *
 950 |      * @param string $tagName имя тега
 951 |      * @param array $tagParams параметры тега
 952 |      * @param string $tagContent контент тега
 953 |      * @param boolean $shortTag короткий ли тег
 954 |      * @return boolean
 955 |      */
 956 |     protected function matchTag(&$tagName, &$tagParams, &$tagContent, &$shortTag)
 957 |     {
 958 |         $tagName = null;
 959 |         $tagParams = array();
 960 |         $tagContent = '';
 961 |         $shortTag = false;
 962 |         $closeTag = null;
 963 | 
 964 |         if(!$this->matchTagOpen($tagName, $tagParams, $shortTag)) {
 965 |             return false;
 966 |         }
 967 | 
 968 |         if($shortTag) {
 969 |             return true;
 970 |         }
 971 | 
 972 |         $curTag = $this->curTag;
 973 |         $typoMode = $this->typoMode;
 974 | 
 975 |         if($this->tagsRules($tagName, self::TAG_NO_TYPOGRAPHY)) {
 976 |             $this->typoMode = false;
 977 |         }
 978 | 
 979 |         $this->curTag = $tagName;
 980 | 
 981 |         if($this->tagsRules($tagName, self::TAG_PREFORMATTED))
 982 |         {
 983 |             $tagContent = $this->makePreformatted($tagName);
 984 |         }
 985 |         else {
 986 |             $tagContent = $this->makeContent($tagName);
 987 |         }
 988 | 
 989 |         if($this->matchTagClose($closeTag) && ($tagName != $closeTag))
 990 |         {
 991 |             $this->setError("Неверный закрывающийся тег ".$closeTag.". Ожидалось закрытие ".$tagName."");
 992 |         }
 993 | 
 994 |         $this->curTag = $curTag;
 995 |         $this->typoMode = $typoMode;
 996 | 
 997 |         return true;
 998 |     }
 999 | 
1000 |     /**
1001 |      * Обработка открывающего тега
1002 |      *
1003 |      * @param string $tagName имя тега
1004 |      * @param array $tagParams параметры тега
1005 |      * @param boolean $shortTag короткий ли тег
1006 |      * @return boolean
1007 |      */
1008 |     protected function matchTagOpen(&$tagName, &$tagParams, &$shortTag)
1009 |     {
1010 |         if($this->curChar != '<') {
1011 |             return false;
1012 |         }
1013 | 
1014 |         $this->saveState();
1015 | 
1016 |         $this->skipSpaces() || $this->moveNextPos();
1017 | 
1018 |         $tagName = $this->grabCharClass(self::TAG_NAME);
1019 | 
1020 |         $this->skipSpaces();
1021 | 
1022 |         if($tagName == '') {
1023 |             $this->restoreState();
1024 |             return false;
1025 |         }
1026 | 
1027 |         $tagName = mb_strtolower($tagName, 'UTF-8');
1028 | 
1029 |         if($this->curChar != '>' && $this->curChar != '/') {
1030 |             $this->matchTagParams($tagParams);
1031 |         }
1032 | 
1033 |         $shortTag = $this->tagsRules($tagName, self::TAG_SHORT);
1034 | 
1035 |         if(!$shortTag && $this->curChar == '/') {
1036 |             $this->restoreState();
1037 |             return false;
1038 |         }
1039 | 
1040 |         if($shortTag && $this->curChar == '/') {
1041 |             $this->moveNextPos();
1042 |         }
1043 | 
1044 |         $this->skipSpaces();
1045 | 
1046 |         if($this->curChar != '>') {
1047 |             $this->restoreState();
1048 |             return false;
1049 |         }
1050 | 
1051 |         $this->removeState();
1052 |         $this->moveNextPos();
1053 | 
1054 |         return true;
1055 |     }
1056 | 
1057 |     /**
1058 |      * Обработка закрывающего тега
1059 |      *
1060 |      * @param string $tagName имя тега
1061 |      * @return boolean
1062 |      */
1063 |     protected function matchTagClose(&$tagName)
1064 |     {
1065 |         if($this->curChar != '<') {
1066 |             return false;
1067 |         }
1068 | 
1069 |         $this->saveState();
1070 | 
1071 |         $this->skipSpaces() || $this->moveNextPos();
1072 | 
1073 |         if($this->curChar != '/') {
1074 |             $this->restoreState();
1075 |             return false;
1076 |         }
1077 | 
1078 |         $this->skipSpaces() || $this->moveNextPos();
1079 | 
1080 |         $tagName = $this->grabCharClass(self::TAG_NAME);
1081 | 
1082 |         $this->skipSpaces();
1083 | 
1084 |         if($tagName == '' || $this->curChar != '>') {
1085 |             $this->restoreState();
1086 |             return false;
1087 |         }
1088 | 
1089 |         $tagName = mb_strtolower($tagName, 'UTF-8');
1090 | 
1091 |         $this->removeState();
1092 |         $this->moveNextPos();
1093 | 
1094 |         return true;
1095 |     }
1096 | 
1097 |     /**
1098 |      * Обработка параметров тега
1099 |      *
1100 |      * @param array $params массив параметров
1101 |      * @return boolean
1102 |      */
1103 |     protected function matchTagParams(&$params)
1104 |     {
1105 |         $name = null;
1106 |         $value = null;
1107 | 
1108 |         while($this->matchTagParam($name, $value))
1109 |         {
1110 |             if(mb_substr($name, 0, 1, 'UTF-8') != '-') {
1111 |                 $params[$name] = $value;
1112 |             }
1113 |             $name = $value = '';
1114 |         }
1115 | 
1116 |         return (count($params) > 0) ? true : false;
1117 |     }
1118 | 
1119 |     /**
1120 |      * Обработка одного параметра тега
1121 |      *
1122 |      * @param string $name имя параметра
1123 |      * @param string $value значение параметра
1124 |      * @return boolean
1125 |      */
1126 |     protected function matchTagParam(&$name, &$value)
1127 |     {
1128 |         $this->saveState();
1129 |         $this->skipSpaces();
1130 | 
1131 |         $name = $this->grabCharClass(self::TAG_PARAM_NAME);
1132 | 
1133 |         if($name == '') {
1134 |             $this->removeState();
1135 |             return false;
1136 |         }
1137 | 
1138 |         $this->skipSpaces();
1139 | 
1140 |         // Параметр без значения
1141 |         if($this->curChar != '=')
1142 |         {
1143 |             if($this->curChar == '>' || $this->curChar == '/' || (($this->curCharClass & self::TAG_PARAM_NAME) && $this->curChar != '-'))
1144 |             {
1145 |                 $value = '';
1146 | 
1147 |                 $this->removeState();
1148 |                 return true;
1149 |             }
1150 |             else {
1151 |                 $this->restoreState();
1152 |                 return false;
1153 |             }
1154 |         }
1155 |         else {
1156 |             $this->moveNextPos();
1157 |         }
1158 | 
1159 |         $this->skipSpaces();
1160 | 
1161 |         if(!$this->matchTagParamValue($value))
1162 |         {
1163 |             $this->restoreState();
1164 |             return false;
1165 |         }
1166 | 
1167 |         $this->skipSpaces();
1168 |         $this->removeState();
1169 | 
1170 |         return true;
1171 |     }
1172 | 
1173 |     /**
1174 |      * Обработка значения параметра тега
1175 |      *
1176 |      * @param string $value значение параметра
1177 |      * @return boolean
1178 |      */
1179 |     protected function matchTagParamValue(&$value)
1180 |     {
1181 |         if($this->curCharClass & self::TAG_QUOTE)
1182 |         {
1183 |             $quote = $this->curChar;
1184 |             $escape = false;
1185 | 
1186 |             $this->moveNextPos();
1187 | 
1188 |             while($this->curCharClass && ($this->curChar != $quote || $escape === true))
1189 |             {
1190 |                 $value .= (isset($this->entities[$this->curChar])) ? $this->entities[$this->curChar] : $this->curChar;
1191 | 
1192 |                 // Возможны экранированные кавычки
1193 |                 $escape = ($this->curChar == '\\') ? true : false;
1194 | 
1195 |                 $this->moveNextPos();
1196 |             }
1197 | 
1198 |             if($this->curChar != $quote) {
1199 |                 return false;
1200 |             }
1201 | 
1202 |             $this->moveNextPos();
1203 |         }
1204 |         else
1205 |         {
1206 |             while($this->curCharClass && ($this->curCharClass & self::SPACE) == self::NIL && $this->curChar != '>')
1207 |             {
1208 |                 $value .= (isset($this->entities[$this->curChar])) ? $this->entities[$this->curChar] : $this->curChar;
1209 |                 $this->moveNextPos();
1210 |             }
1211 |         }
1212 | 
1213 |         return true;
1214 |     }
1215 | 
1216 |     /**
1217 |      * Готовит преформатированный контент
1218 |      *
1219 |      * @param string $openTag текущий открывающий тег
1220 |      * @return string
1221 |      */
1222 |     protected function makePreformatted($openTag = null)
1223 |     {
1224 |         $content = "";
1225 | 
1226 |         while($this->curCharClass)
1227 |         {
1228 |             if($this->curChar == '<' && !is_null($openTag))
1229 |             {
1230 |                 $closeTag = '';
1231 |                 $this->saveState();
1232 | 
1233 |                 $isClosedTag = $this->matchTagClose($closeTag);
1234 | 
1235 |                 if($isClosedTag) {
1236 |                     $this->restoreState();
1237 |                 }
1238 |                 else {
1239 |                     $this->removeState();
1240 |                 }
1241 | 
1242 |                 if($isClosedTag && $openTag == $closeTag) {
1243 |                     break;
1244 |                 }
1245 |             }
1246 | 
1247 |             $content .= (isset($this->entities[$this->curChar])) ? $this->entities[$this->curChar] : $this->curChar;
1248 | 
1249 |             $this->moveNextPos();
1250 |         }
1251 | 
1252 |         return $content;
1253 |     }
1254 | 
1255 |     /**
1256 |      * Готовит тег к печати
1257 |      *
1258 |      * @param string $tagName имя тега
1259 |      * @param array $tagParams параметры тега
1260 |      * @param string $tagContent контент тега
1261 |      * @param boolean $shortTag короткий ли тег
1262 |      * @param string $parentTag имя тега родителя, если есть
1263 |      * @return boolean
1264 |      */
1265 |     protected function makeTag($tagName, $tagParams, $tagContent, $shortTag, $parentTag = null)
1266 |     {
1267 |         $text = "";
1268 |         $tagName = mb_strtolower($tagName, 'UTF-8');
1269 | 
1270 |         // Тег необходимо вырезать вместе с содержимым
1271 |         if($this->tagsRules($tagName, self::TAG_CUT)) {
1272 |             return "";
1273 |         }
1274 | 
1275 |         // Допустим ли тег к использованию
1276 |         if(!$this->tagsRules($tagName, self::TAG_ALLOWED)) {
1277 |             return ($this->tagsRules($parentTag, self::TAG_PARENT_ONLY)) ? "" : $tagContent;
1278 |         }
1279 | 
1280 |         // Должен ли тег НЕ быть дочерним к любому другому тегу
1281 |         if($this->tagsRules($tagName, self::TAG_GLOBAL_ONLY) && !is_null($parentTag)) {
1282 |             return $tagContent;
1283 |         }
1284 | 
1285 |         // Может ли тег находиться внутри родительского тега
1286 |         if($this->tagsRules($parentTag, self::TAG_PARENT_ONLY) && !$this->tagsRules($parentTag, self::TAG_CHILD, $tagName)) {
1287 |             return "";
1288 |         }
1289 | 
1290 |         // Тег может находиться только внутри другого тега
1291 |         if($this->tagsRules($tagName, self::TAG_CHILD_ONLY) && !$this->tagsRules($tagName, self::TAG_PARENT, $parentTag)) {
1292 |             return $tagContent;
1293 |         }
1294 | 
1295 |         // Параметры тега
1296 |         $tagParamsResult = array();
1297 |         foreach($tagParams as $param => $value)
1298 |         {
1299 |             $param = mb_strtolower($param, 'UTF-8');
1300 |             $value = trim($value);
1301 | 
1302 |             // Разрешен ли этот атрибут
1303 |             $paramAllowedValues = ($this->tagsRules($tagName, self::TAG_PARAM_ALLOWED, $param)) ? $this->tagsRules[$tagName][self::TAG_PARAM_ALLOWED][$param] : false;
1304 | 
1305 |             if($paramAllowedValues === false) {
1306 |                 continue;
1307 |             }
1308 | 
1309 |             // Параметр есть в списке и это массив возможных значений
1310 |             if(is_array($paramAllowedValues))
1311 |             {
1312 |                 if(isset($paramAllowedValues['#link']) && is_array($paramAllowedValues['#link']))
1313 |                 {
1314 |                     if(preg_match('#javascript:#iu', $value)) {
1315 |                         $this->setError('Попытка вставить JavaScript в URI');
1316 |                         continue;
1317 |                     }
1318 | 
1319 |                     $protocols = implode('|', array_map(function($item){
1320 |                         return $item.":";
1321 |                     }, $this->linkProtocolAllow));
1322 | 
1323 |                     $found = false;
1324 |                     foreach($paramAllowedValues['#link'] as $domain) {
1325 |                         $domain = preg_quote($domain);
1326 |                         // (http:|https:)? или то, или то, или ничего
1327 |                         if(preg_match('#^('.$protocols.')?//'.$domain.'(/|$)#iu', $value)) {
1328 |                             $found = true;
1329 |                             break;
1330 |                         }
1331 |                     }
1332 |                     if(!$found) {
1333 |                         $this->setError('Недопустимое значение "'.$value.'" для атрибута "'.$param.'" тега "'.$tagName.'"');
1334 |                         continue;
1335 |                     }
1336 |                 }
1337 |                 else if(!in_array($value, $paramAllowedValues))
1338 |                 {
1339 |                     $this->setError('Недопустимое значение "'.$value.'" для атрибута "'.$param.'" тега "'.$tagName.'"');
1340 |                     continue;
1341 |                 }
1342 |             }
1343 | 
1344 |             // Параметр есть в списке и это строка представляющая правило
1345 |             if(is_string($paramAllowedValues))
1346 |             {
1347 |                 if($paramAllowedValues == '#int')
1348 |                 {
1349 |                     if(!preg_match('#^[0-9]+$#iu', $value)) {
1350 |                         $this->setError('Недопустимое значение "'.$value.'" для атрибута "'.$param.'" тега "'.$tagName.'". Ожидалось число');
1351 |                         continue;
1352 |                     }
1353 |                 }
1354 | 
1355 |                 else if($paramAllowedValues == '#text')
1356 |                 {
1357 |                     // ничего не делаем
1358 |                 }
1359 | 
1360 |                 else if($paramAllowedValues == '#bool')
1361 |                 {
1362 |                     $value = null;
1363 |                 }
1364 | 
1365 |                 else if($paramAllowedValues == '#link')
1366 |                 {
1367 |                     if(preg_match('#javascript:#iu', $value)) {
1368 |                         $this->setError('Попытка вставить JavaScript в URI');
1369 |                         continue;
1370 |                     }
1371 | 
1372 |                     if(!preg_match('#^[a-z0-9\/\#]#iu', $value)) {
1373 |                         $this->setError('Первый символ URL должен быть буквой, цифрой, символами слеша или решетки');
1374 |                         continue;
1375 |                     }
1376 | 
1377 |                     $protocols = implode('|', array_map(function($item){
1378 |                         return $item.":";
1379 |                     }, $this->linkProtocolAllow));
1380 | 
1381 |                     // (http:|https:)? или то, или то, или ничего
1382 |                     if(!preg_match('#^('.$protocols.')?\/\/#iu', $value) && !preg_match('#^(\/|\#)#iu', $value) && !preg_match('#^mailto:#iu', $value))
1383 |                     {
1384 |                         $value = 'http://'.$value;
1385 |                     }
1386 |                 }
1387 | 
1388 |                 else if(strpos($paramAllowedValues, '#regexp') === 0)
1389 |                 {
1390 |                     if(preg_match('#^\#regexp\((.*?)\)$#iu', $paramAllowedValues, $match)) {
1391 |                         if(!preg_match('#^'.$match[1].'$#iu', $value)) {
1392 |                             $this->setError('Недопустимое значение "'.$value.'" для атрибута "'.$param.'" тега "'.$tagName.'". Ожидалась строка подходящая под регулярное выражение "'.$match[1].'"');
1393 |                             continue;
1394 |                         }
1395 |                     } else {
1396 |                         $this->setError('Недопустимое значение "'.$value.'" для атрибута "'.$param.'" тега "'.$tagName.'". Ожидалось "'.$paramAllowedValues.'"');
1397 |                         continue;
1398 |                     }
1399 |                 }
1400 | 
1401 |                 else if($paramAllowedValues != $value)
1402 |                 {
1403 |                     $this->setError('Недопустимое значение "'.$value.'" для атрибута "'.$param.'" тега "'.$tagName.'". Ожидалось "'.$paramAllowedValues.'"');
1404 |                     continue;
1405 |                 }
1406 |             }
1407 | 
1408 |             $tagParamsResult[$param] = $value;
1409 |         }
1410 | 
1411 |         // Проверка обязательных параметров тега
1412 |         $requiredParams = ($this->tagsRules($tagName, self::TAG_PARAM_REQUIRED)) ? array_keys($this->tagsRules[$tagName][self::TAG_PARAM_REQUIRED]) : array();
1413 | 
1414 |         foreach($requiredParams as $requiredParam)
1415 |         {
1416 |             if(!isset($tagParamsResult[$requiredParam])) {
1417 |                 return $tagContent;
1418 |             }
1419 |         }
1420 | 
1421 |         // Авто добавляемые параметры
1422 |         if($this->tagsRules($tagName, self::TAG_PARAM_AUTO_ADD))
1423 |         {
1424 |             foreach($this->tagsRules[$tagName][self::TAG_PARAM_AUTO_ADD] as $param => $value)
1425 |             {
1426 |                 if(!isset($tagParamsResult[$param]) || $value['rewrite']) {
1427 |                     $tagParamsResult[$param] = $value['value'];
1428 |                 }
1429 |             }
1430 |         }
1431 | 
1432 |         // Удаляем пустые не короткие теги если не сказано другого
1433 |         if(!$this->tagsRules($tagName, self::TAG_EMPTY))
1434 |         {
1435 |             if(!$shortTag && $tagContent == '') {
1436 |                 return '';
1437 |             }
1438 |         }
1439 | 
1440 |         // Вызываем callback функцию event... перед сборкой тега
1441 |         if($this->tagsRules($tagName, self::TAG_EVENT_CALLBACK))
1442 |         {
1443 |             call_user_func($this->tagsRules[$tagName][self::TAG_EVENT_CALLBACK], $tagName, $tagParamsResult, $tagContent);
1444 |         }
1445 | 
1446 |         // Вызываем callback функцию, если тег собирается именно так
1447 |         if($this->tagsRules($tagName, self::TAG_BUILD_CALLBACK))
1448 |         {
1449 |             return call_user_func($this->tagsRules[$tagName][self::TAG_BUILD_CALLBACK], $tagName, $tagParamsResult, $tagContent);
1450 |         }
1451 | 
1452 |         // Собираем тег
1453 |         $text .= '<'.$tagName;
1454 | 
1455 |         foreach($tagParamsResult as $param => $value)
1456 |         {
1457 |             if (is_null($value)) {
1458 |                 if ($this->isXHTMLMode) {
1459 |                     $text .= ' '.$param.'="'.$param.'"';
1460 |                 } else {
1461 |                     $text .= ' '.$param;
1462 |                 }
1463 |             } else {
1464 |                 $text .= ' '.$param.'="'.$value.'"';
1465 |             }
1466 |         }
1467 | 
1468 |         $text .= ($shortTag && $this->isXHTMLMode) ? '/>' : '>';
1469 | 
1470 |         if($this->tagsRules($tagName, self::TAG_PARENT_ONLY)) {
1471 |             $text .= "\n";
1472 |         }
1473 | 
1474 |         if(!$shortTag) {
1475 |             $text .= $tagContent.'</'.$tagName.'>';
1476 |         }
1477 | 
1478 |         if($this->tagsRules($parentTag, self::TAG_PARENT_ONLY)) {
1479 |             $text .= "\n";
1480 |         }
1481 | 
1482 |         if($this->tagsRules($tagName, self::TAG_BLOCK_TYPE)) {
1483 |             $text .= "\n";
1484 |         }
1485 | 
1486 |         if($tagName == 'br') {
1487 |             $text .= "\n";
1488 |         }
1489 | 
1490 |         return $text;
1491 |     }
1492 | 
1493 |     /**
1494 |      * Проверяет текущую позицию на вхождение тире пригодного для замены
1495 |      *
1496 |      * @param string $dash тире
1497 |      * @return boolean
1498 |      */
1499 |     protected function matchDash(&$dash = '')
1500 |     {
1501 |         if($this->curChar != '-') {
1502 |             return false;
1503 |         }
1504 | 
1505 |         if(($this->prevCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET)) == self::NIL && $this->prevCharClass != self::NIL) {
1506 |             return false;
1507 |         }
1508 | 
1509 |         $this->saveState();
1510 | 
1511 |         while($this->nextChar == '-') {
1512 |             $this->moveNextPos();
1513 |         }
1514 | 
1515 |         if(($this->nextCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET)) == self::NIL && $this->nextCharClass != self::NIL) {
1516 |             $this->restoreState();
1517 |             return false;
1518 |         }
1519 |         else
1520 |         {
1521 |             $dash = $this->dash;
1522 |             $this->removeState();
1523 |             $this->moveNextPos();
1524 |             return true;
1525 |         }
1526 |     }
1527 | 
1528 |     /**
1529 |      * Определяет HTML сущности
1530 |      *
1531 |      * @param string $entity сущность
1532 |      * @return boolean
1533 |      */
1534 |     protected function matchHTMLEntity(&$entity = '')
1535 |     {
1536 |         if($this->curChar != '&') {
1537 |             return "";
1538 |         }
1539 | 
1540 |         $this->saveState();
1541 |         $this->moveNextPos();
1542 | 
1543 |         if($this->curChar == '#')
1544 |         {
1545 |             $this->moveNextPos();
1546 | 
1547 |             $entityCode = $this->grabCharClass(self::NUMERIC);
1548 | 
1549 |             if($entityCode == '' || $this->curChar != ';') {
1550 |                 $this->restoreState();
1551 |                 return false;
1552 |             }
1553 |             else {
1554 |                 $this->removeState();
1555 |                 $this->moveNextPos();
1556 |             }
1557 | 
1558 |             $entity = html_entity_decode("&#".$entityCode.";", ENT_COMPAT, 'UTF-8');
1559 | 
1560 |             return true;
1561 |         }
1562 |         else
1563 |         {
1564 |             $entityName = $this->grabCharClass(self::ALPHA | self::NUMERIC);
1565 | 
1566 |             if($entityName == '' || $this->curChar != ';') {
1567 |                 $this->restoreState();
1568 |                 return false;
1569 |             }
1570 |             else {
1571 |                 $this->removeState();
1572 |                 $this->moveNextPos();
1573 |             }
1574 | 
1575 |             $entity = html_entity_decode("&".$entityName.";", ENT_COMPAT, 'UTF-8');
1576 | 
1577 |             return true;
1578 |         }
1579 |     }
1580 | 
1581 |     /**
1582 |      * Проверяет текущую позицию на вхождение кавычки пригодной для замены
1583 |      *
1584 |      * @param string $quote кавычка
1585 |      * @return boolean
1586 |      */
1587 |     protected function matchQuote(&$quote = '')
1588 |     {
1589 |         if(($this->curCharClass & self::TEXT_QUOTE) == self::NIL) {
1590 |             return false;
1591 |         }
1592 | 
1593 |         $type = ($this->quotesOpened >= 2) ||
1594 |                 ($this->quotesOpened > 0 &&
1595 |                 ((($this->prevCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET)) == self::NIL && $this->prevCharClass != self::NIL) ||
1596 |                  (($this->nextCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET | self::PUNCTUATUON)) || $this->nextCharClass == self::NIL))) ? 'close' : 'open';
1597 | 
1598 | 
1599 |         if($type == 'open' && ($this->prevCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET)) == self::NIL && $this->prevCharClass != self::NIL) {
1600 |             return false;
1601 |         }
1602 | 
1603 |         if($type == 'close' && ($this->nextCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET | self::PUNCTUATUON)) == self::NIL && $this->nextCharClass != self::NIL) {
1604 |             return false;
1605 |         }
1606 | 
1607 |         $this->quotesOpened += ($type == 'open') ? 1 : -1;
1608 | 
1609 |         $level = ($type == 'open') ? $this->quotesOpened - 1 : $this->quotesOpened;
1610 |         $index = ($type == 'open') ? 0 : 1;
1611 | 
1612 |         $quote = $this->quotes[$level][$index];
1613 | 
1614 |         $this->moveNextPos();
1615 | 
1616 |         return true;
1617 |     }
1618 | 
1619 |     /**
1620 |      * Пытается найти и "сделать" текст
1621 |      *
1622 |      * @return string
1623 |      */
1624 |     protected function makeText()
1625 |     {
1626 |         $text = '';
1627 | 
1628 |         while($this->curChar != '<' && $this->curCharClass)
1629 |         {
1630 |             $brCount = 0;
1631 |             $spResult = null;
1632 |             $entity = null;
1633 |             $quote = null;
1634 |             $dash = null;
1635 |             $url = null;
1636 | 
1637 |             // Преобразование HTML сущностей
1638 |             if($this->curChar == '&' && $this->matchHTMLEntity($entity))
1639 |             {
1640 |                 $text .= (isset($this->entities[$entity])) ? $this->entities[$entity] : $entity;
1641 |             }
1642 |             // Добавление символов пунктуации
1643 |             else if($this->curCharClass & self::PUNCTUATUON)
1644 |             {
1645 |                 $text .= $this->curChar;
1646 |                 $this->moveNextPos();
1647 |             }
1648 |             // Преобразование символов тире в длинное тире
1649 |             else if($this->typoMode && $this->curChar == '-' && $this->matchDash($dash))
1650 |             {
1651 |                 $text .= $dash;
1652 |             }
1653 |             // Преобразование кавычек
1654 |             else if($this->typoMode && ($this->curCharClass & self::TEXT_QUOTE) && $this->matchQuote($quote))
1655 |             {
1656 |                 $text .= $quote;
1657 |             }
1658 |             // Преобразование пробельных символов
1659 |             else if($this->curCharClass & self::SPACE)
1660 |             {
1661 |                 $this->skipSpaces();
1662 | 
1663 |                 $text .= ' ';
1664 |             }
1665 |             // Преобразование символов перевода строк в тег <br>
1666 |             else if($this->isAutoBrMode && ($this->curCharClass & self::NL))
1667 |             {
1668 |                 $brCount = $this->skipNL();
1669 | 
1670 |                 if(!$this->tagsRules($this->curTag, self::TAG_NO_AUTO_BR))
1671 |                 {
1672 |                     $br = $this->br."\n";
1673 |                     $text .= ($brCount == 1) ? $br : $br.$br;
1674 |                 }
1675 |             }
1676 |             // Преобразование текста похожего на ссылку в кликабельную ссылку
1677 |             else if($this->isAutoLinkMode && ($this->curCharClass & self::ALPHA) && $this->curTag != 'a' && $this->matchURL($url))
1678 |             {
1679 |                 $text .= $this->makeTag('a' , array('href' => $url), $url, false);
1680 |             }
1681 |             // Вызов callback-функции если строка предварена специальным символом
1682 |             else if($this->isSpecialCharMode && ($this->curCharClass & self::SPECIAL_CHAR) && $this->curTag != 'a' && $this->matchSpecialChar($spResult))
1683 |             {
1684 |                 $text .= $spResult;
1685 |             }
1686 |             // Другие печатные символы
1687 |             else if($this->curCharClass & self::PRINATABLE)
1688 |             {
1689 |                 $text .= (isset($this->entities[$this->curChar])) ? $this->entities[$this->curChar] : $this->curChar;
1690 |                 $this->moveNextPos();
1691 |             }
1692 |             // Не печатные символы
1693 |             else
1694 |             {
1695 |                 $this->moveNextPos();
1696 |             }
1697 |         }
1698 | 
1699 |         return $text;
1700 |     }
1701 | 
1702 |     /**
1703 |      * Определяет текстовые ссылки
1704 |      *
1705 |      * @param string $url ссылка
1706 |      * @return boolean
1707 |      */
1708 |     protected function matchURL(&$url = '')
1709 |     {
1710 |         if(($this->prevCharClass & (self::SPACE | self::NL | self::TEXT_QUOTE | self::TEXT_BRACKET)) == self::NIL && $this->prevCharClass != self::NIL) {
1711 |             return false;
1712 |         }
1713 | 
1714 |         $this->saveState();
1715 | 
1716 |         if($this->matchStr('http://') && in_array('http', $this->linkProtocolAllow)) {}
1717 |         else if($this->matchStr('https://') && in_array('https', $this->linkProtocolAllow)) {}
1718 |         else if($this->matchStr('ftp://') && in_array('ftp', $this->linkProtocolAllow)) {}
1719 |         else if($this->matchStr('www.')) {
1720 |             $url = "http://";
1721 |         } else {
1722 |             $this->restoreState();
1723 |             return false;
1724 |         }
1725 | 
1726 |         $openBracket = (($this->prevCharClass & self::TEXT_BRACKET) && isset($this->bracketsALL[$this->prevChar])) ? $this->prevChar : null;
1727 |         $closeBracket = (!is_null($openBracket)) ? $this->bracketsALL[$this->prevChar] : null;
1728 | 
1729 |         $openedBracket = (!is_null($openBracket)) ? 1 : 0;
1730 | 
1731 |         $buffer = "";
1732 |         while($this->curCharClass & self::PRINATABLE)
1733 |         {
1734 |             if($this->curChar == "<") {
1735 |                 break;
1736 |             }
1737 |             else if(($this->curCharClass & self::TEXT_QUOTE)) {
1738 |                 break;
1739 |             }
1740 |             else if(($this->curCharClass & self::TEXT_BRACKET) && $openedBracket > 0)
1741 |             {
1742 |                 if($this->curChar == $closeBracket && $openedBracket == 1) {
1743 |                     break;
1744 |                 }
1745 | 
1746 |                 if($this->curChar == $openBracket) { $openedBracket += 1; }
1747 |                 if($this->curChar == $closeBracket) { $openedBracket -= 1; }
1748 |             }
1749 |             else if($this->curCharClass & self::PUNCTUATUON)
1750 |             {
1751 |                 $this->saveState();
1752 |                 $punctuatuon = $this->grabCharClass(self::PUNCTUATUON);
1753 | 
1754 |                 if(($this->curCharClass & self::PRINATABLE) == self::NIL)
1755 |                 {
1756 |                     $this->restoreState();
1757 |                     break;
1758 |                 }
1759 |                 else {
1760 |                     $this->removeState();
1761 |                     $buffer .= $punctuatuon;
1762 | 
1763 |                     if(($this->curCharClass & (self::TEXT_QUOTE | self::TEXT_BRACKET))) {
1764 |                         break;
1765 |                     }
1766 |                 }
1767 |             }
1768 | 
1769 |             $buffer .= $this->curChar;
1770 |             $this->moveNextPos();
1771 |         }
1772 | 
1773 |         if($buffer == "")
1774 |         {
1775 |             $this->restoreState();
1776 |             return false;
1777 |         }
1778 |         else
1779 |         {
1780 |             $this->removeState();
1781 |         }
1782 | 
1783 |         $url = $url.$buffer;
1784 | 
1785 |         return true;
1786 |     }
1787 | 
1788 |     /**
1789 |      * Определяет строки предваренные спецсимволами
1790 |      *
1791 |      * @param string $spResult результат работы callback-функции
1792 |      * @return boolean
1793 |      */
1794 |     protected function matchSpecialChar(&$spResult = '')
1795 |     {
1796 |         if(($this->curCharClass & self::SPECIAL_CHAR) == self::NIL) {
1797 |             return false;
1798 |         }
1799 | 
1800 |         if(!isset($this->specialChars[$this->curChar])) {
1801 |             return false;
1802 |         }
1803 | 
1804 |         if($this->prevCharClass && ($this->prevCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET)) == self::NIL) {
1805 |             return false;
1806 |         }
1807 | 
1808 |         $buffer = "";
1809 |         $spChar = $this->curChar;
1810 | 
1811 |         $this->saveState();
1812 |         $this->moveNextPos();
1813 | 
1814 |         if(($this->curCharClass & self::TEXT_BRACKET) && isset($this->bracketsSPC[$this->curChar]))
1815 |         {
1816 |             $closeBracket = $this->bracketsSPC[$this->curChar];
1817 |             $escape = false;
1818 | 
1819 |             $this->moveNextPos();
1820 | 
1821 |             while($this->curCharClass && ($this->curCharClass & self::NL) == self::NIL && ($this->curChar != $closeBracket || $escape === true))
1822 |             {
1823 |                 if(($this->curCharClass & self::SPACE) && ($this->prevCharClass & self::SPACE))
1824 |                 {
1825 |                     $this->skipSpaces();
1826 |                     continue;
1827 |                 }
1828 | 
1829 |                 $buffer .= $this->curChar;
1830 | 
1831 |                 // Возможны экранированные скобки
1832 |                 $escape = ($this->curChar == '\\') ? true : false;
1833 | 
1834 |                 $this->moveNextPos();
1835 |             }
1836 | 
1837 |             if($this->curChar != $closeBracket) {
1838 |                 $this->restoreState();
1839 |                 return false;
1840 |             }
1841 | 
1842 |             $this->moveNextPos();
1843 |         }
1844 |         else
1845 |         {
1846 |             while($this->curCharClass && ($this->curCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET)) == self::NIL)
1847 |             {
1848 |                 if($this->curCharClass & self::PUNCTUATUON)
1849 |                 {
1850 |                     $this->saveState();
1851 | 
1852 |                     $punctuatuon = $this->grabCharClass(self::PUNCTUATUON);
1853 | 
1854 |                     if($this->curCharClass & (self::SPACE | self::NL | self::TEXT_BRACKET) || $this->curCharClass == self::NIL)
1855 |                     {
1856 |                         $this->restoreState();
1857 |                         break;
1858 |                     }
1859 |                     else {
1860 |                         $this->removeState();
1861 |                         $buffer .= $punctuatuon;
1862 |                     }
1863 |                 }
1864 | 
1865 |                 $buffer .= $this->curChar;
1866 |                 $this->moveNextPos();
1867 |             }
1868 |         }
1869 | 
1870 |         $buffer = trim($buffer);
1871 | 
1872 |         if($buffer == "")
1873 |         {
1874 |             $this->restoreState();
1875 |             return false;
1876 |         }
1877 | 
1878 |         $spResult = call_user_func($this->specialChars[$spChar], $buffer);
1879 | 
1880 |         if(!$spResult) {
1881 |             $this->restoreState();
1882 |             return false;
1883 |         }
1884 | 
1885 |         $this->removeState();
1886 | 
1887 |         return true;
1888 |     }
1889 | 
1890 |     /**
1891 |      * Возвращает код символа по его строковому представлению
1892 |      *
1893 |      * @param string $chr символ
1894 |      * @return int|boolean
1895 |      */
1896 |     public static function ord($chr)
1897 |     {
1898 |         $ord = ord($chr[0]);
1899 | 
1900 |         if($ord < 0x80) return $ord;
1901 |         if($ord < 0xC2) return false;
1902 |         if($ord < 0xE0) return ($ord & 0x1F) <<  6 | (ord($chr[1]) & 0x3F);
1903 |         if($ord < 0xF0) return ($ord & 0x0F) << 12 | (ord($chr[1]) & 0x3F) << 6  | (ord($chr[2]) & 0x3F);
1904 |         if($ord < 0xF5) return ($ord & 0x0F) << 18 | (ord($chr[1]) & 0x3F) << 12 | (ord($chr[2]) & 0x3F) << 6 | (ord($chr[3]) & 0x3F);
1905 | 
1906 |         return false;
1907 |     }
1908 | 
1909 |     /*
1910 |      * Медленно!
1911 |      *
1912 |     public static function ord($chr)
1913 |     {
1914 |         $result = unpack('N', mb_convert_encoding($chr, 'UCS-4BE', 'UTF-8'));
1915 |         return (is_array($result)) ? $result[1] : false;
1916 |     }
1917 |     */
1918 | 
1919 |     /**
1920 |      * Возвращает строковое представление символа по его коду
1921 |      *
1922 |      * @param string $ord код символа
1923 |      * @return string|boolean
1924 |      */
1925 |     public static function chr($ord)
1926 |     {
1927 |         if($ord < 0x80)     return chr($ord);
1928 |         if($ord < 0x800)    return chr(0xC0 | $ord >> 6)  . chr(0x80 | $ord & 0x3F);
1929 |         if($ord < 0x10000)  return chr(0xE0 | $ord >> 12) . chr(0x80 | $ord >> 6  & 0x3F) . chr(0x80 | $ord & 0x3F);
1930 |         if($ord < 0x110000) return chr(0xF0 | $ord >> 18) . chr(0x80 | $ord >> 12 & 0x3F) . chr(0x80 | $ord >> 6 & 0x3F) . chr(0x80 | $ord & 0x3F);
1931 | 
1932 |         return false;
1933 |     }
1934 | 
1935 |     /*
1936 |      * Медленно...
1937 |      *
1938 |     public static function chr($ord)
1939 |     {
1940 |         return mb_convert_encoding('&#'.intval($ord).';', 'UTF-8', 'HTML-ENTITIES');
1941 |     }
1942 |     */
1943 | 
1944 |     /**
1945 |      * Устанавливает сообщение об ошибке (для внутренних нужд)
1946 |      *
1947 |      * @param string $message сообщение об ошибке
1948 |      * @return void
1949 |      */
1950 |     protected function setError($message)
1951 |     {
1952 |         $this->errorsList[] = array(
1953 |             'message' => $message,
1954 |             'position' => $this->curPos
1955 |         );
1956 |     }
1957 | 
1958 |     /**
1959 |      * Получить сообщения список сообщений об ошибке
1960 |      *
1961 |      * @return array
1962 |      */
1963 |     public function getError()
1964 |     {
1965 |         return $this->errorsList;
1966 |     }
1967 | }
1968 | ?>
1969 | 


--------------------------------------------------------------------------------