You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
455 lines
12 KiB
455 lines
12 KiB
var parse = require('../definition-syntax/parse'); |
|
|
|
var MATCH = { type: 'Match' }; |
|
var MISMATCH = { type: 'Mismatch' }; |
|
var DISALLOW_EMPTY = { type: 'DisallowEmpty' }; |
|
var LEFTPARENTHESIS = 40; // ( |
|
var RIGHTPARENTHESIS = 41; // ) |
|
|
|
function createCondition(match, thenBranch, elseBranch) { |
|
// reduce node count |
|
if (thenBranch === MATCH && elseBranch === MISMATCH) { |
|
return match; |
|
} |
|
|
|
if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) { |
|
return match; |
|
} |
|
|
|
if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) { |
|
thenBranch = match.then; |
|
match = match.match; |
|
} |
|
|
|
return { |
|
type: 'If', |
|
match: match, |
|
then: thenBranch, |
|
else: elseBranch |
|
}; |
|
} |
|
|
|
function isFunctionType(name) { |
|
return ( |
|
name.length > 2 && |
|
name.charCodeAt(name.length - 2) === LEFTPARENTHESIS && |
|
name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS |
|
); |
|
} |
|
|
|
function isEnumCapatible(term) { |
|
return ( |
|
term.type === 'Keyword' || |
|
term.type === 'AtKeyword' || |
|
term.type === 'Function' || |
|
term.type === 'Type' && isFunctionType(term.name) |
|
); |
|
} |
|
|
|
function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) { |
|
switch (combinator) { |
|
case ' ': |
|
// Juxtaposing components means that all of them must occur, in the given order. |
|
// |
|
// a b c |
|
// = |
|
// match a |
|
// then match b |
|
// then match c |
|
// then MATCH |
|
// else MISMATCH |
|
// else MISMATCH |
|
// else MISMATCH |
|
var result = MATCH; |
|
|
|
for (var i = terms.length - 1; i >= 0; i--) { |
|
var term = terms[i]; |
|
|
|
result = createCondition( |
|
term, |
|
result, |
|
MISMATCH |
|
); |
|
}; |
|
|
|
return result; |
|
|
|
case '|': |
|
// A bar (|) separates two or more alternatives: exactly one of them must occur. |
|
// |
|
// a | b | c |
|
// = |
|
// match a |
|
// then MATCH |
|
// else match b |
|
// then MATCH |
|
// else match c |
|
// then MATCH |
|
// else MISMATCH |
|
|
|
var result = MISMATCH; |
|
var map = null; |
|
|
|
for (var i = terms.length - 1; i >= 0; i--) { |
|
var term = terms[i]; |
|
|
|
// reduce sequence of keywords into a Enum |
|
if (isEnumCapatible(term)) { |
|
if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) { |
|
map = Object.create(null); |
|
result = createCondition( |
|
{ |
|
type: 'Enum', |
|
map: map |
|
}, |
|
MATCH, |
|
result |
|
); |
|
} |
|
|
|
if (map !== null) { |
|
var key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase(); |
|
if (key in map === false) { |
|
map[key] = term; |
|
continue; |
|
} |
|
} |
|
} |
|
|
|
map = null; |
|
|
|
// create a new conditonal node |
|
result = createCondition( |
|
term, |
|
MATCH, |
|
result |
|
); |
|
}; |
|
|
|
return result; |
|
|
|
case '&&': |
|
// A double ampersand (&&) separates two or more components, |
|
// all of which must occur, in any order. |
|
|
|
// Use MatchOnce for groups with a large number of terms, |
|
// since &&-groups produces at least N!-node trees |
|
if (terms.length > 5) { |
|
return { |
|
type: 'MatchOnce', |
|
terms: terms, |
|
all: true |
|
}; |
|
} |
|
|
|
// Use a combination tree for groups with small number of terms |
|
// |
|
// a && b && c |
|
// = |
|
// match a |
|
// then [b && c] |
|
// else match b |
|
// then [a && c] |
|
// else match c |
|
// then [a && b] |
|
// else MISMATCH |
|
// |
|
// a && b |
|
// = |
|
// match a |
|
// then match b |
|
// then MATCH |
|
// else MISMATCH |
|
// else match b |
|
// then match a |
|
// then MATCH |
|
// else MISMATCH |
|
// else MISMATCH |
|
var result = MISMATCH; |
|
|
|
for (var i = terms.length - 1; i >= 0; i--) { |
|
var term = terms[i]; |
|
var thenClause; |
|
|
|
if (terms.length > 1) { |
|
thenClause = buildGroupMatchGraph( |
|
combinator, |
|
terms.filter(function(newGroupTerm) { |
|
return newGroupTerm !== term; |
|
}), |
|
false |
|
); |
|
} else { |
|
thenClause = MATCH; |
|
} |
|
|
|
result = createCondition( |
|
term, |
|
thenClause, |
|
result |
|
); |
|
}; |
|
|
|
return result; |
|
|
|
case '||': |
|
// A double bar (||) separates two or more options: |
|
// one or more of them must occur, in any order. |
|
|
|
// Use MatchOnce for groups with a large number of terms, |
|
// since ||-groups produces at least N!-node trees |
|
if (terms.length > 5) { |
|
return { |
|
type: 'MatchOnce', |
|
terms: terms, |
|
all: false |
|
}; |
|
} |
|
|
|
// Use a combination tree for groups with small number of terms |
|
// |
|
// a || b || c |
|
// = |
|
// match a |
|
// then [b || c] |
|
// else match b |
|
// then [a || c] |
|
// else match c |
|
// then [a || b] |
|
// else MISMATCH |
|
// |
|
// a || b |
|
// = |
|
// match a |
|
// then match b |
|
// then MATCH |
|
// else MATCH |
|
// else match b |
|
// then match a |
|
// then MATCH |
|
// else MATCH |
|
// else MISMATCH |
|
var result = atLeastOneTermMatched ? MATCH : MISMATCH; |
|
|
|
for (var i = terms.length - 1; i >= 0; i--) { |
|
var term = terms[i]; |
|
var thenClause; |
|
|
|
if (terms.length > 1) { |
|
thenClause = buildGroupMatchGraph( |
|
combinator, |
|
terms.filter(function(newGroupTerm) { |
|
return newGroupTerm !== term; |
|
}), |
|
true |
|
); |
|
} else { |
|
thenClause = MATCH; |
|
} |
|
|
|
result = createCondition( |
|
term, |
|
thenClause, |
|
result |
|
); |
|
}; |
|
|
|
return result; |
|
} |
|
} |
|
|
|
function buildMultiplierMatchGraph(node) { |
|
var result = MATCH; |
|
var matchTerm = buildMatchGraph(node.term); |
|
|
|
if (node.max === 0) { |
|
// disable repeating of empty match to prevent infinite loop |
|
matchTerm = createCondition( |
|
matchTerm, |
|
DISALLOW_EMPTY, |
|
MISMATCH |
|
); |
|
|
|
// an occurrence count is not limited, make a cycle; |
|
// to collect more terms on each following matching mismatch |
|
result = createCondition( |
|
matchTerm, |
|
null, // will be a loop |
|
MISMATCH |
|
); |
|
|
|
result.then = createCondition( |
|
MATCH, |
|
MATCH, |
|
result // make a loop |
|
); |
|
|
|
if (node.comma) { |
|
result.then.else = createCondition( |
|
{ type: 'Comma', syntax: node }, |
|
result, |
|
MISMATCH |
|
); |
|
} |
|
} else { |
|
// create a match node chain for [min .. max] interval with optional matches |
|
for (var i = node.min || 1; i <= node.max; i++) { |
|
if (node.comma && result !== MATCH) { |
|
result = createCondition( |
|
{ type: 'Comma', syntax: node }, |
|
result, |
|
MISMATCH |
|
); |
|
} |
|
|
|
result = createCondition( |
|
matchTerm, |
|
createCondition( |
|
MATCH, |
|
MATCH, |
|
result |
|
), |
|
MISMATCH |
|
); |
|
} |
|
} |
|
|
|
if (node.min === 0) { |
|
// allow zero match |
|
result = createCondition( |
|
MATCH, |
|
MATCH, |
|
result |
|
); |
|
} else { |
|
// create a match node chain to collect [0 ... min - 1] required matches |
|
for (var i = 0; i < node.min - 1; i++) { |
|
if (node.comma && result !== MATCH) { |
|
result = createCondition( |
|
{ type: 'Comma', syntax: node }, |
|
result, |
|
MISMATCH |
|
); |
|
} |
|
|
|
result = createCondition( |
|
matchTerm, |
|
result, |
|
MISMATCH |
|
); |
|
} |
|
} |
|
|
|
return result; |
|
} |
|
|
|
function buildMatchGraph(node) { |
|
if (typeof node === 'function') { |
|
return { |
|
type: 'Generic', |
|
fn: node |
|
}; |
|
} |
|
|
|
switch (node.type) { |
|
case 'Group': |
|
var result = buildGroupMatchGraph( |
|
node.combinator, |
|
node.terms.map(buildMatchGraph), |
|
false |
|
); |
|
|
|
if (node.disallowEmpty) { |
|
result = createCondition( |
|
result, |
|
DISALLOW_EMPTY, |
|
MISMATCH |
|
); |
|
} |
|
|
|
return result; |
|
|
|
case 'Multiplier': |
|
return buildMultiplierMatchGraph(node); |
|
|
|
case 'Type': |
|
case 'Property': |
|
return { |
|
type: node.type, |
|
name: node.name, |
|
syntax: node |
|
}; |
|
|
|
case 'Keyword': |
|
return { |
|
type: node.type, |
|
name: node.name.toLowerCase(), |
|
syntax: node |
|
}; |
|
|
|
case 'AtKeyword': |
|
return { |
|
type: node.type, |
|
name: '@' + node.name.toLowerCase(), |
|
syntax: node |
|
}; |
|
|
|
case 'Function': |
|
return { |
|
type: node.type, |
|
name: node.name.toLowerCase() + '(', |
|
syntax: node |
|
}; |
|
|
|
case 'String': |
|
// convert a one char length String to a Token |
|
if (node.value.length === 3) { |
|
return { |
|
type: 'Token', |
|
value: node.value.charAt(1), |
|
syntax: node |
|
}; |
|
} |
|
|
|
// otherwise use it as is |
|
return { |
|
type: node.type, |
|
value: node.value.substr(1, node.value.length - 2).replace(/\\'/g, '\''), |
|
syntax: node |
|
}; |
|
|
|
case 'Token': |
|
return { |
|
type: node.type, |
|
value: node.value, |
|
syntax: node |
|
}; |
|
|
|
case 'Comma': |
|
return { |
|
type: node.type, |
|
syntax: node |
|
}; |
|
|
|
default: |
|
throw new Error('Unknown node type:', node.type); |
|
} |
|
} |
|
|
|
module.exports = { |
|
MATCH: MATCH, |
|
MISMATCH: MISMATCH, |
|
DISALLOW_EMPTY: DISALLOW_EMPTY, |
|
buildMatchGraph: function(syntaxTree, ref) { |
|
if (typeof syntaxTree === 'string') { |
|
syntaxTree = parse(syntaxTree); |
|
} |
|
|
|
return { |
|
type: 'MatchGraph', |
|
match: buildMatchGraph(syntaxTree), |
|
syntax: ref || null, |
|
source: syntaxTree |
|
}; |
|
} |
|
};
|
|
|