UNIT global; {$project vt}
{ globale Variablen und Typdeklarationen zum Programm VideoText }

INTERFACE;

CONST qlen = 800;      { Warteschlange für Seitennummern }
      maxactive = 4;   { Anzahl gleichzeitig suchbarer Seiten im SAA 5246 }
      maxsubpage = 79; { sinnvolle Grenze wegen der BCD-Maske $3F7F }

TYPE p_onepage = ^onepage;
     onepage = RECORD
                 next,prev: p_onepage;
                 pg,sp: Integer;
                 chars: ARRAY [0..959] OF Byte;
                 cbits: Word;
                 dejavu: Boolean;
               END;
     str80 = String[80];
     bigstring = String[256];
     zeiteintrag = RECORD tage,min,tics: Long; END;

VAR queue: ARRAY [1..qlen] OF RECORD
             pg,sp: Integer;
           END;
    queued,firstinq: Integer;
    fifo: Boolean;
    activejobs: ARRAY [0..maxactive-1] OF RECORD
        pg,sp: Integer;          { dies sind Hexzahlen }
        sp_max,akt_sp: Integer;  { (normalerweise BCD) }
        sp_count: Integer;  { dies eine echte Dezimalzahl }
        sp_check: ARRAY [0..maxsubpage] OF Boolean;
        lastaction: zeiteintrag;     { so 'ne Art DateStamp }
        wartezeit: Integer;      { in 50stel Sekunden }
        holen,erledigt: Boolean;
      END;
    thisjob: Integer; { zeigt auf einen wartenden (<0) oder aktiven Job (>=0) }
    outputname,iffpicname: str80;
    asciifile, withicon: Boolean;
    lastkey: Char;

FUNCTION hexstr(l: Long; digits: Integer): Str;
FUNCTION hexval(s: Str80): Long;
FUNCTION get_bcd(x: Word): Word;
FUNCTION make_bcd(x: Word): Word;

{ ---------------------------------------------------------------------- }

IMPLEMENTATION;

{$ opt q,s+,i+} { keine Laufzeitprüfungen außer Stack und Feldindizes }

FUNCTION hexstr{(l: Long; digits: Integer): Str};
{ Zahl mit mindestens <digits> Stellen nach Hex wandeln: }
VAR i,j,x: Integer;
    s: String[10]; STATIC; { Wichtig! }
BEGIN
  IF digits<1 THEN digits := 1;
  j := 1;
  FOR i := 7 DOWNTO 0 DO
    IF (i<digits) OR (l SHR (4*i)>0) THEN BEGIN
      x := (l SHR (4*i)) AND $F;
      IF x<10 THEN s[j] := Chr(x+ord('0'))
      ELSE s[j] := Chr(x-10+ord('A'));
      Inc(j);
    END;
  s[j] := #0;
  hexstr := ^s;
END;

FUNCTION hexval{(s: Str80): Long};
{ kann Hexzahlen dekodieren, evtl. "$" wird überlesen }
VAR i: Integer;
    x: Long;
BEGIN
  i := 1; x := 0;
  WHILE s[i]=' ' DO Inc(i);
  IF s[i]='$' THEN Inc(i);
  WHILE s[i] IN ['0'..'9','A'..'F','a'..'f'] DO BEGIN
    x := x SHL 4 + ord(s[i]);
    CASE s[i] OF
      '0'..'9': x := x - ord('0');
      'A'..'F': x := x - ord('A') + 10;
      'a'..'f': x := x - ord('a') + 10;
    END;
    Inc(i);
  END;
  hexval := x;
END;

FUNCTION get_bcd{(x: Word): Word};
{ "Binary Coded Decimal" auswerten, z. B. $3465 ergibt 3465. }
VAR i,y: Word;
BEGIN
  y := 0;
  FOR i := 3 DOWNTO 0 DO
    y := 10*y + (x SHR (4*i)) AND $F;
  get_bcd := y;
END;

FUNCTION make_bcd{(x: Word): Word};
{ BCD erzeugen, geht bis max. 9999 => $9999 }
VAR i,y,q: Word;
BEGIN
  y := 0; q := 1000;
  FOR i := 3 DOWNTO 0 DO BEGIN
    y := y SHL 4 + (x DIV q) MOD 10;
    q := q DIV 10;
  END;
  make_bcd := y;
END;

BEGIN  { Initialisierungen }
  thisjob := 0;
  asciifile := True; withicon := FromWB;
  outputname := 'RAM:VTdatei';
  queued := 0; firstinq := 1; fifo := True;
END.