home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / l / l180 / 1.ddi / DOSCALLS.BAS < prev    next >
Encoding:
BASIC Source File  |  1989-02-07  |  38.2 KB  |  1,042 lines
  1.   ' ************************************************
  2.   ' **  Name:          DOSCALLS                   **
  3.   ' **  Type:          Toolbox                    **
  4.   ' **  Module:        DOSCALLS.BAS               **
  5.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  6.   ' ************************************************
  7.   '
  8.   ' Demonstrates several interrupt calls to MS-DOS.
  9.   '
  10.   ' USAGE:          No command line parameters
  11.   ' REQUIREMENTS:   MS-DOS 3.0 or later
  12.   '                 MIXED.QLB/.LIB
  13.   '.MAK FILE:       (none)
  14.   ' PARAMETERS:     (none)
  15.   ' VARIABLES:      buffer$    String for buffered input demonstration
  16.   '                 x$         Buffered input string
  17.   '                 drive$     Current disk drive name
  18.   '                 desc       Structure of type MediaDescriptorType
  19.   '                 state%     Current status of the Verify state
  20.   '                 oppositeState%   Opposite state for Verify
  21.   '                 disk       Structure of type DiskFreeSpaceType
  22.   '                 country    Structure of type CountryType
  23.   '                 i%         Loop index for creating translation characters
  24.   '                 a$         Characters to be translated
  25.   '                 path$      Current directory
  26.   '                 result%    Result code from call to SetDirectory
  27.   '                 t$         Temporary copy of TIME$
  28.   '                 attr       Structure of type FileAttributesType
  29.   '                 fileName$  Name of file for determining file attributes
  30.   
  31.   
  32.     TYPE RegType
  33.         ax    AS INTEGER
  34.         bx    AS INTEGER
  35.         cx    AS INTEGER
  36.         dx    AS INTEGER
  37.         bp    AS INTEGER
  38.         si    AS INTEGER
  39.         di    AS INTEGER
  40.         flags AS INTEGER
  41.     END TYPE
  42.   
  43.     TYPE RegTypeX
  44.         ax    AS INTEGER
  45.         bx    AS INTEGER
  46.         cx    AS INTEGER
  47.         dx    AS INTEGER
  48.         bp    AS INTEGER
  49.         si    AS INTEGER
  50.         di    AS INTEGER
  51.         flags AS INTEGER
  52.         ds    AS INTEGER
  53.         es    AS INTEGER
  54.     END TYPE
  55.   
  56.     TYPE MediaDescriptorType
  57.         sectorsPerAllocationUnit AS INTEGER
  58.         bytesPerSector AS INTEGER
  59.         FATIdentificationByte AS INTEGER
  60.     END TYPE
  61.   
  62.     TYPE DiskFreeSpaceType
  63.         sectorsPerCluster AS INTEGER
  64.         bytesPerSector AS INTEGER
  65.         clustersPerDrive AS LONG
  66.         availableClusters AS LONG
  67.         availableBytes AS LONG
  68.     END TYPE
  69.   
  70.     TYPE CountryType
  71.         dateTimeFormat AS STRING * 11
  72.         currencySymbol AS STRING * 4
  73.         thousandsSeparator AS STRING * 1
  74.         decimalSeparator AS STRING * 1
  75.         dateSeparator AS STRING * 1
  76.         timeSeparator AS STRING * 1
  77.         currencyThenSymbol AS INTEGER
  78.         currencySymbolSpace AS INTEGER
  79.         currencyPlaces AS INTEGER
  80.         hours24 AS INTEGER
  81.         caseMapSegment AS INTEGER
  82.         caseMapOffset AS INTEGER
  83.         dataListSeparator AS STRING * 1
  84.     END TYPE
  85.   
  86.     TYPE FileAttributesType
  87.         readOnly AS INTEGER
  88.         hidden AS INTEGER
  89.         systemFile AS INTEGER
  90.         archive AS INTEGER
  91.         result AS INTEGER
  92.     END TYPE
  93.   
  94.   ' Subprograms
  95.     DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  96.     DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  97.     DECLARE SUB SetDrive (drive$)
  98.     DECLARE SUB GetMediaDescriptor (drive$, desc AS MediaDescriptorType)
  99.     DECLARE SUB SetVerifyState (state%)
  100.     DECLARE SUB GetDiskFreeSpace (drive$, disk AS DiskFreeSpaceType)
  101.     DECLARE SUB GetCountry (country AS CountryType)
  102.     DECLARE SUB CaseMap (character%, BYVAL Segment%, BYVAL Offset%)
  103.     DECLARE SUB SetDirectory (path$, result%)
  104.     DECLARE SUB WriteToDevice (handle%, a$, result%)
  105.     DECLARE SUB GetFileAttributes (fileName$, attr AS FileAttributesType)
  106.     DECLARE SUB SetFileAttributes (fileName$, attr AS FileAttributesType)
  107.   
  108.   ' Functions
  109.     DECLARE FUNCTION DOSVersion! ()
  110.     DECLARE FUNCTION BufferedKeyInput$ (n%)
  111.     DECLARE FUNCTION GetDrive$ ()
  112.     DECLARE FUNCTION GetVerifyState% ()
  113.     DECLARE FUNCTION TranslateCountry$ (a$, country AS CountryType)
  114.     DECLARE FUNCTION GetDirectory$ (drive$)
  115.   
  116.   ' Try the Buffered Keyboard Input call
  117.     CLS
  118.     PRINT "BufferedKeyInput$:"
  119.     PRINT "Enter a string of up to nine characters...  ";
  120.     x$ = BufferedKeyInput$(9)
  121.     PRINT
  122.     PRINT "Here's the nine-character string result... ";
  123.     PRINT CHR$(34); x$; CHR$(34)
  124.   
  125.   ' Get the MS-DOS version number
  126.     PRINT
  127.     PRINT "DosVersion!:"
  128.     PRINT "DOS Version number is "; DOSVersion!
  129.   
  130.   ' Demonstrate the GetDrive and SetDrive routines
  131.     PRINT
  132.     PRINT "GetDrive$ and SetDrive:"
  133.     drive$ = GetDrive$
  134.     PRINT "The current drive is "; drive$
  135.     PRINT "Setting the current drive to A:"
  136.     SetDrive "A:"
  137.     PRINT "Now the current drive is "; GetDrive$
  138.     PRINT "Setting the current drive back to "; drive$
  139.     SetDrive drive$
  140.     PRINT "Now the current drive is "; GetDrive$
  141.   
  142.   ' Call the MS-DOS "Media Descriptor" function for the current drive
  143.     PRINT
  144.     PRINT "GetMediaDescriptor"
  145.     DIM desc AS MediaDescriptorType
  146.     GetMediaDescriptor drive$, desc
  147.     PRINT "Drive                        "; drive$
  148.     PRINT "Sectors per allocation unit "; desc.sectorsPerAllocationUnit
  149.     PRINT "Bytes per sector            "; desc.bytesPerSector
  150.     PRINT "FAT identification byte      &H"; HEX$(desc.FATIdentificationByte)
  151.   
  152.   ' Wait for user
  153.     PRINT
  154.     PRINT
  155.     PRINT "Press any key to continue"
  156.     DO
  157.     LOOP UNTIL INKEY$ <> ""
  158.     CLS
  159.   
  160.   ' Demonstrate the GetVerifyState and SetVerifyState routines
  161.     PRINT
  162.     PRINT "GetVerifyState% and SetVerifyState:"
  163.     state% = GetVerifyState%
  164.     PRINT "Current verify state is"; state%
  165.     oppositeState% = 1 AND NOT state%
  166.     SetVerifyState oppositeState%
  167.     PRINT "Now the verify state is"; GetVerifyState%
  168.     SetVerifyState state%
  169.     PRINT "Now the verify state is"; GetVerifyState%
  170.   
  171.   ' Determine free space on the current drive
  172.     PRINT
  173.     PRINT "GetDiskFreeSpace:"
  174.     DIM disk AS DiskFreeSpaceType
  175.     GetDiskFreeSpace drive$, disk
  176.     PRINT "Sectors per cluster     "; disk.sectorsPerCluster
  177.     PRINT "Bytes per sector        "; disk.bytesPerSector
  178.     PRINT "Total clusters on drive "; disk.clustersPerDrive
  179.     PRINT "Available clusters      "; disk.availableClusters
  180.     PRINT "Available bytes         "; disk.availableBytes
  181.   
  182.   ' Wait for user
  183.     PRINT
  184.     PRINT
  185.     PRINT "Press any key to continue"
  186.     DO
  187.     LOOP UNTIL INKEY$ <> ""
  188.     CLS
  189.   
  190.   ' Get country-dependent information
  191.     PRINT
  192.     PRINT "GetCountry:"
  193.     DIM country AS CountryType
  194.     GetCountry country
  195.     PRINT "Date and time format    "; country.dateTimeFormat
  196.     PRINT "Currency symbol         "; country.currencySymbol
  197.     PRINT "Thousands separator     "; country.thousandsSeparator
  198.     PRINT "Decimal separator       "; country.decimalSeparator
  199.     PRINT "Date separator          "; country.dateSeparator
  200.     PRINT "Time separator          "; country.timeSeparator
  201.     PRINT "Currency before symbol "; country.currencyThenSymbol
  202.     PRINT "Currency symbol space  "; country.currencySymbolSpace
  203.     PRINT "Currency decimal places"; country.currencyPlaces
  204.     PRINT "24-hour time           "; country.hours24
  205.     PRINT "Case map segment       "; country.caseMapSegment
  206.     PRINT "Case map offset        "; country.caseMapOffset
  207.     PRINT "Data list separator     "; country.dataListSeparator
  208.   
  209.   ' Let's translate lowercase characters for the current country
  210.     PRINT
  211.     PRINT "TranslateCountry$:"
  212.     FOR i% = 128 TO 175
  213.         a$ = a$ + CHR$(i%)
  214.     NEXT i%
  215.     PRINT "Character codes 128 to 175, before and after translation... "
  216.     PRINT a$
  217.     PRINT TranslateCountry$(a$, country)
  218.   
  219.   ' Wait for user
  220.     PRINT
  221.     PRINT
  222.     PRINT "Press any key to continue"
  223.     DO
  224.     LOOP UNTIL INKEY$ <> ""
  225.     CLS
  226.   
  227.   ' Demonstrate the SetDirectory and GetDirectory routines
  228.     PRINT
  229.     PRINT "GetDirectory$ and SetDirectory:"
  230.     path$ = GetDirectory$(drive$)
  231.     PRINT "Current directory is "; path$
  232.     SetDirectory GetDrive$ + "\", result%
  233.     PRINT "Now the directory is "; GetDirectory$(drive$)
  234.     SetDirectory path$, result%
  235.     PRINT "Now the directory is "; GetDirectory$(drive$)
  236.   
  237.   ' Write to a file or device
  238.     PRINT
  239.     PRINT "WriteToDevice:"
  240.     PRINT "Writing a 'bell' character to the CRT"
  241.     WriteToDevice 1, CHR$(7), result%
  242.     t$ = TIME$
  243.     DO
  244.     LOOP UNTIL t$ <> TIME$
  245.     PRINT "Writing a 'bell' character to the printer"
  246.     WriteToDevice 4, CHR$(7), result%
  247.   
  248.   ' Wait for user
  249.     PRINT
  250.     PRINT
  251.     PRINT "Press any key to continue"
  252.     DO
  253.     LOOP UNTIL INKEY$ <> ""
  254.     CLS
  255.   
  256.   ' Demonstrate the GetFileAttributes and SetFileAttributes routines
  257.     PRINT
  258.     PRINT "GetFileAttributes and SetFileAttributes:"
  259.     DIM attr AS FileAttributesType
  260.     fileName$ = "C:\IBMDOS.COM"
  261.     GetFileAttributes fileName$, attr
  262.     PRINT "File attributes for "; fileName$
  263.     PRINT "Result of call "; attr.result
  264.     PRINT "Read only      "; attr.readOnly
  265.     PRINT "Hidden         "; attr.hidden
  266.     PRINT "System         "; attr.systemFile
  267.     PRINT "Archive        "; attr.archive
  268.     PRINT
  269.     attr.hidden = 0
  270.     SetFileAttributes fileName$, attr
  271.     GetFileAttributes fileName$, attr
  272.     PRINT "File attributes for "; fileName$
  273.     PRINT "Result of call "; attr.result
  274.     PRINT "Read only      "; attr.readOnly
  275.     PRINT "Hidden         "; attr.hidden
  276.     PRINT "System         "; attr.systemFile
  277.     PRINT "Archive        "; attr.archive
  278.     PRINT
  279.     attr.hidden = 1
  280.     SetFileAttributes fileName$, attr
  281.     GetFileAttributes fileName$, attr
  282.     PRINT "File attributes for "; fileName$
  283.     PRINT "Result of call "; attr.result
  284.     PRINT "Read only      "; attr.readOnly
  285.     PRINT "Hidden         "; attr.hidden
  286.     PRINT "System         "; attr.systemFile
  287.     PRINT "Archive        "; attr.archive
  288.     PRINT
  289.  
  290.   ' ************************************************
  291.   ' **  Name:          BufferedKeyInput$          **
  292.   ' **  Type:          Function                   **
  293.   ' **  Module:        DOSCALLS.BAS               **
  294.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  295.   ' ************************************************
  296.   '
  297.   ' Calls the "Buffered Keyboard Input" MS-DOS function
  298.   ' and returns the entered string of characters.
  299.   '
  300.   ' EXAMPLE OF USE:  x$ = BufferedKeyInput$(n%)
  301.   ' PARAMETERS:      buffer$    Buffer for keyboard input
  302.   ' VARIABLES:       regX       Structure of type RegTypeX
  303.   '                  bufSize%   Length of buffer$
  304.   '                  b$         Working copy of buffer$
  305.   '                  count%     Count of characters entered
  306.   ' MODULE LEVEL
  307.   '   DECLARATIONS:  TYPE RegTypeX
  308.   '                     ax    AS INTEGER
  309.   '                     bx    AS INTEGER
  310.   '                     cx    AS INTEGER
  311.   '                     dx    AS INTEGER
  312.   '                     bp    AS INTEGER
  313.   '                     si    AS INTEGER
  314.   '                     di    AS INTEGER
  315.   '                     flags AS INTEGER
  316.   '                     ds    AS INTEGER
  317.   '                     es    AS INTEGER
  318.   '                  END TYPE
  319.   '
  320.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  321.   '   DECLARE FUNCTION BufferedKeyInput$ (n%)
  322.   '
  323.     FUNCTION BufferedKeyInput$ (n%) STATIC
  324.         DIM regX AS RegTypeX
  325.         b$ = CHR$(n% + 1) + SPACE$(n% + 2)
  326.         regX.ax = &HA00
  327.         regX.ds = VARSEG(b$)
  328.         regX.dx = SADD(b$)
  329.         InterruptX &H21, regX, regX
  330.         count% = ASC(MID$(b$, 2, 1))
  331.         BufferedKeyInput$ = MID$(b$, 3, count%) + SPACE$(n% - count%)
  332.     END FUNCTION
  333.  
  334.   ' ************************************************
  335.   ' **  Name:          DOSVersion!                **
  336.   ' **  Type:          Function                   **
  337.   ' **  Module:        DOSCALLS.BAS               **
  338.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  339.   ' ************************************************
  340.   '
  341.   ' Returns the version number of MS-DOS.
  342.   '
  343.   ' EXAMPLE OF USE:  PRINT "MS-DOS Version number is "; DOSVersion!
  344.   ' PARAMETERS:      (none)
  345.   ' VARIABLES:       reg        Structure of type RegType
  346.   '                  major%     Integer part of the MS-DOS version number
  347.   '                  minor%     Fractional part of the MS-DOS version number
  348.   ' MODULE LEVEL
  349.   '   DECLARATIONS:  TYPE RegType
  350.   '                     ax    AS INTEGER
  351.   '                     bx    AS INTEGER
  352.   '                     cx    AS INTEGER
  353.   '                     dx    AS INTEGER
  354.   '                     bp    AS INTEGER
  355.   '                     si    AS INTEGER
  356.   '                     di    AS INTEGER
  357.   '                     flags AS INTEGER
  358.   '                  END TYPE
  359.   '
  360.   '      DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  361.   '      DECLARE FUNCTION DOSVersion! ()
  362.   '
  363.     FUNCTION DOSVersion! STATIC
  364.         DIM reg AS RegType
  365.         reg.ax = &H3000
  366.         Interrupt &H21, reg, reg
  367.         major% = reg.ax MOD 256
  368.         minor% = reg.ax \ 256
  369.         DOSVersion! = major% + minor% / 100!
  370.     END FUNCTION
  371.  
  372.   ' ************************************************
  373.   ' **  Name:          GetCountry                 **
  374.   ' **  Type:          Subprogram                 **
  375.   ' **  Module:        DOSCALLS.BAS               **
  376.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  377.   ' ************************************************
  378.   '
  379.   ' Returns country-dependent information as defined
  380.   ' by MS-DOS.
  381.   '
  382.   ' EXAMPLE OF USE:  GetCountry country
  383.   ' PARAMETERS:      country    Structure of type CountryType
  384.   ' VARIABLES:       regX       Structure of type RegTypeX
  385.   '                  c$         Buffer for data returned from interrupt
  386.   ' MODULE LEVEL
  387.   '   DECLARATIONS:  TYPE RegTypeX
  388.   '                     ax    AS INTEGER
  389.   '                     bx    AS INTEGER
  390.   '                     cx    AS INTEGER
  391.   '                     dx    AS INTEGER
  392.   '                     bp    AS INTEGER
  393.   '                     si    AS INTEGER
  394.   '                     di    AS INTEGER
  395.   '                     flags AS INTEGER
  396.   '                     ds    AS INTEGER
  397.   '                     es    AS INTEGER
  398.   '                  END TYPE
  399.   '
  400.   '                  TYPE CountryType
  401.   '                     DateTimeFormat AS STRING * 11
  402.   '                     CurrencySymbol AS STRING * 4
  403.   '                     ThousandsSeparator AS STRING * 1
  404.   '                     DecimalSeparator AS STRING * 1
  405.   '                     DateSeparator AS STRING * 1
  406.   '                     TimeSeparator AS STRING * 1
  407.   '                     CurrencyThenSymbol AS INTEGER
  408.   '                     CurrencySymbolSpace AS INTEGER
  409.   '                     CurrencyPlaces AS INTEGER
  410.   '                     Hours24 AS INTEGER
  411.   '                     caseMapSegment AS INTEGER
  412.   '                     caseMapOffset AS INTEGER
  413.   '                     DataListSeparator AS STRING * 1
  414.   '                  END TYPE
  415.   '
  416.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  417.   '   DECLARE SUB GetCountry (country AS CountryType)
  418.   '
  419.     SUB GetCountry (country AS CountryType)
  420.         DIM regX AS RegTypeX
  421.         regX.ax = &H3800
  422.         c$ = SPACE$(32)
  423.         regX.ds = VARSEG(c$)
  424.         regX.dx = SADD(c$)
  425.         InterruptX &H21, regX, regX
  426.         SELECT CASE CVI(LEFT$(c$, 2))
  427.         CASE 0
  428.             country.dateTimeFormat = "h:m:s m/d/y"
  429.         CASE 1
  430.             country.dateTimeFormat = "h:m:s d/m/y"
  431.         CASE 2
  432.             country.dateTimeFormat = "y/m/d h:m:s"
  433.         CASE ELSE
  434.             country.dateTimeFormat = "h:m:s m/d/y"
  435.         END SELECT
  436.         country.currencySymbol = MID$(c$, 3, 4)
  437.         country.thousandsSeparator = MID$(c$, 8, 1)
  438.         country.decimalSeparator = MID$(c$, 10, 1)
  439.         country.dateSeparator = MID$(c$, 12, 1)
  440.         country.timeSeparator = MID$(c$, 14, 1)
  441.         country.currencyThenSymbol = ASC(MID$(c$, 16)) AND 1
  442.         country.currencySymbolSpace = (ASC(MID$(c$, 16)) AND 2) \ 2
  443.         country.currencyPlaces = ASC(MID$(c$, 17))
  444.         country.hours24 = ASC(MID$(c$, 18))
  445.         country.caseMapSegment = CVI(MID$(c$, 21, 2))
  446.         country.caseMapOffset = CVI(MID$(c$, 19, 2))
  447.         country.dataListSeparator = MID$(c$, 23, 1)
  448.     END SUB
  449.  
  450.   ' ************************************************
  451.   ' **  Name:          GetDirectory$              **
  452.   ' **  Type:          Function                   **
  453.   ' **  Module:        DOSCALLS.BAS               **
  454.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  455.   ' ************************************************
  456.   '
  457.   ' Returns the name of the current directory for any drive.
  458.   '
  459.   ' EXAMPLE OF USE:  path$ = GetDirectory$(drive$)
  460.   ' PARAMETERS:      drive$     Drive of concern, or null string for default
  461.   '                             drive
  462.   ' VARIABLES:       regX       Structure of type RegTypeX
  463.   '                  d$         Working copy of drive$
  464.   '                  p$         Buffer space for returned path
  465.   ' MODULE LEVEL
  466.   '   DECLARATIONS:  TYPE RegTypeX
  467.   '                     ax    AS INTEGER
  468.   '                     bx    AS INTEGER
  469.   '                     cx    AS INTEGER
  470.   '                     dx    AS INTEGER
  471.   '                     bp    AS INTEGER
  472.   '                     si    AS INTEGER
  473.   '                     di    AS INTEGER
  474.   '                     flags AS INTEGER
  475.   '                     ds    AS INTEGER
  476.   '                     es    AS INTEGER
  477.   '                  END TYPE
  478.   '
  479.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  480.   '   DECLARE FUNCTION GetDirectory$ (drive$)
  481.   '
  482.     FUNCTION GetDirectory$ (drive$) STATIC
  483.         DIM regX AS RegTypeX
  484.         IF drive$ = "" THEN
  485.             d$ = GetDrive$
  486.         ELSE
  487.             d$ = UCASE$(drive$)
  488.         END IF
  489.         drive% = ASC(d$) - 64
  490.         regX.dx = drive%
  491.         regX.ax = &H4700
  492.         p$ = SPACE$(64)
  493.         regX.ds = VARSEG(p$)
  494.         regX.si = SADD(p$)
  495.         InterruptX &H21, regX, regX
  496.         p$ = LEFT$(p$, INSTR(p$, CHR$(0)) - 1)
  497.         GetDirectory$ = LEFT$(d$, 1) + ":\" + p$
  498.         IF regX.flags AND 1 THEN
  499.             GetDirectory$ = ""
  500.         END IF
  501.     END FUNCTION
  502.  
  503.   ' ************************************************
  504.   ' **  Name:          GetDiskFreeSpace           **
  505.   ' **  Type:          Subprogram                 **
  506.   ' **  Module:        DOSCALLS.BAS               **
  507.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  508.   ' ************************************************
  509.   '
  510.   ' Get information about a drive's organization, including
  511.   ' total number of bytes available.
  512.   '
  513.   ' EXAMPLE OF USE:  GetDiskFreeSpace drive$, disk
  514.   ' PARAMETERS:      drive$     Disk drive designation
  515.   '                  disk       Structure of type DiskFreeSpaceType
  516.   ' VARIABLES:       reg        Structure of type RegType
  517.   '                  drive%     Numeric drive designation
  518.   ' MODULE LEVEL
  519.   '   DECLARATIONS:  TYPE RegType
  520.   '                     ax    AS INTEGER
  521.   '                     bx    AS INTEGER
  522.   '                     cx    AS INTEGER
  523.   '                     dx    AS INTEGER
  524.   '                     bp    AS INTEGER
  525.   '                     si    AS INTEGER
  526.   '                     di    AS INTEGER
  527.   '                     flags AS INTEGER
  528.   '                  END TYPE
  529.   '
  530.   '                  TYPE DiskFreeSpaceType
  531.   '                     sectorsPerCluster AS INTEGER
  532.   '                     bytesPerSector AS INTEGER
  533.   '                     clustersPerDrive AS LONG
  534.   '                     availableClusters AS LONG
  535.   '                     availableBytes AS LONG
  536.   '                  END TYPE
  537.   '
  538.   '      DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  539.   '      DECLARE SUB GetDiskFreeSpace (drive$, disk AS DiskFreeSpaceType)
  540.   '
  541.     SUB GetDiskFreeSpace (drive$, disk AS DiskFreeSpaceType)
  542.         DIM reg AS RegType
  543.         IF drive$ <> "" THEN
  544.             drive% = ASC(UCASE$(drive$)) - 64
  545.         ELSE
  546.             drive% = 0
  547.         END IF
  548.         IF drive% >= 0 THEN
  549.             reg.dx = drive%
  550.         ELSE
  551.             reg.dx = 0
  552.         END IF
  553.         reg.ax = &H3600
  554.         Interrupt &H21, reg, reg
  555.         disk.sectorsPerCluster = reg.ax
  556.         disk.bytesPerSector = reg.cx
  557.         IF reg.dx >= 0 THEN
  558.             disk.clustersPerDrive = reg.dx
  559.         ELSE
  560.             disk.clustersPerDrive = reg.dx + 65536
  561.         END IF
  562.         IF reg.bx >= 0 THEN
  563.             disk.availableClusters = reg.bx
  564.         ELSE
  565.             disk.availableClusters = reg.bx + 65536
  566.         END IF
  567.         disk.availableBytes = disk.availableClusters * reg.ax * reg.cx
  568.     END SUB
  569.  
  570.   ' ************************************************
  571.   ' **  Name:          GetDrive$                  **
  572.   ' **  Type:          Function                   **
  573.   ' **  Module:        DOSCALLS.BAS               **
  574.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  575.   ' ************************************************
  576.   '
  577.   ' Returns the current disk drive name, such as "A:".
  578.   '
  579.   ' EXAMPLE OF USE:  drive$ = GetDrive$
  580.   ' PARAMETERS:      (none)
  581.   ' VARIABLES:       reg        Structure of type RegType
  582.   ' MODULE LEVEL
  583.   '   DECLARATIONS:  TYPE RegType
  584.   '                     ax    AS INTEGER
  585.   '                     bx    AS INTEGER
  586.   '                     cx    AS INTEGER
  587.   '                     dx    AS INTEGER
  588.   '                     bp    AS INTEGER
  589.   '                     si    AS INTEGER
  590.   '                     di    AS INTEGER
  591.   '                     flags AS INTEGER
  592.   '                  END TYPE
  593.   '
  594.   '      DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  595.   '      DECLARE FUNCTION GetDrive$ ()
  596.   '
  597.     FUNCTION GetDrive$ STATIC
  598.         DIM reg AS RegType
  599.         reg.ax = &H1900
  600.         Interrupt &H21, reg, reg
  601.         GetDrive$ = CHR$((reg.ax AND &HFF) + 65) + ":"
  602.     END FUNCTION
  603.  
  604.   ' ************************************************
  605.   ' **  Name:          GetFileAttributes          **
  606.   ' **  Type:          Subprogram                 **
  607.   ' **  Module:        DOSCALLS.BAS               **
  608.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  609.   ' ************************************************
  610.   '
  611.   ' Returns the file attribute settings for a file.
  612.   '
  613.   ' EXAMPLE OF USE:  GetFileAttributes fileName$, attr
  614.   ' PARAMETERS:      fileName$  Name of file
  615.   '                  attr       Structure of type FileAttributesType
  616.   ' VARIABLES:       regX       Structure of type RegTypeX
  617.   '                  f$         Null terminated copy of fileName$
  618.   ' MODULE LEVEL
  619.   '   DECLARATIONS:  TYPE RegTypeX
  620.   '                     ax    AS INTEGER
  621.   '                     bx    AS INTEGER
  622.   '                     cx    AS INTEGER
  623.   '                     dx    AS INTEGER
  624.   '                     bp    AS INTEGER
  625.   '                     si    AS INTEGER
  626.   '                     di    AS INTEGER
  627.   '                     flags AS INTEGER
  628.   '                     ds    AS INTEGER
  629.   '                     es    AS INTEGER
  630.   '                  END TYPE
  631.   '
  632.   '                  TYPE FileAttributesType
  633.   '                     readOnly AS INTEGER
  634.   '                     hidden AS INTEGER
  635.   '                     systemFile AS INTEGER
  636.   '                     archive AS INTEGER
  637.   '                     result AS INTEGER
  638.   '                  END TYPE
  639.   '
  640.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  641.   '   DECLARE SUB GetFileAttributes (fileName$, attr AS FileAttributesType)
  642.   '
  643.     SUB GetFileAttributes (fileName$, attr AS FileAttributesType) STATIC
  644.         DIM regX AS RegTypeX
  645.         regX.ax = &H4300
  646.         f$ = fileName$ + CHR$(0)
  647.         regX.ds = VARSEG(f$)
  648.         regX.dx = SADD(f$)
  649.         InterruptX &H21, regX, regX
  650.         IF regX.flags AND 1 THEN
  651.             attr.result = regX.ax
  652.         ELSE
  653.             attr.result = 0
  654.         END IF
  655.         attr.readOnly = regX.cx AND 1
  656.         attr.hidden = (regX.cx \ 2) AND 1
  657.         attr.systemFile = (regX.cx \ 4) AND 1
  658.         attr.archive = (regX.cx \ 32) AND 1
  659.     END SUB
  660.  
  661.   ' ************************************************
  662.   ' **  Name:          GetMediaDescriptor         **
  663.   ' **  Type:          Subprogram                 **
  664.   ' **  Module:        DOSCALLS.BAS               **
  665.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  666.   ' ************************************************
  667.   '
  668.   ' Calls the MS-DOS "Get Media Descriptor" function for
  669.   ' the indicated drive.  Results are returned in a
  670.   ' structure of type MediaDescriptorType.
  671.   '
  672.   ' EXAMPLE OF USE:  GetMediaDescriptor drive$, desc
  673.   ' PARAMETERS:      drive$     Drive designation, such as "A:"
  674.   '                  desc       Structure of type MediaDescriptorType
  675.   ' VARIABLES:       regX       Structure of type RegTypeX
  676.   '                  drive%     Numeric drive designation
  677.   ' MODULE LEVEL
  678.   '   DECLARATIONS:  TYPE RegTypeX
  679.   '                     ax    AS INTEGER
  680.   '                     bx    AS INTEGER
  681.   '                     cx    AS INTEGER
  682.   '                     dx    AS INTEGER
  683.   '                     bp    AS INTEGER
  684.   '                     si    AS INTEGER
  685.   '                     di    AS INTEGER
  686.   '                     flags AS INTEGER
  687.   '                     ds    AS INTEGER
  688.   '                     es    AS INTEGER
  689.   '                  END TYPE
  690.   '
  691.   '                  TYPE MediaDescriptorType
  692.   '                     sectorsPerAllocationUnit AS INTEGER
  693.   '                     bytesPerSector AS INTEGER
  694.   '                     FATIdentificationByte AS INTEGER
  695.   '                  END TYPE
  696.   '
  697.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  698.   '   DECLARE SUB GetMediaDescriptor (drive$, desc AS MediaDescriptorType)
  699.   '
  700.     SUB GetMediaDescriptor (drive$, desc AS MediaDescriptorType) STATIC
  701.         DIM regX AS RegTypeX
  702.         IF drive$ <> "" THEN
  703.             drive% = ASC(UCASE$(drive$)) - 64
  704.         ELSE
  705.             drive% = 0
  706.         END IF
  707.         IF drive% >= 0 THEN
  708.             regX.dx = drive%
  709.         ELSE
  710.             regX.dx = 0
  711.         END IF
  712.         regX.ax = &H1C00
  713.         InterruptX &H21, regX, regX
  714.         desc.sectorsPerAllocationUnit = regX.ax AND &HFF
  715.         desc.bytesPerSector = regX.cx
  716.         DEF SEG = regX.ds
  717.         desc.FATIdentificationByte = PEEK(regX.bx)
  718.         DEF SEG
  719.     END SUB
  720.  
  721.   ' ************************************************
  722.   ' **  Name:          GetVerifyState%            **
  723.   ' **  Type:          Function                   **
  724.   ' **  Module:        DOSCALLS.BAS               **
  725.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  726.   ' ************************************************
  727.   '
  728.   ' Returns the current state of the MS-DOS "Verify After
  729.   ' Write" flag.
  730.   '
  731.   ' EXAMPLE OF USE:  state% = GetVerifyState%
  732.   ' PARAMETERS:      (none)
  733.   ' VARIABLES:       reg        Structure of type RegType
  734.   ' MODULE LEVEL
  735.   '   DECLARATIONS:  TYPE RegTypeX
  736.   '                     ax    AS INTEGER
  737.   '                     bx    AS INTEGER
  738.   '                     cx    AS INTEGER
  739.   '                     dx    AS INTEGER
  740.   '                     bp    AS INTEGER
  741.   '                     si    AS INTEGER
  742.   '                     di    AS INTEGER
  743.   '                     flags AS INTEGER
  744.   '                  END TYPE
  745.   '
  746.   '      DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  747.   '      DECLARE FUNCTION GetVerifyState% ()
  748.   '
  749.     FUNCTION GetVerifyState% STATIC
  750.         DIM reg AS RegType
  751.         reg.ax = &H5400
  752.         Interrupt &H21, reg, reg
  753.         GetVerifyState% = reg.ax AND &HFF
  754.     END FUNCTION
  755.  
  756.   ' ************************************************
  757.   ' **  Name:          SetDirectory               **
  758.   ' **  Type:          Subprogram                 **
  759.   ' **  Module:        DOSCALLS.BAS               **
  760.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  761.   ' ************************************************
  762.   '
  763.   ' Sets the current directory.
  764.   '
  765.   ' EXAMPLE OF USE:  SetDirectory path$, result%
  766.   ' PARAMETERS:      path$      The path to the directory
  767.   '                  result%    Returned error code, zero if successful
  768.   ' VARIABLES:       regX       Structure of type RegTypeX
  769.   '                  p$         Null terminated copy of path$
  770.   ' MODULE LEVEL
  771.   '   DECLARATIONS:  TYPE RegTypeX
  772.   '                     ax    AS INTEGER
  773.   '                     bx    AS INTEGER
  774.   '                     cx    AS INTEGER
  775.   '                     dx    AS INTEGER
  776.   '                     bp    AS INTEGER
  777.   '                     si    AS INTEGER
  778.   '                     di    AS INTEGER
  779.   '                     flags AS INTEGER
  780.   '                     ds    AS INTEGER
  781.   '                     es    AS INTEGER
  782.   '                  END TYPE
  783.   '
  784.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  785.   '   DECLARE SUB SetDirectory (path$, result%)
  786.   '
  787.     SUB SetDirectory (path$, result%) STATIC
  788.         DIM regX AS RegTypeX
  789.         regX.ax = &H3B00
  790.         p$ = path$ + CHR$(0)
  791.         regX.ds = VARSEG(p$)
  792.         regX.dx = SADD(p$)
  793.         InterruptX &H21, regX, regX
  794.         IF regX.flags AND 1 THEN
  795.             result% = regX.ax
  796.         ELSE
  797.             result% = 0
  798.         END IF
  799.     END SUB
  800.  
  801.   ' ************************************************
  802.   ' **  Name:          SetDrive                   **
  803.   ' **  Type:          Subprogram                 **
  804.   ' **  Module:        DOSCALLS.BAS               **
  805.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  806.   ' ************************************************
  807.   '
  808.   ' Calls MS-DOS to set the current drive.
  809.   '
  810.   ' EXAMPLE OF USE:  SetDrive drive$
  811.   ' PARAMETERS:      drive$     Drive designation, such as "A:"
  812.   ' VARIABLES:       reg        Structure of type RegType
  813.   '                  drive%     Numeric value of drive
  814.   ' MODULE LEVEL
  815.   '   DECLARATIONS:  TYPE RegTypeX
  816.   '                     ax    AS INTEGER
  817.   '                     bx    AS INTEGER
  818.   '                     cx    AS INTEGER
  819.   '                     dx    AS INTEGER
  820.   '                     bp    AS INTEGER
  821.   '                     si    AS INTEGER
  822.   '                     di    AS INTEGER
  823.   '                     flags AS INTEGER
  824.   '                  END TYPE
  825.   '
  826.   '      DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  827.   '      DECLARE SUB SetDrive (drive$)
  828.   '
  829.     SUB SetDrive (drive$) STATIC
  830.         DIM reg AS RegType
  831.         IF drive$ <> "" THEN
  832.             drive% = ASC(UCASE$(drive$)) - 65
  833.         ELSE
  834.             drive% = 0
  835.         END IF
  836.         IF drive% >= 0 THEN
  837.             reg.dx = drive%
  838.         ELSE
  839.             reg.dx = 0
  840.         END IF
  841.         reg.ax = &HE00
  842.         Interrupt &H21, reg, reg
  843.     END SUB
  844.  
  845.   ' ************************************************
  846.   ' **  Name:          SetFileAttributes          **
  847.   ' **  Type:          Subprogram                 **
  848.   ' **  Module:        DOSCALLS.BAS               **
  849.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  850.   ' ************************************************
  851.   '
  852.   ' Sets attribute bits for a file.
  853.   '
  854.   ' EXAMPLE OF USE:  SetFileAttributes fileName$, attr
  855.   ' PARAMETERS:      fileName$  Name of file
  856.   '                  attr       Structure of type FileAttributesType
  857.   ' VARIABLES:       regX       Structure of type RegTypeX
  858.   '                  f$         Null terminated copy of fileName$
  859.   ' MODULE LEVEL
  860.   '   DECLARATIONS:  TYPE RegTypeX
  861.   '                     ax    AS INTEGER
  862.   '                     bx    AS INTEGER
  863.   '                     cx    AS INTEGER
  864.   '                     dx    AS INTEGER
  865.   '                     bp    AS INTEGER
  866.   '                     si    AS INTEGER
  867.   '                     di    AS INTEGER
  868.   '                     flags AS INTEGER
  869.   '                     ds    AS INTEGER
  870.   '                     es    AS INTEGER
  871.   '                  END TYPE
  872.   '
  873.   '                 TYPE FileAttributesType
  874.   '                    readOnly AS INTEGER
  875.   '                    hidden AS INTEGER
  876.   '                    systemFile AS INTEGER
  877.   '                    archive AS INTEGER
  878.   '                    result AS INTEGER
  879.   '                 END TYPE
  880.   '
  881.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  882.   '   DECLARE SUB SetFileAttributes (fileName$, attr AS FileAttributesType)
  883.   '
  884.     SUB SetFileAttributes (fileName$, attr AS FileAttributesType)
  885.         DIM regX AS RegTypeX
  886.         regX.ax = &H4301
  887.         IF attr.readOnly THEN
  888.             regX.cx = 1
  889.         ELSE
  890.             regX.cx = 0
  891.         END IF
  892.         IF attr.hidden THEN
  893.             regX.cx = regX.cx + 2
  894.         END IF
  895.         IF attr.systemFile THEN
  896.             regX.cx = regX.cx + 4
  897.         END IF
  898.         IF attr.archive THEN
  899.             regX.cx = regX.cx + 32
  900.         END IF
  901.         f$ = fileName$ + CHR$(0)
  902.         regX.ds = VARSEG(f$)
  903.         regX.dx = SADD(f$)
  904.         InterruptX &H21, regX, regX
  905.         IF regX.flags AND 1 THEN
  906.             attr.result = regX.ax
  907.         ELSE
  908.             attr.result = 0
  909.         END IF
  910.     END SUB
  911.  
  912.   ' ************************************************
  913.   ' **  Name:          SetVerifyState             **
  914.   ' **  Type:          Subprogram                 **
  915.   ' **  Module:        DOSCALLS.BAS               **
  916.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  917.   ' ************************************************
  918.   '
  919.   ' Sets or clears the "Verify After Write" MS-DOS flag.
  920.   '
  921.   ' EXAMPLE OF USE:  SetVerifyState state%
  922.   ' PARAMETERS:      state%     If 0, resets Verify;  If non-zero,
  923.   '                             then sets Verify on
  924.   ' VARIABLES:       reg        Structure of type RegType
  925.   ' MODULE LEVEL
  926.   '   DECLARATIONS:  TYPE RegTypeX
  927.   '                     ax    AS INTEGER
  928.   '                     bx    AS INTEGER
  929.   '                     cx    AS INTEGER
  930.   '                     dx    AS INTEGER
  931.   '                     bp    AS INTEGER
  932.   '                     si    AS INTEGER
  933.   '                     di    AS INTEGER
  934.   '                     flags AS INTEGER
  935.   '                  END TYPE
  936.   '
  937.   '      DECLARE SUB Interrupt (intnum%, inreg AS RegType, outreg AS RegType)
  938.   '      DECLARE SUB SetVerifyState (state%)
  939.   '
  940.     SUB SetVerifyState (state%) STATIC
  941.         DIM reg AS RegType
  942.         IF state% THEN
  943.             reg.ax = &H2E01
  944.         ELSE
  945.             reg.ax = &H2E00
  946.         END IF
  947.         Interrupt &H21, reg, reg
  948.     END SUB
  949.  
  950.   ' ************************************************
  951.   ' **  Name:          TranslateCountry$          **
  952.   ' **  Type:          Function                   **
  953.   ' **  Module:        DOSCALLS.BAS               **
  954.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  955.   ' ************************************************
  956.   '
  957.   ' Returns a string of characters translated according to
  958.   ' the current country setting of MS-DOS.
  959.   '
  960.   ' EXAMPLE OF USE:  b$ = TranslateCountry$(a$, country)
  961.   ' PARAMETERS:      a$         String to be translated
  962.   '                  country    Structure of type CountryType
  963.   ' VARIABLES:       i%         Index to each character of a$
  964.   '                  c%         Byte value of each character in a$
  965.   ' MODULE LEVEL
  966.   '   DECLARATIONS:  TYPE CountryType
  967.   '                     DateTimeFormat AS STRING * 11
  968.   '                     CurrencySymbol AS STRING * 4
  969.   '                     ThousandsSeparator AS STRING * 1
  970.   '                     DecimalSeparator AS STRING * 1
  971.   '                     DateSeparator AS STRING * 1
  972.   '                     TimeSeparator AS STRING * 1
  973.   '                     CurrencyThenSymbol AS INTEGER
  974.   '                     CurrencySymbolSpace AS INTEGER
  975.   '                     CurrencyPlaces AS INTEGER
  976.   '                     Hours24 AS INTEGER
  977.   '                     caseMapSegment AS INTEGER
  978.   '                     caseMapOffset AS INTEGER
  979.   '                     DataListSeparator AS STRING * 1
  980.   '                  END TYPE
  981.   '
  982.   '           DECLARE SUB CaseMap (character%, BYVAL Segment%, BYVAL Offset%)
  983.   '           DECLARE FUNCTION TranslateCountry$ (a$, country AS CountryType)
  984.   '
  985.     FUNCTION TranslateCountry$ (a$, country AS CountryType) STATIC
  986.         FOR i% = 1 TO LEN(a$)
  987.             c% = ASC(MID$(a$, i%))
  988.             CaseMap c%, country.caseMapSegment, country.caseMapOffset
  989.             MID$(a$, i%, 1) = CHR$(c%)
  990.         NEXT i%
  991.         TranslateCountry$ = a$
  992.     END FUNCTION
  993.  
  994.   ' ************************************************
  995.   ' **  Name:          WriteToDevice              **
  996.   ' **  Type:          Subprogram                 **
  997.   ' **  Module:        DOSCALLS.BAS               **
  998.   ' **  Language:      Microsoft QuickBASIC 4.00  **
  999.   ' ************************************************
  1000.   '
  1001.   ' Writes bytes to a file or device.
  1002.   '
  1003.   ' EXAMPLE OF USE:  WriteToDevice handle%, a$, result%
  1004.   ' PARAMETERS:      handle%    File or device handle
  1005.   '                  a$         String to be output
  1006.   '                  result%    Error code returned from MS-DOS
  1007.   ' VARIABLES:       regX       Structure of type RegTypeX
  1008.   ' MODULE LEVEL
  1009.   '   DECLARATIONS:  TYPE RegTypeX
  1010.   '                     ax    AS INTEGER
  1011.   '                     bx    AS INTEGER
  1012.   '                     cx    AS INTEGER
  1013.   '                     dx    AS INTEGER
  1014.   '                     bp    AS INTEGER
  1015.   '                     si    AS INTEGER
  1016.   '                     di    AS INTEGER
  1017.   '                     flags AS INTEGER
  1018.   '                     ds    AS INTEGER
  1019.   '                     es    AS INTEGER
  1020.   '                  END TYPE
  1021.   '
  1022.   '   DECLARE SUB InterruptX (intnum%, inreg AS RegTypeX, outreg AS RegTypeX)
  1023.   '   DECLARE SUB WriteToDevice (handle%, a$, result%)
  1024.   '
  1025.     SUB WriteToDevice (handle%, a$, result%) STATIC
  1026.         DIM regX AS RegTypeX
  1027.         regX.ax = &H4000
  1028.         regX.cx = LEN(a$)
  1029.         regX.bx = handle%
  1030.         regX.ds = VARSEG(a$)
  1031.         regX.dx = SADD(a$)
  1032.         InterruptX &H21, regX, regX
  1033.         IF regX.flags AND 1 THEN
  1034.             result% = regX.ax
  1035.         ELSEIF regX.ax <> LEN(a$) THEN
  1036.             result% = -1
  1037.         ELSE
  1038.             result% = 0
  1039.         END IF
  1040.     END SUB
  1041.  
  1042.