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 | 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 2x 2x 2x 2x 2x 6x 6x 1x 1x 1x 1x 6x 5x 2x 5x 1x 1x 1x 1x 1x 1x 1x 1x 171x 171x 1x 6x 2x 2x 2x 2x 2x 2x 1x | import * as Expressions from "../../2_statements/expressions";
import * as Statements from "../../2_statements/statements";
import * as Structures from "../../3_structures/structures";
import {StatementNode, StructureNode} from "../../nodes";
import {TypedIdentifier} from "../../types/_typed_identifier";
import * as Basic from "../../types/basic";
import {IStructureComponent} from "../../types/basic";
import {Static} from "../statements/static";
import {CheckSyntaxKey, SyntaxInput, syntaxIssue} from "../_syntax_input";
// todo, this is much like DATA, refactor?
export class Statics {
public runSyntax(node: StructureNode, input: SyntaxInput): TypedIdentifier | undefined {
const name = node.findFirstExpression(Expressions.DefinitionName)!.getFirstToken();
let table: boolean = false;
const components: IStructureComponent[] = [];
for (const c of node.getChildren()) {
const ctyp = c.get();
if (c instanceof StatementNode && ctyp instanceof Statements.Static) {
const found = new Static().runSyntax(c, input);
if (found) {
components.push({name: found.getName(), type: found.getType()});
}
} else if (c instanceof StructureNode && ctyp instanceof Structures.Statics) {
const found = new Statics().runSyntax(c, input);
if (found) {
components.push({name: found.getName(), type: found.getType()});
}
} else if (c instanceof StatementNode && ctyp instanceof Statements.StaticBegin) {
if (c.findDirectTokenByText("OCCURS")) {
table = true;
}
} else if (c instanceof StatementNode && ctyp instanceof Statements.IncludeType) {
// INCLUDES
const typeName = c.findFirstExpression(Expressions.TypeName)?.getFirstToken().getStr();
let found = input.scope.findType(typeName)?.getType();
if (found === undefined) {
const f = input.scope.getDDIC().lookupTableOrView(typeName).type;
if (f instanceof TypedIdentifier) {
found = f.getType();
} else {
found = f;
}
}
if (found instanceof Basic.VoidType) {
if (table === true) {
const ttyp = new Basic.TableType(found, {withHeader: true, keyType: Basic.TableKeyType.default});
return new TypedIdentifier(name, input.filename, ttyp);
} else {
return new TypedIdentifier(name, input.filename, found);
}
}
if (found instanceof Basic.UnknownType) {
return new TypedIdentifier(name, input.filename, new Basic.UnknownType("unknown type, " + typeName));
}
if (!(found instanceof Basic.StructureType)) {
const message = "not structured, " + typeName;
input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
return new TypedIdentifier(name, input.filename, new Basic.VoidType(CheckSyntaxKey));
}
for (const c of found.getComponents()) {
components.push(c);
}
}
}
if (table === true) {
const ttyp = new Basic.TableType(new Basic.StructureType(components), {withHeader: true, keyType: Basic.TableKeyType.default});
return new TypedIdentifier(name, input.filename, ttyp);
} else {
return new TypedIdentifier(name, input.filename, new Basic.StructureType(components));
}
}
} |