occam-verify-cli 0.0.903 → 0.0.905
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/conclusion.js +3 -3
- package/lib/verifier/node/metastatement.js +31 -6
- package/lib/verifier/node/statementAsCombinator.js +32 -12
- package/lib/verifier/node/termAsConstructor.js +25 -5
- package/lib/verifier/nodes/equality.js +19 -4
- package/lib/verifier/nodes/intrinsicLevel.js +13 -3
- package/lib/verifier/nodes/intrinsicLevelAgainstMetaLevel.js +13 -3
- package/lib/verifier/nodes/statementAgainstCombinator.js +13 -3
- package/lib/verifier/nodes/termAgainstConstructor.js +13 -3
- package/lib/verify/statement.js +7 -4
- package/lib/verify/statementAsCombinator.js +1 -2
- package/lib/verify/term.js +21 -21
- package/package.json +1 -1
- package/src/conclusion.js +2 -2
- package/src/verifier/node/metastatement.js +46 -6
- package/src/verifier/node/statementAsCombinator.js +49 -16
- package/src/verifier/node/termAsConstructor.js +37 -6
- package/src/verifier/nodes/equality.js +32 -5
- package/src/verifier/nodes/intrinsicLevel.js +18 -3
- package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js +18 -3
- package/src/verifier/nodes/statementAgainstCombinator.js +18 -3
- package/src/verifier/nodes/termAgainstConstructor.js +19 -4
- package/src/verify/statement.js +7 -3
- package/src/verify/statementAsCombinator.js +0 -1
- package/src/verify/term.js +37 -37
|
@@ -11,6 +11,7 @@ import { verifyStandaloneMetavariable } from "../../verify/metavariable";
|
|
|
11
11
|
|
|
12
12
|
const termNodeQuery = nodeQuery("/term!"),
|
|
13
13
|
variableNodeQuery = nodeQuery("/variable!"),
|
|
14
|
+
nonTerminalNodeQuery = nodeQuery("/*"),
|
|
14
15
|
metavariableNodeQuery = nodeQuery("/metavariable!");
|
|
15
16
|
|
|
16
17
|
class MetastatementNodeVerifier extends NodeVerifier {
|
|
@@ -20,23 +21,62 @@ class MetastatementNodeVerifier extends NodeVerifier {
|
|
|
20
21
|
const nodeQueryMaps = [
|
|
21
22
|
{
|
|
22
23
|
nodeQuery: termNodeQuery,
|
|
23
|
-
verifyNode:
|
|
24
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
25
|
+
let nonTerminalNodeVerified;
|
|
26
|
+
|
|
27
|
+
const termNode = node, ///
|
|
28
|
+
termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
|
|
29
|
+
|
|
30
|
+
nonTerminalNodeVerified = termNodeVerified; ///
|
|
31
|
+
|
|
32
|
+
return nonTerminalNodeVerified;
|
|
33
|
+
}
|
|
24
34
|
},
|
|
25
35
|
{
|
|
26
36
|
nodeQuery: variableNodeQuery,
|
|
27
|
-
verifyNode:
|
|
37
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
38
|
+
let nonTerminalNodeVerified;
|
|
39
|
+
|
|
40
|
+
const variableNode = node, ///
|
|
41
|
+
variableNodeVerified = this.verifyVariableNode(variableNode, localMetaContext, verifyAhead);
|
|
42
|
+
|
|
43
|
+
nonTerminalNodeVerified = variableNodeVerified; ///
|
|
44
|
+
|
|
45
|
+
return nonTerminalNodeVerified;
|
|
46
|
+
}
|
|
28
47
|
},
|
|
29
48
|
{
|
|
30
49
|
nodeQuery: metavariableNodeQuery,
|
|
31
|
-
verifyNode:
|
|
50
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
51
|
+
let nonTerminalNodeVerified;
|
|
52
|
+
|
|
53
|
+
const metavariableNode = node, ///
|
|
54
|
+
metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead);
|
|
55
|
+
|
|
56
|
+
nonTerminalNodeVerified = metavariableNodeVerified; ///
|
|
57
|
+
|
|
58
|
+
return nonTerminalNodeVerified;
|
|
59
|
+
}
|
|
60
|
+
},
|
|
61
|
+
{
|
|
62
|
+
nodeQuery: nonTerminalNodeQuery,
|
|
63
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
64
|
+
let nonTerminalNodeVerified;
|
|
65
|
+
|
|
66
|
+
const nonTerminalNode = node; ///
|
|
67
|
+
|
|
68
|
+
nonTerminalNodeVerified =
|
|
69
|
+
|
|
70
|
+
super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
|
|
71
|
+
|
|
72
|
+
return nonTerminalNodeVerified;
|
|
73
|
+
}
|
|
32
74
|
}
|
|
33
75
|
];
|
|
34
76
|
|
|
35
77
|
const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localMetaContext, verifyAhead);
|
|
36
78
|
|
|
37
|
-
nonTerminalNodeVerified = nodeVerified
|
|
38
|
-
true :
|
|
39
|
-
super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
|
|
79
|
+
nonTerminalNodeVerified = nodeVerified; ///
|
|
40
80
|
|
|
41
81
|
return nonTerminalNodeVerified;
|
|
42
82
|
}
|
|
@@ -10,7 +10,8 @@ import { verifyStandaloneStatement } from "../../verify/statement";
|
|
|
10
10
|
|
|
11
11
|
const termNodeQuery = nodeQuery("/term!"),
|
|
12
12
|
typeNodeQuery = nodeQuery("/type!"),
|
|
13
|
-
statementNodeQuery = nodeQuery("/statement!")
|
|
13
|
+
statementNodeQuery = nodeQuery("/statement!"),
|
|
14
|
+
nonTerminalNodeQuery = nodeQuery("/*");
|
|
14
15
|
|
|
15
16
|
class StatementAsCombinatorNodeVerifier extends NodeVerifier {
|
|
16
17
|
verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
|
|
@@ -19,37 +20,69 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
|
|
|
19
20
|
const nodeQueryMaps = [
|
|
20
21
|
{
|
|
21
22
|
nodeQuery: termNodeQuery,
|
|
22
|
-
verifyNode:
|
|
23
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
24
|
+
let nonTerminalNodeVerified;
|
|
25
|
+
|
|
26
|
+
const termNode = node, ///
|
|
27
|
+
termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
|
|
28
|
+
|
|
29
|
+
nonTerminalNodeVerified = termNodeVerified; ///
|
|
30
|
+
|
|
31
|
+
return nonTerminalNodeVerified;
|
|
32
|
+
}
|
|
23
33
|
},
|
|
24
34
|
{
|
|
25
35
|
nodeQuery: typeNodeQuery,
|
|
26
|
-
verifyNode:
|
|
36
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
37
|
+
let nonTerminalNodeVerified;
|
|
38
|
+
|
|
39
|
+
const typeNode = node, ///
|
|
40
|
+
typeNodeVerified = this.verifyTypeNode(typeNode, localMetaContext, verifyAhead);
|
|
41
|
+
|
|
42
|
+
nonTerminalNodeVerified = typeNodeVerified; ///
|
|
43
|
+
|
|
44
|
+
return nonTerminalNodeVerified;
|
|
45
|
+
}
|
|
27
46
|
},
|
|
28
47
|
{
|
|
29
48
|
nodeQuery: statementNodeQuery,
|
|
30
|
-
verifyNode:
|
|
49
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
50
|
+
let nonTerminalNodeVerified;
|
|
51
|
+
|
|
52
|
+
const statementNode = node, ///
|
|
53
|
+
statementNodeVerified = this.verifyStatementNode(statementNode, localMetaContext, verifyAhead);
|
|
54
|
+
|
|
55
|
+
nonTerminalNodeVerified = statementNodeVerified; ///
|
|
56
|
+
|
|
57
|
+
return nonTerminalNodeVerified;
|
|
58
|
+
}
|
|
59
|
+
},
|
|
60
|
+
{
|
|
61
|
+
nodeQuery: nonTerminalNodeQuery,
|
|
62
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
63
|
+
let nonTerminalNodeVerified;
|
|
64
|
+
|
|
65
|
+
const nonTerminalNode = node; ///
|
|
66
|
+
|
|
67
|
+
nonTerminalNodeVerified =
|
|
68
|
+
|
|
69
|
+
super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
|
|
70
|
+
|
|
71
|
+
return nonTerminalNodeVerified;
|
|
72
|
+
}
|
|
31
73
|
}
|
|
32
74
|
];
|
|
33
75
|
|
|
34
76
|
const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
|
|
35
77
|
|
|
36
|
-
nonTerminalNodeVerified = nodeVerified
|
|
37
|
-
true :
|
|
38
|
-
super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
|
|
78
|
+
nonTerminalNodeVerified = nodeVerified; ///
|
|
39
79
|
|
|
40
80
|
return nonTerminalNodeVerified;
|
|
41
81
|
}
|
|
42
82
|
|
|
43
83
|
verifyStatementNode(statementNode, localContext, verifyAhead) {
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext);
|
|
47
|
-
|
|
48
|
-
if (standaloneStatementVerified) {
|
|
49
|
-
const verifiedAhead = verifyAhead; ///
|
|
50
|
-
|
|
51
|
-
statementNodeVerified = verifiedAhead; ///
|
|
52
|
-
}
|
|
84
|
+
const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
|
|
85
|
+
statementNodeVerified = standaloneStatementVerified; ///
|
|
53
86
|
|
|
54
87
|
return statementNodeVerified;
|
|
55
88
|
}
|
|
@@ -8,7 +8,8 @@ import { verifyStandaloneType } from "../../verify/type";
|
|
|
8
8
|
import { verifyStandaloneTerm } from "../../verify/term";
|
|
9
9
|
|
|
10
10
|
const termNodeQuery = nodeQuery("/term!"),
|
|
11
|
-
typeNodeQuery = nodeQuery("/type!")
|
|
11
|
+
typeNodeQuery = nodeQuery("/type!"),
|
|
12
|
+
nonTerminalNodeQuery = nodeQuery("/*");
|
|
12
13
|
|
|
13
14
|
class TermAsConstructorNodeVerifier extends NodeVerifier {
|
|
14
15
|
verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
|
|
@@ -17,19 +18,49 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
|
|
|
17
18
|
const nodeQueryMaps = [
|
|
18
19
|
{
|
|
19
20
|
nodeQuery: termNodeQuery,
|
|
20
|
-
verifyNode:
|
|
21
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
22
|
+
let nonTerminalNodeVerified;
|
|
23
|
+
|
|
24
|
+
const termNode = node, ///
|
|
25
|
+
termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
|
|
26
|
+
|
|
27
|
+
nonTerminalNodeVerified = termNodeVerified; ///
|
|
28
|
+
|
|
29
|
+
return nonTerminalNodeVerified;
|
|
30
|
+
}
|
|
21
31
|
},
|
|
22
32
|
{
|
|
23
33
|
nodeQuery: typeNodeQuery,
|
|
24
|
-
verifyNode:
|
|
34
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
35
|
+
let nonTerminalNodeVerified;
|
|
36
|
+
|
|
37
|
+
const typeNode = node, ///
|
|
38
|
+
typeNodeVerified = this.verifyTypeNode(typeNode, localMetaContext, verifyAhead);
|
|
39
|
+
|
|
40
|
+
nonTerminalNodeVerified = typeNodeVerified; ///
|
|
41
|
+
|
|
42
|
+
return nonTerminalNodeVerified;
|
|
43
|
+
}
|
|
44
|
+
},
|
|
45
|
+
{
|
|
46
|
+
nodeQuery: nonTerminalNodeQuery,
|
|
47
|
+
verifyNode: (node, localMetaContext, verifyAhead) => {
|
|
48
|
+
let nonTerminalNodeVerified;
|
|
49
|
+
|
|
50
|
+
const nonTerminalNode = node; ///
|
|
51
|
+
|
|
52
|
+
nonTerminalNodeVerified =
|
|
53
|
+
|
|
54
|
+
super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
|
|
55
|
+
|
|
56
|
+
return nonTerminalNodeVerified;
|
|
57
|
+
}
|
|
25
58
|
}
|
|
26
59
|
];
|
|
27
60
|
|
|
28
61
|
const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
|
|
29
62
|
|
|
30
|
-
nonTerminalNodeVerified = nodeVerified
|
|
31
|
-
true :
|
|
32
|
-
super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
|
|
63
|
+
nonTerminalNodeVerified = nodeVerified; ///
|
|
33
64
|
|
|
34
65
|
return nonTerminalNodeVerified;
|
|
35
66
|
}
|
|
@@ -6,7 +6,8 @@ import verifyTermAgainstTerm from "../../verify/termAgainstTerm";
|
|
|
6
6
|
import { nodeQuery } from "../../utilities/query";
|
|
7
7
|
import { verifyNodes } from "../../utilities/verifier";
|
|
8
8
|
|
|
9
|
-
const termNodeQuery = nodeQuery("/term!")
|
|
9
|
+
const termNodeQuery = nodeQuery("/term!"),
|
|
10
|
+
nonTerminalNodeQuery = nodeQuery("/*");
|
|
10
11
|
|
|
11
12
|
class EqualityNodesVerifier extends NodesVerifier {
|
|
12
13
|
verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
|
|
@@ -27,6 +28,22 @@ class EqualityNodesVerifier extends NodesVerifier {
|
|
|
27
28
|
|
|
28
29
|
nonTerminalNodeVerified = termNodeVerifiedAgainstTermNode; ///
|
|
29
30
|
|
|
31
|
+
return nonTerminalNodeVerified;
|
|
32
|
+
}
|
|
33
|
+
},
|
|
34
|
+
{
|
|
35
|
+
nodeQueryA: nonTerminalNodeQuery,
|
|
36
|
+
nodeQueryB: nonTerminalNodeQuery,
|
|
37
|
+
verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
|
|
38
|
+
let nonTerminalNodeVerified;
|
|
39
|
+
|
|
40
|
+
const nonTerminalNodeA = nodeA, ///
|
|
41
|
+
nonTerminalNodeB = nodeB; ///
|
|
42
|
+
|
|
43
|
+
nonTerminalNodeVerified =
|
|
44
|
+
|
|
45
|
+
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
46
|
+
|
|
30
47
|
return nonTerminalNodeVerified;
|
|
31
48
|
}
|
|
32
49
|
}
|
|
@@ -34,9 +51,7 @@ class EqualityNodesVerifier extends NodesVerifier {
|
|
|
34
51
|
|
|
35
52
|
const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
36
53
|
|
|
37
|
-
nonTerminalNodeVerified = nodesVerified
|
|
38
|
-
true :
|
|
39
|
-
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
54
|
+
nonTerminalNodeVerified = nodesVerified; ///
|
|
40
55
|
|
|
41
56
|
return nonTerminalNodeVerified;
|
|
42
57
|
}
|
|
@@ -46,7 +61,19 @@ class EqualityNodesVerifier extends NodesVerifier {
|
|
|
46
61
|
|
|
47
62
|
const termVerifiedAgainstTerm = verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead);
|
|
48
63
|
|
|
49
|
-
|
|
64
|
+
if (termVerifiedAgainstTerm) {
|
|
65
|
+
termNodeVerifiedAgainstTermNode = true;
|
|
66
|
+
} else {
|
|
67
|
+
const nonTerminalNodeA = termNodeA, ///
|
|
68
|
+
nonTerminalNodeB = termNodeB, ///
|
|
69
|
+
nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
|
|
70
|
+
nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
|
|
71
|
+
childNodesA = nonTerminalNodeAChildNodes, ///
|
|
72
|
+
childNodesB = nonTerminalNodeBChildNodes, ///
|
|
73
|
+
childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, localContext, verifyAhead);
|
|
74
|
+
|
|
75
|
+
termNodeVerifiedAgainstTermNode = childNodesVerified; ///
|
|
76
|
+
}
|
|
50
77
|
|
|
51
78
|
return termNodeVerifiedAgainstTermNode;
|
|
52
79
|
}
|
|
@@ -7,6 +7,7 @@ import { nodeQuery } from "../../utilities/query";
|
|
|
7
7
|
import { verifyNodes } from "../../utilities/verifier";
|
|
8
8
|
|
|
9
9
|
const termNodeQuery = nodeQuery("/term!"),
|
|
10
|
+
nonTerminalNodeQuery = nodeQuery("/*"),
|
|
10
11
|
termVariableNodeQuery = nodeQuery("/term/variable!");
|
|
11
12
|
|
|
12
13
|
class IntrinsicLevelNodesVerifier extends NodesVerifier {
|
|
@@ -28,6 +29,22 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
|
|
|
28
29
|
|
|
29
30
|
nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode; ///
|
|
30
31
|
|
|
32
|
+
return nonTerminalNodeVerified;
|
|
33
|
+
}
|
|
34
|
+
},
|
|
35
|
+
{
|
|
36
|
+
nodeQueryA: nonTerminalNodeQuery,
|
|
37
|
+
nodeQueryB: nonTerminalNodeQuery,
|
|
38
|
+
verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
|
|
39
|
+
let nonTerminalNodeVerified;
|
|
40
|
+
|
|
41
|
+
const nonTerminalNodeA = nodeA, ///
|
|
42
|
+
nonTerminalNodeB = nodeB; ///
|
|
43
|
+
|
|
44
|
+
nonTerminalNodeVerified =
|
|
45
|
+
|
|
46
|
+
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
|
|
47
|
+
|
|
31
48
|
return nonTerminalNodeVerified;
|
|
32
49
|
}
|
|
33
50
|
}
|
|
@@ -35,9 +52,7 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
|
|
|
35
52
|
|
|
36
53
|
const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
|
|
37
54
|
|
|
38
|
-
nonTerminalNodeVerified = nodesVerified
|
|
39
|
-
true :
|
|
40
|
-
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
|
|
55
|
+
nonTerminalNodeVerified = nodesVerified; ///
|
|
41
56
|
|
|
42
57
|
return nonTerminalNodeVerified;
|
|
43
58
|
}
|
|
@@ -10,6 +10,7 @@ import { verifyNodes } from "../../utilities/verifier";
|
|
|
10
10
|
|
|
11
11
|
const termNodeQuery = nodeQuery("/term!"),
|
|
12
12
|
statementNodeQuery = nodeQuery("/statement!"),
|
|
13
|
+
nonTerminalNodeQuery = nodeQuery("/*"),
|
|
13
14
|
termVariableNodeQuery = nodeQuery("/term/variable!"),
|
|
14
15
|
metastatementNodeQuery = nodeQuery("/metastatement!"),
|
|
15
16
|
metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
|
|
@@ -88,6 +89,22 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
|
|
|
88
89
|
|
|
89
90
|
nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode; ///
|
|
90
91
|
|
|
92
|
+
return nonTerminalNodeVerified;
|
|
93
|
+
}
|
|
94
|
+
},
|
|
95
|
+
{
|
|
96
|
+
nodeQueryA: nonTerminalNodeQuery,
|
|
97
|
+
nodeQueryB: nonTerminalNodeQuery,
|
|
98
|
+
verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
|
|
99
|
+
let nonTerminalNodeVerified;
|
|
100
|
+
|
|
101
|
+
const nonTerminalNodeA = nodeA, ///
|
|
102
|
+
nonTerminalNodeB = nodeB; ///
|
|
103
|
+
|
|
104
|
+
nonTerminalNodeVerified =
|
|
105
|
+
|
|
106
|
+
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
|
|
107
|
+
|
|
91
108
|
return nonTerminalNodeVerified;
|
|
92
109
|
}
|
|
93
110
|
}
|
|
@@ -95,9 +112,7 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
|
|
|
95
112
|
|
|
96
113
|
const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
|
|
97
114
|
|
|
98
|
-
nonTerminalNodeVerified = nodesVerified
|
|
99
|
-
true :
|
|
100
|
-
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
|
|
115
|
+
nonTerminalNodeVerified = nodesVerified; ///
|
|
101
116
|
|
|
102
117
|
return nonTerminalNodeVerified;
|
|
103
118
|
}
|
|
@@ -8,6 +8,7 @@ import { nodeQuery } from "../../utilities/query";
|
|
|
8
8
|
import { verifyNodes } from "../../utilities/verifier";
|
|
9
9
|
|
|
10
10
|
const argumentNodeQuery = nodeQuery("/argument!"),
|
|
11
|
+
nonTerminalNodeQuery = nodeQuery("/*"),
|
|
11
12
|
metaArgumentMetaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
|
|
12
13
|
metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!");
|
|
13
14
|
|
|
@@ -47,6 +48,22 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
|
|
|
47
48
|
|
|
48
49
|
nonTerminalNodeVerified = argumentNodeVerifiedAgainstArgumentNode; ///
|
|
49
50
|
|
|
51
|
+
return nonTerminalNodeVerified;
|
|
52
|
+
}
|
|
53
|
+
},
|
|
54
|
+
{
|
|
55
|
+
nodeQueryA: nonTerminalNodeQuery,
|
|
56
|
+
nodeQueryB: nonTerminalNodeQuery,
|
|
57
|
+
verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
|
|
58
|
+
let nonTerminalNodeVerified;
|
|
59
|
+
|
|
60
|
+
const nonTerminalNodeA = nodeA, ///
|
|
61
|
+
nonTerminalNodeB = nodeB; ///
|
|
62
|
+
|
|
63
|
+
nonTerminalNodeVerified =
|
|
64
|
+
|
|
65
|
+
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
66
|
+
|
|
50
67
|
return nonTerminalNodeVerified;
|
|
51
68
|
}
|
|
52
69
|
}
|
|
@@ -54,9 +71,7 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
|
|
|
54
71
|
|
|
55
72
|
const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
56
73
|
|
|
57
|
-
nonTerminalNodeVerified = nodesVerified
|
|
58
|
-
true :
|
|
59
|
-
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
74
|
+
nonTerminalNodeVerified = nodesVerified; ///
|
|
60
75
|
|
|
61
76
|
return nonTerminalNodeVerified;
|
|
62
77
|
}
|
|
@@ -7,7 +7,8 @@ import { nodeQuery } from "../../utilities/query";
|
|
|
7
7
|
import { verifyNodes } from "../../utilities/verifier";
|
|
8
8
|
|
|
9
9
|
const termNodeQuery = nodeQuery("/argument/term!"),
|
|
10
|
-
typeNodeQuery = nodeQuery("/argument/type!")
|
|
10
|
+
typeNodeQuery = nodeQuery("/argument/type!"),
|
|
11
|
+
nonTerminalNodeQuery = nodeQuery("/*");
|
|
11
12
|
|
|
12
13
|
class TermAgainstConstructorNodesVerifier extends NodesVerifier {
|
|
13
14
|
verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
|
|
@@ -28,6 +29,22 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
|
|
|
28
29
|
|
|
29
30
|
nonTerminalNodeVerified = termNodeVerifiedAgainstTypeNode; ///
|
|
30
31
|
|
|
32
|
+
return nonTerminalNodeVerified;
|
|
33
|
+
}
|
|
34
|
+
},
|
|
35
|
+
{
|
|
36
|
+
nodeQueryA: nonTerminalNodeQuery,
|
|
37
|
+
nodeQueryB: nonTerminalNodeQuery,
|
|
38
|
+
verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
|
|
39
|
+
let nonTerminalNodeVerified;
|
|
40
|
+
|
|
41
|
+
const nonTerminalNodeA = nodeA, ///
|
|
42
|
+
nonTerminalNodeB = nodeB; ///
|
|
43
|
+
|
|
44
|
+
nonTerminalNodeVerified =
|
|
45
|
+
|
|
46
|
+
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
47
|
+
|
|
31
48
|
return nonTerminalNodeVerified;
|
|
32
49
|
}
|
|
33
50
|
}
|
|
@@ -35,9 +52,7 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
|
|
|
35
52
|
|
|
36
53
|
const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
37
54
|
|
|
38
|
-
nonTerminalNodeVerified = nodesVerified
|
|
39
|
-
true :
|
|
40
|
-
super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
|
|
55
|
+
nonTerminalNodeVerified = nodesVerified; ///
|
|
41
56
|
|
|
42
57
|
return nonTerminalNodeVerified;
|
|
43
58
|
}
|
package/src/verify/statement.js
CHANGED
|
@@ -45,8 +45,8 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
|
|
|
45
45
|
return statementVerified;
|
|
46
46
|
}
|
|
47
47
|
|
|
48
|
-
export function verifyStandaloneStatement(statementNode, localContext) {
|
|
49
|
-
let standaloneStatementVerified;
|
|
48
|
+
export function verifyStandaloneStatement(statementNode, localContext, verifyAhead) {
|
|
49
|
+
let standaloneStatementVerified = false;
|
|
50
50
|
|
|
51
51
|
const statementString = localContext.nodeAsString(statementNode);
|
|
52
52
|
|
|
@@ -56,7 +56,11 @@ export function verifyStandaloneStatement(statementNode, localContext) {
|
|
|
56
56
|
assignments = [],
|
|
57
57
|
statementVerified = verifyStatement(statementNode, assignments, derived);
|
|
58
58
|
|
|
59
|
-
|
|
59
|
+
if (statementVerified) {
|
|
60
|
+
const verifiedAhead = verifyAhead();
|
|
61
|
+
|
|
62
|
+
standaloneStatementVerified = verifiedAhead; ///
|
|
63
|
+
}
|
|
60
64
|
|
|
61
65
|
if (standaloneStatementVerified) {
|
|
62
66
|
localContext.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
|
|
@@ -1,7 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
|
|
3
3
|
import Combinator from "../combinator";
|
|
4
|
-
import LocalContext from "../context/local";
|
|
5
4
|
import statementAsCombinatorNodeVerifier from "../verifier/node/statementAsCombinator";
|
|
6
5
|
|
|
7
6
|
export default function verifyStatementAsCombinator(statementNode, fileContext) {
|
package/src/verify/term.js
CHANGED
|
@@ -100,43 +100,6 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
|
|
|
100
100
|
return termVerifiedAsVariable;
|
|
101
101
|
}
|
|
102
102
|
|
|
103
|
-
function verifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
|
|
104
|
-
let termVerifiedAgainstConstructor;
|
|
105
|
-
|
|
106
|
-
const termString = localContext.nodeAsString(termNode),
|
|
107
|
-
constructorString = constructor.getString();
|
|
108
|
-
|
|
109
|
-
localContext.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
|
|
110
|
-
|
|
111
|
-
const constructorTermNode = constructor.getTermNode(),
|
|
112
|
-
nonTerminalNNdeA = termNode, ///
|
|
113
|
-
nonTerminalNodeB = constructorTermNode, ///
|
|
114
|
-
nodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, localContext, () => {
|
|
115
|
-
let verifiedAhead;
|
|
116
|
-
|
|
117
|
-
const type = constructor.getType(),
|
|
118
|
-
term = Term.fromTermNodeAndType(termNode, type);
|
|
119
|
-
|
|
120
|
-
terms.push(term);
|
|
121
|
-
|
|
122
|
-
verifiedAhead = verifyAhead();
|
|
123
|
-
|
|
124
|
-
if (!verifiedAhead) {
|
|
125
|
-
terms.pop();
|
|
126
|
-
}
|
|
127
|
-
|
|
128
|
-
return verifiedAhead;
|
|
129
|
-
});
|
|
130
|
-
|
|
131
|
-
termVerifiedAgainstConstructor = nodeVerified; ///
|
|
132
|
-
|
|
133
|
-
if (termVerifiedAgainstConstructor) {
|
|
134
|
-
localContext.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
|
|
135
|
-
}
|
|
136
|
-
|
|
137
|
-
return termVerifiedAgainstConstructor;
|
|
138
|
-
}
|
|
139
|
-
|
|
140
103
|
function verifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {
|
|
141
104
|
let termVerifiedAgainstConstructors = false;
|
|
142
105
|
|
|
@@ -220,3 +183,40 @@ function verifyTermAgainstBracketedConstructor(termNode, terms, localContext, ve
|
|
|
220
183
|
return termVerifiedAgainstBracketedConstructor;
|
|
221
184
|
}
|
|
222
185
|
|
|
186
|
+
function verifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
|
|
187
|
+
let termVerifiedAgainstConstructor;
|
|
188
|
+
|
|
189
|
+
const termString = localContext.nodeAsString(termNode),
|
|
190
|
+
constructorString = constructor.getString();
|
|
191
|
+
|
|
192
|
+
localContext.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
|
|
193
|
+
|
|
194
|
+
const constructorTermNode = constructor.getTermNode(),
|
|
195
|
+
nonTerminalNNdeA = termNode, ///
|
|
196
|
+
nonTerminalNodeB = constructorTermNode, ///
|
|
197
|
+
nodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, localContext, () => {
|
|
198
|
+
let verifiedAhead;
|
|
199
|
+
|
|
200
|
+
const type = constructor.getType(),
|
|
201
|
+
term = Term.fromTermNodeAndType(termNode, type);
|
|
202
|
+
|
|
203
|
+
terms.push(term);
|
|
204
|
+
|
|
205
|
+
verifiedAhead = verifyAhead();
|
|
206
|
+
|
|
207
|
+
if (!verifiedAhead) {
|
|
208
|
+
terms.pop();
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
return verifiedAhead;
|
|
212
|
+
});
|
|
213
|
+
|
|
214
|
+
termVerifiedAgainstConstructor = nodeVerified; ///
|
|
215
|
+
|
|
216
|
+
if (termVerifiedAgainstConstructor) {
|
|
217
|
+
localContext.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
return termVerifiedAgainstConstructor;
|
|
221
|
+
}
|
|
222
|
+
|