PASCAL + MACRO11 (УКНЦ-ДВК).

[hobot]

OMSI Pascal разрешает.

транслятор проверяет только синтаксис и тип данных
позволяет скорее редактор местный текстовый - который единственно правильный для работы
с исходниками может оказаться в некоторых случаях...

тип "СТРОКА" - одна из возможных реализаций для OMSI PASCAL

CONST   STRINGMAX=100;

TYPE    STRING=RECORD
           LEN: 0..STRINGMAX;
           CH: PACKED ARRAY[1..STRINGMAX] OF CHAR
           END;

FUNCTION LEN(VAR S:STRING):INTEGER;
BEGIN   LEN:= S.LEN
END;

PROCEDURE CLEAR(VAR S:STRING);
VAR     I: INTEGER;
BEGIN   S.LEN:=0;
        FOR I:=1 TO STRINGMAX DO S.CH[I]:=' '
END;

PROCEDURE CONCATENATE(VAR S:STRING; VAR T:STRING);
VAR     I,J: INTEGER;
BEGIN
        IF S.LEN+T.LEN>STRINGMAX
           THEN J:=STRINGMAX-S.LEN (* OVERFLOW *)
           ELSE J:=T.LEN;
        FOR I:=1 TO J DO S.CH[S.LEN+I]:=T.CH[I];
        S.LEN:=S.LEN+J;
END;

FUNCTION SEARCH(VAR S,T:STRING; START:INTEGER):INTEGER;
VAR     I,J: 0..STRINGMAX;
        UNEQ: BOOLEAN;
BEGIN
        IF START<1 THEN START:=1;
        IF (START+T.LEN>S.LEN+1) OR (T.LEN=0)
           THEN SEARCH:=0
           ELSE BEGIN
              I:=START-1;
              REPEAT
                 I:=I+1; J:=0;
                 REPEAT
                    J:=J+1;
                    UNEQ:=T.CH[J]<>S.CH[I+J-1];
                 UNTIL UNEQ OR (J=T.LEN);
              UNTIL (NOT UNEQ) OR (I=S.LEN-T.LEN+1);
              IF UNEQ
                 THEN SEARCH:=0
                 ELSE SEARCH:=I;
              END;
END;

PROCEDURE READSTRING(VAR F:TEXT; VAR S:STRING);
BEGIN
        CLEAR(S);
        WITH S DO
           WHILE (NOT EOLN(F)) AND (LEN<STRINGMAX) DO BEGIN
              LEN:=LEN+1;
              READ(F,CH[LEN]);
              END;
        READLN(F);
END;

PROCEDURE WRITESTRING(VAR F:TEXT; VAR S:STRING);
BEGIN   WRITE(F,S.CH:S.LEN)
END;

PROCEDURE SUBSTRING(VAR T:STRING; VAR S:STRING; START,SPAN:INTEGER);
VAR     I: INTEGER;
BEGIN
        IF SPAN<0 THEN BEGIN SPAN:= -SPAN; START:=START-SPAN END;
        IF START<1 THEN BEGIN SPAN:=SPAN+START-1; START:=1 END;
        IF START+SPAN>S.LEN+1 THEN SPAN:=S.LEN-START+1;
        IF SPAN<=0
           THEN CLEAR(T)
           ELSE BEGIN
              FOR I:=1 TO SPAN DO T.CH[I]:=S.CH[START+I-1];
              FOR I:=SPAN+1 TO STRINGMAX DO T.CH[I]:=' ';
              T.LEN:=SPAN;
              END;
END;

PROCEDURE DELETE(VAR S:STRING; START,SPAN:INTEGER);
VAR     I,LIMIT: INTEGER;
BEGIN
        IF SPAN<0 THEN BEGIN SPAN:=-SPAN; START:=START-SPAN END;
        LIMIT:=START+SPAN;
        IF START<1 THEN START:=1;
        IF LIMIT>S.LEN+1 THEN LIMIT:=S.LEN+1;
        SPAN:=LIMIT-START;
        IF SPAN>0 THEN BEGIN
           FOR I:=0 TO S.LEN-LIMIT DO S.CH[START+I]:=S.CH[LIMIT+I];
           FOR I:=S.LEN-SPAN+1 TO S.LEN DO S.CH[I]:=' ';
           S.LEN:=S.LEN-SPAN;
           END;
END;

PROCEDURE INSERT(VAR S:STRING;VAR T:STRING; P:INTEGER);
VAR     I,J: INTEGER;
BEGIN
        IF T.LEN>0 THEN
           IF (P>0) AND (P<=S.LEN+1)
              THEN BEGIN
                 IF S.LEN+T.LEN<=STRINGMAX
                    THEN S.LEN:=S.LEN+T.LEN
                    ELSE S.LEN:=STRINGMAX (* OVERFLOW *) ;
                 FOR I:=S.LEN DOWNTO P+T.LEN DO S.CH[I]:=S.CH[I-T.LEN];
                 IF S.LEN<P+T.LEN
                    THEN J:=S.LEN
                    ELSE J:=P+T.LEN-1;
                 FOR I:=P TO J DO S.CH[I]:=T.CH[I-P+1];
                 END
              ELSE (* ERROR: NON-CONTIGUOUS STRING *)
END;