UNIT startup; {$project vt }
{ Wertet die Programmstartargumente für VideoText aus }

INTERFACE; FROM vt USES global,jobs,datei,i2c_serial;

PROCEDURE get_args;

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

IMPLEMENTATION;
{$opt b-}
{$incl "workbench/startup.h", "icon.lib", "dos.lib" }

FUNCTION value(s: Str80): Long;
{ kann Hex- und Dezimalzahlen dekodieren (Hex muß mit "$" anfangen) }
{ Sehr primitive Version: Vorzeichen wird nicht berücksichtigt }
VAR i: Integer;
    x: Long;
BEGIN
  i := 1; x := 0;
  WHILE s[i]=' ' DO Inc(i);
  IF s[i]='$' THEN BEGIN
    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;
  END ELSE
    WHILE s[i] IN ['0'..'9'] DO BEGIN
      x := x*10 + ord(s[i]) - ord('0');
      Inc(i);
    END;
  value := x;
END;

FUNCTION getpages(filename: Str80): Integer;
{ Alle VT-Seiten aus einer VTPG-Datei einlesen und in die Seitenliste }
{ einreihen. Rückgabewert: Anzahl der gelesenen Seiten }
VAR i, gelesen: Integer;
    bytes: ^ARRAY[1..41] OF Char;
    datei: Text;
    zeile: Str80;
    seite: p_onepage;
BEGIN
  gelesen := 0;
  Reset(datei,filename);
  IF (IOresult<>0) THEN     { Datei existiert nicht }
    Exit;
  WHILE NOT EoF(datei) DO BEGIN
    REPEAT
      ReadLn(datei,zeile);
    UNTIL (zeile='VTPG') OR EoF(datei);
    if zeile='VTPG' THEN BEGIN
      New(seite);
      FOR i := 0 to 23 DO BEGIN
        bytes := Ptr(^seite^.chars[40*i]);
        BlockRead(datei,bytes^,40);
        ReadLn(datei);
      END;
      Read(datei,seite^.pg,seite^.sp); ReadLn(datei,zeile);
      seite^.cbits := value(zeile);
      ins_to_list(seite); Inc(gelesen);
    END;
  END;
  Close(datei);
  getpages := gelesen;
END;

PROCEDURE get_args;
{ wertet CLI- oder WorkBench-Argumente aus }
{ ToolTypes:                  CLI-Parameter:  }
{ FILE=<output name>          -f=<output name> }
{ MAXWAIT=<seconds>           -w<seconds> }
{ BUSDELAY=<counter>          -d<counter> }
{ BURST=<tics>                -b<tics> }
{ SHUFFLE=<tics>              -s<tics> }
{                             <page> <page> ... }
{                             <file> <file> ... }
var s: bigstring;
    len,i,j,k,ok,gelesen: integer;
    name: str80;
    is_job: Boolean;
    hail: p_WBStartup;
    arg: p_WBArg;
    olddir: BPTR;
    icon: p_DiskObject;
    entry: Str;
FUNCTION is_space(ch: Char): Boolean;
  BEGIN  is_space := (ch=' ') OR (ch=#9) OR (ch=#10) OR (ch=#13);  END;
BEGIN
  outputname := 'RAM:VTdatei'; { default-Ausgabedatei }
  queued := 0;
  maxwait := 60;
  busdelay := 0;
  burst := 0;
  shuffle := 20;
  gelesen := 0;
  IF fromWB THEN BEGIN
    OpenLib(IconBase,'icon.library',0);
    hail := StartupMessage;
    arg := hail^.sm_ArgList;
    FOR i := 1 to hail^.sm_NumArgs DO BEGIN
      olddir := CurrentDir(arg^.wa_Lock);
      name := arg^.wa_Name;
      IF i=1 THEN BEGIN  { 1. Datei: das Programm selbst, ToolTypes checken }
        icon := GetDiskObject(name);
        IF icon<>Nil THEN BEGIN
          entry := FindToolType(icon^.do_ToolTypes, 'FILE');
          if ptr(entry)<>Nil then
            outputname := entry;
          entry := FindToolType(icon^.do_ToolTypes, 'MAXWAIT');
          if ptr(entry)<>Nil then
            Val(entry,maxwait,ok);
          entry := FindToolType(icon^.do_ToolTypes, 'BUSDELAY');
          if ptr(entry)<>Nil then
            Val(entry,busdelay,ok);
          entry := FindToolType(icon^.do_ToolTypes, 'BURST');
          if ptr(entry)<>Nil then
            Val(entry,burst,ok);
          entry := FindToolType(icon^.do_ToolTypes, 'SHUFFLE');
          if ptr(entry)<>Nil then
            Val(entry,shuffle,ok);
          FreeDiskObject(icon);
        END;
      END ELSE  { zusätzliche Dateien: enthalten Seiten, einlesen }
        IF filetype(name)=1 THEN
          gelesen := gelesen + getpages(name);
      olddir := CurrentDir(olddir);
      { auf nächsten WBArg-Zeiger zugreifen: }
      arg := Ptr(Long(arg)+SizeOf(WBArg));
    END;
    CloseLib(IconBase);
  end else if ParameterLen>0 then begin
    s := copy(ParameterStr,1,ParameterLen);
    len := length(s);
    { Parameterzeile in Worte zerlegen, wie der argv[] in C es schon ist :-( }
    i := 1; while i<=len do begin
      while is_space(s[i]) do Inc(i);
      j := i + 1;
      if s[i]='"' then begin
        Inc(i); while (s[j]<>'"') AND (j<=len) do Inc(j);
      end else begin
        while NOT is_space(s[j]) AND (j<=len) do Inc(j);
      end;
      { Zeiger i: 1. Zeichen des Wortes, j: 1. Trennzeichen dahinter }
      if s[i]='-' then begin
        i := i+2;
        case s[i-1] of
          'f': begin
              if s[i] = '=' then Inc(i);
              if j>i then
                outputname := copy(s,i,j-i);
            end;
          'd': Val(copy(s,i,j-i),busdelay,ok);
          'w': Val(copy(s,i,j-i),maxwait,ok);
          'b': Val(copy(s,i,j-i),burst,ok);
          's': Val(copy(s,i,j-i),shuffle,ok);
          otherwise begin
            writeln('usage:');
            writeln('VideoText <pages> <files> -f=<name> -d<loops> -w<secs> -b<tics> -s<tics>');
            writeln('-f: OUTPUT file, -d: slow down I²C-bus, -w: max. wait for pages to arrive');
            writeln('transmission time per page ... -b: in burst mode, -s: in shuffle mode');
            writeln('e. g.: VideoText 112 113 114 115 -f=RAM:VTdatei -d0 -w60 -b0 -s20');
          end;
        end;
      END ELSE BEGIN
        { Was nur aus '0123456789/' besteht, ist eine Seitennummer, alles andere eine }
        { Eingabedatei. }
        is_job := True;
        FOR k := i TO j-1 DO
          IF NOT (s[k] IN ['0'..'9','/']) THEN is_job := False;
        IF is_job THEN
          add_job(copy(s,i,j-i))
        ELSE IF filetype(Copy(s,i,j-i))=1 THEN
          gelesen := gelesen + getpages(Copy(s,i,j-i));
      END;
      i := j + 1;
    END;
  END;
  IF (queued=0) AND (gelesen=0) THEN BEGIN
    queued := 1;
    queue[1].pg := 100; queue[1].sp := 0;
  END;
END;

BEGIN  { Initialisierung }
END.