The Programmer Disk/The Programmer Disk (Microforum).iso/xpro/basic1/pro8/getfiles.bas

BASIC Source File | 1988-10-07 | 19.5 KB | 597 lines

'************************** Getfiles.Bas  ********************************
'These routines included have been constructed from source code that I have
'found in the public domain on a few BBS's and my own code. It was written
'using the Microsoft QuickBasic Compiler 2.0.
'I used the /L switch when loading the QuickBasic compiler and used the
'library named USERLIB.EXE which included the definittions for the INT86
'assembler routines that comes with the compiler. I have included that library
'under the named MYLIB.EXE within the archive file that has this source code.
'The assembly language routines were extracted from a file named BASTODOS.ARC
'written by James P. Morgan of Orlando, Florida. The sort routine was from an
'anonymous author under the filename QUIKSORT.ARC.
'These were my first attempts at writing with the QUICKBASIC 2.0 compiler
'I hope that maybe one of these routines will help someone out. It's been a
'great help for me to have access to some good code for nothing, and to have
'learned from it. I wish the same for you.

'                                       Michael Graves
'                                       Brooklyn, NY
'                                       Work: [phone]
'                                       Compuserve [72507,1203]

'************************ INITIALIZE PUBLIC VARIABLES ************************
'
DIM GETFILES.SUBRT%(43) ' DIMENSION GETFILES ROUTINE
DIM DTA%(43)            ' DIMENSION DISK TRANSFER AREA (THAT HOLDS FILE NAME, DATE ECT.)
DIM FILE.NAME$(500)    ' DIMENSION FILE NAME ARRAY
DIM FILE.ATTR%(500)
DIM SUB.DIRECT.NAME$(512)
DIM CURR.DIR.SUBRT%(40)

'**************   FOR INTERRUPT SERVICE ROUTINES  ******************
DIM INPUT.INTRPT.ARRAY%(9), OUTPUT.INTRPT.ARRAY%(9)
COMMON SHARED INPUT.INTRPT.ARRAY%(), OUTPUT.INTRPT.ARRAY%()

COMMON SHARED DTA%(), GETFILES.SUBRT%(), GETFILES.SUBRT.OFFSET%, FILE.NAME$()
COMMON SHARED GET.FIRST%, GET.NEXT%, PATH$, ASCIIZ.STRING$, ATTRIBUTE%
COMMON SHARED GET.FILES.LOADED%, RETURN.CODE%, FILE.CTR%, FILE.ATTR%()
COMMON SHARED SEARCH.DRIVE$, FILE.MASK$, VOLUME.LABEL$, OLD.VOLUME.LABEL$
COMMON SHARED SUB.DIRECT.NAME$(), SUB.DIR.CTR%, DOS.VERSION$
COMMON SHARED ROW%, COLUMN%, CURRENT.DRIVE$, CURR.DIR.OFFSET%, CURR.DIR.SUBRT%()
COMMON SHARED CURRENT.DIRECTORY$, TEMP.PATH$
COMMON SHARED NEW.DRIVE.NAME$, DRIVE.NAME$

' REGISTER DEFINITIONS FOR INTERRUPT SERVICE ROUTINES
AXREG% = 0
BXREG% = 1
CXREG% = 2
DXREG% = 3
BPREG% = 4
SIREG% = 5
DIREG% = 6
FLREG% = 7
DSREG% = 8
ESREG% = 9


'**********************************************************************
'*********************       MAIN PROGRAM       ***********************
'**********************************************************************

  CLS
  CALL INIT.ASM.ROUTINES
  CALL GET.DOS.VERSION
  CALL GET.CURRENT.DRIVE
  CALL GET.CURRENT.DIRECTORY
  CALL GET.FILESPEC
  CALL GET.FILES
  CALL QUICKSORT
  CALL DISPLAY.FILES

END
'**********************************************************************
'**************            END OF MAIN PROGRAM           **************
'**********************************************************************


'**************************************************************************
'*********************** SUBROUTINE - GET DOS VERSION  ********************
'**************************************************************************
SUB GET.DOS.VERSION STATIC

SHARED DOS.VERSION$
 DEF SEG
 DIM GET.DOS.VERSION.SUBRT%(40)
 GET.DOS.VERSION.SUBRT.OFFSET%=0

 RESTORE GET.DOS.VERSION.DATA
 FOR I% = 0 TO 27
 READ J
 POKE (VARPTR(GET.DOS.VERSION.SUBRT%(0))+I%),J
 NEXT

 MAJOR.VERSION%=0
 MINOR.VERSION%=0
 RETURN.CODE%=0
 GET.DOS.VERSION.SUBRT.OFFSET%=VARPTR(GET.DOS.VERSION.SUBRT%(0))
 CALL ABSOLUTE (MAJOR.VERSION%,MINOR.VERSION%,RETURN.CODE%,GET.DOS.VERSION.SUBRT.OFFSET%)
 IF MAJOR.VERSION% = 0 THEN
   PRINT
   PRINT "DOS 2.0 OR HIGHER IS REQUIRED FOR THIS PROGRAM !!!"
   PRINT "PROGRAM HALTED!!!!!! "
   PRINT
   STOP
 END IF
 DOS.VERSION$ = STR$(MAJOR.VERSION%)+"."+STR$(MINOR.VERSION%)

GET.DOS.VERSION.DATA:
 DATA &H55
 DATA &H89,&HE5
 DATA &HB4,&H30
 DATA &HCD,&H21
 DATA &H8B,&H76,&H0A
 DATA &H88,&H04
 DATA &H8B,&H76,&H08
 DATA &H88,&H24
 DATA &H8B,&H76,&H06
 DATA &H31,&HDB
 DATA &H89,&H1C
 DATA &H5D
 DATA &HCA,&H06,&H00
END SUB
'**********************************************************************
'**********        END OF SUBROUTINE GET DOS VERSION        ***********
'**********************************************************************

DEF FNUPCASE$(STR.TO.CONVERT$)
  LENGTH = LEN(STR.TO.CONVERT$)
  IF LENGTH = 0 THEN FNUPCASE$ = "" : EXIT DEF
  FOR I = 1 TO LENGTH
    CH = ASC(MID$(STR.TO.CONVERT$,I,1))
    IF CH > 96 AND CH < 127 THEN
      MID$(STR.TO.CONVERT$,I,1) = CHR$(CH-32)
    END IF
  NEXT
  FNUPCASE$ = STR.TO.CONVERT$
END DEF

SUB GET.CURRENT.DRIVE STATIC
SHARED INPUT.INTRPT.ARRAY%(), OUTPUT.INTRPT.ARRAY%(), DRIVE.NAME$
  INPUT.INTRPT.ARRAY%(AXREG%) = &H1900
  CALL INT86(&H21, VARPTR(INPUT.INTRPT.ARRAY%(0)),VARPTR(OUTPUT.INTRPT.ARRAY%(0)))
  DRIVE.NAME$ = CHR$(65+(OUTPUT.INTRPT.ARRAY%(AXREG%) AND &HFF))+":"
END SUB

'**********************************************************************
'**************     SUBROUTINE - GET.CURRENT.DIRECTORY      ***********
'**********************************************************************
SUB GET.CURRENT.DIRECTORY STATIC
SHARED CURRENT.DRIVE$
'**********************************************************************
'* CALL FORMAT         :
'* ---------------------
'* CALL OFFSET%(DRIVE%,ASCIIZ.STRING$,RETURN.CODE%)
'* PARAMETERS PASSED   : DRIVE%                (0=DEFAULT,1=A,2=B..ECT)
'*                       ASCIIZ.STRING$        (AT LEAST A 64 BYTE
'*                                             CHARACTER STRING RETURN
'*                                             AREA)
'*                       RETURN.CODE%=0
'* PARAMETERS RETURNED : DRIVE%
'*                       ASCIIZ.STRING$        (CURRENT DIRECTORY)
'*                       RETURN.CODE%          (SEE ERROR CODE LIST)
'* COMMENTS           :
'*                     THIS SUBROUTINE WILL RETURN THE CURRENT DIRECTORY
'*                    FOR THE SPECIFIED DRIVE. THE FULL PATH NAME ,
'*                    STARTING WITH THE ROOT DIRECTORY IS RETURNED.
'*                     THE DRIVE LETTER WILL NOT BE PART OF THE RETURNED
'*                    STRING. THE STRING WILL NOT BEGIN WITH THE "\" AND
'*                    WILL BE TERMINATED WITH A BYTE CONTAINING A HEX 00.
'*
'*************************************************************************

  DRIVE%=0
  ASCIIZ.STRING$=STRING$(64,0)
  CURRENT.DIRECTORY$=""
  RETURN.CODE%=0

  CALL ABSOLUTE (DRIVE%,ASCIIZ.STRING$,RETURN.CODE%,CURR.DIR.OFFSET%)
  IF RETURN.CODE%<>0 THEN CURRENT.DIRECTORY$="INVALID DRIVE SPECIFIED":EXIT SUB
  INSTR.LOC=INSTR(ASCIIZ.STRING$,CHR$(0))
  IF INSTR.LOC<2 THEN CURRENT.DIRECTORY$="\":EXIT SUB
  CURRENT.DIRECTORY$="\"+LEFT$(ASCIIZ.STRING$,INSTR.LOC-1)

  'Remove comments below for testing
  'PRINT "DRIVE REQUESTED   = ";DRIVE%
  'PRINT "CURRENT DIRECTORY = ";CURRENT.DIRECTORY$
  'PRINT "RETURN CODE       = ";RETURN.CODE%
  'INPUT A$

END SUB


SUB CHANGE.DRIVE.TO(NEW.DRIVE.NAME$) STATIC
SHARED INPUT.INTRPT.ARRAY%(), OUTPUT.INTRPT.ARRAY%()
  IF NEW.DRIVE.NAME$="" THEN
    GOTO ERROR.EXIT.ROUTINE
  END IF
 NEW.DRIVE.NAME$ = MID$(NEW.DRIVE.NAME$,1,1)
  IF INSTR("ABCDEFGHIJKLMNOPQRSTUVWXYZ",NEW.DRIVE.NAME$) = 0 THEN
    GOTO ERROR.EXIT.ROUTINE
  END IF
  INPUT.INTRPT.ARRAY%(AXREG%) = &H0E
  INPUT.INTRPT.ARRAY%(DXREG%) = &H00 'ASC(NEW.DRIVE.NAME$)-ASC("A")
  CALL INT86(&H21,VARPTR(INPUT.INTRPT.ARRAY%(0)),VARPTR(OUTPUT.INTRPT.ARRAY%(0)))
  IF (OUTPUT.INTRPT.ARRAY%(DXREG%) < 0) THEN
    GOTO ERROR.EXIT.ROUTINE
  END IF
  GOTO NORMAL.EXIT
ERROR.EXIT.ROUTINE:
  PRINT "ERROR -- INVALID DISK DRIVE, '";NEW.DRIVE.NAME$;"'"
  EXIT SUB
NORMAL.EXIT:
  DRIVE.NAME$ = NEW.DRIVE.NAME$+":"
END SUB


'**********************************************************************
'**************     SUBROUTINE - INIT.ASM.ROUTINES          ***********
'*                                                                    *
'* This subroutine loads into memory the assembly language code that  *
'* is executed by a call statement more than once, thus avoiding the  *
'* repitition of the read statement.                                  *
'**********************************************************************

SUB INIT.ASM.ROUTINES STATIC

'***** VARIABLES FOR GET FIRST GET NEXT ROUTINES *****
SHARED DTA%(), GETFILES.SUBRT%(), GETFILES.SUBRT.OFFSET%
SHARED GET.FIRST%, GET.NEXT%, FILE.NAME$(), CURRENT.DRIVE$
SHARED CURR.DIR.OFFSET%, CURR.DIR.SUBRT%()

'******* FIRST INITIALIZE THE GET FILES.NAMES ARRAY ***********

  FOR X% = 1 TO 500
    FILE.NAME$(X%) = SPACE$(29)
  NEXT X%


'******** INITIALIZE SUBROUTINE OFFSET ************
  GETFILES.SUBRT.OFFSET%=0
  GET.FIRST%=&H4E
  GET.NEXT%=&H4F


' INITIALIZE ASSEMBLY LANGUAGE ROUTINE
  FOR I=0 TO 43
    DTA%(I)=0
  NEXT

' READ ASSEMBLY EXECUTABLE CODE INTO VARIABLE GETFILES.SUBRT%
  RESTORE GETFILES.DATA
  FOR I=0 TO 65
    READ J
    POKE (VARPTR(GETFILES.SUBRT%(0))+I),J
  NEXT

' SET OFFSET TO MACHINE LANGUAGE ROUTINE
  GETFILES.SUBRT.OFFSET%=VARPTR(GETFILES.SUBRT%(0))


  GETFILES.DATA:
    DATA &H55
    DATA &H89,&HE5
    DATA &H31,&HC0
    DATA &H31,&HC9
    DATA &H31,&HD2
    DATA &H8B,&H76,&H0E
    DATA &H8A,&H24
    DATA &H8B,&H76,&H0C
    DATA &H8B,&H0C
    DATA &H8B,&H76,&H0A
    DATA &H8B,&H54,&H02
    DATA &HCD,&H21
    DATA &H8B,&H76,&H06
    DATA &H88,&H04
    DATA &H8B,&H76,&H08
    DATA &H89,&HF7
    DATA &H06
    DATA &H31,&HDB
    DATA &HB4,&H2F
    DATA &HCD,&H21
    DATA &HFC
    DATA &HB9,&H2C,&H00
    DATA &H89,&HDE
    DATA &H90,&H90,&H90
    DATA &H1E
    DATA &H06
    DATA &H1F
    DATA &H07
    DATA &HF3
    DATA &HA4
    DATA &H06
    DATA &H1F
    DATA &H07
    DATA &H5D
    DATA &HCA,&H0A,&H00
END.GETFILES.LOAD:


' ** LOAD GET CURRENT DIRECTORY LETTER ROUTINE TO MEMORY

  CURR.DIR.OFFSET%=0
  RESTORE GET.CURR.DIR.DATA
  FOR I=0 TO 28
  READ J
  POKE (VARPTR(CURR.DIR.SUBRT%(0))+I),J
  NEXT

  CURR.DIR.OFFSET%=VARPTR(CURR.DIR.SUBRT%(0))

GET.CURR.DIR.DATA:
    DATA &H55
    DATA &H89,&HE5
    DATA &H8B,&H76,&H0A
    DATA &H8A,&H14
    DATA &H8B,&H5E,&H08
    DATA &H8B,&H77,&H02
    DATA &H31,&HC0
    DATA &HB4,&H47
    DATA &HCD,&H21
    DATA &H8B,&H76,&H06
    DATA &H88,&H04
    DATA &H5D
    DATA &HCA,&H06,&H00
END.GET.CURR.DIR.DATA:

END SUB
'**********************************************************************
'*************** END OF SUBROUTINE INIT.ASM.ROUTINE *******************
'**********************************************************************




'**********************************************************************
'**************         SUBROUTINE - GET.FILESPEC        **************
'**********************************************************************
SUB GET.FILESPEC STATIC

SHARED PATH$, TEMP.PATH$

'CHECK FOR VALID DRIVE LETTER
'DIRECTORY PATH STRING
'FILENAME AND EXTENSION

  PATH$ = "\????????.???"
  INPUT "Enter DRIVE:\PATH\FILE-MASK >>>> ",PATH$
  TEMP.PATH$=PATH$
  IF PATH$= "" THEN
    PATH$=DRIVE.NAME$+CURRENT.DIRECTORY$+"\????????.???"
    EXIT SUB
  END IF
  IF LEN(PATH$) = 3 THEN
    IF RIGHT$(PATH$,1)="\" THEN
      PATH$=PATH$+"????????.???"
    END IF
    EXIT SUB
  END IF
  IF MID$(PATH$,2,1) = ":" THEN
    DRIVE$ = LEFT$(PATH$,2)
    IF INSTR(PATH$,"\") THEN
      PATH$=MID$(PATH$,INSTR(PATH$,"\"))
      PATH$ = DRIVE$ + PATH$
    END IF
    IF LEN(TEMP.PATH$) = 2 THEN
      PATH$=PATH$+CURRENT.DIRECTORY$+"\????????.???"
    END IF
    IF PATH$= "\*.*" THEN
      PATH$="\????????.???"
    END IF
    EXIT SUB
  END IF
  IF MID$(PATH$,2,1) = ":" THEN
    IF LEN(PATH$) > 2 THEN
      DRIVE$ = LEFT$(PATH$,2)
      PATH$ = MID$(PATH$,3)
      PATH$ = DRIVE$ + PATH$
    ELSE
      PATH$ = DRIVE$ + "????????.???"
    END IF
    EXIT SUB
  END IF
  IF PATH$= "\*.*" THEN
    PATH$="\????????.???"
  END IF
END SUB
'**********************************************************************
'**************      END OF SUBROUTINE - GET.FILESPEC    **************
'**********************************************************************



'**********************************************************************
'******************    SUBROUTINE - GET FILES   ***********************
'**********************************************************************
SUB GET.FILES STATIC

SHARED DTA%(), GETFILES.SUBRT%(), GETFILES.SUBRT.OFFSET%, FILE.NAME$()
SHARED GET.FIRST%, GET.NEXT%, PATH$, ASCIIZ.STRING$, ATTRIBUTE%
SHARED GET.FILES.LOADED%, RETURN.CODE%, FILE.CTR%, FILE.ATTR%()
SHARED SEARCH.DRIVE$, FILE.MASK$, VOLUME.LABEL$, OLD.VOLUME.LABEL$
SHARED SUB.DIRECT.NAME$(), SUB.DIR.CTR%


  'PATH$ = "\????????.???" ' USE WITHOUT COMMENT FOR TESTING


  VOLUME.LABEL$ = "NONE"
  FILE.CTR% = 0
  SUB.DIR.CTR% = 0
  ASCIIZ.STRING$=PATH$+CHR$(0)
  ATTRIBUTE% = 249
  RETURN.CODE%=0
  CALL ABSOLUTE (GET.FIRST%,ATTRIBUTE%,ASCIIZ.STRING$,DTA%(0),RETURN.CODE%, GETFILES.SUBRT.OFFSET%)
  IF RETURN.CODE% <> 18 THEN
    CALL STORE.FILE.BY.TYPE
  END IF

  IF RETURN.CODE% = 18 AND FILE.CTR% = 0 THEN
    print
    PRINT"No files found to match --> ";PATH$
    print
    EXIT SUB
  END IF

  DONE% = FALSE
  WHILE (DONE% = FALSE)
    RETURN.CODE% = 0
    ATTRIBUTE% = 255
    CALL ABSOLUTE (GET.NEXT%,ATTRIBUTE%,ASCIIZ.STRING$,DTA%(0),RETURN.CODE%, GETFILES.SUBRT.OFFSET%)
    IF RETURN.CODE% = 18 THEN
      DONE% = TRUE
      EXIT SUB
    END IF
    CALL STORE.FILE.BY.TYPE
  WEND
  GET.FILES.EXIT:
END SUB
'**********************************************************************
'**************     END OF - SUBROUTINE - GET.FILES      **************
'**********************************************************************


'**********************************************************************
'********************* SUBROUTINE - STORE.FILE.BY.TYPE ****************
'**********************************************************************
SUB STORE.FILE.BY.TYPE STATIC

SHARED FILE.NAME$(), FILE.CTR%, DTA%(), FILE.DATE$(), FILE.TIME$()
SHARED SUB.DIRECT.NAME$(), SUB.DIR.CTR%, VOLUME.LABEL$

  IF (PEEK(VARPTR(DTA%(0))+21) AND 16) = 16 THEN
    SUB.DIR.CTR% = SUB.DIR.CTR% + 1
    SUB.DIRECT.NAME$(SUB.DIR.CTR%) = ""
    I = 30
    WHILE (PEEK(VARPTR(DTA%(0))+I) <> 0)
      SUB.DIRECT.CHAR$=CHR$(PEEK(VARPTR(DTA%(0))+I))
      SUB.DIRECT.NAME$(SUB.DIR.CTR%)=SUB.DIRECT.NAME$(SUB.DIR.CTR%) + SUB.DIRECT.CHAR$
      I = I + 1
    WEND
    EXIT SUB
  END IF
  IF (PEEK(VARPTR(DTA%(0))+21) AND 8) = 8 THEN
    VOLUME.LABEL$ = ""
    I = 30
    WHILE (PEEK(VARPTR(DTA%(0))+I) <> 0)
      VOLUME.LABEL.CHAR$=CHR$(PEEK(VARPTR(DTA%(0))+I))
      IF VOLUME.LABEL.CHAR$ <> "." THEN
        VOLUME.LABEL$ = VOLUME.LABEL$ + VOLUME.LABEL.CHAR$
      END IF
      I = I + 1
    WEND
    EXIT SUB
  END IF
  IF ((PEEK(VARPTR(DTA%(0))+21) AND 32) = 0) OR ((PEEK(VARPTR(DTA%(0))+21) AND 32) = 32) THEN
      FILE.CTR% = FILE.CTR% + 1
      FILE.NAME$(FILE.CTR%) = ""
      I = 30
    WHILE (PEEK(VARPTR(DTA%(0))+I) <> 0)
      FILE.NAME.CHAR$=CHR$(PEEK(VARPTR(DTA%(0))+I))
      FILE.NAME$(FILE.CTR%)=FILE.NAME$(FILE.CTR%) + FILE.NAME.CHAR$
      I = I + 1
    WEND
    FILE.ATTR%(FILE.CTR%) = PEEK(VARPTR(DTA%(0))+21)
  END IF
END SUB


'**********************************************************************
'********************* SUBROUTINE - DISPLAY.FILES *********************
'**********************************************************************
SUB DISPLAY.FILES STATIC

SHARED SUB.DIR.CTR%, SUB.DIRECT.NAME$, CURRENT.DIRECTORY$

IF FILE.CTR% > 0 THEN
  CLS
  PRINT "Volume label = ";
  CALL PRINT.INVERTED(VOLUME.LABEL$)
  PRINT "     ";
  PRINT "Dos Version = ";
  CALL PRINT.INVERTED(DOS.VERSION$)
  LOCATE 2,1
  PRINT "Current Drive and Path =";
  CALL PRINT.INVERTED(DRIVE.NAME$)
  CALL PRINT.INVERTED(CURRENT.DIRECTORY$)
  PRINT
  LOCATE 3,1
  PRINT "Requested Path =";
  CALL PRINT.INVERTED(TEMP.PATH$)
  LOCATE 10,1
  ROW% = 4
  COLUMN% = 1
  OFFSET% = 15
  IF SUB.DIR.CTR% > 0 THEN
    FOR X% = 1 TO SUB.DIR.CTR%
      LOCATE ROW%,COLUMN%
      CALL PRINT.HIGHLIGHTED(SUB.DIRECT.NAME$(X%))
      CALL ADVANCE.TO.PRINT.FILENAME
      PRINT
    NEXT X%
  END IF
  FOR X%=1 TO FILE.CTR%
    IF FILE.NAME$(X%) <> "" THEN
      LOCATE ROW%,COLUMN%
      PRINT FILE.NAME$(X%)';"  ";:LOCATE ROW%,COLUMN%+OFFSET%:PRINT FILE.ATTR%(X%)
      CALL ADVANCE.TO.PRINT.FILENAME
    END IF
  NEXT X%
  LOCATE 24,1
  PRINT FILE.CTR%;"File(s)";"    ";SUB.DIR.CTR%;" Sub Directorie(s)";
    ELSE
      print
      PRINT"No files found to match --> ";PATH$
      print
END IF
END SUB
'**********************************************************************
'********************** END OF SUBROUTINE DISPLAY.FILES ***************
'**********************************************************************


SUB PRINT.INVERTED(STRING.TO.PRINT$) STATIC
  COLOR 0,7
  PRINT STRING.TO.PRINT$;
  COLOR 2,0
END SUB



SUB PRINT.HIGHLIGHTED(STRING.TO.PRINT$) STATIC
  COLOR 15,0
  PRINT STRING.TO.PRINT$;
  COLOR 2,0
END SUB



SUB ADVANCE.TO.PRINT.FILENAME STATIC
SHARED ROW%, COLUMN%
    IF ROW% < 23 THEN
      ROW% = ROW% + 1
    ELSE
      ROW% = 4
      IF COLUMN% < 60 THEN
        COLUMN% = COLUMN% + 20
      END IF
    END IF
END SUB


'**********************************************************************
'*********************    SUBROUTINE - QUICKSORT    *******************
'**********************************************************************
SUB QUICKSORT STATIC

SHARED FILE.NAME$(), FILE.CTR%

IF FILE.CTR% <= 0 THEN EXIT SUB
50380 S.AL% = FILE.CTR% ' Limit of array to be sorted **** REQUIRED FOR SORT ****
50400 DIM S.SP%(CINT(LOG(S.AL%)/.346574),2) ' If sort is to be called more than once, `DIM' the stack `S.SP%' for the largest size of the array outside the sort
50420 S.IS% = 0: S.LL% = 1: S.UL% = S.AL%: GOTO 50540
50440 SWAP FILE.NAME$(S.SL%),FILE.NAME$(S.LL%):IF S.SL% > S.UL%-2 THEN S.UL% = S.SL%-1 ELSE IF S.SL% < S.LL%+2 THEN S.LL% = S.LL%+1 ELSE S.IS% = S.IS%+1: S.SP%(S.IS%,1)=S.LL%: S.SP%(S.IS%,2) = S.SL%-1: S.LL%=S.SL%+1
50460 GOTO 50540
50480 FOR S.I1% = S.LL% + 1 TO S.UL%: FOR S.I2% = S.LL% TO S.I1%: IF FILE.NAME$(S.I1%) < FILE.NAME$(S.I2%) THEN SWAP FILE.NAME$(S.I1%),FILE.NAME$(S.I2%)
50500 NEXT S.I2%: NEXT S.I1%
50520 IF S.IS% = 0 THEN EXIT SUB ELSE S.LL% = S.SP%(S.IS%,1): S.UL%=S.SP%(S.IS%,2): S.IS% = S.IS%-1
50540 IF S.UL% - S.LL% <= 9 THEN 50480 ELSE S.LS% = S.LL%: S.US% = S.UL% + 1: SWAP FILE.NAME$(S.LL%),FILE.NAME$(INT((S.US%-S.LS%)/2)+S.LL%)
50560 IF S.US% = S.LS%+1 THEN S.SL% = S.LS%: GOTO 50440 ELSE S.LS% = S.LS% + 1: IF FILE.NAME$(S.LS%) <= FILE.NAME$(S.LL%) THEN 50600
50580 IF S.US% = S.LS% + 1 THEN S.SL% = S.LS%-1: GOTO 50440 ELSE S.US% = S.US% - 1: IF FILE.NAME$(S.US%) >= FILE.NAME$(S.LL%) THEN 50580 ELSE SWAP FILE.NAME$(S.LS%),FILE.NAME$(S.US%): GOTO 50560
50600 IF S.US% = S.LS% + 1 THEN S.SL% = S.LS%: GOTO 50440 ELSE S.US% = S.US% - 1: IF FILE.NAME$(S.US%) >= FILE.NAME$(S.LL%) THEN 50560
50620 IF S.US% = S.LS% + 1 THEN S.SL% = S.US%: GOTO 50440 ELSE S.LS% = S.LS% + 1: IF FILE.NAME$(S.LS%) <= FILE.NAME$(S.LL%) THEN 50620 ELSE SWAP FILE.NAME$(S.LS%),FILE.NAME$(S.US%): GOTO 50600
50640 '******** End of quicker sort subroutine **
END SUB
'**********************************************************************
'*********************** END OF SUBROUTINE QUICKSORT ******************
'**********************************************************************