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 87 | 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 124x 124x 124x 124x 124x 124x 124x 124x 7x 7x 117x 124x 61x 61x 56x 56x 124x 26x 7x 7x 7x 7x 26x 26x 30x 124x 22x 6x 6x 6x 6x 22x 22x 8x 8x 8x 1x 7x 7x 7x 7x 7x 7x 7x 7x 7x 7x 7x 5x 5x 7x 2x 2x 7x 3x 3x 4x 4x 1x 1x 1x 133x 133x 133x 123x 123x 133x 5x 1x 1x 5x 9x 9x | import {INode} from "../../nodes/_inode";
import * as Expressions from "../../2_statements/expressions";
import {CharacterType, DateType, HexType, NumericType, TimeType, VoidType} from "../../types/basic";
import {AbstractType} from "../../types/basic/_abstract_type";
import {CheckSyntaxKey, SyntaxInput, syntaxIssue} from "../_syntax_input";
// The type of a substring with a static offset or length, used for reading and writing positions.
// On a character or byte field of fixed length the substring must lie inside the field, else it is
// a syntax error. Other types, a dynamic offset or length and "*" (undefined) are left alone, as is
// length 0. The offset is applied first, so the length is compared to what remains after the offset.
// A substring of a date, time or numeric text field has type n; its bounds are not checked.
export function substringType(
context: AbstractType | undefined,
offset: number | undefined,
length: number | undefined,
node: INode,
input: SyntaxInput): AbstractType | undefined {
if (context instanceof DateType || context instanceof TimeType || context instanceof NumericType) {
return numericSubstringType(context, offset, length);
}
if (!(context instanceof CharacterType) && !(context instanceof HexType)) {
return context;
}
const fieldLength = context.getLength();
if (offset !== undefined && offset > 0) {
if (offset >= fieldLength) {
const message = `Offset ${offset} is outside the field of length ${fieldLength}`;
input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
return VoidType.get(CheckSyntaxKey);
}
return context instanceof CharacterType ? new CharacterType(fieldLength - offset) : new HexType(fieldLength - offset);
}
if (length !== undefined && length > 0) {
if (length > fieldLength) {
const message = `Length ${length} exceeds the remaining length ${fieldLength} of the field`;
input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
return VoidType.get(CheckSyntaxKey);
}
return context instanceof CharacterType ? new CharacterType(length) : new HexType(length);
}
return context;
}
function numericSubstringType(
context: DateType | TimeType | NumericType,
offset: number | undefined,
length: number | undefined): AbstractType {
const hasOffset = offset !== undefined && offset > 0;
const hasLength = length !== undefined && length > 0;
if (hasOffset === false && hasLength === false) {
return context;
}
let remaining = context instanceof DateType ? 8 : context instanceof TimeType ? 6 : context.getLength();
if (hasOffset) {
remaining = remaining - offset!;
}
if (hasLength) {
remaining = Math.min(remaining, length!);
}
if (remaining <= 0) {
return context;
}
return new NumericType(remaining);
}
// A field symbol typed "c" or "x" is generic, but its type is represented with length 1, so the
// offset or length at "index" is not checked when it directly follows the field symbol
export function isFieldSymbolItself(children: readonly INode[], index: number): boolean {
const first = children[0]?.get();
if (!(first instanceof Expressions.SourceFieldSymbol) && !(first instanceof Expressions.TargetFieldSymbol)) {
return false;
}
for (let i = 1; i < index; i++) {
if (!(children[i].get() instanceof Expressions.FieldOffset)) {
return false;
}
}
return true;
}
|