AOH :: DOSREF1.TXT

DOS programmer's reference card - 132 columns


SA2U
                                                                        |                                                          |
                 1                                                      |  2             ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿            |
                          IBM PC-DOS PROGRAMMER'S                       |                ³ INT 20 - PROGRAM TERMINATE ³            |
                          QUICK REFERENCE SUMMARY                       |                ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ            |
                            by DAVID E. POWELL                          |                                                          |
                                                                        |   DESCRIPTION: INT 20 RESTORES THE TERMINATE, CTL-BREAK, |
                             ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿                          |                AND CRITICAL ERROR EXIT ADDRESSES, FLUSHES|
                             ³ ERROR RETURNS ³                          |                ALL BUFFERS, AND RETURNS TO DOS           |
                             ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ                          |                                                          |
                                                                        |   INPUT PARMS: CS = ADDRESS OF PROGRAM SEGMENT PREFIX    |
                OF THE FOLLOWING ERROR CODES, ONLY CODES 1-12 ARE       |                                                          |
                RETURNED IN AX UPON EXIT FROM INTERRUPT 21 OR 24.       |  OUTPUT PARMS: NONE                                      |
                THE REST ARE OBTAINED BY ISSUING THE "GET EXTENDED      |                                                          |
                ERROR" FUNCTION CALL (SEE INT 21, AH=59).               |                                                          |
                                                                        |                                                          |
                01 - INVALID FUNCTION NUMBER                            |                ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿             |
                02 - FILE NOT FOUND                                     |                ³ INT 21 - FUNCTION REQUEST ³             |
                03 - PATH NOT FOUND                                     |                ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ             |
                04 - TOO MANY OPEN FILES (NO HANDLES LEFT)              |                                                          |
                05 - ACCESS DENIED                                      |   DESCRIPTION: PERFORM A DOS FUNCTION.                   |
                06 - INVALID HANDLE                                     |                                                          |
                07 - MEMORY CONTROL BLOCKS DESTROYED                    |   INPUT PARMS: AH = FUNCTION NUMBER. OTHER REGISTERS     |
                08 - INSUFFICIENT MEMORY                                |                ARE SET AS DESCRIBED BELOW.               |
                09 - INVALID MEMORY BLOCK ADDRESS                       |                                                          |
                0A - INVALID ENVIRONMENT                                |  OUTPUT PARMS: IF ERROR ENCOUNTERED, CY IS SET TO 1 AND  |
                0B - INVALID FORMAT                                     |                AX CONTAINS A RUDIMENTARY ERROR CODE.     |
                0C - INVALID ACCESS CODE                                |                EXTENDED ERROR INFORMATION MAY BE OBTAINED|
                0D - INVALID DATA                                       |                BY ISSUING FUNCTION REQUEST 59.           |
                0E - RESERVED                                           |                                                          |
                0F - INVALID DRIVE WAS SPECIFIED                        |                                                          |
                10 - ATTEMPT TO REMOVE THE CURRENT DIRECTORY            |         --------- FUNCTION REQUEST SUMMARY ----------    |
                11 - NOT SAME DEVICE                                    |                                                          |
                12 - NO MORE FILES                                      |     00 - PROGRAM TERMINATE                               |
                13 - ATTEMPT TO WRITE ON A WRITE-PROTECTED DISKETTE     |     01 - WAIT FOR KEYBOARD INPUT                         |
                14 - UNKNOWN UNIT                                       |     02 - DISPLAY OUTPUT                                  |
                15 - DRIVE NOT READY                                    |     03 - WAIT FOR AUXILIARY DEVICE INPUT                 |
                16 - UNKNOWN COMMAND                                    |     04 - AUXILARY OUTPUT                                 |
                17 - CRC ERROR                                          |     05 - PRINTER OUTPUT                                  |
                18 - BAD REQUEST STRUCTURE LENGTH                       |     06 - DIRECT CONSOLE I/O                              |
                19 - SEEK ERROR                                         |     07 - WAIT FOR DIRECT CONSOLE INPUT WITHOUT ECHO      |
                1A - UNKNOWN MEDIA TYPE                                 |     08 - WAIT FOR CONSOLE INPUT WITHOUT ECHO             |
                1B - SECTOR NOT FOUND                                   |     09 - PRINT STRING                                    |
                1C - PRINTER OUT OF PAPER                               |     0A - BUFFERED KEYBOARD INPUT                         |
                1D - WRITE FAULT                                        |     0B - CHECK STANDARD INPUT STATUS                     |
                1E - READ FAULT                                         |     0C - CLEAR KEYBOARD BUFFER, INVOKE KEYBOARD FUNCTION |
                1F - GENERAL FAILURE                                    |     0D - DISK RESET                                      |
                20 - SHARING VIOLATION                                  |     0E - SELECT DISK                                     |
                21 - LOCK VIOLATION                                     |     0F - OPEN FILE                                       |
                22 - INVALID DISK CHANGE                                |     10 - CLOSE FILE                                      |
                23 - FCB UNAVAILABLE                                    |     11 - SEARCH FOR FIRST ENTRY                          |
               24-4F RESERVED                                           |     12 - SEARCH FOR NEXT ENTRY                           |
                50 - FILE EXISTS                                        |     13 - DELETE FILE                                     |
                51 - RESERVED                                           |     14 - SEQUENTIAL READ                                 |
                52 - CANNOT MAKE                                        |     15 - SEQUENTIAL WRITE                                |
                53 - FAIL ON INT 24                                     |     16 - CREATE A FILE                                   |
                                                                        |     17 - RENAME FILE                                     |
                      -------- ERROR CLASSES --------                   |     19 - GET CURRENT DEFAULT DRIVE                       |
                                                                        |     1A - SET DISK TRANSFER ADDRESS                       |
                01 - OUT OF RESOURCE     ³ 08 - NOT FOUND               |     1B - GET ALLOCATION TABLE INFORMATION                |
                02 - TEMPORARY SITUATION ³ 09 - BAD FORMAT              |     1C - GET ALLOCATION TABLE INFO FOR SPECIFIC DEVICE   |
                03 - AUTHORIZATION       ³ 0A - LOCKED                  |     21 - RANDOM READ                                     |
                04 - INTERNAL            ³ 0B - MEDIA FAILURE           |     22 - RANDOM WRITE                                    |
                05 - HARDWARE FAILURE    ³ 0C - ALREADY EXISTS          |     23 - GET FILE SIZE                                   |
                06 - SYSTEM FAILURE      ³ 0D - UNKNOWN                 |     24 - SET RELATIVE RECORD FIELD                       |
                07 - APPLICATION ERROR   ³                              |     25 - SET INTERRUPT VECTOR                            |
                                                                        |     26 - CREATE NEW PROGRAM SEGMENT                      |
                                                                        |     27 - RANDOM BLOCK READ                               |
                    --------- ACTION CODES ----------                   |     28 - RANDOM BLOCK WRITE                              |
                                                                        |     29 - PARSE FILENAME                                  |
                01 - RETRY               ³ 05 - IMMEDIATE EXIT          |     2A - GET DATE                                        |
                02 - DELAY RETRY         ³ 06 - IGNORE                  |     2B - SET DATE                                        |
                03 - RE-ENTER INPUT      ³ 07 - USER INTERVENTION       |     2C - GET TIME                                        |
                04 - ABORT               ³                              |     2D - SET TIME                                        |
                                                                        |     2E - SET/RESET VERIFY SWITCH                         |
                                                                        |     2F - GET DISK TRANSFER ADDRESS                       |
                   -------------- LOCUS --------------                  |     30 - GET DOS VERSION NUMBER                          |
                                                                        |     31 - TERMINATE PROCESS AND REMAIN RESIDENT           |
                01 - UNKNOWN             ³ 04 - SERIAL DEVICE           |     33 - GET/SET CTL-BREAK CHECK STATE                   |
                02 - BLOCK DEVICE        ³ 05 - MEMORY                  |     35 - GET VECTOR                                      |
                03 - RESERVED            ³                              |     36 - GET DISK FREE SPACE                             |
                                                                        |     38 - GET/SET COUNTRY DEPENDENT INFORMATION           |
                                                                        |     39 - CREATE SUBDIRECTORY (MKDIR)                     |
                                                                        |     3A - REMOVE SUBDIRECTORY (RMDIR)                     |
                                                                        |     3B - CHANGE CURRENT SUBDIRECTORY (CHDIR)             |
                                                                        |     3C - CREATE A FILE                                   |
                                                                        |     3D - OPEN A FILE                                     |
                                                                        |     3E - CLOSE A FILE HANDLE                             |
                                                                        |     3F - READ FROM A FILE OR DEVICE                      |
                                                                        |     40 - WRITE TO A FILE OR DEVICE                       |
                                                                        |     41 - DELETE A FILE FROM A SPECIFIED SUBDIRECTORY     |
                                                                        |     42 - MOVE FILE READ/WRITE POINTER                    |
                                                                        |     43 - CHANGE FILE MODE                                |
                                                                        |     44 - I/O CONTROL FOR DEVICES                         |
                           ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿                 |     45 - DUPLICATE A FILE HANDLE                         |
                           ³ PRE-DEFINED FILE HANDLES ³                 |     46 - FORCE A DUPLICATE OF A FILE HANDLE              |
                           ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ                 |     47 - GET CURRENT DIRECTORY                           |
                                                                        |     48 - ALLOCATE MEMORY BLOCKS                          |
                0000 - STANDARD INPUT DEVICE - CAN BE REDIRECTED        |     49 - FREE ALLOCATED MEMORY BLOCKS                    |
                0001 - STANDARD OUTPUT DEVICE - CAN BE REDIRECTED       |     4A - MODIFY ALLOCATED MEMORY BLOCKS                  |
                0002 - STANDARD ERROR DEVICE - CANNOT BE REDIRECTED     |     4B - LOAD/EXECUTE A PROGRAM                          |
                0003 - STANDARD AUXILARY DEVICE                         |     4C - TERMINATE A PROCESS                             |
                0004 - STANDARD PRINTER DEVICE                          |     4D - GET RETURN CODE OF A SUB_PROCESS                |
                                                                        |     4E - FIND FIRST MATCHING FILE                        |
                                                                        |     4F - FIND NEXT MATCHING FILE                         |
                                                                        |     54 - GET VERIFY SETTING                              |
                             ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿                  |     56 - RENAME A FILE                                   |
                             ³ DOS INTERRUPT SUMMARY ³                  |     57 - GET/SET A FILE'S DATE AND TIME                  |
                             ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ                  |     59 - GET EXTENDED ERROR INFORMATION                  |
                                                                        |     5A - CREATE A TEMPORARY FILE                         |
                      20 - PROGRAM TERMINATE                            |     5B - CREATE A NEW FILE                               |
                      21 - FUNCTION REQUEST                             |     5C - LOCK/UNLOCK A FILE'S ACCESS                     |
                      22 - TERMINATE ADDRESS                            |     62 - GET ADDRESS OF PROGRAM SEGMENT PREFIX           |
                      23 - CTL-BREAK EXIT ADDRESS                       |                                                          |
                      24 - CRITICAL ERROR HANDLER ADDRESS               |                                                          |
                      25 - ABSOLUTE DISK READ                           |                                                          |
                      26 - ABSOLUTE DISK WRITE                          |                                                          |
                      27 - TERMINATE BUT STAY RESIDENT                  |                                                          |
                      2F - PRINTER                                      |                                                          |
                                                                        |                                  CONTINUED ON NEXT PANEL |
                                                                        |                                                          |


                                                                        |  4  INT 21 - FUNCTION REQUEST (CONT.)                    |
                3  INT 21 - FUNCTION REQUEST (CONT.)                    |                                                          |
                                                                        |  AH = 19 - GET CURRENT DEFAULT DRIVE                     |
                                                                        |        INPUT: NONE                                       |
               AH = 00 - PROGRAM TERMINATE                              |       OUTPUT: AL = CURRENT DEFAULT DRIVE (0=A,1=B,etc.)  |
                   INPUT: NONE                                          |                                                          |
                  OUTPUT: NONE                                          |  AH = 1A - SET DISK TRANSFER ADDRESS                     |
                                                                        |        INPUT: DS:DX = THE NEW DISK TRANSFER ADDRESS      |
               AH = 01 - WAIT FOR KEYBOARD INPUT                        |       OUTPUT: NONE                                       |
                   INPUT: NONE                                          |                                                          |
                  OUTPUT: AL = CHARACTER FROM STANDARD INPUT DEVICE     |  AH = 1B - GET ALLOCATION TABLE INFORMATION              |
                                                                        |        INPUT: NONE                                       |
               AH = 02 - DISPLAY OUTPUT                                 |       OUTPUT: DS:BX = POINTER TO THE BYTE CONTAINING THE |
                   INPUT: DL = ASCII CHARACTER TO OUTPUT                |                       FAT ID BYTE FOR THE DEFAULT DRIVE  |
                  OUTPUT: NONE                                          |               DX = THE NUMBER OF ALLOCATION UNITS        |
                                                                        |               AL = THE NUMBER OF SECTORS/ALLOCATION UNIT |
               AH = 03 - WAIT FOR AUXILIARY DEVICE INPUT                |               CX = THE SIZE OF THE PHYSICAL SECTOR       |
                   INPUT: NONE                                          |                                                          |
                  OUTPUT: AL = CHARACTER FROM THE AUXILIARY DEVICE      |  AH = 1C - GET ALLOCATION TABLE INFO FOR SPECIFIC DEVICE |
                                                                        |        INPUT: DL = DRIVE NUMBER (0 FOR DEFAULT)          |
               AH = 04 - AUXILIARY OUTPUT                               |       OUTPUT: DS:BX = POINTER TO THE BYTE CONTAINING THE |
                   INPUT: DL = CHARACTER TO OUTPUT                      |                       FAT ID BYTE FOR THE REQUESTED DRIVE|
                  OUTPUT: NONE                                          |               DX = THE NUMBER OF ALLOCATION UNITS        |
                                                                        |               AL = THE NUMBER OF SECTORS/ALLOCATION UNIT |
               AH = 05 - PRINTER OUTPUT                                 |               CX = THE SIZE OF THE PHYSICAL SECTOR       |
                   INPUT: DL = CHARACTER TO OUTPUT                      |                                                          |
                  OUTPUT: NONE                                          |  AH = 21 - RANDOM READ                                   |
                                                                        |        INPUT: DS:DX = POINTER TO AN OPENED FCB           |
               AH = 06 - DIRECT CONSOLE I/O                             |       OUTPUT: AL = 00 IF READ WAS SUCCESSFUL             |
                   INPUT: DL = CHARACTER TO OUTPUT IF <> FF             |               AL = 01 IF EOF (NO DATA READ)              |
                          DL = FF IF CONSOLE INPUT REQUEST              |               AL = 02 IF DTA IS TOO SMALL                |
                  OUTPUT: AL = INPUT CHARACTER IF DL = FF               |               AL = 03 IF EOF (PARTIAL RECORD READ)       |
                          ZF = 1 IF DL = FF AND NO CHARACTER IS READY   |                                                          |
                                                                        |  AH = 22 - RANDOM WRITE                                  |
               AH = 07 - WAIT FOR DIRECT CONSOLE INPUT WITHOUT ECHO     |        INPUT: DS:DX = POINTER TO AN OPENED FCB           |
                   INPUT: NONE                                          |       OUTPUT: AL = 00 IF WRITE WAS SUCCESSFUL            |
                  OUTPUT: AL = CHARACTER FROM STANDARD INPUT DEVICE     |               AL = 01 IF DISKETTE IS FULL                |
                                                                        |               AL = 02 IF DTA IS TOO SMALL                |
               AH = 08 - WAIT FOR CONSOLE INPUT WITHOUT ECHO            |                                                          |
                   INPUT: NONE                                          |  AH = 23 - GET FILE SIZE                                 |
                  OUTPUT: AL = CHARACTER FROM STANDARD INPUT DEVICE     |        INPUT: DS:DX = POINTER TO AN UNOPENED FCB         |
                                                                        |       OUTPUT: AL = 00 IF THE DIRECTORY ENTRY IS FOUND    |
               AH = 09 - PRINT STRING                                   |               AL = FF IF THE DIRECTORY ENTRY IS NOT FOUND|
                   INPUT: DS:DX = POINTER TO STRING ENDING IN "$"       |                                                          |
                  OUTPUT: NONE                                          |  AH = 24 - SET RELATIVE RECORD FIELD                     |
                                                                        |        INPUT: DS:DX = POINTER TO AN OPENED FCB           |
               AH = 0A - BUFFERED KEYBOARD INPUT                        |       OUTPUT: NONE                                       |
                   INPUT: DS:DX = POINTER TO INPUT BUFFER:              |                                                          |
                          ÚÄÂÄÂÄÄÄÄÄÄÄÄÄÄ  ¿                            |  AH = 25 - SET INTERRUPT VECTOR                          |
                          ³1³2³ BUFFER  ...³                            |        INPUT: DS:DX = ADDRESS OF INTERRUPT HANDLER       |
                          ÀÄÁÄÁÄÄÄÄÄÄÄÄÄÄ  Ù                            |               AL = INTERRUPT NUMBER                      |
                           ³ ³     ³                                    |       OUTPUT: NONE                                       |
                           ³ ³     ÀÄÄÄÄÄÄÄÄ PLACE FOR INPUT CHARS      |                                                          |
                           ³ ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄ NUMBER OF CHARS IN BUFFER  |  AH = 26 - CREATE A NEW PROGRAM SEGMENT                  |
                           ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ SIZE OF BUFFER             |        INPUT: DX = SEGMENT NUMBER FOR THE NEW PROGRAM    |
                  OUTPUT: CHARACTERS UP TO AND INCLUDING A CR ARE       |       OUTPUT: NONE                                       |
                          PLACED INTO THE BUFFER BEGINNING AT BYTE      |                                                          |
                          3. BYTE 2 IS SET TO THE NUMBER OF CHARACTERS  |  AH = 27 - RANDOM BLOCK READ                             |
                          PLACED INTO THE BUFFER.                       |        INPUT: DS:DX = POINTER TO AN OPENED FCB           |
                                                                        |               CX = THE NUMBER OF RECORDS TO BE READ      |
               AH = 0B - CHECK STANDARD INPUT STATUS                    |       OUTPUT: AL = 00 IF READ WAS SUCCESSFUL             |
                   INPUT: NONE                                          |                    01 IF EOF (NO DATA READ)              |
                  OUTPUT: AL = FF IF CHARACTER IS AVAILABLE; 00 IF NOT  |                    02 IF DTA IS TOO SMALL                |
                                                                        |                    03 IF EOF (PARTIAL RECORD READ)       |
               AH = 0C - CLEAR KEYBOARD BUFFER, INVOKE KEYBOARD FUNCTION|               CX = ACTUAL NUMBER OF RECORDS READ         |
                   INPUT: AL = INT 21 FUNCTION # 01,06,07,08,OR 0A      |                                                          |
                  OUTPUT: KEYBOARD IS CLEARED,FUNCTION IN AL IS INVOKED |  AH = 28 - RANDOM BLOCK WRITE                            |
                                                                        |        INPUT: DS:DX = POINTER TO AN OPENED FCB           |
               AH = 0D - DISK RESET                                     |               CX = NUMBER OF RECORDS TO BE WRITTEN       |
                   INPUT: NONE                                          |       OUTPUT: AL = 00 IF WRITE WAS SUCCESSFUL            |
                  OUTPUT: FLUSHES ALL FILE BUFFERS                      |                  = 01 IF DISKETTE IS FULL                |
                                                                        |                  = 02 IF DTA IS TOO SMALL                |
               AH = 0E - SELECT DISK                                    |               CX = ACTUAL NUMBER OF RECORDS WRITTEN      |
                   INPUT: DL = DRIVE NUMBER (0=A,1=B,etc.)              |                                                          |
                  OUTPUT: AL = TOTAL NUMBER OF DRIVES INCL. HARDFILES   |  AH = 29 - PARSE A FILENAME                              |
                                                                        |        INPUT: DS:SI = POINTER TO A COMMAND LINE TO PARSE |
               AH = 0F - OPEN A FILE                                    |               ES:DI = POINTER TO A BUFFER TO BE FILLED   |
                   INPUT: DS:DX = POINTER TO AN UNOPENED FCB            |                       WITH AN UNOPENED FCB               |
                  OUTPUT: AL = 00 IF FILE OPENED; AL = FF IF NOT        |               AL = BIT PATTERN TO CONTROL PARSING        |
                                                                        |                    (SEE DOS MANUAL FOR BIT MEANINGS)     |
               AH = 10 - CLOSE A FILE                                   |       OUTPUT: AL = 00 IF NO GLOBAL CHARACTERS            |
                   INPUT: DS:DX = POINTER TO AN OPENED FCB              |                  = 01 IF GLOBAL CHARACTERS PRESENT       |
                  OUTPUT: AL = 00 IF FILE IS FOUND; AL = FF IF NOT      |                  = FF IF DRIVE SPECIFIER IS INVALID      |
                                                                        |               DS:SI = POINTER TO THE FIRST CHARACTER     |
               AH = 11 - SEARCH FOR FIRST ENTRY                         |                       AFTER THE PARSED FILENAME          |
                   INPUT: DS:DX = POINTER TO AN UNOPENED FCB            |               ES:DI = POINTER TO THE UNOPENED FCB        |
                  OUTPUT: AL = 00 IF MATCHING FILENAME FOUND; FF IF NOT |                                                          |
                                                                        |  AH = 2A - GET DATE                                      |
               AH = 12 - SEARCH FOR NEXT ENTRY                          |        INPUT: NONE                                       |
                   INPUT: DS:DX = POINTER TO SAME FCB IN AH=11 ABOVE    |       OUTPUT: AL = DAY OF THE WEEK (0=SUNDAY)            |
                  OUTPUT: AL = 00 IF MATCHING FILENAME FOUND; FF IF NOT |               CX = YEAR (1980-2099)                      |
                                                                        |               DH = MONTH (1-12)                          |
               AH = 13 - DELETE A FILE                                  |               DL = DAY (1-31)                            |
                   INPUT: DS:DX = POINTER TO AN UNOPENED FCB            |                                                          |
                  OUTPUT: AL = 00 IF FILE DELETED                       |  AH = 2B - SET DATE                                      |
                          AL = FF IF FILE NOT FOUND                     |        INPUT: CX = YEAR (1980-2099)                      |
                                                                        |               DH = MONTH (1-12)                          |
               AH = 14 - SEQUENTIAL READ                                |               DL = DAY (1-31)                            |
                   INPUT: DS:DX = POINTER TO AN OPENED FCB              |       OUTPUT: AL = 00 IF DATE WAS VALID; AL=FF IF NOT    |
                  OUTPUT: AL = 00 IF SUCCESSFUL READ                    |                                                          |
                          AL = 01 IF END OF FILE (NO DATA READ)         |  AH = 2C - GET TIME                                      |
                          AL = 02 IF DTA IS TOO SMALL                   |        INPUT: NONE                                       |
                          AL = 03 IF END OF FILE (PARTIAL RECORD READ)  |       OUTPUT: CH = HOUR (0-23)                           |
                                                                        |               CL = MINUTES (0-59)                        |
               AH = 15 - SEQUENTIAL WRITE                               |               DH = SECONDS (0-59)                        |
                   INPUT: DS:DX = POINTER TO AN OPENED FCB              |               DL = HUNDREDTHS (0-99)                     |
                  OUTPUT: AL = 00 IF WRITE WAS SUCCESSFUL               |                                                          |
                          AL = 01 IF DISKETTE IS FULL                   |  AH = 2D - SET TIME                                      |
                          AL = 02 IF DTA IS TOO SMALL                   |        INPUT: CH = HOUR (0-23)                           |
                                                                        |               CL = MINUTES (0-59)                        |
               AH = 16 - CREATE A FILE                                  |               DH = SECONDS (0-59)                        |
                   INPUT: DS:DX = POINTER TO AN UNOPENED FCB            |               DL = HUNDREDTHS (0-99)                     |
                  OUTPUT: AL = 00 IF FILE CREATED; AL = FF IF NOT       |       OUTPUT: AL = 00 IF TIME WAS VALID; AL=FF IF NOT    |
                                                                        |                                                          |
               AH = 17 - RENAME A FILE                                  |  AH = 2E - SET/RESET VERIFY SWITCH                       |
                   INPUT: DS:DX = POINTER TO A MODIFIED FCB             |        INPUT: AL = 01 TO SET VERIFY ON; AL=00 TO SET OFF |
                  OUTPUT: AL = 00 IF FILE RENAMED; AL = FF IF NOT       |       OUTPUT: NONE                                       |
                                                                        |                                                          |
                                              CONTINUED ON NEXT PANEL   |                                CONTINUED ON NEXT PANEL   |
                                                                        |                                                          |



Make REAL money with your website!

The entire AOH site is optimized to look best in Firefox® 2.0 on a widescreen monitor (1440x900 or better).
Site design & layout copyright © 1986-2008 AOH
We do not send spam. If you have received spam bearing an artofhacking.com email address, please forward it with full headers to abuse@artofhacking.com.