{NEWSQWK.PAS}

{
  Converts USENET files to QWK format ..

  You'll need PKZIP to use this.

  I use NXpress for my Newsgroup reader, in it saves it files with an
  extension of .MBX.  If you newsreader saves in someother format, then
  change the extension default at the front of the program.

  Perhaps you newsreader has a SAVEAS feature that allows you to download
  all of the material and save it as a text file.  If so, you could use it.
  Just save the files as SOMEFILE.MBX in the same DIR as this program,
  and it'll create the QWK file for you.

  Gayle Davis 05/28/96

}

{$V-,S-,I-}
{$M 16384,0,655360}   { no need to leave memory for PKZIP !!!
                        see the EXECUTE procedure below and find out how !!}

USES
  Dos, Crt, Upper, RLine;
       { NOTE : Upper is in STRINGS.SWG
                RLINE is in TEXTFILE.SWG }

CONST
     ControlHdr : ARRAY [1..11] OF STRING [30] = (

 {1} 'SOURCEWARE ARCHIVAL GROUP',  { change this to whatever you want ! }
 {2} 'Goshen',                     { ditto }
 {3} '875-8133',                   { ditto }
 {4} 'Gayle Davis',                { ditto }
 {5} '99999,SWAG',                 { ditto }
 {6} '11-03-1993,04:41:37',        { this will get updated automatically }
 {7} 'SWAG Genius',                { whatever pleases you ! }
 {8} '',     { QMAIL Menu name ???                 }
 {9} '0',    { allways ZERO ???                    }
{10} '0',    { total number of messages in package }
{11} '0');   { number of conferences-1 here        }
             { next is 0 , then first conference   }

TYPE

  BlockArray   = ARRAY [1..128] OF CHAR;
  CharArray    = ARRAY [1..6] OF CHAR;  { to read in chunks }
  ControlArray = ARRAY [1..100] OF STRING [40]; { set to 100 conferences !!}
  bsingle      = array [0..4] of byte;

  MSGDATHdr = RECORD
    Status   : CHAR;
    MSGNum   : ARRAY [1..7] OF CHAR;
    Date     : ARRAY [1..8] OF CHAR;
    Time     : ARRAY [1..5] OF CHAR;
    UpTO     : ARRAY [1..25] OF CHAR;
    UpFROM   : ARRAY [1..25] OF CHAR;
    Subject  : ARRAY [1..25] OF CHAR;
    PassWord : ARRAY [1..12] OF CHAR;
    ReferNum : ARRAY [1..8] OF CHAR;
    NumChunk : CharArray;
    Alive    : BYTE;
    LeastSig : BYTE;
    MostSig  : BYTE;
    Reserved : ARRAY [1..3] OF CHAR;
  END;

  MBXHeader = RECORD
   Xref     : STRING[70];
   Path     : STRING;
   From     : STRING[70];
   Subject  : STRING[70];
   Date     : STRING[40];
   Lines    : WORD;
   Status   : CHAR;
   END;

CONST

     PKZIP   : PathStr = 'PKZIP.EXE';
     QWKFile : PathStr = 'NEWS.QWK';

VAR

  MBXF        : TEXT;
  QWKF        : FILE;
  ControlF    : TEXT;

  FOL         : FileOfLinesPtr;
  FOLPos      : LONGINT;

  SavePath,
  SwagPath,
  MBXFn,
  MsgFName    : PATHSTR;

  TR          : SearchRec;

  ConfNum,
  Number      : WORD;  { message number, conference number }

  MSGHdr      : MSGDatHdr;
  ch          : CHAR;
  count       : INTEGER;
  chunks      : INTEGER;
  ControlVal  : ControlArray;
  ControlIdx  : BYTE;
  ConfName,
  WStr        : STRING;

FUNCTION TrimL (InpStr : STRING) : STRING; ASSEMBLER;
ASM
      PUSH   DS
      LDS    SI, InpStr
      XOR    AX, AX
      LODSB
      XCHG   AX, CX
      LES    DI, @Result
      INC    DI
      JCXZ   @@2

      MOV    BL, ' '
      CLD
@@1 :  LODSB
      CMP    AL, BL
      LOOPE  @@1
      DEC    SI
      INC    CX
      REP    MOVSB

@@2 :  XCHG   AX, DI
      MOV    DI, WORD PTR @Result
      SUB    AX, DI
      DEC    AX
      STOSB
      POP    DS
END;

FUNCTION TrimR (InpStr : STRING) : STRING;

VAR i : INTEGER;

BEGIN
   i := LENGTH (InpStr);
   WHILE (i >= 1) AND (InpStr [i] = ' ') DO
      i := i - 1;
   TrimR := COPY (InpStr, 1, i)
END;

FUNCTION TrimB (InpStr : STRING) : STRING;

BEGIN
 TrimB := TrimL (TrimR (InpStr) );
END;

FUNCTION PadR (InpStr : STRING; FieldLen : BYTE) : STRING;
  {-Return a string right-padded to length len with ch}
VAR
  o    : STRING;
  SLen : BYTE ABSOLUTE InpStr;
BEGIN
  IF LENGTH (InpStr) >= FieldLen THEN
    PadR := COPY (InpStr, 1, FieldLen)
  ELSE BEGIN
    o [0] := CHR (FieldLen);
    MOVE (InpStr [1], o [1], SLen);
    IF SLen < 255 THEN
      FILLCHAR (o [SUCC (SLen) ], FieldLen - SLen, #32);
    PadR := o;
  END;
END;


FUNCTION GoodNumber (S : STRING) : BOOLEAN;
VAR
   Num  : LONGINT;
   Code : WORD;

BEGIN
Num := 0;
VAL (S, Num, Code);
GoodNumber := ( (Code = 0) AND (Num > 0) AND (S > '') );
END;


FUNCTION IntStr (Num : LONGINT; Width : BYTE; Zeros : BOOLEAN) : STRING;
{ Return a string value (width 'w')for the input integer ('n') }
  VAR
    Stg : STRING;
  BEGIN
    STR (Num : Width, Stg);
    IF Zeros THEN BEGIN
    FOR Num := 1 TO Width DO IF Stg [Num] = #32 THEN Stg [Num] := '0';
    END ELSE Stg := TrimL (Stg);
    IntStr := Stg;
  END;

 FUNCTION GetStr (VAR InpStr : STRING; Delim : CHAR) : STRING;

VAR i : INTEGER;
BEGIN
   i := POS (Delim, InpStr);
   IF i = 0 THEN
   BEGIN
      GetStr := InpStr;
      InpStr := ''
      END ELSE
          BEGIN
          GetStr := COPY (InpStr, 1, i - 1);
          DELETE (InpStr, 1, i)
          END
END;

FUNCTION Str2LongInt (S : STRING; VAR I : LONGINT) : BOOLEAN;
    {-Convert a string to an integer, returning true if successful}
  VAR
    code : WORD;
  BEGIN
    VAL (S, I, code);
    IF code <> 0 THEN BEGIN
      i := 0;
      Str2LongInt := FALSE;
    END ELSE
      Str2LongInt := TRUE;
  END;

FUNCTION GetNumber (VAR InpStr : STRING; Delim : CHAR) : LONGINT;

VAR S, S1 : STRING;
    I    : LONGINT;
BEGIN
   I  := 0;
   S1 := InpStr;
   S  := GetStr (InpStr, Delim);
   IF NOT GoodNumber (S) THEN InpStr := S1 ELSE
   Str2LongInt (S, I);
   GetNumber := I;
END;


FUNCTION NameOnly (FileName : PathStr) : PathStr;
{ Strip any path information from a file specification }
VAR
   Dir  : DirStr;
   Name : NameStr;
   Ext  : ExtStr;
BEGIN
   FSplit (FileName, Dir, Name, Ext);
   NameOnly := Name;
END {NameOnly};

FUNCTION SlashDate(AddCentury : BOOLEAN) : STRING; {10/08/88}

VAR
  MonthName, dayname, yearname, dayofweekname : WORD;

BEGIN

  GETDATE (yearname, MonthName, dayname, dayofweekname);

  IF AddCentury THEN
  SlashDate := IntStr (MonthName, 2, TRUE) + '/' +
  IntStr (dayname, 2, TRUE) + '/' +
  IntStr (yearname, 4, TRUE) ELSE

  SlashDate := IntStr (MonthName, 2, TRUE) + '/' +
  IntStr (dayname, 2, TRUE) + '/' +
  COPY (IntStr (yearname, 4, TRUE), 3, 2);

END;

FUNCTION PlainTime : STRING; {09:10:01}

VAR
  Hr, Min, Sec, sec100 : WORD;

BEGIN
  GETTIME (Hr, Min, Sec, sec100);
  PlainTime := IntStr (Hr, 2, TRUE) + ':' +
  IntStr (Min, 2, TRUE) + ':' +
  IntStr (Sec, 2, TRUE);

END;

FUNCTION EraseFile ( S : PathStr ) : BOOLEAN ;
VAR F : FILE;
BEGIN
EraseFile := FALSE;
ASSIGN (F, S);
RESET (F);
IF IORESULT <> 0 THEN EXIT;
  CLOSE (F);
  ERASE (F);
  EraseFile := (IORESULT = 0);
END;

PROCEDURE ReallocateMemory(P : POINTER); ASSEMBLER;
ASM
  MOV  AX, PrefixSeg
  MOV  ES, AX
  MOV  BX, WORD PTR P+2
  CMP  WORD PTR P,0
  JE   @OK
  INC  BX

 @OK:
  SUB  BX, AX
  MOV  AH, 4Ah
  INT  21h
  JC   @X
  LES  DI, P
  MOV  WORD PTR HeapEnd,DI
  MOV  WORD PTR HeapEnd+2,ES

 @X:
END;

FUNCTION EXECUTE(Name : PathStr ; Tail : STRING) : WORD; ASSEMBLER;
ASM
  {$IFDEF CPU386}
  DB      66h
  PUSH    WORD PTR HeapEnd
  DB      66h
  PUSH    WORD PTR Name
  DB      66h
  PUSH    WORD PTR Tail
  DB      66h
  PUSH    WORD PTR HeapPtr
  {$ELSE}
  PUSH    WORD PTR HeapEnd+2
  PUSH    WORD PTR HeapEnd
  PUSH    WORD PTR Name+2
  PUSH    WORD PTR Name
  PUSH    WORD PTR Tail+2
  PUSH    WORD PTR Tail
  PUSH    WORD PTR HeapPtr+2
  PUSH    WORD PTR HeapPtr
  {$ENDIF}
  CALL ReallocateMemory
  CALL SwapVectors
  CALL DOS.EXEC
  CALL SwapVectors
  CALL ReallocateMemory
  MOV  AX, DosError
  OR   AX, AX
  JNZ  @OUT
  MOV  AH, 4Dh
  INT  21h

 @OUT:
END;


PROCEDURE FindPKZip;
VAR
  S : PathStr;
BEGIN
  S := FSearch ('PKZIP.EXE', GetEnv ('PATH') );
  IF S = '' THEN
     BEGIN
     WriteLn(#7,'You GOTTA have PKZIP somewhere on your PATH to do this !!');
     HALT(1);
     END;
     PKZIP := FExpand (S);
END;

PROCEDURE CleanUp;
{ clean up after ourselves }
BEGIN
  FINDFIRST ('*.NDX', $21, TR);
  WHILE DosError = 0 DO
        BEGIN
        EraseFile(TR.NAME);
        FINDNEXT (TR);
        END;
  EraseFile('MESSAGES.DAT');
  EraseFile('CONTROL.DAT');

END;

PROCEDURE CreateControlDat;
VAR
    I : BYTE;
BEGIN

     ControlHdr [ 6] := SlashDate(TRUE)+','+PlainTime;
     ControlHdr [10] := IntStr (Count, 5, FALSE);
     ControlHdr [11] := IntStr (PRED (ConfNum), 3, FALSE);

     ASSIGN (ControlF, 'CONTROL.DAT');
     REWRITE (ControlF);
     FOR I := 1 TO 11 DO
         WRITELN (ControlF, ControlHdr [i]);
     FOR I := 1 TO ControlIdx DO
         WRITELN (ControlF, ControlVal [i]);
     CLOSE (ControlF);
END;

PROCEDURE CreateMessageDat;
VAR
    I    : BYTE;
    Buff : BlockArray;
BEGIN

  FILLCHAR (ControlVal, SIZEOF (ControlVal), #0);
  FILLCHAR (Buff, SIZEOF (Buff), #32);
  FILLCHAR (MsgHdr, SIZEOF (MsgHdr), #32);
  ConfNum    := 0;
  ControlIdx := 0;
  Number     := 0;
  ASSIGN (QWKF, 'MESSAGES.DAT');
  REWRITE (QWKF, SIZEOF (MsgHdr) );
  WStr := 'NEWS TO QWK (c) 1996 GDSOFT';
  FOR I := 1 TO LENGTH (WStr) DO Buff [i] := WSTR [i];
  BLOCKWRITE (QwkF, Buff, 1);
END;

FUNCTION ArrayTOInteger (B : CharArray; Len : BYTE) : LONGINT;

VAR I : BYTE;
    S : STRING;
    E  : INTEGER;
    T  : INTEGER;

BEGIN
    S := '';
    FOR I := 1 TO PRED (Len) DO IF B [i] <> #32 THEN S := S + B [i];
    VAL (S, T, E);
    IF E = 0 THEN ArrayToInteger := T;
END;

PROCEDURE GetNewsGroupHeader(VAR NGH : MBXHeader);

VAR
   Junk : STRING;

BEGIN
     WHILE POS('STATUS:',UpCaseStr(FOL^.LastLine)) = 0 DO
         BEGIN
         FOL^.SeekLine(FOLPos);
         INC(FOLPos);
         IF POS('XREF:',UpCaseStr(FOL^.LastLine)) > 0 THEN
            NGH.XRef := TrimB(COPY(FOL^.LastLine,6,$FF));
         IF POS('PATH:',UpCaseStr(FOL^.Lastline)) > 0 THEN
            NGH.Path := TrimB(COPY(FOL^.LastLine,6,$FF));
         IF POS('FROM:',UpCaseStr(FOL^.Lastline)) > 0 THEN
            NGH.From := TrimB(COPY(FOL^.LastLine,6,$FF));
         IF POS('SUBJECT:',UpCaseStr(FOL^.Lastline)) > 0 THEN
            NGH.Subject := Trimb(COPY(FOL^.LastLine,9,$FF));
         IF POS('DATE:',UpCaseStr(FOL^.Lastline)) > 0 THEN
            NGH.Date := Trimb(COPY(FOL^.LastLine,6,$FF));
         IF POS('LINES:',UpCaseStr(FOL^.Lastline)) > 0 THEN
            BEGIN
            Junk := GetStr(FOL^.LastLine,#32);
            NGH.Lines := GetNumber(FOL^.LastLine,#32);
            END;
         IF POS('STATUS:',UpCaseStr(FOL^.Lastline)) > 0 THEN
            NGH.STATUS := 'S';
         END;
END;

PROCEDURE ReadMessage(HdrPos : LONGINT);
VAR

  HDR    : MsgDatHdr;
  Block  : BlockArray;
  EndPos : LONGINT;
  Chunks : LONGINT;
  J,K    : INTEGER;
  I,SFOL : LONGINT;
  NS     : STRING;
  NGH    : MBXHeader;

  PROCEDURE MoveDataToBlock (Start, Len : BYTE; S : STRING; VAR Block : BlockArray);
  VAR I, K : BYTE;

  BEGIN
      K := 0;
      FOR I := Start TO PRED (Start + Len) DO
          BEGIN
          INC (k);
          Block [i] := S [k];
          END;
  END;


  PROCEDURE WriteHeader;
  BEGIN
  { write the header out }
  Seek(QwkF,HdrPos);
  FillChar(Block,SizeOf(Block),#32);
  MoveDataToBlock(  2, 7,PadR(IntStr(Number,7,FALSE),7),Block); { number }
  MoveDataToBlock(  9, 8,SlashDate(FALSE),Block);               { date }
  MoveDataToBlock( 17, 5,PlainTime,Block);                      { Time }
  MoveDataToBlock( 22,25,PadR(ControlHdr[4],25),Block);               { To   }
  MoveDataToBlock( 47,25,PadR(NGH.FROM,25),Block);              { From }
  MoveDataToBlock( 72,25,PadR(NGH.Subject,25),Block);           { Subj }
  MoveDataToBlock( 97,20,PadR('IMPORT',20),Block);              { Confname }
  MoveDataToBlock(117, 6,PadR(IntStr(Chunks,6,FALSE),6),Block); { Numpacs }
  MoveDataToBlock(124, 1,Chr(64),Block);
  BlockWrite(QwkF,Block,1);
  END;

  PROCEDURE WriteBlock;
  BEGIN
       BLOCKWRITE (QwkF, Block, 1);
       FILLCHAR (Block, SIZEOF (Block), #32);
       INC (chunks);  { increment block count }
       k := 0;
  END;

  PROCEDURE ProcessLine;
  VAR
     c : BYTE;
  BEGIN
       FOR c := 1 TO LENGTH(FOL^.LastLine) DO
           BEGIN
           INC (k);
           {
           IF FOL^.LastLine [c] = #13 THEN
              BEGIN
              Block [k] := #227;
              INC (c);
              END ELSE Block [k] := FOL^.LastLine [c];
           }
           Block[k] := FOL^.Lastline[c];
           IF k = 128 THEN WriteBlock;

           END; { for }

      { write end of line }
      INC(k);
      Block[k] := #227;
      IF k=128 THEN WriteBlock;
  END;

BEGIN

  SFOL := SUCC(FOLPos);

  { read the header block }
  GetNewsGroupHeader(NGH);

  { fill QWK Header with info }

  FILLCHAR (Block, SIZEOF (Block), #32);
  FILLCHAR(Hdr,SizeOF(Hdr),#0);

  { write the header out }
  chunks := 1;  { number packs }
  INC(Number);  { update message number }

   { write the header to our QWK file }
   WriteHeader;

   { write the blocks out }
   K := 0;
   FILLCHAR (Block, SIZEOF (Block), #32);

   FOR I := FOLPos TO FOLPos + NGH.Lines DO
       BEGIN
       FOL^.SeekLine(i);
       ProcessLine;
       END;

  J := I; { save the FOLPos for later }

  { write the original header out }
  FOL^.LastLine := ' ';
  ProcessLine;
  FOL^.LastLine := 'Original Header:';
  ProcessLine;
  FOL^.LastLine := ' ';
  ProcessLine;

  FOR I := SFOL TO FOLPos DO
      BEGIN
      FOL^.Seekline(i);
      ProcessLine;
      END;

  IF k > 0 THEN WriteBlock;
  FOLPos := j; { update the position in the file }

  EndPos := FilePos(QwkF);

  { update the header }
  WriteHeader;
  SEEK(QwkF, EndPos);

END;

PROCEDURE ProcessUseNetFile (FN : PathStr);
{ this is the heart !!  Read messages from MBX file and save in QWK file }
VAR
    ndxF : File;
    b    : bSingle;
    r    : REAL;
    n    : LONGINT;

    { converts TP real to Microsoft 4 bytes single .. GOOFY !!!! }
    procedure real_to_msb (preal : real; var b : bsingle);
    var
         r : array [0 .. 5] of byte absolute preal;
    begin
         b [3] := r [0];
         move (r [3], b [0], 3);
    end; { procedure real_to_msb }


BEGIN

  WriteLn('Process .. ',FN);

  { create the NDX file }
  ASSIGN  (ndxF,IntStr(ConfNum,3,TRUE)+'.NDX');
  REWRITE (ndxF,1);

  WHILE (FOLPos < FOL^.Totallines) DO
        BEGIN

        n := SUCC(FilePos(QwkF));      { ndx wants the RELATIVE position }
        r := N;                        { make a REAL                     }
        REAL_TO_MSB(r,b);              { convert to MSB format           }
        BLOCKWRITE(ndxF,B,SizeOf(B));  { store it                        }

        WriteLn('Process message .. ',IntStr(Number+1,5,FALSE));
        ReadMessage(PRED(n));
        INC(Count);
        END;

  CLOSE (NdxF);

  { update the CONTROL file array }
  INC (ControlIdx);
  ControlVal [ControlIdx] := IntStr (ConfNum, 3, TRUE);
  INC (ControlIdx);
  ControlVal [ControlIdx] := ConfName;
  INC (ConfNum);

END;

PROCEDURE GetConferenceName;

VAR
   Junk : STRING;

BEGIN
     WHILE POS('NEWSGROUPS:',UpCaseStr(FOL^.LastLine)) = 0 DO
         BEGIN
         FOL^.SeekLine(FOLPos);
         INC(FOLPos);
         END;
Junk     := GetStr(FOL^.LastLine,' ');
ConfName := TrimB(FOL^.Lastline);
FOLPos   := 1;
END;

BEGIN

  ClrScr;

  IF ParamCount > 0 THEN MBXfn := FExpand(ParamStr(1)) ELSE MBXfn := '*.MBX';

  EraseFile(QWKFile);  { make sure we don't have one yet }

  FindPkZip;

  CreateMessageDat;

  Count := 0;  { total messages in package }

  { process all the files that we find with the extension }
  FINDFIRST (MBXFn, $21, TR);
  WHILE DosError = 0 DO
        BEGIN
        NEW(FOL, Init(TR.Name, 1024));
        FOLPos := 1;  { current position in RLINE array }
        GetConferenceName;
        ProcessUseNetFile (TR.Name);
        DISPOSE (FOL, Done);
        FindNext(TR);
        END;

  CLOSE (QwkF);

  CreateControlDat;

  Execute(PKZIP,' -ex '+QWKFile+' *.NDX MESSAGES.DAT CONTROL.DAT');

  CleanUp;


END.