开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
INTHNDLR.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：32k
源码类别：

操作系统开发

开发平台：

DOS

INTHNDLR.C：源码内容
  1. /****************************************************************/
  2. /*                                                              */
  3. /*                          inthndlr.c                          */
  4. /*                                                              */
  5. /*    Interrupt Handler and Function dispatcher for Kernel      */
  6. /*                                                              */
  7. /*                      Copyright (c) 1995                      */
  8. /*                      Pasquale J. Villani                     */
  9. /*                      All Rights Reserved                     */
  10. /*                                                              */
  11. /* This file is part of DOS-C.                                  */
  12. /*                                                              */
  13. /* DOS-C is free software; you can redistribute it and/or       */
  14. /* modify it under the terms of the GNU General Public License  */
  15. /* as published by the Free Software Foundation; either version */
  16. /* 2, or (at your option) any later version.                    */
  17. /*                                                              */
  18. /* DOS-C is distributed in the hope that it will be useful, but */
  19. /* WITHOUT ANY WARRANTY; without even the implied warranty of   */
  20. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
  21. /* the GNU General Public License for more details.             */
  22. /*                                                              */
  23. /* You should have received a copy of the GNU General Public    */
  24. /* License along with DOS-C; see the file COPYING.  If not,     */
  25. /* write to the Free Software Foundation, 675 Mass Ave,         */
  26. /* Cambridge, MA 02139, USA.                                    */
  27. /*                                                              */
  28. /****************************************************************/
  30. #include "../../hdr/portab.h"
  31. #include "globals.h"
  33. #ifdef VERSION_STRINGS
  34. BYTE *RcsId = "$Header:   C:/dos-c/src/kernel/inthndlr.c_v   1.13   07 Feb 1998 20:38:46   patv  $";
  35. #endif
  37. /* $Log:   C:/dos-c/src/kernel/inthndlr.c_v  $
  38.  * 
  39.  *    Rev 1.13   07 Feb 1998 20:38:46   patv
  40.  * Modified stack fram to match DOS standard
  41.  * 
  42.  *    Rev 1.12   22 Jan 1998  4:09:26   patv
  43.  * Fixed pointer problems affecting SDA
  44.  * 
  45.  *    Rev 1.11   06 Jan 1998 20:13:18   patv
  46.  * Broke apart int21_system from int21_handler.
  47.  * 
  48.  *    Rev 1.10   04 Jan 1998 23:15:22   patv
  49.  * Changed Log for strip utility
  50.  * 
  51.  *    Rev 1.9   04 Jan 1998 17:26:16   patv
  52.  * Corrected subdirectory bug
  53.  * 
  54.  *    Rev 1.8   03 Jan 1998  8:36:48   patv
  55.  * Converted data area to SDA format
  56.  * 
  57.  *    Rev 1.7   01 Aug 1997  2:00:10   patv
  58.  * COMPATIBILITY: Added return '$' in AL for function int 21h fn 09h
  59.  * 
  60.  *    Rev 1.6   06 Feb 1997 19:05:54   patv
  61.  * Added hooks for tsc command
  62.  * 
  63.  *    Rev 1.5   22 Jan 1997 13:18:32   patv
  64.  * pre-0.92 Svante Frey bug fixes.
  65.  * 
  66.  *    Rev 1.4   16 Jan 1997 12:46:46   patv
  67.  * pre-Release 0.92 feature additions
  68.  * 
  69.  *    Rev 1.3   29 May 1996 21:03:40   patv
  70.  * bug fixes for v0.91a
  71.  * 
  72.  *    Rev 1.2   19 Feb 1996  3:21:48   patv
  73.  * Added NLS, int2f and config.sys processing
  74.  * 
  75.  *    Rev 1.1   01 Sep 1995 17:54:20   patv
  76.  * First GPL release.
  77.  * 
  78.  *    Rev 1.0   02 Jul 1995  8:33:34   patv
  79.  * Initial revision.
  80.  */
  81. /* $EndLog$ */
  83. #ifdef TSC
  84. static VOID StartTrace(VOID);
  85. static bTraceNext = FALSE;
  86. #endif
  88. extern UWORD Int21AX;
  90. /* Special entry for far call into the kernel                           */
  91. #pragma argsused
  92. VOID FAR 
  93. int21_entry (iregs UserRegs)
  94. {
  95. int21_handler(UserRegs);
  96. }
  99. /* Convert an interrupt into our register struct definition             */
  100. VOID
  101. int21_syscall(iregs FAR *irp)
  102. {
  103. static COUNT FAR *stack;
  104. enable();
  106. if (irp -> AH > 0x67)
  107. {
  108. irp -> AL = 0;
  109. return;
  110. }
  112. Int21AX = irp -> AX;
  114. switch(irp -> AH)
  115. {
  116. /* DosVars - get/set dos variables                              */
  117. case 0x33:
  118. switch(irp -> AL)
  119. {
  120. /* Get Ctrl-C flag                                      */
  121. case 0x00:
  122. irp -> DL = break_ena ? TRUE : FALSE;
  123. break;
  125. /* Set Ctrl-C flag                                      */
  126. case 0x01:
  127. break_ena = irp -> DL ? TRUE : FALSE;
  128. break;
  130. /* Get Boot Drive                                       */
  131. case 0x05:
  132. irp -> DL = BootDrive;
  133. break;
  135. /* Get DOS-C version                                    */
  136. case 0x06:
  137. irp -> BL = os_major;
  138. irp -> BH = os_minor;
  139. irp -> DL = rev_number;
  140. irp -> DH = version_flags;
  141. break;
  142. default:
  143. irp -> AX = -DE_INVLDFUNC;
  144. irp -> FLAGS |= FLG_CARRY;
  145. break;
  147. /* Toggle DOS-C rdwrblock trace dump                    */
  148. case 0xfd:
  149. bDumpRdWrParms = !bDumpRdWrParms;
  150. break;
  152. /* Toggle DOS-C syscall trace dump                      */
  153. case 0xfe:
  154. bDumpRegs = !bDumpRegs;
  155. break;
  157. /* Get DOS-C release string pointer                     */
  158. case 0xff:
  159. irp -> DX = FP_SEG(os_release);
  160. irp -> AX = FP_OFF(os_release);
  161. break;
  162. }
  163. break;
  165. /* Set PSP                                                      */
  166. case 0x50:
  167. cu_psp = irp -> BX;
  168. break;
  170. /* Get PSP                                                      */
  171. case 0x51:
  172. irp -> BX = cu_psp;
  173. break;
  175. /* UNDOCUMENTED: return current psp                             */
  176. case 0x62:
  177. irp -> BX = cu_psp;
  178. break;
  180. /* Normal DOS function - switch stacks          */
  181. default:
  182. ++InDOS;
  183. user_r = irp;
  184. stack = irp -> AH < 0x0c ? &char_api_tos : &disk_api_tos;
  185.      
  186. /* Initialize stacks                                            */
  187. api_sp = FP_OFF(stack);
  188. api_ss = FP_SEG(stack);
  190. set_stack();
  192. int21_service(user_r);
  194. restore_stack();
  195. --InDOS;
  196. }
  197. }
  199. VOID int21_service(iregs far *r)
  200. {
  201. COUNT rc, rc1;
  202. ULONG lrc;
  203. psp FAR *p = MK_FP(cu_psp, 0);
  205. p -> ps_stack = r;
  207. if(bDumpRegs)
  208. {
  209. fbcopy((VOID FAR *)user_r, (VOID FAR *)&error_regs, sizeof(iregs));
  210. printf("System call (21h): %02xn", user_r -> AX);
  211. dump_regs = TRUE;
  212. dump();
  213. }
  215. /* The dispatch handler                                         */
  216. switch(r -> AH)
  217. {
  218. /* int 21h common error handler */
  219. case 0x64:
  220. case 0x6b:
  221. error_invalid:
  222. r -> AX = -DE_INVLDFUNC;
  223. goto error_out;
  224. error_exit:
  225. r -> AX = -rc;
  226. error_out:
  227. r -> FLAGS |= FLG_CARRY;
  228. break;
  230. /* Terminate Program                                            */
  231. case 0x00:
  232. tsr = FALSE;
  233. return_mode = break_flg ? 1 : 0;
  234. return_code = r -> AL;
  235. DosMemCheck();
  236. #ifdef TSC
  237. StartTrace();
  238. #endif
  239. return_user();
  240. break;
  242. /* Read Keyboard with Echo                      */
  243. case 0x01:
  244. r -> AL = DosCharInputEcho();
  245. break;
  247. /* Display Character                                            */
  248. case 0x02:
  249. DosDisplayOutput(r -> DL);
  250. break;
  252. /* Auxiliary Input                                                      */
  253. case 0x03:
  254. r -> AL = _sti();
  255. break;
  257. /* Auxiliary Output                                                     */
  258. case 0x04:
  259. sto(r -> DL);
  260. break;
  262. /* Print Character                                                      */
  263. case 0x05:
  264. sto(r -> DL);
  265. break;
  267. /* Direct Cosole I/O                                            */
  268. case 0x06:
  269. DosDirectConsoleIO(r);
  270. break;
  272. /* Direct Console Input                                         */
  273. case 0x07:
  274. r -> AL = DosCharInput();
  275. break;
  277. /* Read Keyboard Without Echo                                   */
  278. case 0x08:
  279. r -> AL = _sti();
  280. break;
  282. /* Display String                                               */
  283. case 0x09:
  284. DosOutputString(MK_FP(r -> DS, r -> DX));
  285. r -> AL = '$';
  286. break;
  288. /* Buffered Keyboard Input                                      */
  289. case 0x0a:
  290. ((keyboard FAR *)MK_FP(r -> DS, r -> DX)) -> kb_count = 0;
  291. sti((keyboard FAR *)MK_FP(r -> DS, r -> DX));
  292. ((keyboard FAR *)MK_FP(r -> DS, r -> DX)) -> kb_count -= 2;
  293. break;
  295. /* Check Keyboard Status                                        */
  296. case 0x0b:
  297. if(KbdBusy())
  298. r -> AL = 0x00;
  299. else
  300. r -> AL = 0xff;
  302. break;
  304. /* Flush Buffer, Read Keayboard                                 */
  305. case 0x0c:
  306. KbdFlush();
  307. switch(r -> AL)
  308. {
  309. /* Read Keyboard with Echo                      */
  310. case 0x01:
  311. r -> AL = DosCharInputEcho();
  312. break;
  314. /* Direct Cosole I/O                            */
  315. case 0x06:
  316. DosDirectConsoleIO(r);
  317. break;
  319. /* Direct Console Input                         */
  320. case 0x07:
  321. r -> AL = DosCharInput();
  322. break;
  324. /* Read Keyboard Without Echo                   */
  325. case 0x08:
  326. r -> AL = _sti();
  327. break;
  329. /* Buffered Keyboard Input                      */
  330. case 0x0a:
  331. sti((keyboard FAR *)MK_FP(r -> DS, r -> DX));
  332. break;
  334. default:
  335. r -> AL = 0x00;
  336. break;
  337. }
  338. break;
  340. /* Reset Drive                                                  */
  341. case 0x0d:
  342. flush();
  343. break;
  345. /* Set Default Drive                                            */
  346. case 0x0e:
  347. if(((COUNT)r -> DL) >= 0 && r -> DL < nblkdev)
  348. default_drive = r -> DL;
  350. r -> AL = nblkdev;            
  351. break;
  353. case 0x0f:
  354. if(FcbOpen(MK_FP(r -> DS, r -> DX)))
  355. r -> AL = 0;
  356. else
  357. r -> AL = 0xff;
  358. break;
  360. case 0x10:
  361. if(FcbClose(MK_FP(r -> DS, r -> DX)))
  362. r -> AL = 0;
  363. else
  364. r -> AL = 0xff;
  365. break;
  367. case 0x11:
  368. if(FcbFindFirst(MK_FP(r -> DS, r -> DX)))
  369. r -> AL = 0;
  370. else
  371. r -> AL = 0xff;
  372. break;
  374. case 0x12:
  375. if(FcbFindNext(MK_FP(r -> DS, r -> DX)))
  376. r -> AL = 0;
  377. else
  378. r -> AL = 0xff;
  379. break;
  381. case 0x13:
  382. if(FcbDelete(MK_FP(r -> DS, r -> DX)))
  383. r -> AL = 0;
  384. else
  385. r -> AL = 0xff;
  386. break;
  388. case 0x14:
  389. {
  390. COUNT nErrorCode;
  392. if(FcbRead(MK_FP(r -> DS, r -> DX), &nErrorCode))
  393. r -> AL = 0;
  394. else
  395. r -> AL = nErrorCode;
  396. break;
  397. }
  399. case 0x15:
  400. {
  401. COUNT nErrorCode;
  403. if(FcbWrite(MK_FP(r -> DS, r -> DX), &nErrorCode))
  404. r -> AL = 0;
  405. else
  406. r -> AL = nErrorCode;
  407. break;
  408. }
  410. case 0x16:
  411. if(FcbCreate(MK_FP(r -> DS, r -> DX)))
  412. r -> AL = 0;
  413. else
  414. r -> AL = 0xff;
  415. break;
  417. case 0x17:
  418. if(FcbRename(MK_FP(r -> DS, r -> DX)))
  419. r -> AL = 0;
  420. else
  421. r -> AL = 0xff;
  422. break;
  424. /* CP/M compatibility functions                                 */
  425. case 0x18:
  426. case 0x1d:
  427. case 0x1e:
  428. case 0x20:
  429. #ifndef TSC
  430. case 0x61:
  431. #endif
  432. default:
  433. r -> AL = 0;
  434. break;
  436. /* Get Default Drive                                            */
  437. case 0x19:
  438. r -> AL = default_drive;
  439. break;
  441. /* Set DTA                                                      */
  442. case 0x1a:
  443. {
  444. psp FAR *p = MK_FP(cu_psp,0);
  446. p -> ps_dta = MK_FP(r -> DS, r -> DX);
  447. dos_setdta(p -> ps_dta);
  448. }
  449. break;
  451. /* Get Default Drive Data                                       */
  452. case 0x1b:
  453. {
  454. BYTE FAR *p;
  456. FatGetDrvData(0,
  457.  (COUNT FAR *)&r -> AX,
  458.  (COUNT FAR *)&r -> CX,
  459.  (COUNT FAR *)&r -> DX,
  460.  (BYTE FAR **)&p);
  461. r -> DS = FP_SEG(p);
  462. r -> BX = FP_OFF(p);
  463. }
  464. break;
  466. /* Get Drive Data                                               */
  467. case 0x1c:
  468. {
  469. BYTE FAR *p;
  471. FatGetDrvData(r -> DL,
  472.  (COUNT FAR *)&r -> AX,
  473.  (COUNT FAR *)&r -> CX,
  474.  (COUNT FAR *)&r -> DX,
  475.  (BYTE FAR **)&p);
  476. r -> DS = FP_SEG(p);
  477. r -> BX = FP_OFF(p);
  478. }
  479. break;
  481. /* Get default DPB                                              */
  482. case 0x1f:
  483. if (default_drive < nblkdev)
  484. {
  485. struct dpb FAR *dpb = &blk_devices[default_drive];
  486. r -> DS = FP_SEG(dpb);
  487. r -> BX = FP_OFF(dpb);
  488. r -> AL = 0;
  489. }
  490. else r -> AL = 0xff;
  491. break;
  493. case 0x21:
  494. {
  495. COUNT nErrorCode;
  497. if(FcbRandomRead(MK_FP(r -> DS, r -> DX), &nErrorCode))
  498. r -> AL = 0;
  499. else
  500. r -> AL = nErrorCode;
  501. break;
  502. }
  504. case 0x22:
  505. {
  506. COUNT nErrorCode;
  508. if(FcbRandomWrite(MK_FP(r -> DS, r -> DX), &nErrorCode))
  509. r -> AL = 0;
  510. else
  511. r -> AL = nErrorCode;
  512. break;
  513. }
  515. /* Get file size in records                                     */
  516. case 0x23:
  517. if(FcbGetFileSize(MK_FP(r -> DS, r -> DX)))
  518. r -> AL = 0;
  519. else
  520. r -> AL = 0xff;
  521. break;
  523. case 0x24:
  524. FcbSetRandom(MK_FP(r -> DS, r -> DX));
  525. break;
  527. /* Set Interrupt Vector                                         */
  528. case 0x25:
  529. {
  530. VOID (INRPT FAR *p)() = MK_FP(r -> DS, r -> DX);
  533. setvec(r -> AL, p);
  534. }
  535. break;
  537. /* Dos Create New Psp                                           */
  538. case 0x26:
  539. {
  540. psp FAR *p = MK_FP(cu_psp, 0);
  542. new_psp((psp FAR *)MK_FP(r -> DX, 0), p -> ps_size);
  543. }
  544. break;
  546. case 0x27:
  547. {
  548. COUNT nErrorCode;
  550. if(FcbRandomBlockRead(MK_FP(r -> DS, r -> DX), r -> CX, &nErrorCode))
  551. r -> AL = 0;
  552. else
  553. r -> AL = nErrorCode;
  554. break;
  555. }
  557. case 0x28:
  558. {
  559. COUNT nErrorCode;
  561. if(FcbRandomBlockWrite(MK_FP(r -> DS, r -> DX), r -> CX, &nErrorCode))
  562. r -> AL = 0;
  563. else
  564. r -> AL = nErrorCode;
  565. break;
  566. }
  568. /* Parse File Name                                              */
  569. case 0x29:
  570. {
  571. BYTE FAR *lpFileName;
  573. lpFileName = MK_FP(r -> DS, r -> SI);
  574. r -> AL = FcbParseFname(r -> AL,
  575.  &lpFileName,
  576.  MK_FP(r -> ES, r -> DI));
  577. r -> DS = FP_SEG(lpFileName);
  578. r -> SI = FP_OFF(lpFileName);
  579. }
  580. break;
  582. /* Get Date                                                     */
  583. case 0x2a:
  584. DosGetDate(
  585.  (BYTE FAR *)&(r -> AL),        /* WeekDay              */
  586.  (BYTE FAR *)&(r -> DH),        /* Month                */
  587.  (BYTE FAR *)&(r -> DL),        /* MonthDay             */
  588.  (COUNT FAR *)&(r -> CX));      /* Year                 */
  589. break;
  591. /* Set Date                                                     */
  592. case 0x2b:
  593. rc = DosSetDate(
  594.  (BYTE FAR *)&(r -> DH),        /* Month                */
  595.  (BYTE FAR *)&(r -> DL),        /* MonthDay             */
  596.  (COUNT FAR *)&(r -> CX));      /* Year                 */
  597. if(rc != SUCCESS)
  598. r -> AL = 0xff;
  599. else
  600. r -> AL = 0;
  601. break;
  603. /* Get Time                                                     */
  604. case 0x2c:
  605. DosGetTime(
  606.  (BYTE FAR *)&(r -> CH),        /* Hour                 */
  607.  (BYTE FAR *)&(r -> CL),        /* Minutes              */
  608.  (BYTE FAR *)&(r -> DH),        /* Seconds              */
  609.  (BYTE FAR *)&(r -> DL));       /* Hundredths           */
  610. break;
  612. /* Set Date                                                     */
  613. case 0x2d:
  614. rc = DosSetTime(
  615.  (BYTE FAR *)&(r -> CH),        /* Hour                 */
  616.  (BYTE FAR *)&(r -> CL),        /* Minutes              */
  617.  (BYTE FAR *)&(r -> DH),        /* Seconds              */
  618.  (BYTE FAR *)&(r -> DL));       /* Hundredths           */
  619. if(rc != SUCCESS)
  620. r -> AL = 0xff;
  621. else
  622. r -> AL = 0;
  623. break;
  625. /* Set verify flag                                              */
  626. case 0x2e:
  627. verify_ena = (r -> AL ? TRUE : FALSE);
  628. break;
  630. /* Get DTA                                                      */
  631. case 0x2f:
  632. r -> ES = FP_SEG(dta);
  633. r -> BX = FP_OFF(dta);
  634. break;
  636. /* Get DOS Version                                              */
  637. case 0x30:
  638. r -> AL = os_major;
  639. r -> AH = os_minor;
  641. switch(r -> AL)
  642. {
  643. default:
  644. case 0:
  645. r -> BH= OEM_ID;
  646. break;
  648. case 1:
  649. r -> BH = 0;    /* RAM only for now             */
  650. break;
  651. }
  652. r -> BL = 0xff;         /* for now                      */
  653. r -> CX = 0xffff;
  654. break;
  656. /* Keep Program                                                 */
  657. case 0x31:
  658. DosMemChange(cu_psp, r -> DX < 6 ? 6 : r -> DX, 0);
  659. //flush();
  660. return_mode = 3;
  661. return_code = r -> AL;
  662. tsr = TRUE;
  663. return_user();
  664. break;
  666. /* Get DPB                                                      */
  667. case 0x32:
  668. if (r -> DL < nblkdev)
  669. {
  670. struct dpb FAR *dpb = &blk_devices[r -> DL];
  671. r -> DS = FP_SEG(dpb);
  672. r -> BX = FP_OFF(dpb);
  673. r -> AL = 0;
  674. } else r->AL = 0xFF;
  675. break;
  677. /* Get InDOS flag                                               */
  678. case 0x34:
  679. {
  680. BYTE FAR *p;
  682. p = (BYTE FAR *)((BYTE *)&InDOS);
  683. r -> ES = FP_SEG(p);
  684. r -> BX = FP_OFF(p);
  685. }
  686. break;
  688. /* Get Interrupt Vector                                         */
  689. case 0x35:
  690. {
  691. BYTE FAR *p;
  693. p = getvec((COUNT)r -> AL);
  694. r -> ES = FP_SEG(p);
  695. r -> BX = FP_OFF(p);
  696. }
  697. break;
  699. /* Dos Get Disk Free Space                                      */
  700. case 0x36:
  701. DosGetFree(
  702. (COUNT)r -> DL,
  703. (COUNT FAR *)&r -> AX,
  704. (COUNT FAR *)&r -> BX,
  705. (COUNT FAR *)&r -> CX,
  706. (COUNT FAR *)&r -> DX);
  707. break;
  709. /* Undocumented Get/Set Switchar                                */
  710. case 0x37:
  711. switch(r -> AL)
  712. {
  713. case 0:
  714. r -> DL = switchar;
  715. break;
  717. case 1:
  718. switchar = r -> DL;
  719. break;
  721. case 2:
  722. case 3:
  723. r -> DL = 0xff;
  724. break;
  726. default:
  727. goto error_invalid;
  728. }
  729. break;
  731. /* Get/Set Country Info                                         */
  732. case 0x38:
  733. {
  734. BYTE FAR *lpTable
  735. = (BYTE FAR *)MK_FP(r -> DS, r -> DX);
  736. BYTE nRetCode;
  738. if(0xffff == r -> DX)
  739. {
  740. r->AX = 0xff;
  741. r->FLAGS |= FLG_CARRY;
  742. break;
  744. r -> BX = SetCtryInfo(
  745. (UBYTE FAR *)&(r -> AL),
  746. (UWORD FAR *)&(r -> BX),
  747. (BYTE FAR *)&lpTable,
  748. (UBYTE *)&nRetCode);
  750. if(nRetCode != 0)
  751. {
  752. r -> AX = 0xff;
  753. r -> FLAGS |= FLG_CARRY;
  754. }
  755. else
  756. {
  757. r -> AX = nRetCode;
  758. r -> FLAGS &= ~FLG_CARRY;
  759. }
  760. }
  761. else
  762. {
  763. r -> BX = GetCtryInfo(&(r -> AL), &(r -> BX), lpTable);
  764. r -> FLAGS &= ~FLG_CARRY;
  765. }
  766. }
  767. break;
  769. /* Dos Create Directory                                         */
  770. case 0x39:
  771. rc = dos_mkdir((BYTE FAR *)MK_FP(r -> DS, r -> DX));
  772. if(rc != SUCCESS)
  773. goto error_exit;
  774. else
  775. {
  776. r -> FLAGS &= ~FLG_CARRY;
  777. }
  778. break;
  780. /* Dos Remove Directory                                         */
  781. case 0x3a:
  782. rc = dos_rmdir((BYTE FAR *)MK_FP(r -> DS, r -> DX));
  783. if(rc != SUCCESS)
  784. goto error_exit;
  785. else
  786. {
  787. r -> FLAGS &= ~FLG_CARRY;
  788. }
  789. break;
  791. /* Dos Change Directory                                         */
  792. case 0x3b:
  793. if((rc = DosChangeDir((BYTE FAR *)MK_FP(r -> DS, r -> DX))) < 0)
  794. goto error_exit;
  795. else
  796. {
  797. r -> FLAGS &= ~FLG_CARRY;
  798. }
  799. break;
  801. /* Dos Create File                                              */
  802. case 0x3c:
  803. if((rc = DosCreat(MK_FP(r -> DS, r -> DX), r -> CX)) < 0)
  804. goto error_exit;
  805. else
  806. {
  807. r -> AX = rc;
  808. r -> FLAGS &= ~FLG_CARRY;
  809. }
  810. break;
  812. /* Dos Open                                                     */
  813. case 0x3d:
  814. if((rc = DosOpen(MK_FP(r -> DS, r -> DX), r -> AL)) < 0)
  815. goto error_exit;
  816. else
  817. {
  818. r -> AX = rc;
  819. r -> FLAGS &= ~FLG_CARRY;
  820. }
  821. break;
  823. /* Dos Close                                                    */
  824. case 0x3e:
  825. if((rc = DosClose(r -> BX)) < 0)
  826. goto error_exit;
  827. else
  828. r -> FLAGS &= ~FLG_CARRY;
  829. break;
  831. /* Dos Read                                                     */
  832. case 0x3f:
  833. rc = DosRead(r -> BX, r -> CX, MK_FP(r -> DS, r -> DX), (COUNT FAR *)&rc1);
  835. if(rc1 != SUCCESS)
  836. {
  837. r -> FLAGS |= FLG_CARRY;
  838. r -> AX = -rc1;
  839. }
  840. else
  841. {
  842. r -> FLAGS &= ~FLG_CARRY;
  843. r -> AX = rc;
  844. }
  845. break;
  847. /* Dos Write                                                    */
  848. case 0x40:
  849. rc = DosWrite(r -> BX, r -> CX, MK_FP(r -> DS, r -> DX), (COUNT FAR *)&rc1);
  850. if(rc1 != SUCCESS)
  851. {
  852. r -> FLAGS |= FLG_CARRY;
  853. r -> AX = -rc1;
  854. }
  855. else
  856. {
  857. r -> FLAGS &= ~FLG_CARRY;
  858. r -> AX = rc;
  859. }
  860. break;
  862. /* Dos Delete File                                              */
  863. case 0x41:
  864. rc = dos_delete((BYTE FAR *)MK_FP(r -> DS, r -> DX));
  865. if(rc < 0)
  866. {
  867. r -> FLAGS |= FLG_CARRY;
  868. r -> AX = -rc1;
  869. }
  870. else
  871. r -> FLAGS &= ~FLG_CARRY;
  872. break;
  874. /* Dos Seek                                                     */
  875. case 0x42:
  876. if((rc = DosSeek(r -> BX, (LONG)((((LONG)(r -> CX)) << 16) + r -> DX), r -> AL, &lrc)) < 0)
  877. goto error_exit;
  878. else
  879. {
  880. r -> DX = (lrc >> 16);
  881. r -> AX = lrc & 0xffff;
  882. r -> FLAGS &= ~FLG_CARRY;
  883. }
  884. break;
  886. /* Get/Set File Attributes                                      */
  887. case 0x43:
  888. switch(r -> AL)
  889. {
  890. case 0x00:
  891. rc = DosGetFattr((BYTE FAR *)MK_FP(r -> DS, r -> DX), (UWORD FAR *)&r -> CX);
  892. if(rc < SUCCESS)
  893. goto error_exit;
  894. else
  895. {
  896. r -> FLAGS &= ~FLG_CARRY;
  897. }
  898. break;
  900. case 0x01:
  901. rc = DosSetFattr((BYTE FAR *)MK_FP(r -> DS, r -> DX), (UWORD FAR *)&r -> CX);
  902. if(rc != SUCCESS)
  903. goto error_exit;
  904. else
  905. r -> FLAGS &= ~FLG_CARRY;
  906. break;
  908. default:
  909. goto error_invalid;
  910. break;
  911. }
  912. break;
  914. /* Device I/O Control                                           */
  915. case 0x44:
  916. {
  917. BOOL bNoChangeAx;
  919. bNoChangeAx = ((r -> AL == 0) || (r -> AL == 1));
  920. rc = DosDevIOctl(r, (COUNT FAR *)&rc1);
  922. if(rc1 != SUCCESS)
  923. {
  924. r -> FLAGS |= FLG_CARRY;
  925. r -> AX = -rc1;
  926. }
  927. else
  928. {
  929. r -> FLAGS &= ~FLG_CARRY;
  930. //if(!bNoChangeAx)
  931. //   r -> AX = rc;
  932. }
  933. }
  934. break;
  936. /* Duplicate File Handle                                        */
  937. case 0x45:
  938. rc = DosDup(r -> BX);
  939. if(rc < SUCCESS)
  940. goto error_exit;
  941. else
  942. {
  943. r -> FLAGS &= ~FLG_CARRY;
  944. r -> AX = rc;
  945. }
  946. break;
  948. /* Force Duplicate File Handle                                  */
  949. case 0x46:
  950. rc = DosForceDup(r -> BX, r -> CX);
  951. if(rc < SUCCESS)
  952. goto error_exit;
  953. else
  954. r -> FLAGS &= ~FLG_CARRY;
  955. break;
  957. /* Get Current Directory                                        */
  958. case 0x47:
  959. if((rc = DosGetCuDir(r -> DL, MK_FP(r -> DS, r -> SI))) < 0)
  960. goto error_exit;
  961. else
  962. {
  963. r -> FLAGS &= ~FLG_CARRY;
  964. }
  965. break;
  967. /* Memory management                                            */
  968. case 0x48:
  969. if((rc = DosMemAlloc(r -> BX, mem_access_mode, &(r -> AX), &(r -> BX))) < 0)
  970. {
  971. DosMemLargest(&(r -> BX));
  972. goto error_exit;
  973. }
  974. else
  975. {
  976. ++(r -> AX);
  977. r -> FLAGS &= ~FLG_CARRY;
  978. }
  979. break;
  982. case 0x49:
  983. if((rc = DosMemFree(--(r -> ES))) < 0)
  984. goto error_exit;
  985. else
  986. r -> FLAGS &= ~FLG_CARRY;
  987. break;
  989. case 0x4a:
  990. {
  991. UWORD maxSize;
  993. if((rc = DosMemChange(r -> ES, r -> BX, &maxSize)) < 0)
  994. {
  995. if (rc == DE_NOMEM)
  996. r -> BX = maxSize;
  998. #if 0
  999. if(cu_psp == r -> ES)
  1000. {
  1002. psp FAR *p;
  1004. p = MK_FP(cu_psp, 0);
  1005. p -> ps_size = r -> BX + cu_psp;
  1006. }
  1007. #endif
  1008. goto error_exit;
  1009. }
  1010. else
  1011. r -> FLAGS &= ~FLG_CARRY;
  1013. break;
  1014. }
  1016. /* Load and Execute Program                                     */
  1017. case 0x4b:
  1018. break_flg = FALSE;
  1020. if((rc = DosExec(r -> AL, MK_FP(r -> ES, r -> BX), MK_FP(r -> DS, r -> DX))) 
  1021. != SUCCESS)
  1022. goto error_exit;
  1023. else
  1024. r -> FLAGS &= ~FLG_CARRY;
  1025. break;
  1027. /* End Program                                                  */
  1028. case 0x4c:
  1029. tsr = FALSE;
  1030. return_mode = break_flg ? 1 : 0;
  1031. return_code = r -> AL;
  1032. DosMemCheck();
  1033. #ifdef TSC
  1034. StartTrace();
  1035. #endif
  1036. return_user();
  1037. break;
  1039. /* Get Child-program Return Value                               */
  1040. case 0x4d:
  1041. r -> AL = return_code;
  1042. r -> AH = return_mode;
  1043. break;
  1045. /* Dos Find First                                               */
  1046. case 0x4e:
  1047. {
  1048. psp FAR *p = MK_FP(cu_psp,0);
  1049. /* dta for this call is set on entry.  This     */
  1050. /* needs to be changed for new versions.        */
  1052. if((rc = DosFindFirst((UCOUNT)r -> CX, (BYTE FAR *)MK_FP(r -> DS, r -> DX))) < 0)
  1053. goto error_exit;
  1054. else
  1055. {
  1056. r -> AX = 0;
  1057. r -> FLAGS &= ~FLG_CARRY;
  1058. }
  1059. }
  1060. break;
  1062. /* Dos Find Next                                                */
  1063. case 0x4f:
  1064. {
  1065. psp FAR *p = MK_FP(cu_psp,0);
  1067. /* dta for this call is set on entry.  This     */
  1068. /* needs to be changed for new versions.        */
  1070. if((rc = DosFindNext()) < 0)
  1071. {
  1072. r -> AX = -rc;
  1074. if (r -> AX == 2)
  1075. r -> AX = 18;
  1077. r -> FLAGS |= FLG_CARRY;
  1078. }
  1079. else
  1080. {
  1081. r -> FLAGS &= ~FLG_CARRY;
  1082. }
  1083. }
  1084. break;
  1086. /* Set PSP                                                      */
  1087. case 0x50:
  1088. cu_psp = r -> BX;
  1089. break;
  1091. /* Get PSP                                                      */
  1092. case 0x51:
  1093. r -> BX = cu_psp;
  1094. break;
  1096. /* ************UNDOCUMENTED**************************************/
  1097. /* Get List of Lists                                            */
  1098. case 0x52:
  1099. {
  1100. BYTE FAR *p;
  1102. p = (BYTE FAR *)&DPBp;
  1103. r -> ES = FP_SEG(p);
  1104. r -> BX = FP_OFF(p);
  1105. }
  1106. break;
  1108. /* Get verify state                                             */
  1109. case 0x54:
  1110. r -> AL = (verify_ena ? TRUE : FALSE);
  1111. break;
  1113. /* ************UNDOCUMENTED**************************************/
  1114. /* Dos Create New Psp & set p_size                              */
  1115. case 0x55:
  1116. new_psp((psp FAR *)MK_FP(r -> DX, 0), r -> SI);
  1117. break;
  1119. /* Dos Rename                                                   */
  1120. case 0x56:
  1121. rc = dos_rename(
  1122.  (BYTE FAR *)MK_FP(r -> DS, r -> DX),   /* OldName      */
  1123.  (BYTE FAR *)MK_FP(r -> ES, r -> DI));  /* NewName      */
  1124. if(rc < SUCCESS)
  1125. goto error_exit;
  1126. else
  1127. {
  1128. r -> FLAGS &= ~FLG_CARRY;
  1129. }
  1130. break;
  1132. /* Get/Set File Date and Time                                   */
  1133. case 0x57:
  1134. switch(r -> AL)
  1135. {
  1136. case 0x00:
  1137. if(!DosGetFtime(
  1138.  (COUNT)r -> BX,        /* Handle               */
  1139.  (date FAR *)&r -> DX,  /* FileDate             */
  1140.  (time FAR *)&r -> CX)) /* FileTime             */
  1141. {
  1142. r -> AX = -DE_INVLDHNDL;
  1143. r -> FLAGS |= FLG_CARRY;
  1144. }
  1145. else
  1146. r -> FLAGS &= ~FLG_CARRY;
  1147. break;
  1149. case 0x01:
  1150. if(!DosSetFtime(
  1151.  (COUNT)r -> BX,        /* Handle               */
  1152.  (date FAR *)&r -> DX,  /* FileDate             */
  1153.  (time FAR *)&r -> CX)) /* FileTime             */
  1154. {
  1155. r -> AX = -DE_INVLDHNDL;
  1156. r -> FLAGS |= FLG_CARRY;
  1157. }
  1158. else
  1159. r -> FLAGS &= ~FLG_CARRY;
  1160. break;
  1162. default:
  1163. goto error_invalid;
  1164. }
  1165. break;
  1168. /* Get/Set Allocation Strategy                                  */
  1169. case 0x58:
  1170. switch(r -> AL)
  1171. {
  1172. case 0x00:
  1173. r -> AX = mem_access_mode;
  1174. break;
  1176. case 0x01:
  1177. if(((COUNT)r -> BX) < 0 || r -> BX > 2)
  1178. goto error_invalid;
  1179. else
  1180. {
  1181. mem_access_mode = r -> BX;
  1182. r -> FLAGS &= ~FLG_CARRY;
  1183. }
  1184. break;
  1186. default:
  1187. goto error_invalid;
  1188. #ifdef DEBUG
  1189. case 0xff:
  1190. show_chain();
  1191. break;
  1192. #endif
  1193. }
  1194. break;
  1196. case 0x5a:
  1197. if((rc = DosMkTmp(MK_FP(r -> DS, r -> DX), r -> CX)) < 0)
  1198. goto error_exit;
  1199. else
  1200. {
  1201.  r -> AX = rc;
  1202.  r -> FLAGS &= ~FLG_CARRY;
  1203. }
  1204. break;
  1206. case 0x5b:
  1208. if((rc = DosOpen(MK_FP(r -> DS, r -> DX), 0)) >= 0)
  1209. {
  1210. DosClose(rc);
  1211. r -> AX = 80;
  1212. r -> FLAGS |= FLG_CARRY;
  1213. } 
  1214. else 
  1215. {
  1216.    if((rc = DosCreat(MK_FP(r -> DS, r -> DX), r -> CX)) < 0)
  1217. goto error_exit;
  1218.    else
  1219.    {
  1220. r -> AX = rc;
  1221. r -> FLAGS &= ~FLG_CARRY;
  1222.    }
  1223. }
  1224. break;
  1226. /* UNDOCUMENTED: server, share.exe and sda function */
  1227. case 0x5d:
  1228. switch(r -> AL)
  1229. {
  1230. case 0x06:
  1231. r -> DS = FP_SEG(internal_data);
  1232. r -> SI = FP_OFF(internal_data);
  1233. r -> CX = swap_always - internal_data;
  1234. r -> DX = swap_indos - internal_data;
  1235. r -> FLAGS &= ~FLG_CARRY;
  1236. break;
  1238. default:
  1239. goto error_invalid;
  1240. }
  1242. case 0x60:      /* TRUENAME */
  1243. if ((rc = truename(MK_FP(r -> DS, r-> SI),
  1244.  adjust_far(MK_FP( r -> ES, r -> DI)))) != SUCCESS)
  1245. goto error_exit;
  1246. else
  1247. {
  1248. r -> FLAGS &= ~FLG_CARRY;
  1249. }
  1250. break;
  1252. #ifdef TSC
  1253. /* UNDOCUMENTED: no-op */
  1254. /* */
  1255. /* DOS-C: tsc support */
  1256. case 0x61:
  1257. switch(r -> AL)
  1258. {
  1259. case 0x01:
  1260. bTraceNext = TRUE;
  1261. break;
  1263. case 0x02:
  1264. bDumpRegs = FALSE;
  1265. break;
  1266. }
  1267. #endif
  1268. break;
  1270. /* UNDOCUMENTED: return current psp                             */
  1271. case 0x62:
  1272. r -> BX = cu_psp;
  1273. break;
  1275. /* UNDOCUMENTED: Double byte and korean tables                  */
  1276. case 0x63:
  1277. {
  1278. #ifdef DBLBYTE
  1279. static char dbcsTable[2] = 
  1280. {
  1281. 0, 0
  1282. };
  1283. void FAR *dp = &dbcsTable;
  1285. r -> DS = FP_SEG(dp);
  1286. r -> SI = FP_OFF(dp);
  1287. r -> AL = 0;
  1288. #else
  1289. /* not really supported, but will pass. */
  1290. r -> AL = 0xff;
  1291. #endif
  1292. break;
  1293. }
  1295. /* Extended country info                                        */
  1296. case 0x65:
  1297. if(r -> AL <= 0x7)
  1298. {
  1299. if(ExtCtryInfo(
  1300. r -> AL,
  1301. r -> BX,
  1302. r -> CX,
  1303. MK_FP(r -> ES, r -> DI)))
  1304. r -> FLAGS &= ~FLG_CARRY;
  1305. else
  1306. goto error_invalid;
  1307. }
  1308. else if((r -> AL >= 0x20) && (r -> AL <= 0x22))
  1309. {
  1310. switch(r -> AL)
  1311. {
  1312. case 0x20:
  1313. r -> DL = upChar(r -> DL);
  1314. goto okay;
  1316. case 0x21:
  1317. upMem(
  1318. MK_FP(r -> DS, r -> DX),
  1319. r -> CX);
  1320. goto okay;
  1322. case 0x22:
  1323. upString(MK_FP(r -> DS, r -> DX));
  1324. okay:
  1325. r -> FLAGS &= ~FLG_CARRY;
  1326. break;
  1328. case 0x23:
  1329. r -> AX = yesNo(r -> DL);
  1330. goto okay;
  1332. default:
  1333. goto error_invalid;
  1334. }
  1335. }
  1336. else
  1337. r -> FLAGS |= FLG_CARRY;
  1338. break;
  1340. case 0x66:
  1341. switch(r -> AL)
  1342. {
  1343. case 1:
  1344. GetGlblCodePage(
  1345. (UWORD FAR *)&(r -> BX),
  1346. (UWORD FAR *)&(r -> DX));
  1347. goto okay_66;
  1349. case 2:
  1350. SetGlblCodePage(
  1351. (UWORD FAR *)&(r -> BX),
  1352. (UWORD FAR *)&(r -> DX));
  1353. okay_66:
  1354. r -> FLAGS &= ~FLG_CARRY;
  1355. break;
  1357. default:
  1358. goto error_invalid;
  1359. }
  1360. break;
  1361. case 0x67: 
  1362. if ((rc = SetJFTSize( r -> BX)) != SUCCESS)
  1363. goto error_exit;
  1364. else
  1365. {
  1366. r -> FLAGS &= ~FLG_CARRY;
  1367. }
  1368. break;
  1369. }
  1371. if(bDumpRegs)
  1372. {
  1373. fbcopy((VOID FAR *)user_r  , (VOID FAR *)&error_regs,
  1374.  sizeof(iregs));
  1375. dump_regs = TRUE;
  1376. dump();
  1377. }
  1378. }
  1382. VOID INRPT FAR 
  1383. int22_handler (void)
  1384. {
  1385. }
  1387. #pragma argsused
  1388. VOID INRPT FAR 
  1389. int23_handler (int es, int ds, int di, int si, int bp, int sp, int bx, int dx, int cx, int ax, int ip, int cs, int flags)
  1390. {
  1391. tsr = FALSE;
  1392. return_mode = 1;
  1393. return_code = -1;
  1394. mod_sto(CTL_C);
  1395. DosMemCheck();
  1396. #ifdef TSC
  1397. StartTrace();
  1398. #endif
  1399. return_user();
  1400. }
  1403. #pragma argsused
  1404. VOID INRPT FAR 
  1405. int24_handler (void)
  1406. {
  1407. }
  1409. /* Structures needed for int 25 / int 26 */
  1410. struct  HugeSectorBlock
  1411. {
  1412. ULONG   blkno;  
  1413. WORD    nblks;
  1414. BYTE    FAR *buf;
  1415. };
  1417. struct  int25regs
  1418. {
  1419. UWORD   es, ds;
  1420. UWORD   di, si, bp, sp;
  1421. UWORD   bx, dx, cx, ax;
  1422. UWORD   flags, ip, cs;
  1423. };
  1425. /* this function is called from an assembler wrapper function */ 
  1426. VOID    int25_handler (struct int25regs FAR *r)
  1427. {
  1428. ULONG   blkno;
  1429. UWORD   nblks;
  1430. BYTE    FAR *buf;
  1431. UBYTE   drv = r->ax & 0xFF;
  1433. InDOS++;
  1435. if (r->cx == 0xFFFF)
  1436. {
  1437. struct HugeSectorBlock FAR *lb = MK_FP(r->ds, r->bx);
  1438. blkno = lb->blkno;
  1439. nblks = lb->nblks;
  1440. buf = lb->buf;
  1441. } else {
  1442. nblks = r->cx;
  1443. blkno = r->dx;
  1444. buf = MK_FP(r->ds, r->bx);
  1445. }
  1447. if (drv >= nblkdev)
  1448. {
  1449. r->ax = 0x202; 
  1450. r->flags |= FLG_CARRY; 
  1451. return;
  1452. }
  1455. while (nblks--)
  1456. {
  1457. struct buffer FAR *bp;
  1459. if ((bp = getblock(blkno + 1, drv)) == NULL) 
  1460. {
  1461. r->ax = 0x202; 
  1462. r->flags |= FLG_CARRY; 
  1463. return;
  1464. }
  1465. fbcopy(bp->b_buffer, buf, maxbksize);
  1466. buf += maxbksize;
  1467. blkno++;
  1468. }
  1469. r->ax = 0;
  1470. r->flags &= ~FLG_CARRY;
  1471. --InDOS;
  1472. }
  1474. VOID int26_handler (struct int25regs FAR *r)
  1475. {
  1476. ULONG   blkno;
  1477. UWORD   nblks;
  1478. BYTE    FAR *buf;
  1479. UBYTE    drv = r->ax & 0xFF;
  1481. InDOS++;
  1483. if (r->cx == 0xFFFF)
  1484. {
  1485. struct HugeSectorBlock FAR *lb = MK_FP(r->ds, r->bx);
  1486. blkno = lb->blkno;
  1487. nblks = lb->nblks;
  1488. buf = lb->buf;
  1489. } else {
  1490. nblks = r->cx;
  1491. blkno = r->dx;
  1492. buf = MK_FP(r->ds, r->bx);
  1493. }
  1495. if (drv >= nblkdev)
  1496. {
  1497. r->ax = 0x202;
  1498. r->flags |= FLG_CARRY;
  1499. return;
  1500. }
  1502. while (nblks--)
  1503. {
  1504. struct buffer FAR *b;
  1506. getbuf(&b, blkno + 1, drv);
  1507. fbcopy(buf, b->b_buffer, maxbksize);
  1508. b -> b_flag |= (BFR_DIRTY | BFR_VALID);
  1509. b -> b_blkno = blkno + 1;
  1510. b -> b_unit = drv;
  1512. if (flush1(b) == FALSE)
  1513. {
  1514. r->ax = 0x202; 
  1515. r->flags |= FLG_CARRY;
  1516. return;
  1517. }
  1519. buf += maxbksize;
  1520. blkno++;
  1521. }
  1522. r->ax = 0;
  1523. r->flags &= ~FLG_CARRY;
  1524. --InDOS;
  1525. }
  1528. VOID INRPT FAR 
  1529. int28_handler (void)
  1530. {
  1531. }
  1534. VOID INRPT FAR
  1535. empty_handler (void)
  1536. {
  1537. }
  1540. #ifdef TSC
  1541. static VOID StartTrace(VOID)
  1542. {
  1543. if(bTraceNext)
  1544. {
  1545. bDumpRegs = TRUE;
  1546. bTraceNext = FALSE;
  1547. }
  1548. else
  1549. bDumpRegs = FALSE;
  1550. }
  1551. #endif