724 lines
22 KiB
JavaScript
724 lines
22 KiB
JavaScript
'use strict';
|
|
|
|
/*
|
|
new function() {
|
|
var parser = new EasySAXParser();
|
|
|
|
parser.ns('rss', { // or false
|
|
'http://search.yahoo.com/mrss/': 'media',
|
|
'http://www.w3.org/1999/xhtml': 'xhtml',
|
|
'http://www.w3.org/2005/Atom': 'atom',
|
|
'http://purl.org/rss/1.0/': 'rss',
|
|
});
|
|
|
|
parser.on('error', function(msgError) {
|
|
});
|
|
|
|
parser.on('startNode', function(elemName, getAttr, isTagEnd, getStrNode) {
|
|
var attr = getAttr();
|
|
});
|
|
|
|
parser.on('endNode', function(elemName, isTagStart, getStrNode) {
|
|
});
|
|
|
|
parser.on('textNode', function(text) {
|
|
});
|
|
|
|
parser.on('cdata', function(data) {
|
|
});
|
|
|
|
|
|
parser.on('comment', function(text) {
|
|
//console.log('--'+text+'--')
|
|
});
|
|
|
|
//parser.on('unknownNS', function(key) {console.log('unknownNS: ' + key)});
|
|
//parser.on('question', function() {}); // <? ... ?>
|
|
//parser.on('attention', function() {}); // <!XXXXX zzzz="eeee">
|
|
|
|
console.time('easysax');
|
|
for(var z=1000;z--;) {
|
|
parser.parse(xml)
|
|
};
|
|
console.timeEnd('easysax');
|
|
};
|
|
|
|
*/
|
|
|
|
// << ------------------------------------------------------------------------ >> //
|
|
|
|
EasySAXParser.entityDecode = xmlEntityDecode;
|
|
export default EasySAXParser;
|
|
|
|
var stringFromCharCode = String.fromCharCode;
|
|
var objectCreate = Object.create;
|
|
function NULL_FUNC() {};
|
|
|
|
function entity2char(x) {
|
|
if (x === 'amp') {
|
|
return '&';
|
|
};
|
|
|
|
switch(x.toLocaleLowerCase()) {
|
|
case 'quot': return '"';
|
|
case 'amp': return '&'
|
|
case 'lt': return '<'
|
|
case 'gt': return '>'
|
|
|
|
case 'plusmn': return '\u00B1';
|
|
case 'laquo': return '\u00AB';
|
|
case 'raquo': return '\u00BB';
|
|
case 'micro': return '\u00B5';
|
|
case 'nbsp': return '\u00A0';
|
|
case 'copy': return '\u00A9';
|
|
case 'sup2': return '\u00B2';
|
|
case 'sup3': return '\u00B3';
|
|
case 'para': return '\u00B6';
|
|
case 'reg': return '\u00AE';
|
|
case 'deg': return '\u00B0';
|
|
case 'apos': return '\'';
|
|
};
|
|
|
|
return '&' + x + ';';
|
|
};
|
|
|
|
function replaceEntities(s, d, x, z) {
|
|
if (z) {
|
|
return entity2char(z);
|
|
};
|
|
|
|
if (d) {
|
|
return stringFromCharCode(d);
|
|
};
|
|
|
|
return stringFromCharCode(parseInt(x, 16));
|
|
};
|
|
|
|
function xmlEntityDecode(s) {
|
|
var s = ('' + s);
|
|
|
|
if (s.length > 3 && s.indexOf('&') !== -1) {
|
|
if (s.indexOf('<') !== -1) {s = s.replace(/</g, '<');}
|
|
if (s.indexOf('>') !== -1) {s = s.replace(/>/g, '>');}
|
|
if (s.indexOf('"') !== -1) {s = s.replace(/"/g, '"');}
|
|
|
|
if (s.indexOf('&') !== -1) {
|
|
s = s.replace(/&#(\d+);|&#x([0123456789abcdef]+);|&(\w+);/ig, replaceEntities);
|
|
};
|
|
};
|
|
|
|
return s;
|
|
};
|
|
|
|
function cloneMatrixNS(nsmatrix) {
|
|
var nn = objectCreate(null);
|
|
for (var n in nsmatrix) {
|
|
nn[n] = nsmatrix[n];
|
|
};
|
|
return nn;
|
|
};
|
|
|
|
|
|
function EasySAXParser(config) {
|
|
if (!this) {
|
|
return null;
|
|
};
|
|
|
|
var onTextNode = NULL_FUNC, onStartNode = NULL_FUNC, onEndNode = NULL_FUNC, onCDATA = NULL_FUNC, onError = NULL_FUNC, onComment, onQuestion, onAttention, onUnknownNS;
|
|
var is_onComment = false, is_onQuestion = false, is_onAttention = false, is_onUnknownNS = false;
|
|
|
|
var isAutoEntity = true; // делать "EntityDecode" всегда
|
|
var entityDecode = xmlEntityDecode;
|
|
var hasSurmiseNS = false;
|
|
var isNamespace = false;
|
|
var returnError = null;
|
|
var parseStop = false; // прервать парсер
|
|
var defaultNS;
|
|
var nsmatrix = null;
|
|
var useNS;
|
|
var xml = ''; // string
|
|
|
|
|
|
this.setup = function (op) {
|
|
for (var name in op) {
|
|
switch(name) {
|
|
case 'entityDecode': entityDecode = op.entityDecode || entityDecode; break;
|
|
case 'autoEntity': isAutoEntity = !!op.autoEntity; break;
|
|
case 'defaultNS': defaultNS = op.defaultNS || null; break;
|
|
case 'ns': isNamespace = !!(useNS = op.ns || null); break;
|
|
case 'on':
|
|
var listeners = op.on;
|
|
for (var ev in listeners) {
|
|
this.on(ev, listeners[ev]);
|
|
};
|
|
break;
|
|
};
|
|
};
|
|
};
|
|
|
|
this.on = function(name, cb) {
|
|
if (typeof cb !== 'function') {
|
|
if (cb !== null) {
|
|
throw error('required args on(string, function||null)');
|
|
};
|
|
};
|
|
|
|
switch(name) {
|
|
case 'startNode': onStartNode = cb || NULL_FUNC; break;
|
|
case 'textNode': onTextNode = cb || NULL_FUNC; break;
|
|
case 'endNode': onEndNode = cb || NULL_FUNC; break;
|
|
case 'error': onError = cb || NULL_FUNC; break;
|
|
case 'cdata': onCDATA = cb || NULL_FUNC; break;
|
|
|
|
case 'unknownNS': onUnknownNS = cb; is_onUnknownNS = !!cb; break;
|
|
case 'attention': onAttention = cb; is_onAttention = !!cb; break; // <!XXXXX zzzz="eeee">
|
|
case 'question': onQuestion = cb; is_onQuestion = !!cb; break; // <? .... ?>
|
|
case 'comment': onComment = cb; is_onComment = !!cb; break;
|
|
};
|
|
};
|
|
|
|
this.ns = function(root, ns) {
|
|
if (!root) {
|
|
isNamespace = false;
|
|
defaultNS = null;
|
|
useNS = null;
|
|
return this;
|
|
};
|
|
|
|
if (!ns || typeof root !== 'string') {
|
|
throw error('required args ns(string, object)');
|
|
};
|
|
|
|
isNamespace = !!(useNS = ns || null);
|
|
defaultNS = root || null;
|
|
|
|
return this;
|
|
};
|
|
|
|
this.parse = function(_xml) {
|
|
if (typeof _xml !== 'string') {
|
|
return 'required args parser(string)'; // error
|
|
};
|
|
|
|
returnError = null;
|
|
xml = _xml;
|
|
|
|
if (isNamespace) {
|
|
nsmatrix = objectCreate(null);
|
|
nsmatrix.xmlns = defaultNS;
|
|
|
|
parse();
|
|
|
|
nsmatrix = null;
|
|
|
|
} else {
|
|
parse();
|
|
};
|
|
|
|
parseStop = false;
|
|
attrRes = true;
|
|
xml = '';
|
|
|
|
return returnError;
|
|
};
|
|
|
|
this.stop = function() {
|
|
parseStop = true;
|
|
};
|
|
|
|
if (config) {
|
|
this.setup(config);
|
|
};
|
|
|
|
// -----------------------------------------------------
|
|
|
|
|
|
var stringNodePosStart; // number
|
|
var stringNodePosEnd; // number
|
|
var attrStartPos; // number начало позиции атрибутов в строке attrString <(div^ class="xxxx" title="sssss")/>
|
|
var attrString; // строка атрибутов <(div class="xxxx" title="sssss")/>
|
|
var attrRes; // закешированный результат разбора атрибутов , null - разбор не проводился, object - хеш атрибутов, true - нет атрибутов, false - невалидный xml
|
|
|
|
/*
|
|
парсит атрибуты по требованию. Важно! - функция не генерирует исключения.
|
|
|
|
если была ошибка разбора возврашается false
|
|
если атрибутов нет и разбор удачен то возврашается true
|
|
если есть атрибуты то возврашается обьект(хеш)
|
|
*/
|
|
|
|
function getAttrs() {
|
|
if (attrRes !== null) {
|
|
return attrRes;
|
|
};
|
|
|
|
var xmlnsAlias;
|
|
var nsAttrName;
|
|
var attrList = isNamespace && hasSurmiseNS ? [] : null;
|
|
var i = attrStartPos + 1; // так как первый символ уже был проверен
|
|
var s = attrString;
|
|
var l = s.length;
|
|
var hasNewMatrix;
|
|
var newalias;
|
|
var value;
|
|
var alias;
|
|
var name;
|
|
var res = {};
|
|
var ok;
|
|
var w;
|
|
var j;
|
|
|
|
|
|
for(; i < l; i++) {
|
|
w = s.charCodeAt(i);
|
|
|
|
if (w === 32 || (w < 14 && w > 8) ) { // \f\n\r\t\v
|
|
continue
|
|
};
|
|
|
|
if (w < 65 || w > 122 || (w > 90 && w < 97) ) { // недопустимые первые символы
|
|
if (w !== 95 && w !== 58) { // char 95"_" 58":"
|
|
return attrRes = false; // error. invalid first char
|
|
};
|
|
};
|
|
|
|
for(j = i + 1; j < l; j++) { // проверяем все символы имени атрибута
|
|
w = s.charCodeAt(j);
|
|
|
|
if ( w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 45 || w === 95) {
|
|
continue;
|
|
};
|
|
|
|
if (w !== 61) { // "=" == 61
|
|
return attrRes = false; // error. invalid char "="
|
|
};
|
|
|
|
break;
|
|
};
|
|
|
|
name = s.substring(i, j);
|
|
ok = true;
|
|
|
|
if (name === 'xmlns:xmlns') {
|
|
return attrRes = false; // error. invalid name
|
|
};
|
|
|
|
w = s.charCodeAt(j + 1);
|
|
|
|
if (w === 34) { // '"'
|
|
j = s.indexOf('"', i = j + 2 );
|
|
|
|
} else {
|
|
if (w !== 39) { // "'"
|
|
return attrRes = false; // error. invalid char
|
|
};
|
|
|
|
j = s.indexOf('\'', i = j + 2 );
|
|
};
|
|
|
|
if (j === -1) {
|
|
return attrRes = false; // error. invalid char
|
|
};
|
|
|
|
if (j + 1 < l) {
|
|
w = s.charCodeAt(j + 1);
|
|
|
|
if (w > 32 || w < 9 || (w < 32 && w > 13)) {
|
|
// error. invalid char
|
|
return attrRes = false;
|
|
};
|
|
};
|
|
|
|
|
|
value = s.substring(i, j);
|
|
i = j + 1; // след. семвол уже проверен потому проверять нужно следуюший
|
|
|
|
if (isAutoEntity) {
|
|
value = entityDecode(value);
|
|
};
|
|
|
|
if (!isNamespace) { //
|
|
res[name] = value;
|
|
continue;
|
|
};
|
|
|
|
if (hasSurmiseNS) {
|
|
// есть подозрение что в атрибутах присутствует xmlns
|
|
newalias = (name !== 'xmlns'
|
|
? name.charCodeAt(0) === 120 && name.substr(0, 6) === 'xmlns:' ? name.substr(6) : null
|
|
: 'xmlns'
|
|
);
|
|
|
|
if (newalias !== null) {
|
|
alias = useNS[entityDecode(value)];
|
|
if (is_onUnknownNS && !alias) {
|
|
alias = onUnknownNS(value);
|
|
};
|
|
|
|
if (alias) {
|
|
if (nsmatrix[newalias] !== alias) {
|
|
if (!hasNewMatrix) {
|
|
nsmatrix = cloneMatrixNS(nsmatrix);
|
|
hasNewMatrix = true;
|
|
};
|
|
|
|
nsmatrix[newalias] = alias;
|
|
};
|
|
} else {
|
|
if (nsmatrix[newalias]) {
|
|
if (!hasNewMatrix) {
|
|
nsmatrix = cloneMatrixNS(nsmatrix);
|
|
hasNewMatrix = true;
|
|
};
|
|
|
|
nsmatrix[newalias] = false;
|
|
};
|
|
};
|
|
|
|
res[name] = value;
|
|
continue;
|
|
};
|
|
|
|
attrList.push(name, value);
|
|
continue;
|
|
};
|
|
|
|
w = name.indexOf(':');
|
|
if (w === -1) {
|
|
res[name] = value;
|
|
continue;
|
|
};
|
|
|
|
if (nsAttrName = nsmatrix[name.substring(0, w)]) {
|
|
nsAttrName = nsmatrix['xmlns'] === nsAttrName ? name.substr(w + 1) : nsAttrName + name.substr(w);
|
|
res[nsAttrName + name.substr(w)] = value;
|
|
};
|
|
};
|
|
|
|
|
|
if (!ok) {
|
|
return attrRes = true; // атрибутов нет, ошибок тоже нет
|
|
};
|
|
|
|
if (hasSurmiseNS) {
|
|
xmlnsAlias = nsmatrix['xmlns'];
|
|
|
|
for (i = 0, l = attrList.length; i < l; i++) {
|
|
name = attrList[i++];
|
|
|
|
w = name.indexOf(':');
|
|
if (w !== -1) {
|
|
if (nsAttrName = nsmatrix[name.substring(0, w)]) {
|
|
nsAttrName = xmlnsAlias === nsAttrName ? name.substr(w + 1) : nsAttrName + name.substr(w);
|
|
res[nsAttrName] = attrList[i];
|
|
};
|
|
continue;
|
|
};
|
|
res[name] = attrList[i];
|
|
};
|
|
};
|
|
|
|
return attrRes = res;
|
|
};
|
|
|
|
function getStringNode() {
|
|
return xml.substring(stringNodePosStart, stringNodePosEnd + 1);
|
|
};
|
|
|
|
|
|
function parse() {
|
|
var stacknsmatrix = [];
|
|
var nodestack = [];
|
|
var stopIndex = 0;
|
|
var _nsmatrix;
|
|
var isTagStart = false;
|
|
var isTagEnd = false;
|
|
var x, y, q, w;
|
|
var j = 0;
|
|
var i = 0;
|
|
var xmlns;
|
|
var elem;
|
|
var stop; // используется при разборе "namespace" . если встретился неизвестное пространство то события не генерируются
|
|
|
|
|
|
while(j !== -1) {
|
|
stop = stopIndex > 0;
|
|
|
|
if (xml.charCodeAt(j) === 60) { // "<"
|
|
i = j;
|
|
} else {
|
|
i = xml.indexOf('<', j);
|
|
};
|
|
|
|
if (i === -1) { // конец разбора
|
|
if (nodestack.length) {
|
|
onError(returnError = 'unexpected end parse');
|
|
return;
|
|
};
|
|
|
|
if (j === 0) {
|
|
onError(returnError = 'missing first tag');
|
|
return;
|
|
};
|
|
|
|
return;
|
|
};
|
|
|
|
if (j !== i && !stop) {
|
|
onTextNode(isAutoEntity ? entityDecode(xml.substring(j, i)) : xml.substring(j, i));
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
};
|
|
|
|
w = xml.charCodeAt(i+1);
|
|
|
|
if (w === 33) { // "!"
|
|
w = xml.charCodeAt(i+2);
|
|
if (w === 91 && xml.substr(i + 3, 6) === 'CDATA[') { // 91 == "["
|
|
j = xml.indexOf(']]>', i);
|
|
if (j === -1) {
|
|
onError(returnError = 'cdata');
|
|
return;
|
|
};
|
|
|
|
if (!stop) {
|
|
onCDATA(xml.substring(i + 9, j));
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
};
|
|
|
|
j += 3;
|
|
continue;
|
|
};
|
|
|
|
|
|
if (w === 45 && xml.charCodeAt(i + 3) === 45) { // 45 == "-"
|
|
j = xml.indexOf('-->', i);
|
|
if (j === -1) {
|
|
onError(returnError = 'expected -->');
|
|
return;
|
|
};
|
|
|
|
|
|
if (is_onComment && !stop) {
|
|
onComment(isAutoEntity ? entityDecode(xml.substring(i + 4, j)) : xml.substring(i + 4, j));
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
};
|
|
|
|
j += 3;
|
|
continue;
|
|
};
|
|
|
|
j = xml.indexOf('>', i + 1);
|
|
if (j === -1) {
|
|
onError(returnError = 'expected ">"');
|
|
return;
|
|
};
|
|
|
|
if (is_onAttention && !stop) {
|
|
onAttention(xml.substring(i, j + 1));
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
};
|
|
|
|
j += 1;
|
|
continue;
|
|
};
|
|
|
|
if (w === 63) { // "?"
|
|
j = xml.indexOf('?>', i);
|
|
if (j === -1) { // error
|
|
onError(returnError = '...?>');
|
|
return;
|
|
};
|
|
|
|
if (is_onQuestion) {
|
|
onQuestion(xml.substring(i, j + 2));
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
};
|
|
|
|
j += 2;
|
|
continue;
|
|
};
|
|
|
|
j = xml.indexOf('>', i + 1);
|
|
|
|
if (j == -1) { // error
|
|
onError(returnError = 'unclosed tag'); // ...>
|
|
return;
|
|
};
|
|
|
|
attrRes = true; // атрибутов нет
|
|
|
|
//if (xml.charCodeAt(i+1) === 47) { // </...
|
|
if (w === 47) { // </...
|
|
isTagStart = false;
|
|
isTagEnd = true;
|
|
|
|
// проверяем что должен быть закрыт тотже тег что и открывался
|
|
if (!nodestack.length) {
|
|
onError(returnError = 'close tag, requires open tag');
|
|
return;
|
|
};
|
|
|
|
x = elem = nodestack.pop();
|
|
q = i + 2 + elem.length;
|
|
|
|
if (elem !== xml.substring(i + 2, q)) {
|
|
onError(returnError = 'close tag, not equal to the open tag');
|
|
return;
|
|
};
|
|
|
|
// проверим что в закрываюшем теге нет лишнего
|
|
for(; q < j; q++) {
|
|
w = xml.charCodeAt(q);
|
|
|
|
if (w === 32 || (w > 8 && w < 14)) { // \f\n\r\t\v пробел
|
|
continue;
|
|
};
|
|
|
|
onError(returnError = 'close tag');
|
|
return;
|
|
};
|
|
|
|
} else {
|
|
if (xml.charCodeAt(j - 1) === 47) { // .../>
|
|
x = elem = xml.substring(i + 1, j - 1);
|
|
|
|
isTagStart = true;
|
|
isTagEnd = true;
|
|
|
|
} else {
|
|
x = elem = xml.substring(i + 1, j);
|
|
|
|
isTagStart = true;
|
|
isTagEnd = false;
|
|
};
|
|
|
|
if (!(w > 96 && w < 123 || w > 64 && w < 91 || w === 95 || w === 58)) { // char 95"_" 58":"
|
|
onError(returnError = 'first char nodeName');
|
|
return;
|
|
};
|
|
|
|
for (q = 1, y = x.length; q < y; q++) {
|
|
w = x.charCodeAt(q);
|
|
|
|
if (w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 45 || w === 95) {
|
|
continue;
|
|
};
|
|
|
|
if (w === 32 || (w < 14 && w > 8)) { // \f\n\r\t\v пробел
|
|
attrRes = null; // возможно есть атирибуты
|
|
elem = x.substring(0, q)
|
|
break;
|
|
};
|
|
|
|
onError(returnError = 'invalid nodeName');
|
|
return;
|
|
};
|
|
|
|
if (!isTagEnd) {
|
|
nodestack.push(elem);
|
|
};
|
|
};
|
|
|
|
|
|
if (isNamespace) {
|
|
if (stop) { // потомки неизвестного пространства имен
|
|
if (isTagEnd) {
|
|
if (!isTagStart) {
|
|
if (--stopIndex === 0) {
|
|
nsmatrix = stacknsmatrix.pop();
|
|
};
|
|
};
|
|
|
|
} else {
|
|
stopIndex += 1;
|
|
};
|
|
|
|
j += 1;
|
|
continue;
|
|
};
|
|
|
|
// добавляем в stacknsmatrix только если !isTagEnd, иначе сохраняем контекст пространств в переменной
|
|
_nsmatrix = nsmatrix;
|
|
if (!isTagEnd) {
|
|
stacknsmatrix.push(nsmatrix);
|
|
};
|
|
|
|
if (isTagStart && (attrRes === null)) {
|
|
if (hasSurmiseNS = x.indexOf('xmlns', q) !== -1) { // есть подозрение на xmlns
|
|
attrStartPos = q;
|
|
attrString = x;
|
|
|
|
getAttrs();
|
|
|
|
hasSurmiseNS = false;
|
|
};
|
|
};
|
|
|
|
w = elem.indexOf(':');
|
|
if (w !== -1) {
|
|
xmlns = nsmatrix[elem.substring(0, w)];
|
|
elem = elem.substr(w + 1);
|
|
|
|
} else {
|
|
xmlns = nsmatrix.xmlns;
|
|
};
|
|
|
|
|
|
if (!xmlns) {
|
|
// элемент неизвестного пространства имен
|
|
if (isTagEnd) {
|
|
nsmatrix = _nsmatrix; // так как тут всегда isTagStart
|
|
} else {
|
|
stopIndex = 1; // первый элемент для которого не определено пространство имен
|
|
};
|
|
|
|
j += 1;
|
|
continue;
|
|
};
|
|
|
|
elem = xmlns + ':' + elem;
|
|
};
|
|
|
|
stringNodePosStart = i;
|
|
stringNodePosEnd = j;
|
|
|
|
if (isTagStart) {
|
|
attrStartPos = q;
|
|
attrString = x;
|
|
|
|
onStartNode(elem, getAttrs, isTagEnd, getStringNode);
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
};
|
|
|
|
if (isTagEnd) {
|
|
onEndNode(elem, isTagStart, getStringNode);
|
|
if (parseStop) {
|
|
return;
|
|
};
|
|
|
|
if (isNamespace) {
|
|
if (isTagStart) {
|
|
nsmatrix = _nsmatrix;
|
|
} else {
|
|
nsmatrix = stacknsmatrix.pop();
|
|
};
|
|
};
|
|
};
|
|
|
|
j += 1;
|
|
};
|
|
};
|
|
};
|