{ String I/O Utility Unit

  File:	   SIO_UNIT.TEXT
  Date:	   29-Aug-82
  Version: 1
  
  COPYRIGHT (c) 1982 SAGE Computer Technology
  
  
  Requirements:	 None
     
  
  Development History:
  
  1    29-Aug-82  Initial release

}

UNIT SIO_Unit;
INTERFACE

FUNCTION SIO_IntRd (VAR Cursor:INTEGER; VAR Source:STRING; VAR Result:INTEGER):
		    BOOLEAN;
FUNCTION SIO_HexRd (VAR Cursor:INTEGER; VAR Source:STRING; VAR ResultH,
		    ResultL:INTEGER):BOOLEAN;
FUNCTION SIO_AlphRd(VAR Cursor:INTEGER; VAR Source:STRING; VAR Result:STRING):
		    BOOLEAN;
FUNCTION SIO_AlNuRd(VAR Cursor:INTEGER; VAR Source:STRING; VAR Result:STRING):
		    BOOLEAN;
FUNCTION SIO_CharRD(VAR Cursor:INTEGER; VAR Source:STRING; Check:CHAR):
		    BOOLEAN;
FUNCTION SIO_ByDlim(VAR Cursor:INTEGER; VAR Source:STRING; Check:STRING):
		    BOOLEAN;

PROCEDURE SIO_CharWt(Value:CHAR; VAR Result:STRING);
PROCEDURE SIO_HexWt (Value:INTEGER; Digits:INTEGER; VAR Result:STRING);
PROCEDURE SIO_IntWt (Value:INTEGER; VAR Result:STRING);
PROCEDURE SIO_Fill  (Count:INTEGER; VAR Result:STRING);
PROCEDURE SIO_Upper (VAR Result:STRING);
PROCEDURE SIO_Suffix(Suffix:STRING; VAR Result:STRING);

IMPLEMENTATION

FUNCTION SIO_CharRd;
BEGIN
  SIO_CharRd:=FALSE;
  IF Cursor <= LENGTH(Source) THEN
    BEGIN
      IF Check = Source[Cursor] THEN
	BEGIN
	  SIO_CharRd:=TRUE;
	  Cursor:=Cursor+1;
	END;
    END;
END;

FUNCTION SIO_ByDlim;
VAR
  CH:CHAR;
  Done:BOOLEAN;
BEGIN
  SIO_ByDlim:=FALSE;
  Done:=FALSE;
  REPEAT
    IF Cursor <= LENGTH(Source) THEN
      BEGIN
	CH:=Source[Cursor];
	IF LENGTH(Check) = 1 THEN
	  BEGIN
	    IF CH = Check[1] THEN
	      BEGIN
		SIO_ByDlim:=TRUE;
		Cursor:=Cursor+1;
	      END
	    ELSE
	      Done:=TRUE;
	  END
	ELSE
	  IF LENGTH(Check) > 0 THEN
	    BEGIN
	      IF SCAN(LENGTH(Check),=CH,Check[1]) <> LENGTH(Check) THEN
		BEGIN
		  SIO_ByDlim:=TRUE;
		  Cursor:=Cursor+1;
		END
	      ELSE
		Done:=TRUE;
	    END
	  ELSE
	    Done:=TRUE;
      END
    ELSE
      Done:=TRUE;
  UNTIL Done;
END;

FUNCTION SIO_IntRd;
VAR
  Negative,Done,Found:BOOLEAN;
  CH:CHAR;
BEGIN
  SIO_IntRd:=FALSE;
  Result:=0;
  Done:=FALSE;
  Negative:=FALSE;
  Found:=FALSE;
  IF SIO_CharRd(Cursor,Source,'-') THEN Negative:=TRUE
  ELSE
    IF SIO_CharRd(Cursor,Source,'+') THEN {ignore};
  REPEAT
    IF Cursor <= LENGTH(Source) THEN
      BEGIN
	CH:=Source[Cursor];
	IF CH IN ['0'..'9'] THEN
	  BEGIN
	    Found:=TRUE;
	    Cursor:=Cursor+1;
	    Result:=(Result*10) + ORD(CH) - ORD('0');
	  END
	ELSE
	  Done:=TRUE;
      END
    ELSE
      Done:=TRUE;
  UNTIL Done;
  IF Found THEN
    BEGIN
      SIO_IntRd:=TRUE;
      IF Negative THEN Result:=-Result;
    END;
END;

FUNCTION SIO_HexRd;
VAR
  Done:BOOLEAN;
  Bias:INTEGER;
  CH:CHAR;
  Convert:PACKED RECORD CASE BOOLEAN OF
		   FALSE:(a:INTEGER);
		   TRUE:(b:PACKED RECORD
			     Low:0..4095;
			     High:0..15;
			   END);
		 END;
BEGIN
  SIO_HexRd:=FALSE;
  ResultH:=0;
  ResultL:=0;
  Done:=FALSE;
  REPEAT
    IF Cursor <= LENGTH(Source) THEN
      BEGIN
	CH:=Source[Cursor];
	IF CH IN ['A'..'F','a'..'f','0'..'9'] THEN
	  BEGIN
	    SIO_HexRd:=TRUE;
	    Cursor:=Cursor+1;
	    IF CH IN ['0'..'9'] THEN Bias:=ORD('0')
	    ELSE
	      BEGIN
		IF CH IN ['A'..'F'] THEN Bias:=ORD('A')-10
		ELSE Bias:=ORD('a')-10;
	      END;
	    Convert.a:=ResultL;
	    ResultH:=(ResultH*16) + Convert.b.High;
	    ResultL:=(ResultL*16) + ORD(CH) - Bias;
	  END
	ELSE
	  Done:=TRUE;
      END
    ELSE
      Done:=TRUE;
  UNTIL Done;
END;

FUNCTION SIO_AlphRd;
VAR
  Done:BOOLEAN;
  CH:CHAR;
BEGIN
  SIO_AlphRd:=FALSE;
  Done:=FALSE;
  REPEAT
    IF Cursor <= LENGTH(Source) THEN
      BEGIN
	CH:=Source[Cursor];
	IF CH IN ['A'..'Z','a'..'z'] THEN
	  BEGIN
	    SIO_AlphRd:=TRUE;
	    Cursor:=Cursor+1;
	    SIO_CharWt(CH,Result);
	  END
	ELSE
	  Done:=TRUE;
      END
    ELSE
      Done:=TRUE;
  UNTIL Done;
END;

FUNCTION SIO_AlNuRd;
VAR
  Done:BOOLEAN;
  CH:CHAR;
BEGIN
  IF NOT SIO_AlphRd(Cursor,Source,Result) THEN
    BEGIN
      SIO_AlNuRd:=FALSE;
      EXIT(SIO_AlNuRd);
    END;
  SIO_AlNuRd:=TRUE;
  Done:=FALSE;
  REPEAT
    IF Cursor <= LENGTH(Source) THEN
      BEGIN
	CH:=Source[Cursor];
	IF CH IN ['A'..'Z','a'..'z','0'..'9'] THEN
	  BEGIN
	    Cursor:=Cursor+1;
	    SIO_CharWt(CH,Result);
	  END
	ELSE
	  Done:=TRUE;
      END
    ELSE
      Done:=TRUE;
  UNTIL Done;
END;


PROCEDURE SIO_Upper;
VAR
  I:INTEGER;
  CH:CHAR;
BEGIN
  IF LENGTH(Result) > 0 THEN
    FOR I := 1 TO LENGTH(Result) DO
      BEGIN
	CH:=Result[I];
	IF CH >= 'a' THEN
	  IF CH <= 'z' THEN Result[I]:=CHR(ORD(CH)-ORD('a')+ORD('A'));
      END;
END;


PROCEDURE SIO_Suffix;
VAR
  Temp:STRING;
BEGIN
  IF LENGTH(Result) = 0 THEN EXIT(SIO_Suffix);
  Temp:=Result;
  SIO_Upper(Temp);
  IF ((POS(Suffix,Temp) <> (LENGTH(Temp)-LENGTH(Suffix)+1)) OR
     (LENGTH(Temp) <= (LENGTH(Suffix)+1))) AND
     (Temp[LENGTH(Temp)] <> '.') THEN Result:=CONCAT(Result,Suffix);
  IF Result[LENGTH(Result)] = '.' THEN DELETE(Result,LENGTH(Result),1);
END;


PROCEDURE SIO_IntWt;
VAR
  Temp:STRING[10];

BEGIN
  STR(Value,Temp);
  Result:=CONCAT(Result,Temp);
END;

PROCEDURE SIO_CharWt;
BEGIN
  IF LENGTH(Result) < 80 THEN
    BEGIN
      {$R-}
      Result[0]:=CHR(LENGTH(Result)+1);
      {$R+}
      Result[LENGTH(Result)]:=Value;
    END;
END;

PROCEDURE SIO_HexWt;
VAR
  I,Nibble:INTEGER;
  CH:CHAR;
  Convert:RECORD CASE BOOLEAN OF
	    TRUE: (Int:INTEGER);
	    FALSE:(HexRec:PACKED ARRAY[0..3] OF 0..15);
	  END;
BEGIN
  IF (Digits > 0) AND (Digits < 5) THEN
    BEGIN
      Convert.Int:=Value;
      FOR I := (Digits-1) DOWNTO 0 DO
	BEGIN
	  Nibble:=Convert.HexRec[I];
	  IF Nibble < 10 THEN
	    CH:=CHR(ORD('0')+Nibble)
	  ELSE
	    CH:=CHR(ORD('A')+Nibble-10);
	  SIO_CharWt(CH,Result);
	END;
    END;
END;

PROCEDURE SIO_Fill;
VAR
  Temp:STRING;
BEGIN
  IF (Count > 0) AND (Count < 81) THEN
    BEGIN
      {$R-}
      Temp[0]:=CHR(Count);
      {$R+}
      FILLCHAR(Temp[1],Count,' ');
      Result:=CONCAT(Result,Temp);
    END;
END;

BEGIN
END.

                                                                                                                                                                                                                                                                                                                                                                                     