'this program is prepared as source code for Quick Basic.
'to use it with GW-Basic, Use your word processor to  add line
'numbers, replace line names with the equivilant line number.
'  Author has a program that will do the coversion.
'  EMail request for conversion
CLS
PRINT "=============== program name =  wipeout.bas ============="

          PRINT "     For DOS 5.   by Bruce Ross, himself"
          PRINT
          PRINT "This program is dedicated to the public domain"
          PRINT "  No warranty for any use is implied or stated."
          PRINT "Author is not responsible for loss incidental or"
          PRINT " consequential to any use this progam may be put."
 PRINT
          PRINT "This program uses the assumption that when a file with a directory entry is"
          PRINT "changed, the changes occur in the same locations as the bytes being changed."
          PRINT "   Is this so?  Only Microsquish knows!!"
          PRINT "   It is a logical assumption, and it seems to be true,"
          PRINT "   but then neither DOS or windows is logical."
 PRINT

ON ERROR GOTO 14300
PRINT "   mode 1 = wipe a file clean"
PRINT "   mode 2 = fill the rest of a disk with a junk file,"
PRINT "            which can then be erased, leaving the junk on the disk"
PRINT "            instead of your goodies."
PRINT "   mode 3 = duplicate a file over and over with progressive file naming."
PRINT "        4 = return to DOS"
PRINT
PRINT "   both modes clear artifacts left over from file deletes"
PRINT "      for best results,  run   CHKDSK   or similar before running"
PRINT "      mode 2 of this program."
PRINT
 
  LU = 127    ' Limits of random characters
  LL = 33
  CRLF$ = CHR$(13) + CHR$(10)
  WHEEL$(1) = "|"
  WHEEL$(2) = "/"
  WHEEL$(3) = "\"
  WHEELCOUNT = 1

  '-----------------------
  DIRFILE$ = "XXXD.TMP"
  SHELL "DIR > " + DIRFILE$
  OPEN DIRFILE$ FOR INPUT AS #1
INLOOP:
   IF EOF(1) THEN PRINT "directory error ": END
   INPUT #1, A$
   z = INSTR(A$, "bytes free")
   IF z = 0 THEN GOTO INLOOP
   DISKSIZE = VAL(A$)
   PRINT USING "###,###,###,###,###."; DISKSIZE; : PRINT "  BYTES OF DISK SPACE TO FILL"
   CLOSE
   



ZINPUT:
INPUT "    mode   <1> "; mood
       IF mood = 0 THEN mood = 1
       IF mood = 1 THEN GOTO WIPEOUT      ' clean a file
       IF mood = 2 THEN GOTO FILLERUP     ' fill all unused segments.
       IF mood = 3 THEN GOTO COPYFILE     ' re-copies a file over and over.
       IF mood = 4 THEN END
       BEEP: RUN
'=================================================================
WIPEOUT:  '  mode 1
PRINT
PRINT "-----------------------------------------------------------"
PRINT "            ERASE WITHOUT A TRACE, (MAYBE)"
PRINT "              PROGRAM NAME = WIPEOUT.BAS"
PRINT "                    JULY 3, 1996"
PRINT
PRINT "PROGRAM IS DESIGNED TO OVERWRITE A FILE WITH JUNK BEFORE "
PRINT " DELETING.     BECAUSE OF THE MYSTERIES OF DOSS AND "
PRINT " WINDOWS, IT MAY NOT GET ALL OF IT.    "
PRINT " THERE IS SOME QUESTION OF WHETHER DOSS ACTUALLY RE-USES "
PRINT " FILE SPACE OR MOVES ON TO THE NEXT AVAILABLE SPACE WHILE"
PRINT " RE-WRITING A FILE."
PRINT "       FILE MAY BE SCRUBBED MORE THAN ONCE.  JUST SELECT"
PRINT "       DO NOT ERASE    AT THE END, THEN REPEAT"
PRINT
CLOSE


PRINT "NAME OF FILE TO WIPE OUT AND/OR ERASE = "
Q$ = "": GOSUB 11960         ' file naming
NEWFILE$ = Q$: GOSUB 12160   ' open newfile$

GOSUB WIPEOUTERS             ' set up wipe out string

  GOSUB SERCH      ' OPEN FILE"
 
LOOBY:
GOSUB SERCH2       ' PULL IN BLOCK TO BUFFER$
ZB = LEN(BUFFER$): ZPX = LEN(PX$)
  
FOR NZ = 1 TO ZB STEP ZPX:
  MID$(BUFFER$, NZ, ZPX) = PX$:
  IF WO$ = "9" THEN GOSUB MAKEPW: PX$ = PW$ + CRLF$:  ' RANDOMIZED WIPEOUT
  IF WO$ = "11" THEN GOSUB MAKEPW: PX$ = PW$ + CRLF$: ' RANDOM ALPHA

NEXT NZ
  XS = NZ - LEN(BUFFER$) - 1
  ZREMINANT = ZPX - XS
10  IF ZREMINANT >= 2 THEN MID$(BUFFER$, NZ - ZPX, ZREMINANT) = STRING$(ZREMINANT - 2, "*") + CRLF$

   PRINT USING "###,###,###"; LEN(BUFFER$); QQQ&; FILEOFFSET&; NZ; ZPX; ZREMINANT
   SEEK #1, QQQ&      ' SET FILE POINTER
 
   PRINT USING "###,###,###"; QQQ&; FILEOFFSET&
   IF LEN(BUFFER$) THEN PUT #1, , BUFFER$            ' ERASE BLOCK
   IF LEN(BUFFER$) < PACKETSIZE THEN GOTO ENDSEQ
 GOSUB 14200
 GOTO LOOBY
  
ENDSEQ:
CLOSE
GOSUB ENDSONG
INPUT " VIEW JUNKED FILE, ERASE IT, or QUIT WITHOUT ERASING.  V/E/Q  <V>"; Q$: GOSUB 14160
IF Q$ = "" THEN Q$ = "V"
IF Q$ = "V" THEN SHELL "LIST " + NEWFILE$: GOTO ENSQ1
IF Q$ = "E" THEN GOTO KILLER
IF Q$ = "Q" THEN GOTO ENSQ1
GOTO ENDSEQ

ENSQ1:
PRINT : BEEP
PRINT "OK TO ERASE "; NEWFILE$; : INPUT " Y/N  <Y>"; Q$: GOSUB 14160
IF Q$ = "" THEN Q$ = "Y"
IF Q$ = "Y" THEN GOTO KILLER
PRINT NEWFILE$; " IS NOT ERASED"
GOTO K1

KILLER:
     KILL NEWFILE$: PRINT NEWFILE$; " IS ERASED":
K1:  GOSUB ENDSONG
     RUN

'----------------------- END


'=================================================================
FILLERUP:     '  mode 2
'
PRINT "Hitting Any key will stop the filling and give you an option to close the file."
100 INPUT "Name of disk to fill C: A: B:, ETC. "; SOURCEFILE$
   IF INSTR(SOURCEFILE$, ":") <> 2 THEN BEEP: PRINT "NEED A : ": GOTO 100
SOURCEFILE$ = SOURCEFILE$ + "xxx.TMP"
SOURCEFILE$ = LTRIM$(RTRIM$(SOURCEFILE$))
SIZE& = 2048 * 4
IF SOURCEFILE$ = "C:XXX.TMP" THEN SIZE& = 2048 * 15&
PRINT "NAME OF DUMMY FILE TO WRITE.  INCLUDE DIRECTORY --  <"; SOURCEFILE$;
INPUT ">  "; Q$
IF Q$ = "" THEN GOTO 120
SOURCEFILE$ = Q$

120  GOSUB WIPEOUTERS
     FOOP$ = PX$

130 PRINT "BUFFER SIZE = "; SIZE&
SHELL "del " + SOURCEFILE$
PRINT "IF "; SOURCEFILE$; " EXISTED, IT IS NOW ERASED."
PRINT
CRLF$ = "XX" + CHR$(13) + CHR$(10)
'CRLF$ = CHR$(13) + CHR$(10)
'SIZE& = 512
CLOSE
PRINT "disk filler."
PRINT "Fills all open space with characters.    <"; FOOP$; ">"
PRINT " AS FILE NAMED "; SOURCEFILE$
PRINT "Note this effectively purges data left on disk by DELETE command "
PRINT
INPUT "CR TO CONTINUE.  X OR Q TO QUIT"; Q$: Q$ = UCASE$(Q$)
IF Q$ = "X" THEN SYSTEM
IF Q$ = "Q" THEN SYSTEM
PRINT "ANY KEY TO STOP"
PRINT "PROGRESS  --  BYTES FILLED"

OPEN SOURCEFILE$ FOR OUTPUT AS #1
FOOBY1:
IF LEN(FOOP$) = 1 THEN filler$ = STRING$(SIZE& - 4, FOOP$): GOTO FOOBY
filler$ = ""
FOR Q = 1 TO (SIZE& - 4) / LEN(FOOP$)
filler$ = filler$ + FOOP$
NEXT Q

'FILLER$ = STRING$(SIZE& - 4, "Z")        ' Z = 01010101

FOOBY:
IF WO$ = "9" THEN GOSUB MAKEPW: filler$ = LEFT$(PW$, SIZE& - 4): SIZE& = 75  ' RANDOMIZED WIPEOUT
IF WO$ = "11" THEN GOSUB MAKEPW: filler$ = LEFT$(PW$, SIZE& - 4): SIZE& = 75 ' RANDOMIZED WIPEOUT A-Z

FOOBY2:
PRINT #1, filler$; CRLF$;
LOCATE 25, 1: PRINT X&; "  "; WHEEL$(WHEELCOUNT);
WHEELCOUNT = WHEELCOUNT + 1: IF WHEELCOUNT > 3 THEN WHEELCOUNT = 1
X& = X& + SIZE&
IF X& - XP& > 1000000! THEN XP& = X&: LOCATE 24, 1: PRINT X&; :
GOSUB 14200   '  WHADYAWANT?
GOTO FOOBY1


'  BUFFER$ = INPUT$(PACKETSIZE, #4)
'  Buffer$ = UCASE$(INPUT$(PACKETSIZE, #4))

 ' ================================================================
COPYFILE:    '  mode 3

    PRINT "DUPLICATE A FILE OVER AND OVER TO FILL DISK."
    PRINT " any existing file can be used.  a junk file can be "
    PRINT " composed using mode 2.  "
    PRINT " Make startup file as large as you wish."
    PRINT
   
   ' INPUT "FILE TO BE COPIED <XXX.TMP>"; SOURCEFILE$
   ' IF SOURCEFILE$ = "" THEN SOURCEFILE$ = "XXX.TMP"
   

    PRINT "NAME OF FILE TO BE COPIED = "
    Q$ = "C:\XXX.TMP": GOSUB 11960     ' file naming
    SOURCEFILE$ = Q$: GOSUB 12160   ' open newfile$
   
    PRINT "NAME OF DUPLICATES <XXX*.TMP>  (*=1, 2, 3, ...)"; OUTFILE$
    Q$ = "C:\XXX*.TMP"
    GOSUB 11960         '  file naming
    OUTFILE$ = Q$
    z = INSTR(OUTFILE$, "*")
    IF z = 0 THEN BEEP: PRINT " DUPLICATE FILE NAME MUST HAVE A *": GOTO COPYFILE
    OF1$ = LEFT$(OUTFILE$, z - 1): OF2$ = RIGHT$(OUTFILE$, LEN(OUTFILE$) - z)
    INPUT "  Build junk file linearly or geometrically?  lin/geo <geo>"; BF$
    IF BF$ = "" THEN BF$ = "GEO"
    BF$ = UCASE$(BF$)
    IF BF$ = "GEO" THEN GOTO CF1
    IF BF$ = "LIN" THEN GOTO CF1
    BEEP: GOTO COPYFILE
CF1:    XX = 0: FILL = 0: FILLED = 0
    OPEN SOURCEFILE$ FOR INPUT AS #1: LENSOURCE = LOF(1): CLOSE   ' file exists?

IF BF$ = "GEO" THEN GOTO GEO:
' linear
PRINT "Two kinds of linear file building. "
PRINT "  1 = a copy of prototype file is attached to the previous disk filler file on each cycle."
PRINT "  2 = N copies of prototype file are made one file for use as disk filler.  N=N+1 each cycle"
PRINT "    2 can be faster because the previous filler file does not have to be read."
PRINT "    Recommend that  prototype file be in ramdisk."
PRINT
INPUT "  Choose  1, 2,  <1>"; LMODE
IF LMODE = 0 THEN LMODE = 1
IF LMODE = 1 THEN GOTO LMODE1
IF LMODE = 2 THEN GOTO LMODE2


LMODE1: 'linear lmode1
LOOPER:    XX = XX + 1       '  NAME COUNTER
    FILLED = FILLED + LENSOURCE
    XX$ = LTRIM$(STR$(XX))
    OUTFILE$ = OF1$ + XX$ + OF2$
    GOSUB 14200              '  STOPPER
   PRINT OF1$; " "; XX$; " "; OF2$; "  ";
   PRINT SOURCEFILE$ + " ---> "; OUTFILE$; "  ";
   PRINT USING "###,###,###,###"; FILLED - LENSOURCE; DISKSIZE
    IF FILLED - LENSOURCE > DISKSIZE THEN BEEP: GOTO GOON   ' stopper
    SHELL "COPY " + SOURCEFILE$ + " " + OUTFILE$
GOTO LOOPER
      
LMODE2:
    'OPEN SOURCEFILE$ AS #2 FOR INPUT
LOOPER2:    XX = XX + 1          '  NAME COUNTER
    FILLED = FILLED + LENSOURCE
    XX$ = LTRIM$(STR$(XX))
    OUTFILE$ = OF1$ + XX$ + OF2$
    GOSUB 14200              '  STOPPER
   PRINT OF1$; " "; XX$; " "; OF2$; "  ";
   PRINT SOURCEFILE$ + " ---> "; OUTFILE$; "  ";
   PRINT USING "###,###,###,###"; FILLED - LENSOURCE; DISKSIZE
    IF FILLED - LENSOURCE > DISKSIZE THEN BEEP: GOTO GOON   ' stopper
   SHELL "COPY " + SOURCEFILE$ + " " + OUTFILE$    ' SEED FILE
   'OPEN  OUTFILE$ AS #1 FOR APPEND
   FOR LOON = 1 TO XX
     
     
     PRINT LOON;
   NEXT LOON
 GOTO LOOPER2



GEO:
  IF BF$ = "LIN" THEN GOTO GOON
  OUTFILE$ = OF1$ + "0" + OF2$
  PRINT OUTFILE$
  SHELL "COPY " + SOURCEFILE$ + " " + OUTFILE$
  FILLED = LENSOURCE
LOGLOOPER:    XX = XX + 1      '  NAME COUNTER
    XXP$ = LTRIM$(STR$(XX - 2))
    IF XX - 2 < 0 THEN XXP$ = "0"
    XXC$ = LTRIM$(STR$(XX - 1))
    IF XX - 1 < 0 THEN XXC$ = "0"
    XX$ = LTRIM$(STR$(XX))
    OUTFILEP$ = OF1$ + XXP$ + OF2$
    OUTFILEC$ = OF1$ + XXC$ + OF2$
    OUTFILE$ = OF1$ + XX$ + OF2$
    OPEN OUTFILEP$ FOR INPUT AS #1: LENSOURCEP = LOF(1): CLOSE   ' file exists?
    OPEN OUTFILEC$ FOR INPUT AS #1: LENSOURCEC = LOF(1): CLOSE   ' file exists?
    FILLING = LENSOURCEP + LENSOURCEC    ' LAST TWO PREVIOUS
    FILLING = LENSOURCEC + LENSOURCEC    ' DOUBLING
    GOSUB 14200              '  STOPPER
   PRINT OF1$; " "; XX$; " "; OF2$; "  ";
   PRINT SOURCEFILE$ + " ---> "; OUTFILE$; "  "
'   PRINT OUTFILE$; FILLING, OUTFILEP$; LENSOURCEP, OUTFILEC$; LENSOURCEC
    TIMEX& = TIMER:  PRINT "START TIME "; TIMEX&
   PRINT "COPYING "; : PRINT USING "###,###,###,###"; FILLING; : PRINT "  BYTES"
'   SHELL "copy " + OUTFILEP$ + " + " + OUTFILEC$ + " " + OUTFILE$
   SHELL "copy " + OUTFILEC$ + " + " + OUTFILEC$ + " " + OUTFILE$  ' doubles
    FILLED = FILLED + FILLING    ' total filled
    PRINT TIMEX&; TIMER; TIMER - TIMEX&; " SECONDS  "; (TIMER - TIMEX&) / 60; " MINUTES"
    PRINT FILLED; " BYTES FILLED"
    PRINT
 GOTO LOGLOOPER


GOON:  PRINT "DISK FULL.   STOP": CLOSE : END

      '-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

     '        [=-=-=-=-=-= [utility subroutines] =-=-=-=-=-=-=]

' [========== search for file PN ===========]
SERCH: ' [---- file searcher using "binary" file mode ----]
     WHEEL$(0) = "/"          ' progress marker wheel
     WHEEL$(1) = "\"
     WHEEL$(2) = "-"
     L00P = 0
SERCH1: CLOSE 1
'     OPEN TMPtmp$ FOR BINARY AS #1: ' restart from beginning each time.
     OPEN NEWFILE$ FOR BINARY AS #1: ' restart from beginning each time.FILELENGTH& = LOF(1)
     FOUNDIT = 0              ' reset found flag
     FILEOFFSET& = 1          ' first byte of packet to fetch
     PACKETSIZE = 10000:      ' search buffer size
     SX = 1                   ' reset buffer search pointer
     PATTERNLENGTH = LEN(PX$) ' search pattern length
     begn& = 0                ' beginning of found file
     QQQ& = FILEOFFSET&
     Q = FRE(Q$)
     RETURN

SERCH2:           ' re-entry point
   FOUNDIT = 0    ' hit flag
   STRINGPOS = 0  ' in case bytesleft& <= patternlength,  last record, nothing to search
   PATTERNLENGTH = LEN(PX$)
   ' Keep searching as long as there are enough bytes left in
   ' the file to contain the pattern you're searching for:

NXTBLK: ' process several buffers full to EOF
   ' Read either 10,000 bytes or the number of bytes left in the file,
   ' whichever is smaller, then store them in Buffer$. (If the number
   ' of bytes left is less than PACKETSIZE, the following statement
   ' still reads just the remaining bytes, since binary I/O doesn't
   ' give "read past end" errors):
     SEEK #1, FILEOFFSET&                    ' seek statement sets put/get pointer
     BUFFER$ = ""
     BUFFER$ = INPUT$(PACKETSIZE, #1)
   ' Find every first of the pattern in Buffer$:
     START = SX                              ' start search at SX
     WH% = WH% + 1: IF WH% > 2 THEN WH% = 0
     LOCATE 25, 79: PRINT WHEEL$(WH%);       ' progress marker
'     STRINGPOS = INSTR(START, BUFFER$, PX$): ' find code pattern
     IF STRINGPOS = 0 THEN GOTO ENDBUFF      ' code pattern not found
   ' Found the pattern, so print the byte position in the file where the pattern starts:
   ' start = STRINGPOS + 1
 '    FOUNDIT = 1: GOTO RETRO  ' found flag -1=eof, 0= not found 1= found
ENDBUFF:  '  stringpos is 0, search failed thus far
'   IF LEN(BUFFER$) < PACKETSIZE THEN GOTO DOON: ' end of file
   ' Find the byte position where the next I/O operation would take place,
   ' then back up the file pointer a distance equal to the length of the
   ' pattern (in case the pattern straddles a 10,000-byte boundary):
   QQQ& = FILEOFFSET&                          ' CURRENT BLOCK STARTS HERE
   FILEOFFSET& = SEEK(1)                       ' NEXT BLOCK STARTS HERE. seek function  like LOC(#)
'   FILEOFFSET& = FILEOFFSET& - PATTERNLENGTH   ' BACK UP SOME.
   SX = 1                                      ' reset buffer search pointer
   RETURN
   'GOTO NXTBLK                                 ' search another block of file



      '============ file and set-up subroutines =============

11960 '[------ file naming -------]
      ' input:  q$ = default name
      ' output: q$ = file name

      PRINT " --  DIR X: for directory. DEL X: for delete "
      A$ = Q$: PRINT "NAME   <"; Q$; ">"; '   print default in <>
      INPUT Q$: Q$ = UCASE$(Q$)
      IF Q$ = "" THEN Q$ = A$    ' insert default
      IF Q$ = "DIR" THEN FILES: PRINT : GOTO 11960
      IF Q$ = "DIR " THEN FILES: PRINT : GOTO 11960
      IF INSTR(Q$, "DIR ") > 0 THEN Q$ = RIGHT$(Q$, LEN(Q$) - 4): SHELL "dir /w /p " + Q$: PRINT : GOTO 11960
      IF INSTR(Q$, "DEL ") > 0 THEN 12100
      GOTO 12140                 ' to return

12100 QQ$ = RIGHT$(Q$, LEN(Q$) - 4): PRINT "delete "; Q$; : INPUT "   Are you sure? <N>"; Q$
      Q$ = LTRIM$(RTRIM$(Q$)): IF Q$ = "Y" THEN KILL QQ$: PRINT QQ$; " has been deleted"
      PRINT

12140 RETURN                     ' return with file name in Q$
'-----------------]

12160 '[-------------- open NEWFILE$ ------------]
      IF NEWFILE$ = "" THEN 12360    ' no newfile
      IF NEWFILE$ <> WRKFILE$ THEN 12220
      NEWFILE$ = TMPFILE$:
      PRINT "INPUT AND OUTPUT FILES ARE SPECIFIED TO BE THE SAME NAME."
      PRINT "OUTPUT FILE HAS BEEN RENAMED "; NEWFILE$
12220 PRINT : CLOSE #2
      ON ERROR GOTO 12330            ' if new file does not exist
      OPEN NEWFILE$ FOR INPUT AS #2  ' test for existance of newfile$
12250 PRINT NEWFILE$; "  EXISTS.": BEEP
      INPUT "   OVERWRITE, APPEND, CANCEL NEW FILE NAME   O/A/C <O>"; Q$
12270 CLOSE #2:  FOO$ = NEWFILE$  ' for error trap
      ON ERROR GOTO 14300         ' main error trap
      Q$ = UCASE$(Q$): IF Q$ = "" THEN Q$ = "O"
      IF Q$ = "0" THEN Q$ = "O"
      IF Q$ = "O" THEN 12360  ' OPEN NEWFILE$ FOR OUTPUT AS #2: GOTO 12360
      IF Q$ = "A" THEN 12360  ' OPEN NEWFILE$ FOR APPEND AS #2: GOTO 12360
      IF Q$ = "C" THEN RUN    ' NEWFILE$ = "": GOTO 12160
      BEEP: GOTO 12250
12330 '     error handler,  file does not exist
      Q$ = "O": RESUME 12270      ' default to open

12360 RETURN
'-------------------]

14160 '[------ SMALL LETTERS ---> CAPS  FIX-UP, LEFT JUSTIFY  ------]
      Q$ = LTRIM$(UCASE$(Q$))
      GOTO 14221:
      RETURN
'--------------------]


14200 '[--------  whadyawant interrupt from kbd. -------]
      IF INKEY$ = "" THEN RETURN
14220 DEF SEG = 0: POKE 1050, PEEK(1052)  ' clear keyboard buffer
      DEF SEG : POKE 106, 0               ' clear basic input buffer
      BEEP: LOCATE 24, 1
      INPUT "whadayawant?  X OR Q to close and quit.  CR to continue"; Q$:
14221 Q$ = UCASE$(Q$)
      IF Q$ = "X" THEN CLOSE : SYSTEM
      IF Q$ = "Q" THEN CLOSE : SYSTEM
    ' IF Q$ <> "" THEN 14220
      RETURN
'--------------------]

14300 ' [------- error handler -------]
     'WRONGFILE = FOO$    ' File where error occured, maybe?
      BEEP: PRINT
      PRINT "Error # "; ERR; "  at or after line "; ERL; ".   Device error # "; ERDEV; "  "; ERDEV$
      PRINT "  Error is -- ";

      IF ERR = 1 THEN PRINT "Next without For coding error"
      IF ERR = 2 THEN PRINT "Coding Syntax error"
      IF ERR = 3 THEN PRINT "Return without Gosub"
      IF ERR = 4 THEN PRINT "Out of DATA"
      IF ERR = 5 THEN PRINT "Illegal function call"
      IF ERR = 6 THEN PRINT "Overflow"
      IF ERR = 7 THEN PRINT "out of memory"
      IF ERR = 8 THEN PRINT "Undefined line number coding error"
      IF ERR = 9 THEN PRINT "SUBSCRIPT OUT OF RANGE "; N
      IF ERR = 10 THEN PRINT "Duplicate definition coding error"
      IF ERR = 11 THEN PRINT "Division by Zero"
      IF ERR = 14 THEN PRINT "Out of string space"
      IF ERR = 15 THEN PRINT "String too long.  255 max"
      IF ERR = 23 THEN PRINT "Line buffer overflow"
      IF ERR = 24 THEN PRINT "Device Time-out"
      IF ERR = 25 THEN PRINT "device fault"
      IF ERR = 27 THEN PRINT "Out of paper"
      IF ERR = 50 THEN PRINT "FIELD overflow."
      IF ERR = 51 THEN PRINT "Internal error"
      IF ERR = 52 THEN 14740 ' " = DISK ERRORS"
      IF ERR = 53 THEN 14740
      IF ERR = 54 THEN 14740
      IF ERR = 55 THEN 14740
      IF ERR = 56 THEN PRINT "Field Statement active"
      IF ERR = 57 THEN PRINT "device I/O error"
      IF ERDEV = 10 THEN PRINT " Printer off line?"
      IF ERR = 58 THEN 14740
      IF ERR = 59 THEN 14740
      IF ERR = 61 THEN 14740
      IF ERR = 62 THEN 14740
      IF ERR = 63 THEN 14740
      IF ERR = 64 THEN GOTO 14740: ' fileerr
      IF ERR = 67 THEN 14740
      IF ERR = 68 THEN PRINT "Device unavailable. Is there a D: directory for the temporary stuff?"
      IF ERR = 69 THEN PRINT "Comm buffer overflow."
      IF ERR = 70 THEN GOTO 14740
      IF ERR = 71 THEN GOTO 14740: ' "Disk ERRORS
      IF ERR = 72 THEN GOTO 14740:
      IF ERR = 73 THEN PRINT "Advanced feature unavailable."
      IF ERR = 74 THEN PRINT "Rename across disks.   see programming manual."
      IF ERR = 75 THEN GOTO 14740:
      IF ERR = 76 THEN GOTO 14740:
      GOTO 15000

14740 'fileerr:
      PRINT "File Related Error # "; ERR; "  at or after line "; ERL; "."
      PRINT "  Error is -- ";
      SHELL "cat"
      PRINT "File Related Error # "; ERR; "  at or after line "; ERL; "."
      PRINT "  Error is -- ";

      IF ERR = 52 THEN PRINT "Bad file name or number."
      IF ERR = 53 THEN PRINT "FILE NOT FOUND. -- "; WRONGFILE$
      IF ERR = 54 THEN PRINT "Bad File Mode."
      IF ERR = 55 THEN PRINT "file already open. -- "; WRONGFILE$
      IF ERR = 58 THEN PRINT "File already exists. -- "; WRONGFILE$
      IF ERR = 59 THEN PRINT "Bad record length."
      IF ERR = 61 THEN PRINT "Disk Full.   DONE.    END.  ": GOSUB ENDSONG: END
      IF ERR = 62 THEN PRINT "Input past end of file."
      IF ERR = 63 THEN PRINT "Bad record number."
      IF ERR = 64 THEN PRINT "Bad file name. Check format."
      IF ERR = 67 THEN PRINT "Too many files."
      IF ERR = 71 THEN PRINT "Disk Not Ready."
      IF ERR = 70 THEN PRINT "Permission denied.   Read only file?  Disk Write protected?": SHELL "attrib " + WRONGFILE$
      IF ERR = 72 THEN PRINT "Disk Media Error."
      IF ERR = 75 THEN PRINT "path / file access error. -- Maybe file attribute is R, Read Only.  "; "ATTRIB " + WRONGFILE$
      IF ERR = 76 THEN PRINT "Path  not found."
      PRINT "File troubles usually are path or file name errors."
      PRINT "  Do you need a \ or c:\ in the path?"
      PRINT "  Does the disk directory exist, especially ramdisks.  D:?"
      PRINT "  Is the file on another directory?"
      PRINT "TROUBLE is most likely in NAME or PATH of  "; WRONGFILE$
      GOTO 15000

15000 INPUT "Fix Problem.  Then CR to continue   X or Q to quit. "; Q$:
      Q$ = UCASE$(Q$)
      IF Q$ = "X" THEN SYSTEM
      IF Q$ = "Q" THEN SYSTEM
      RESUME   ' back to line from whence the error occured


ENDSONG:  '[-------- end song --------]
    RANDOMIZE TIMER
    FOR Q = 1 TO 25: SOUND INT(2500 - 200) * RND + 200, 4: NEXT Q
    SOUND 32000, 15
    
     SOUND 2000, 1: SOUND 32000, 2: SOUND 2000, 3: SOUND 32000, 2
     SOUND 2000, 1: SOUND 32000, 2: SOUND 2000, 3: SOUND 32000, 2
     SOUND 2000, 1: SOUND 32000, 2  ' .-.-.
     LOCATE 24, 1: PRINT "--- DONE ---"
     Q& = TIMER + 1:
DOOLAY: IF TIMER < Q& THEN GOTO DOOLAY
     RETURN
'-------------------------]

SEED: ' [----- RE-SEEDS RANDOM NUMBER GENERATOR FROM CLOCK.
'                     (WORKS ONLY ONCE / RE-START) -----]
SEED$ = TIME$: PRINT SEED$
ZO0OP: Q = INSTR(SEED$, ":"):  PRINT Q; SEED$
       IF Q THEN SEED$ = LEFT$(SEED$, Q - 1) + RIGHT$(SEED$, LEN(SEED$) - Q): GOTO ZO0OP
       SEED = VAL(SEED$)
SE1:   IF SEED > 32767 THEN SEED = SEED - 16795: GOTO SE1
SEED1: PRINT SEED
       RANDOMIZE SEED
RETURN
'-------------------]

MAKEPW:    '[ ------- MAKES UP RANDOM LINE -------- ]

MM = 5: NN = 75 / MM
PW$ = ""
FOR N = 1 TO NN:          ' 6 GROUPS
FOR M = 1 TO MM:          ' OF 5 ALPHA/NUMERIC CHARACTERS

MPW1:
   XR% = (INT(LU - LL + 1) * RND + LL)
   IF XR% = 34 THEN GOTO MPW1   ' skip quotie
   IF WO$ <> "11" THEN GOTO MPW2
    IF XR% = 58 THEN XR% = 32: GOTO MPW2
    IF XR% < 65 THEN IF XR% > 57 THEN GOTO MPW1
    IF XR% < 97 THEN IF XR% > 90 THEN GOTO MPW1
MPW2:   X$ = CHR$(XR%)

   'PRINT X$
   PW$ = PW$ + X$

NEXT M:
NEXT N

PW$ = RTRIM$(LTRIM$(PW$))
'PRINT NAMEO$, PW$
RETURN
'------------------]

'[----------- selects the cover-up string ---------]
WIPEOUTERS:    ' SET COVER UP STRING
  PX1$ = STRING$(75, "Q") + "."
  PX2$ = "WIPEOUT WIPEOUT WIPEOUT WIPE0UT WIPE0UT WIPEOUT WIPEOUT WIPEOUT WIPEOUT.  "
  PX3$ = "WIPED OUT, SCRUBBED, GONE GOOSE, NADA, NUNCA, WOW, OOPS, NYET, OWIE, OOF, VAPORWARE, NUKED."
  PX4$ = STRING$(75, "U")
  PX5$ = STRING$(75, &HAA)
  PX6$ = STRING$(75, "Z")
  PX7$ = STRING$(75, &H0)
  PX8$ = STRING$(75, &HFF)
  PRINT "COVER-UP TEXTS:"
  PRINT "1= "; PX1$
  PRINT "2= "; PX2$
  PRINT "3= "; PX3$
  PRINT "4= "; PX4$
  PRINT "5= "; PX5$
  PRINT "6= "; PX6$
  PRINT "7= CHR$(0)"
  PRINT "8= CHR$(255)"
  PRINT "9=   TOTALLY RANDOM PRINTABLE CHARACTERS"
  PRINT "10 = REPEATED LINES OF RANDOM PRINTABLE CHARACTERS"
  PRINT "11 = TOTALLY RANDOM A-Z, a-z, 0-9, SPACE":
  PRINT "12=  REPEATED LINE FROM KEYBOARD"
  PRINT "   4 IS 01010101010101010......"
  PRINT "   5 IS 10101010101010101......"
  PRINT "   6 is 01011010010110100......"
  PRINT "   7 IS 00000000000000000......"
  PRINT "   8 IS 11111111111111111......"

  INPUT "CHOOSE ONE  1-12  <3>"; Q$: GOSUB 14160
  IF Q$ = "" THEN Q$ = "3"
  IF Q$ = "1" THEN PX$ = PX1$: PQ$ = PX$
  IF Q$ = "2" THEN PX$ = PX2$: PQ$ = PX$
  IF Q$ = "3" THEN PX$ = PX3$: PQ$ = PX$
  IF Q$ = "4" THEN PX$ = PX4$: PQ$ = PX$
  IF Q$ = "5" THEN PX$ = PX5$: PQ$ = PX$
  IF Q$ = "6" THEN PX$ = PX6$: PQ$ = PX$
  IF Q$ = "7" THEN PX$ = PX6$: PQ$ = "CHR$(0)"
  IF Q$ = "8" THEN PX$ = PX7$: PQ$ = "CHR$(255)"
  IF Q$ = "9" THEN GOSUB SEED: GOSUB MAKEPW: PX$ = PW$:
  IF Q$ = "10" THEN GOSUB SEED: GOSUB MAKEPW: PX$ = PW$:
  IF Q$ = "11" THEN GOSUB SEED: GOSUB MAKEPW: PX$ = PW$: LU = 122: LL = 48
  IF Q$ = "12" THEN PRINT "COVER UP WORDS, LETTERS, NUMBERS, ETC.  (USE QUOTIES IF STRING HAS COMMAS)": INPUT ; PX$
  IF PX$ = "" THEN BEEP: GOTO WIPEOUTERS
 
  PRINT PQ$
  IF Q$ = "9" THEN WO$ = Q$
  IF Q$ = "11" THEN WO$ = Q$
  PX$ = PX$ + CRLF$
  TIMX& = TIMER + 2
TX: IF TIMER < TIMX& THEN GOTO TX    ' DELAY
  RETURN
  '---------------]
'=========================== END OF CODE ==========================