Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 13x 13x 27x 27x 13x 13x 13x 4x 4x 4x 4x 4x 4x 4x 4x 4x 4x 2x 2x 2x 2x 4x 13x 13x 13x 7x 6x 6x 7x 13x 13x 13x 13x 13x 13x 13x 13x 13x 4x 4x 13x 13x 7x 18x 4x 18x 4x 4x 18x 18x 7x 18x 3x 3x 18x 7x 13x 1x 1x 1x 1x 14x 14x 14x 14x 14x 1x 1x | import * as Expressions from "../../2_statements/expressions";
import {StatementNode, ExpressionNode} from "../../nodes";
import {InlineData} from "../expressions/inline_data";
import {StringType, StructureType, IntegerType, TableType, TableKeyType} from "../../types/basic";
import {Source} from "../expressions/source";
import {Target} from "../expressions/target";
import {AbstractType} from "../../types/basic/_abstract_type";
import {StatementSyntax} from "../_statement_syntax";
import {SyntaxInput} from "../_syntax_input";
export class Find implements StatementSyntax {
public runSyntax(node: StatementNode, input: SyntaxInput): void {
for (const s of node.findDirectExpressions(Expressions.Source)) {
Source.runSyntax(s, input);
}
const rfound = node.findExpressionAfterToken("RESULTS");
if (rfound && rfound.get() instanceof Expressions.Target) {
const sub = new StructureType([
{name: "OFFSET", type: IntegerType.get()},
{name: "LENGTH", type: IntegerType.get()}], "SUBMATCH_RESULT", "SUBMATCH_RESULT");
const type = new StructureType([
{name: "LINE", type: IntegerType.get()},
{name: "OFFSET", type: IntegerType.get()},
{name: "LENGTH", type: IntegerType.get()},
{name: "SUBMATCHES", type: new TableType(sub, {withHeader: false, keyType: TableKeyType.default})},
], "MATCH_RESULT", "MATCH_RESULT");
if (node.concatTokens().toUpperCase().startsWith("FIND FIRST")) {
this.inline(rfound, input, type);
} else {
this.inline(rfound, input, new TableType(type, {withHeader: false, keyType: TableKeyType.default}, "MATCH_RESULT_TAB"));
}
}
const ofound = node.findExpressionsAfterToken("OFFSET");
for (const o of ofound) {
if (o.get() instanceof Expressions.Target) {
this.inline(o, input, IntegerType.get());
}
}
const lfound = node.findExpressionAfterToken("LINE");
if (lfound && lfound.get() instanceof Expressions.Target) {
this.inline(lfound, input, IntegerType.get());
}
const cfound = node.findExpressionAfterToken("COUNT");
if (cfound && cfound.get() instanceof Expressions.Target) {
this.inline(cfound, input, IntegerType.get());
}
const lnfound = node.findExpressionAfterToken("LENGTH");
if (lnfound && lnfound.get() instanceof Expressions.Target) {
this.inline(lnfound, input, IntegerType.get());
}
if (node.findDirectTokenByText("SUBMATCHES")) {
for (const t of node.findDirectExpressions(Expressions.Target)) {
if (t === rfound || t === lfound || t === cfound || t === lnfound) {
continue;
} else if (ofound.indexOf(t) >= 0) {
continue;
}
const inline = t?.findDirectExpression(Expressions.InlineData);
if (inline) {
InlineData.runSyntax(inline, input, StringType.get());
} else {
Target.runSyntax(t, input);
}
}
}
}
/////////////////////
private inline(node: ExpressionNode, input: SyntaxInput, type: AbstractType): void {
const inline = node.findDirectExpression(Expressions.InlineData);
if (inline) {
InlineData.runSyntax(inline, input, type);
} else {
Target.runSyntax(node, input);
}
}
} |