1045637538

Build Type

github

Committed by GitHub

Commit Message

Merge 5ddcd2afa into 91e42575e

Pull Request Pull Request #397: Compare jscodegen

Run Details

4709 of 5056 branches covered (93.14%)

Branch coverage included in aggregate %.

181 of 189 new or added lines in 11 files covered. (95.77%)

1 existing line in 1 file now uncovered.

9379 of 9605 relevant lines covered (97.65%)

5688982.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.76

/src/jsCodegen/emitCompare.ts

import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import { emitOperand } from './emitOperand';
// import { emitBaseExpr } from './emitBaseExpression';
import {
        acceptAst,
        CompiledResultType,
        FunctionIdentifier,
        getCompiledValueCode,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';

/**
 * Generates javascript code for a value compare expression.
 *
 * @param ast The ast of the value compare expression
 * @param compareType The type of comparison we're executing
 * @param firstExpr The generated code of the first expression
 * @param secondExpr The generated code of the second expression
 * @param identifier The identifier of the result
 * @param staticContext The code generation context
 * @returns Generated code of the value compare
 */
export function emitValueCompare(
        ast: IAST,
        compareType: string,
        firstExpr: PartialCompilationResult,
        secondExpr: PartialCompilationResult,
        identifier: string,
        _staticContext: CodeGenContext
): PartialCompilationResult {
        const leftType = astHelper.getAttribute(
                astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST,
                'type'
        );
        const rightType = astHelper.getAttribute(
                astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST,
                'type'
        );

        if (!firstExpr.isAstAccepted || !secondExpr.isAstAccepted) {
                return rejectAst("One of the two operands in compare wasn't accepted");
        }

        // Make sure both child expression got annotated
        if (!leftType || !rightType) {
                return rejectAst("Operands in compare weren't annotated");
        }

        const compareOperators: Record<string, string> = {
                eqOp: '===',
                neOp: '!==',
        };

        // Make sure we support the comparison type
        if (!compareOperators[compareType]) {
                return rejectAst(compareType + ' not yet implemented');
        }

        // Get the correct operator
        const operator = compareOperators[compareType];

        // String - string compare
        if (leftType.type === ValueType.XSSTRING && rightType.type === ValueType.XSSTRING) {
                // We just execute the compare operator with the two operands.
                const code = `
                function ${identifier}(contextItem) {
                        ${firstExpr.variables.join('\n')}
                        ${secondExpr.variables.join('\n')}
                        return ${getCompiledValueCode(firstExpr.code, firstExpr.resultType)} 
                                        ${operator}
                                        ${getCompiledValueCode(secondExpr.code, secondExpr.resultType)};
                }
                `;

                return acceptAst(code, CompiledResultType.Function);
        }
        // Node - string compare
        else if (leftType.type === ValueType.NODE && rightType.type === ValueType.XSSTRING) {
                // If the left-hand operand is an empty node sequence, we just return an empty sequence.
                // Otherwise we execute the correct comparison operator
                const code = `
                function ${identifier}(contextItem) {
                        ${firstExpr.variables.join('\n')}
                        ${secondExpr.variables.join('\n')}
                        const value = ${getCompiledValueCode(firstExpr.code, firstExpr.resultType)}.next();
                        
                        if (value.done) return [];

                        return value.value.value.node.nodeValue
                                        ${operator}
                                        ${getCompiledValueCode(secondExpr.code, secondExpr.resultType)};
                }
                `;

                return acceptAst(code, CompiledResultType.Function);
        } else {
                return rejectAst('Value compare only supports strings for now');
        }
}

/**
 * Generates javascript code for a general compare expression.
 *
 * @param ast The ast of the general compare expression
 * @param compareType The type of comparison we're executing
 * @param firstExpr The generated code of the first expression
 * @param secondExpr The generated code of the second expression
 * @param identifier The identifier of the result
 * @param staticContext The code generation context
 * @returns Generated code of the general compare
 */
export function emitGeneralCompare(
        ast: IAST,
        compareType: string,
        firstExpr: PartialCompilationResult,
        secondExpr: PartialCompilationResult,
        identifier: string,
        staticContext: CodeGenContext
): PartialCompilationResult {
        const firstAstOp = astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST;
        const firstType: SequenceType = astHelper.getAttribute(ast, 'type');
        const secondAstOp = astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST;
        const secondType: SequenceType = astHelper.getAttribute(ast, 'type');
        if (!firstType || !secondType) {
                return rejectAst('types of compare are not known');
        }
        if (
                firstType.mult === SequenceMultiplicity.EXACTLY_ONE &&
                secondType.mult === SequenceMultiplicity.EXACTLY_ONE
        ) {
                return emitValueCompare(
                        ast,
                        OPERATOR_TRANSLATION[compareType],
                        firstExpr,
                        secondExpr,
                        identifier,
                        staticContext
                );
        } else {
                return rejectAst('generalCompare with sequences is still in development');
        }
}

/**
 * Compiles compare expressions to a JavaScript function.
 *
 *
 * @param ast Logical expression AST node.
 * @param identifier Function identifier for the emitted function
 * @param staticContext Static context parameter to retrieve context-dependent information.
 * @param compareType The exact operator that will be compiled
 * @returns Wrapped compare expression.
 */
export function emitCompareExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext,
        compareType: string
): PartialCompilationResult {
        const firstExpr = emitOperand(ast, identifier, 'firstOperand', staticContext);
        if (!firstExpr.isAstAccepted) {
                return firstExpr;
        }

        const secondExpr = emitOperand(ast, identifier, 'secondOperand', staticContext);
        if (!secondExpr.isAstAccepted) {
                return secondExpr;
        }

        switch (compareType) {
                // valueCompare
                case 'eqOp':
                case 'neOp':
                case 'ltOp':
                case 'leOp':
                case 'gtOp':
                case 'geOp':
                case 'isOp':
                        return emitValueCompare(
                                ast,
                                compareType,
                                firstExpr,
                                secondExpr,
                                identifier,
                                staticContext
                        );
                // generalCompare
                case 'equalOp':
                case 'notEqualOp':
                case 'lessThanOrEqualOp':
                case 'lessThanOp':
                case 'greaterThanOrEqualOp':
                case 'greaterThanOp':
                        return emitGeneralCompare(
                                ast,
                                compareType,
                                firstExpr,
                                secondExpr,
                                identifier,
                                staticContext
                        );
                // nodeCompare
                case 'nodeBeforeOp':
                case 'nodeAfterOp':
                default:
                        return rejectAst('Unsupported compare type');
        }
}

/**
 *  A map to translate from general compare to value compare
 */
const OPERATOR_TRANSLATION: { [s: string]: string } = {
        ['equalOp']: 'eqOp',
        ['notEqualOp']: 'neOp',
        ['lessThanOrEqualOp']: 'leOp',
        ['lessThanOp']: 'ltOp',
        ['greaterThanOrEqualOp']: 'geOp',
        ['greaterThanOp']: 'gtOp',
};

1	import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
2	import astHelper, { IAST } from '../parsing/astHelper';	18✔
3	import { CodeGenContext } from './CodeGenContext';
4	import { emitOperand } from './emitOperand';	18✔
5	// import { emitBaseExpr } from './emitBaseExpression';
6	import {	18✔
7	acceptAst,
8	CompiledResultType,
9	FunctionIdentifier,
10	getCompiledValueCode,
11	PartialCompilationResult,
12	rejectAst,
13	} from './JavaScriptCompiledXPath';
14
15	/**
16	* Generates javascript code for a value compare expression.
17	*
18	* @param ast The ast of the value compare expression
19	* @param compareType The type of comparison we're executing
20	* @param firstExpr The generated code of the first expression
21	* @param secondExpr The generated code of the second expression
22	* @param identifier The identifier of the result
23	* @param staticContext The code generation context
24	* @returns Generated code of the value compare
25	*/
26	export function emitValueCompare(	18✔
27	ast: IAST,
28	compareType: string,
29	firstExpr: PartialCompilationResult,
30	secondExpr: PartialCompilationResult,
31	identifier: string,
32	_staticContext: CodeGenContext
33	): PartialCompilationResult {
34	const leftType = astHelper.getAttribute(	282✔
35	astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST,
36	'type'
37	);
38	const rightType = astHelper.getAttribute(	282✔
39	astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST,
40	'type'
41	);
42
43	if (!firstExpr.isAstAccepted \|\| !secondExpr.isAstAccepted) {	282!
NEW 44	return rejectAst("One of the two operands in compare wasn't accepted");	×
45	}
46
47	// Make sure both child expression got annotated
48	if (!leftType \|\| !rightType) {	282✔
49	return rejectAst("Operands in compare weren't annotated");	12✔
50	}
51
52	const compareOperators: Record<string, string> = {	270✔
53	eqOp: '===',
54	neOp: '!==',
55	};
56
57	// Make sure we support the comparison type
58	if (!compareOperators[compareType]) {	270✔
59	return rejectAst(compareType + ' not yet implemented');	72✔
60	}
61
62	// Get the correct operator
63	const operator = compareOperators[compareType];	198✔
64
65	// String - string compare
66	if (leftType.type === ValueType.XSSTRING && rightType.type === ValueType.XSSTRING) {	198✔
67	// We just execute the compare operator with the two operands.
68	const code = `	120✔
69	function ${identifier}(contextItem) {
70	${firstExpr.variables.join('\n')}
71	${secondExpr.variables.join('\n')}
72	return ${getCompiledValueCode(firstExpr.code, firstExpr.resultType)}
73	${operator}
74	${getCompiledValueCode(secondExpr.code, secondExpr.resultType)};
75	}
76	`;
77
78	return acceptAst(code, CompiledResultType.Function);	120✔
79	}
80	// Node - string compare
81	else if (leftType.type === ValueType.NODE && rightType.type === ValueType.XSSTRING) {	78✔
82	// If the left-hand operand is an empty node sequence, we just return an empty sequence.
83	// Otherwise we execute the correct comparison operator
84	const code = `	48✔
85	function ${identifier}(contextItem) {
86	${firstExpr.variables.join('\n')}
87	${secondExpr.variables.join('\n')}
88	const value = ${getCompiledValueCode(firstExpr.code, firstExpr.resultType)}.next();
89
90	if (value.done) return [];
91
92	return value.value.value.node.nodeValue
93	${operator}
94	${getCompiledValueCode(secondExpr.code, secondExpr.resultType)};
95	}
96	`;
97
98	return acceptAst(code, CompiledResultType.Function);	48✔
99	} else {
100	return rejectAst('Value compare only supports strings for now');	30✔
101	}
102	}
103
104	/**
105	* Generates javascript code for a general compare expression.
106	*
107	* @param ast The ast of the general compare expression
108	* @param compareType The type of comparison we're executing
109	* @param firstExpr The generated code of the first expression
110	* @param secondExpr The generated code of the second expression
111	* @param identifier The identifier of the result
112	* @param staticContext The code generation context
113	* @returns Generated code of the general compare
114	*/
115	export function emitGeneralCompare(	18✔
116	ast: IAST,
117	compareType: string,
118	firstExpr: PartialCompilationResult,
119	secondExpr: PartialCompilationResult,
120	identifier: string,
121	staticContext: CodeGenContext
122	): PartialCompilationResult {
123	const firstAstOp = astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST;	48✔
124	const firstType: SequenceType = astHelper.getAttribute(ast, 'type');	48✔
125	const secondAstOp = astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST;	48✔
126	const secondType: SequenceType = astHelper.getAttribute(ast, 'type');	48✔
127	if (!firstType \|\| !secondType) {	48!
NEW 128	return rejectAst('types of compare are not known');	×
129	}
130	if (	48!
131	firstType.mult === SequenceMultiplicity.EXACTLY_ONE &&	96✔
132	secondType.mult === SequenceMultiplicity.EXACTLY_ONE
133	) {
134	return emitValueCompare(	48✔
135	ast,
136	OPERATOR_TRANSLATION[compareType],
137	firstExpr,
138	secondExpr,
139	identifier,
140	staticContext
141	);
142	} else {
NEW 143	return rejectAst('generalCompare with sequences is still in development');	×
144	}
145	}
146
147	/**
148	* Compiles compare expressions to a JavaScript function.
149	*
150	*
151	* @param ast Logical expression AST node.
152	* @param identifier Function identifier for the emitted function
153	* @param staticContext Static context parameter to retrieve context-dependent information.
154	* @param compareType The exact operator that will be compiled
155	* @returns Wrapped compare expression.
156	*/
157	export function emitCompareExpr(	18✔
158	ast: IAST,
159	identifier: FunctionIdentifier,
160	staticContext: CodeGenContext,
161	compareType: string
162	): PartialCompilationResult {
163	const firstExpr = emitOperand(ast, identifier, 'firstOperand', staticContext);	18,942✔
164	if (!firstExpr.isAstAccepted) {	18,942✔
165	return firstExpr;	18,510✔
166	}
167
168	const secondExpr = emitOperand(ast, identifier, 'secondOperand', staticContext);	432✔
169	if (!secondExpr.isAstAccepted) {	432✔
170	return secondExpr;	150✔
171	}
172
173	switch (compareType) {	282✔
174	// valueCompare
175	case 'eqOp':	1,593!
176	case 'neOp':
177	case 'ltOp':
178	case 'leOp':
179	case 'gtOp':
180	case 'geOp':
181	case 'isOp':
182	return emitValueCompare(	234✔
183	ast,
184	compareType,
185	firstExpr,
186	secondExpr,
187	identifier,
188	staticContext
189	);
190	// generalCompare
191	case 'equalOp':
192	case 'notEqualOp':
193	case 'lessThanOrEqualOp':
194	case 'lessThanOp':
195	case 'greaterThanOrEqualOp':
196	case 'greaterThanOp':
197	return emitGeneralCompare(	48✔
198	ast,
199	compareType,
200	firstExpr,
201	secondExpr,
202	identifier,
203	staticContext
204	);
205	// nodeCompare
206	case 'nodeBeforeOp':
207	case 'nodeAfterOp':
208	default:
NEW 209	return rejectAst('Unsupported compare type');	×
210	}
211	}
212
213	/**
214	* A map to translate from general compare to value compare
215	*/
216	const OPERATOR_TRANSLATION: { [s: string]: string } = {	18✔
217	['equalOp']: 'eqOp',
218	['notEqualOp']: 'neOp',
219	['lessThanOrEqualOp']: 'leOp',
220	['lessThanOp']: 'ltOp',
221	['greaterThanOrEqualOp']: 'geOp',
222	['greaterThanOp']: 'gtOp',
223	};

FontoXML / fontoxpath / 1045637538

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous