home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 26 / CD_ASCQ_26_1295.iso / vrac / volume_3.zip / BIOS21.CPP < prev    next >
Text File  |  1995-10-31  |  12KB  |  553 lines
  1. #ifndef __BIOS21_
  2.     #include "C:\tc\bios21.h"
  3. #endif
  4.  
  5.  
  6.  
  7. int Change_Name(char far *oldfilename,char far *newfilename)
  8.  {
  9.     union REGS regs; struct SREGS sregs;
  10.     int ret;
  11.     regs.h.ah = 0x56;                      /* delete file */
  12.     regs.x.dx = FP_OFF(oldfilename);
  13.     sregs.ds = FP_SEG(oldfilename);
  14.     regs.x.di = FP_OFF(newfilename);
  15.     sregs.es = FP_SEG(newfilename);
  16.     ret = intdosx(®s, ®s, &sregs);
  17.  
  18.     /* if carry flag is set, there was an error */
  19.     return(regs.x.cflag ? ret : 0);
  20.  }
  21.  
  22.  
  23.  
  24.  
  25.  
  26.  
  27. // attrib = 0x0000 Normal read/write
  28. //          0x0001 Read Only
  29. //          0x0002 Hidden
  30. //          0x0004 System
  31. //          0x0008 Volume
  32. //          0x0010 Directory, not file
  33. //          0x0020 Archive
  34. int set_attrib(char far *filename,int attrib)
  35.  {
  36.     union REGS regs; struct SREGS sregs;
  37.     int ret;
  38.     regs.h.ah = 0x43;                      /* create Directory */
  39.     regs.h.al = 0x01;
  40.     regs.h.ch = 0x00;
  41.     regs.h.cl = attrib;
  42.     regs.x.dx = FP_OFF(filename);
  43.     sregs.ds = FP_SEG(filename);
  44.     ret = intdosx(®s, ®s, &sregs);
  45.     /* if carry flag is set, there was an error */
  46.     return(regs.x.cflag ? ret : 0);
  47.  }
  48.  
  49.  
  50.  
  51.  
  52. //attrib = 16 directory; 32 for normal file....test for rest?
  53. int get_attrib(char far *filename,int *attrib)
  54.  {
  55.     union REGS regs; struct SREGS sregs;
  56.     int ret;
  57.     regs.h.ah = 0x43;                      /* create Directory */
  58.     regs.h.al = 0x00;
  59.     regs.x.dx = FP_OFF(filename);
  60.     sregs.ds = FP_SEG(filename);
  61.     ret = intdosx(®s, ®s, &sregs);
  62.     *attrib = regs.h.cl;
  63.     /* if carry flag is set, there was an error */
  64.     return(regs.x.cflag ? ret : 0);
  65.  }
  66.  
  67.  
  68. // err = create_dir("DOS"); Has to be a subdirectory of current dir
  69. int create_dir(char far *dirname)
  70.  {
  71.     union REGS regs; struct SREGS sregs;
  72.     int ret;
  73.     regs.h.ah = 0x39;                      /* create Directory */
  74.     regs.x.dx = FP_OFF(dirname);
  75.     sregs.ds = FP_SEG(dirname);
  76.     ret = intdosx(®s, ®s, &sregs);
  77.  
  78.     /* if carry flag is set, there was an error */
  79.     return(regs.x.cflag ? ret : 0);
  80.  }
  81.  
  82.  
  83.  
  84.  
  85.  
  86. // err = change_dir("DOS"); Has to be a subdirectory of current dir
  87. int change_dir(char far *dirname)
  88.  {
  89.     union REGS regs; struct SREGS sregs;
  90.     int ret;
  91.     regs.h.ah = 0x3B;                      /* change Directory */
  92.     regs.x.dx = FP_OFF(dirname);
  93.     sregs.ds = FP_SEG(dirname);
  94.     ret = intdosx(®s, ®s, &sregs);
  95.  
  96.     /* if carry flag is set, there was an error */
  97.     return(regs.x.cflag ? ret : 0);
  98.  }
  99.  
  100.  
  101.  
  102. // err = delete_dir("DOS"); Has to be a subdirectory of current dir
  103. //Also has to be no files in it
  104. int delete_dir(char far *dirname)
  105.  {
  106.     union REGS regs; struct SREGS sregs;
  107.     int ret;
  108.     regs.h.ah = 0x3A;                      /* delete Directory */
  109.     regs.x.dx = FP_OFF(dirname);
  110.     sregs.ds = FP_SEG(dirname);
  111.     ret = intdosx(®s, ®s, &sregs);
  112.  
  113.     /* if carry flag is set, there was an error */
  114.     return(regs.x.cflag ? ret : 0);
  115.  }
  116.  
  117.  
  118.  
  119. // err = delete_file("TC0008.SWP");
  120. int delete_file(char far *filename)
  121.  {
  122.     union REGS regs; struct SREGS sregs;
  123.     int ret;
  124.     regs.h.ah = 0x41;                      /* delete file */
  125.     regs.x.dx = FP_OFF(filename);
  126.     sregs.ds = FP_SEG(filename);
  127.     ret = intdosx(®s, ®s, &sregs);
  128.  
  129.     /* if carry flag is set, there was an error */
  130.     return(regs.x.cflag ? ret : 0);
  131.  }
  132.  
  133.  
  134.  
  135.  
  136.  
  137. //INT 21H AH = 54h Get Verify Flag
  138. //flag set to TRUE Verify on
  139. int Get_Verify(void)
  140. {
  141.    union REGS regs;
  142.    regs.h.ah = 0x54;
  143.    int86(0x21, ®s, ®s);
  144. return regs.h.al;  //0 Verify off
  145. }
  146.  
  147.  
  148.  
  149.  
  150. //INT 21H AH = 33h AL = 06h Get Dos Version
  151. //    printf("%1.2f",(Get_Dos_Version() / 100) );
  152. float Get_Dos_Version(void)
  153. {
  154.    union REGS regs;
  155.    regs.h.al = 0x06;
  156.    regs.h.ah = 0x33;
  157.    int86(0x21, ®s, ®s);
  158. return( (regs.h.bl * 100) + regs.h.bh);
  159. }
  160.  
  161.  
  162.  
  163. //INT 21H AH = 33h AL = 05h Get Startup Drive
  164. //Returns.....0 = A; 1 = B; etc
  165. int Get_Boot_Drive(void)
  166. {
  167.    union REGS regs;
  168.    regs.h.al = 0x05;
  169.    regs.h.ah = 0x33;
  170.    int86(0x21, ®s, ®s);
  171. return regs.h.dl - 1;
  172. }
  173.  
  174.  
  175. //INT 21H AH = 33h AL = 01h Set CTRL+C Check Flag
  176. void Set_CTRL_C(int checking)
  177. {
  178.    union REGS regs;
  179.    switch(checking)
  180.       {
  181.       case TRUE:
  182.       regs.h.dl = 1;
  183.       break;
  184.       case FALSE:
  185.       regs.h.dl = 0;
  186.       break;
  187.       }
  188.    regs.h.al = 0x01;
  189.    regs.h.ah = 0x33;
  190.    int86(0x21, ®s, ®s);
  191. return;
  192. }
  193.  
  194.  
  195. //INT 21H AH = 33h AL = 00h Get CTRL+C Check Flag
  196. int Get_CTRL_C(void)
  197. {
  198.    union REGS regs;
  199.    regs.h.al = 0x00;
  200.    regs.h.ah = 0x33;
  201.    int86(0x21, ®s, ®s);
  202. return regs.h.dl;  //Returns 0 if disabled
  203. }
  204.  
  205.  
  206.  
  207. //INT 21H AH = 2Eh Set/Reset Verify Flag
  208. //flag set to TRUE Verify on
  209. void Set_Verify(int flag)
  210. {
  211.    union REGS regs;
  212.    switch(flag)
  213.     {
  214.     case TRUE:
  215.     regs.h.al = 1;
  216.     break;
  217.  
  218.     case FALSE:
  219.     regs.h.al = 0;
  220.     break;
  221.     }
  222.    regs.h.ah = 0x2E;
  223.    int86(0x21, ®s, ®s);
  224. return;
  225. }
  226.  
  227.  
  228.  
  229.  
  230. //INT 21H AH = 2Dh Set Time
  231. int Set_Time(int Hour,int Min,int Sec)
  232. {
  233.    union REGS regs;
  234.    regs.h.ah = 0x2B;
  235.    regs.h.ch = Hour;
  236.    regs.h.cl = Min;
  237.    regs.h.dh = Sec;
  238.    int86(0x21, ®s, ®s);
  239. return regs.h.al;  //Returns 0 if valid
  240. }
  241.  
  242.  
  243.  
  244.  
  245. //INT 21H AH = 2Ch Get Hour
  246. int Get_Hour(void)
  247. {
  248.    union REGS regs;
  249.    regs.h.ah = 0x2C;
  250.    int86(0x21, ®s, ®s);
  251. return regs.h.ch;
  252. }
  253. //INT 21H AH = 2Ch Get Min
  254. int Get_Min(void)
  255. {
  256.    union REGS regs;
  257.    regs.h.ah = 0x2C;
  258.    int86(0x21, ®s, ®s);
  259. return regs.h.cl;
  260. }
  261. //INT 21H AH = 2Ch Get Sec
  262. int Get_Sec(void)
  263. {
  264.    union REGS regs;
  265.    regs.h.ah = 0x2C;
  266.    int86(0x21, ®s, ®s);
  267. return regs.h.dh;
  268. }
  269. //INT 21H AH = 2Ch Get Hundredths of sec
  270. int Get_Hund_Sec(void)
  271. {
  272.    union REGS regs;
  273.    regs.h.ah = 0x2C;
  274.    int86(0x21, ®s, ®s);
  275. return regs.h.dl;
  276. }
  277.  
  278.  
  279.  
  280. //INT 21H AH = 2Bh Set Date
  281. int Set_Date(int year,int month,int day)
  282. {
  283.    union REGS regs;
  284.    regs.h.ah = 0x2B;
  285.    regs.x.cx = year;
  286.    regs.h.dh = month;
  287.    regs.h.dl = day;
  288.    int86(0x21, ®s, ®s);
  289. return regs.h.al;  //Returns 0 if valid
  290. }
  291.  
  292.  
  293.  
  294. //INT 21H AH = 2Ah Get Date
  295. //See Date structure
  296. void Get_Date(void)
  297. {
  298.    union REGS regs;
  299.    regs.h.ah = 0x2A;
  300.    int86(0x21, ®s, ®s);
  301.    Date.year  = regs.x.cx;
  302.    Date.month = regs.h.dh;
  303.    Date.day   = regs.h.dl;
  304.    switch (regs.h.al)
  305.     {
  306.     case 0:
  307.     strcpy(Date.day_string,"SUNDAY");
  308.     break;
  309.  
  310.     case 1:
  311.     strcpy(Date.day_string,"MONDAY");
  312.     break;
  313.  
  314.     case 2:
  315.     strcpy(Date.day_string,"TUESDAY");
  316.     break;
  317.  
  318.     case 3:
  319.     strcpy(Date.day_string,"WEDNESDAY");
  320.     break;
  321.  
  322.     case 4:
  323.     strcpy(Date.day_string,"THURSDAY");
  324.     break;
  325.  
  326.     case 5:
  327.     strcpy(Date.day_string,"FRIDAY");
  328.     break;
  329.  
  330.     case 6:
  331.     strcpy(Date.day_string,"SATURDAY");
  332.     break;
  333.     }
  334. return;
  335. }
  336.  
  337. //INT 21H AH = 19h Get Current Drive
  338. //drive_num.......0=A, 1=B etc
  339. int Get_Current_Drive(void)
  340. {
  341.    union REGS regs;
  342.    regs.h.ah = 0x19;
  343.    int86(0x21, ®s, ®s);
  344. return regs.h.al;
  345. }
  346.  
  347.  
  348. //INT 21H AH = 0Dh Set Default Drive
  349. //drive_num.......0=A, 1=B etc
  350. //if drive doesn't exist nothing happens no error's etc
  351. void Set_Default_Drive(int drive_num)
  352. {
  353.    union REGS regs;
  354.    regs.h.ah = 0x0E;
  355.    regs.h.dl = drive_num;
  356.    int86(0x21, ®s, ®s);
  357. return;
  358. }
  359.  
  360. //INT 21H AH = 0Dh Reset Drive
  361. //Flushes all file buffers to disk
  362. //It's necessary to close all files to update directory
  363. void Reset_Drive(void)
  364. {
  365.    union REGS regs;
  366.    regs.h.ah = 0x0D;
  367.    int86(0x21, ®s, ®s);
  368. return;
  369. }
  370.  
  371.  
  372.  
  373.  
  374.  
  375. //INT 21H AH = 0Ch Flush Buffer, Read Keyboard
  376. //Waits on a KeyPress before continue
  377. //Doesn't have to press Enter
  378. int Flush_Buffer_Read_Key(int select = 1)//Default to 1
  379. {
  380. union REGS regs;
  381. switch(select)
  382.     {
  383.     case 0:
  384.     regs.h.al = 0x01;  //Read Keyboard with Echo
  385.     break;
  386.  
  387.     case 1:
  388.     regs.h.al = 0x08;  //Read Keyboard without Echo
  389.     break;
  390.     }
  391. regs.h.ah = 0x0C;
  392. int86(0x21, ®s, ®s);
  393. return regs.h.al;
  394. }
  395.  
  396.  
  397.  
  398.  
  399. //INT 21H AH = 0Bh Check Keyboard Status
  400. //Does not get Key from buffer!!!!!!!!!!
  401. //Will continue TRUE until char has been gotten out
  402. int Check_Keyboard(void)
  403. {
  404.    union REGS regs;
  405.    regs.h.ah = 0x0B;
  406.    int86(0x21, ®s, ®s);
  407.    if(regs.h.al != 0x00) return TRUE;
  408. return FALSE;
  409. }
  410.  
  411.  
  412.  
  413.  
  414. //INT 21H AH = 0Bh Check Keyboard Status
  415. //Does not get Key from buffer!!!!!!!!!!
  416. //Will continue TRUE until char has been gotten out
  417. void Kill_Key(void)
  418. {
  419. union REGS regs;
  420. int buff = FALSE;
  421. while(!buff)
  422.    {
  423.    regs.h.ah = 0x08;
  424.    int86(0x21, ®s, ®s);
  425.    buff = regs.h.al;
  426.    if(buff) getch();
  427.    }
  428. return;
  429. }
  430.  
  431.  
  432. //int 21h Ah = 00H Terminate Program
  433. //Closes all File Buffers
  434. //Frees all memaory from calling program
  435. void terminate(void)
  436. {
  437.    union REGS regs;
  438.    regs.h.ah = 0x00;
  439.    int86(0x21, ®s, ®s);
  440. }
  441.  
  442.  
  443. //int 21h Ah = 01H Read Keyboard with echo
  444. //Control-C enabled
  445. //Returns ASCII the number
  446. //Waits till a key is pressed!!!!!!!!!!!!!!
  447. //Displays key and removes it from the keyboard buffer
  448. int Read_Key_Echo_int()
  449. {
  450.    union REGS regs;
  451.    regs.h.ah = 0x01;
  452.    int86(0x21, ®s, ®s);
  453. return regs.h.al;
  454. }
  455. //Returns Character same as above
  456. char Read_Key_Echo_char()
  457. {
  458. char ASCII;
  459.    union REGS regs;
  460.    regs.h.ah = 0x01;
  461.    int86(0x21, ®s, ®s);
  462.    ASCII = regs.h.al;
  463. return ASCII;
  464. }
  465.  
  466. //INT 21 Ah = 02H Display Character
  467. //Cursor position updated
  468. //if Backspace cursor moves to left but char isn't erased.
  469. void Display_Char(int ASCII)
  470. {
  471.    union REGS regs;
  472.    regs.h.ah = 0x02;
  473.    regs.h.dl = ASCII;
  474.    int86(0x21, ®s, ®s);
  475. return;
  476. }
  477. //INT 21 Ah = 02H Display Character
  478. //Cursor position updated
  479. //if Backspace cursor moves to left but char isn't erased.
  480. void Display_Char(char ASCII)
  481. {
  482.    union REGS regs;
  483.    regs.h.ah = 0x02;
  484.    regs.h.dl = ASCII;
  485.    int86(0x21, ®s, ®s);
  486. return;
  487. }
  488.  
  489.  
  490. //INT 21 Ah = 06H Direct Console I/O   STDIN  STDOUT
  491. //if IO_Switch set to IN it will return FALSE if no key is in buffer
  492. //it does not wait to return the key,so of moniters the keyboard.
  493. //If a key is available it will set ASCII varialble to the
  494. //ASCII character number for the keypress
  495. //If IO_Switch is set to OUT I have no ideal?
  496. int Direct_Console_IO(int IO_Switch,int *ASCII)
  497. {
  498.    int SS;
  499.    if(IO_Switch == IN)
  500.     {
  501.     SS = 0xFF;
  502.     }
  503.    else if(IO_Switch == OUT)   //???????????????????????????????
  504.     {
  505.     SS = 0x00;
  506.     }
  507.  
  508.    union REGS regs;
  509.    regs.h.ah = 0x06;
  510.    regs.h.dl = SS;
  511.    int86(0x21, ®s, ®s);
  512.    *ASCII = regs.h.al; //set to 00H if no char avail
  513.    if(regs.x.flags == 13015) return FALSE;
  514. //No return value if OUT requested
  515. return regs.x.flags; //set to 0 if no char available
  516. }                    //& IO_Switch set to IN
  517.  
  518.  
  519.  
  520. //INT 21 Ah = 07H Direct Console Input
  521. //Does not echo char or check for CTRL+C
  522. //WILL WAIT FOR KEYPRESS!!!!!!!!!!!!!!!!!!!!!!!!!1
  523. //Extended ASCII codes require 2 function calls?????????
  524. //RETURNS the ASCII, works with all keys except CTRL,ALT,SHIFT
  525. //But will return ALT+keypress!!!!!!!!!!!!!!!!!!!
  526. int Console_Input(void)
  527. {
  528.    union REGS regs;
  529.    regs.h.ah = 0x07;
  530.    int86(0x21, ®s, ®s);
  531. return regs.h.al;
  532. }
  533.  
  534.  
  535. //INT 21 Ah = 08H Read Keyboard without echo
  536. //Works same as above, waits for keypress
  537. int Read_Key_No_Echo_int(void)
  538. {
  539.    union REGS regs;
  540.    regs.h.ah = 0x08;
  541.    int86(0x21, ®s, ®s);
  542. return regs.h.al;
  543. }
  544. //INT 21 Ah = 08H Read Keyboard without echo
  545. char Read_Key_No_Echo_char(void)
  546. {
  547.    union REGS regs;
  548.    regs.h.ah = 0x08;
  549.    int86(0x21, ®s, ®s);
  550. return regs.h.al;
  551. }
  552.  
  553.