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

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

操作系统开发

开发平台：

DOS

FCBFNS.C：源码内容
  2. /****************************************************************/
  3. /*                                                              */
  4. /*                          fcbfns.c                            */
  5. /*                                                              */
  6. /*           Old CP/M Style Function Handlers for Kernel        */
  7. /*                                                              */
  8. /*                      Copyright (c) 1995                      */
  9. /*                      Pasquale J. Villani                     */
  10. /*                      All Rights Reserved                     */
  11. /*                                                              */
  12. /* This file is part of DOS-C.                                  */
  13. /*                                                              */
  14. /* DOS-C is free software; you can redistribute it and/or       */
  15. /* modify it under the terms of the GNU General Public License  */
  16. /* as published by the Free Software Foundation; either version */
  17. /* 2, or (at your option) any later version.                    */
  18. /*                                                              */
  19. /* DOS-C is distributed in the hope that it will be useful, but */
  20. /* WITHOUT ANY WARRANTY; without even the implied warranty of   */
  21. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
  22. /* the GNU General Public License for more details.             */
  23. /*                                                              */
  24. /* You should have received a copy of the GNU General Public    */
  25. /* License along with DOS-C; see the file COPYING.  If not,     */
  26. /* write to the Free Software Foundation, 675 Mass Ave,         */
  27. /* Cambridge, MA 02139, USA.                                    */
  28. /****************************************************************/
  30. #include "../../hdr/portab.h"
  31. #include "globals.h"
  33. /* $Logfile:   C:/dos-c/src/fs/fcbfns.c_v  $ */
  34. #ifdef VERSION_STRINGS
  35. static BYTE *RcsId = "$Header:   C:/dos-c/src/fs/fcbfns.c_v   1.6   04 Jan 1998 23:14:38   patv  $";
  36. #endif
  38. /* $Log:   C:/dos-c/src/fs/fcbfns.c_v  $
  39.  * 
  40.  *    Rev 1.6   04 Jan 1998 23:14:38   patv
  41.  * Changed Log for strip utility
  42.  * 
  43.  *    Rev 1.5   03 Jan 1998  8:36:02   patv
  44.  * Converted data area to SDA format
  45.  * 
  46.  *    Rev 1.4   16 Jan 1997 12:46:38   patv
  47.  * pre-Release 0.92 feature additions
  48.  * 
  49.  *    Rev 1.3   29 May 1996 21:15:14   patv
  50.  * bug fixes for v0.91a
  51.  * 
  52.  *    Rev 1.2   01 Sep 1995 17:48:44   patv
  53.  * First GPL release.
  54.  * 
  55.  *    Rev 1.1   30 Jul 1995 20:50:26   patv
  56.  * Eliminated version strings in ipl
  57.  * 
  58.  *    Rev 1.0   02 Jul 1995  8:06:06   patv
  59.  * Initial revision.
  60.  */
  61. /* $EndLog$ */
  63. #define FCB_SUCCESS     0
  64. #define FCB_ERR_NODATA  1
  65. #define FCB_ERR_EOF     3
  66. #define FCB_ERR_WRITE   1
  67. #define D_ALL   D_NORMAL | D_RDONLY | D_HIDDEN | D_SYSTEM | D_DIR | D_ARCHIVE
  69. #ifdef PROTO
  70. fcb FAR *ExtFcbToFcb(xfcb FAR *lpExtFcb);
  71. fcb FAR *CommonFcbInit(xfcb FAR *lpExtFcb, BYTE *pszBuffer, COUNT *pCurDrive);
  72. void FcbNameInit(fcb FAR *lpFcb, BYTE *pszBuffer, COUNT *pCurDrive);
  73. sft FAR *FcbGetSft(COUNT SftIndex);
  74. VOID FcbNextRecord(fcb FAR *lpFcb);
  75. sft FAR *FcbGetFreeSft(WORD FAR *sft_idx);
  76. BOOL FcbFnameMatch(BYTE FAR *s, BYTE FAR *d, COUNT n, COUNT mode);
  77. BOOL FcbCharMatch(COUNT s, COUNT d, COUNT mode);
  78. BOOL FcbCalcRec(xfcb FAR *lpXfcb);
  79. VOID MoveDirInfo(dmatch FAR *lpDmatch, struct dirent FAR *lpDir);
  80. #else
  81. fcb FAR *ExtFcbToFcb();
  82. fcb FAR *CommonFcbInit();
  83. void FcbNameInit();
  84. sft FAR *FcbGetSft();
  85. VOID FcbNextRecord();
  86. sft FAR *FcbGetFreeSft();
  87. BOOL FcbFnameMatch();
  88. BOOL FcbCharMatch();
  89. BOOL FcbCalcRec();
  90. VOID MoveDirInfo();
  91. #endif
  93. static dmatch Dmatch;
  95. VOID DosOutputString(BYTE FAR *s)
  96. {
  97. while(*s != '$')
  98. DosCharOutput(*s++);
  99. }
  101. static BYTE *con_name = "CON";
  103. int DosCharInputEcho(VOID)
  104. {
  105. BYTE cb;
  107. CharReqHdr.r_length = sizeof(request);
  108. CharReqHdr.r_command = C_INPUT;
  109. CharReqHdr.r_count = 1;
  110. CharReqHdr.r_trans = (VOID FAR *)&cb;
  111. CharReqHdr.r_status = 0;
  112. execrh((request FAR *)&CharReqHdr, syscon);
  113. if(CharReqHdr.r_status & S_ERROR)
  114. return char_error(&CharReqHdr, con_name);
  115. DosCharOutput(cb);
  116. return cb;
  117. }
  120. int DosCharInput(VOID)
  121. {
  122. BYTE cb;
  124. CharReqHdr.r_length = sizeof(request);
  125. CharReqHdr.r_command = C_INPUT;
  126. CharReqHdr.r_count = 1;
  127. CharReqHdr.r_trans = (VOID FAR *)&cb;
  128. CharReqHdr.r_status = 0;
  129. execrh((request FAR *)&CharReqHdr, syscon);
  130. if(CharReqHdr.r_status & S_ERROR)
  131. return char_error(&CharReqHdr, con_name);
  132. return cb;
  133. }
  136. VOID DosDirectConsoleIO(iregs FAR *r)
  137. {
  138. BYTE buf;
  140. if(r -> DL == 0xff)
  141. {
  142. r -> FLAGS &= ~FLG_ZERO;
  144. CharReqHdr.r_length = sizeof(request);
  145. CharReqHdr.r_command = C_ISTAT;
  146. CharReqHdr.r_status = 0;
  147. execrh((request FAR *)&CharReqHdr, syscon);
  148. if(CharReqHdr.r_status & S_ERROR)
  149. {
  150. char_error(&CharReqHdr, con_name);
  151. return;
  152. }
  154. if(CharReqHdr.r_status & S_BUSY)
  155. {
  156. CharReqHdr.r_length = sizeof(request);
  157. CharReqHdr.r_command = C_INPUT;
  158. CharReqHdr.r_count = 1;
  159. CharReqHdr.r_trans = (VOID FAR *)&buf;
  160. CharReqHdr.r_status = 0;
  161. execrh((request FAR *)&CharReqHdr, syscon);
  162. if(CharReqHdr.r_status & S_ERROR)
  163. {
  164. char_error(&CharReqHdr, con_name);
  165. return;
  166. }
  168. r -> AL = buf;
  169. r -> FLAGS |= FLG_ZERO;
  170. }
  172. }
  173. else
  174. {
  175. CharReqHdr.r_length = sizeof(request);
  176. CharReqHdr.r_command = C_OUTPUT;
  177. CharReqHdr.r_count = 1;
  178. CharReqHdr.r_trans = (VOID FAR *)(&buf);
  179. CharReqHdr.r_status = 0;
  180. execrh((request FAR *)&CharReqHdr, syscon);
  181. if(CharReqHdr.r_status & S_ERROR)
  182. char_error(&CharReqHdr, con_name);
  183. }
  184. }
  186. /* Console output with printer echo                                     */
  187. VOID DosCharOutput(COUNT c)
  188. {
  189. BYTE buf = c;
  191. /* Test for break first                                         */
  192. if(con_break())
  193. return;
  195. /* Now do an output directly to the console                     */
  196. CharReqHdr.r_length = sizeof(request);
  197. CharReqHdr.r_command = C_OUTPUT;
  198. CharReqHdr.r_count = 1;
  199. CharReqHdr.r_trans = (VOID FAR *)(&buf);
  200. CharReqHdr.r_status = 0;
  201. execrh((request FAR *)&CharReqHdr, syscon);
  202. if(CharReqHdr.r_status & S_ERROR)
  203. char_error(&CharReqHdr, con_name);
  204. ++scr_pos;
  206. /* printer echo stuff                                   */
  207. }
  210. VOID DosDisplayOutput(COUNT c)
  211. {
  212. /* Non-portable construct                                       */
  213. if(c < ' ' || c == 0x7f)
  214. {
  215. switch(c)
  216. {
  217. case 'r':
  218. scr_pos = 0;
  219. break;
  221. case 0x7f:
  222. ++scr_pos;
  223. break;
  225. case 'b':
  226. if(scr_pos > 0)
  227. --scr_pos;
  228. break;
  230. case 't':
  231. do
  232. DosCharOutput(' ');
  233. while(scr_pos & 7);
  234. return;
  236. default:
  237. break;
  238. }
  239. DosCharOutput(c);
  240. }
  241. else
  242. {
  243. DosCharOutput(c);
  244. }
  245. }
  248. VOID 
  249. FatGetDrvData (COUNT drive, COUNT FAR *spc, COUNT FAR *bps, COUNT FAR *nc, BYTE FAR **mdp)
  250. {
  251. struct dpb *dpbp;
  253. /* first check for valid drive                                  */
  254. if(drive < 0 || drive > NDEVS)
  255. {
  256. *spc = -1;
  257. return;
  258. }
  260. /* next - "log" in the drive                                    */
  261. drive = (drive == 0 ? default_drive : drive - 1);
  262. dpbp = &blk_devices[drive];
  263. ++(dpbp -> dpb_count);
  264. dpbp -> dpb_flags = -1;
  265. if((media_check(dpbp) < 0) || (dpbp -> dpb_count <= 0))
  266. {
  267. *spc = -1;
  268. return;
  269. }
  271. /* get the data vailable from dpb                       */
  272. *nc = dpbp -> dpb_size;
  273. *spc = dpbp -> dpb_clsmask;
  274. *bps = dpbp -> dpb_secsize;
  276. /* Point to the media desctriptor fotr this drive               */
  277. *mdp = &(dpbp -> dpb_mdb);
  278. --(dpbp -> dpb_count);
  279. }
  281. #define PARSE_SEP_STOP          0x01
  282. #define PARSE_DFLT_DRIVE        0x02
  283. #define PARSE_BLNK_FNAME        0x04
  284. #define PARSE_BLNK_FEXT         0x08
  286. #define PARSE_RET_NOWILD        0
  287. #define PARSE_RET_WILD          1
  288. #define PARSE_RET_BADDRIVE      0xff
  290. #ifndef IPL
  291. WORD FcbParseFname(wTestMode, lpFileName, lpFcb)
  292. REG WORD wTestMode;
  293. BYTE FAR **lpFileName;
  294. fcb FAR *lpFcb;
  295. {
  296. COUNT   nIndex;
  297. WORD    wRetCode = PARSE_RET_NOWILD;
  299. /* pjv -- ExtFcbToFcb?                                          */
  300. /* Start out with some simple stuff first.  Check if we are     */
  301. /* going to use a default drive specificaton.                   */
  302. if(!(wTestMode & PARSE_DFLT_DRIVE))
  303. lpFcb -> fcb_drive = FDFLT_DRIVE;
  304. if(!(wTestMode & PARSE_BLNK_FNAME))
  305. {
  306. for(nIndex = 0; nIndex < FNAME_SIZE; ++nIndex)
  307. lpFcb -> fcb_fname[nIndex] = ' ';
  308. }
  309. if(!(wTestMode & PARSE_BLNK_FEXT))
  310. {
  311. for(nIndex = 0; nIndex < FEXT_SIZE; ++nIndex)
  312. lpFcb -> fcb_fext[nIndex] = ' ';
  313. }                              
  315. /* Undocumented behavior, set record number & record size to 0  */
  316. lpFcb -> fcb_cublock = lpFcb -> fcb_recsiz = 0;
  318. if(!(wTestMode & PARSE_SEP_STOP))
  319. {
  320. *lpFileName = ParseSkipWh(*lpFileName);
  321. if(TestCmnSeps(*lpFileName))
  322. ++*lpFileName;
  323. }
  325. /* Undocumented "feature," we skip white space anyway           */
  326. *lpFileName = ParseSkipWh(*lpFileName);
  328. /* Now check for drive specification                            */
  329. if(*(*lpFileName + 1) == ':')
  330. {
  331. REG BYTE Drive = upChar(**lpFileName);
  333. /* non-portable construct to be changed                 */
  334. if(Drive < 'A' || Drive > 'Z')
  335. return PARSE_RET_BADDRIVE;
  336. Drive -= ('A' - 1);
  337. if(Drive > nblkdev)
  338. return PARSE_RET_BADDRIVE;
  339. else
  340. lpFcb -> fcb_drive = Drive;
  341. *lpFileName += 2;
  342. }
  344. /* Now to format the file name into the string                  */
  345. *lpFileName = GetNameField(*lpFileName, (BYTE FAR *)lpFcb -> fcb_fname, FNAME_SIZE, (BOOL *)&wRetCode);
  347. /* Do we have an extension? If do, format it else return        */
  348. if(**lpFileName == '.')
  349. *lpFileName = GetNameField(++*lpFileName, (BYTE FAR *)lpFcb -> fcb_fext, FEXT_SIZE, (BOOL *)&wRetCode);
  351. return wRetCode ? PARSE_RET_WILD : PARSE_RET_NOWILD;
  352. }
  355. BYTE FAR *
  356. ParseSkipWh (BYTE FAR *lpFileName)
  357. {
  358. while(*lpFileName == ' ' || *lpFileName == 't')
  359. ++lpFileName;
  360. return lpFileName;
  361. }
  364. BOOL 
  365. TestCmnSeps (BYTE FAR *lpFileName)
  366. {
  367. BYTE *pszTest, *pszCmnSeps = ":<|>+=,";
  369. for(pszTest = pszCmnSeps; *pszTest != ''; ++pszTest)
  370. if(*lpFileName == *pszTest)
  371. return TRUE;
  372. return FALSE;
  373. }
  375. BOOL 
  376. TestFieldSeps (BYTE FAR *lpFileName)
  377. {
  378. BYTE *pszTest, *pszCmnSeps = "/"[]<>|.";
  380. /* Another non-portable construct                               */
  381. if(*lpFileName <= ' ')
  382. return TRUE;
  384. for(pszTest = pszCmnSeps; *pszTest != ''; ++pszTest)
  385. if(*lpFileName == *pszTest)
  386. return TRUE;
  387. return FALSE;
  388. }
  390. BYTE FAR *
  391. GetNameField (BYTE FAR *lpFileName, BYTE FAR *lpDestField, COUNT nFieldSize, BOOL *pbWildCard)
  392. {
  393. COUNT nIndex = 0;
  394. BYTE cFill = ' ';
  396. *pbWildCard = FALSE;
  397. while(*lpFileName != '' && !TestFieldSeps(lpFileName) && nIndex< nFieldSize)
  398. {
  399. if(*lpFileName == ' ')
  400. break;
  401. if(*lpFileName == '*')
  402. {
  403. *pbWildCard = TRUE;
  404. cFill = '?';
  405. ++lpFileName;
  406. break;
  407. }
  408. if(*lpFileName == '?')
  409. *pbWildCard = TRUE;
  410. *lpDestField++ = upChar(*lpFileName++);
  411. ++nIndex;
  412. }
  414. /* Blank out remainder of field on exit                         */
  415. for( ; nIndex < nFieldSize; ++nIndex)
  416. *lpDestField++ = cFill;
  417. return lpFileName;
  418. }
  420. static sft FAR *FcbGetSft(SftIndex)
  421. COUNT SftIndex;
  422. {
  423. /* Get the SFT block that contains the SFT      */
  424. for(lpCurSft = sfthead; lpCurSft != (sfttbl FAR *)-1;
  425.  lpCurSft = lpCurSft -> sftt_next)
  426. {
  427. if(SftIndex < lpCurSft -> sftt_count)
  428. break;
  429. else
  430. SftIndex -= lpCurSft -> sftt_count;
  431. }
  433. /* If not found, return an error                */
  434. if(lpCurSft == (sfttbl FAR *)-1)
  435. return (sft FAR *)-1;
  437. /* finally, point to the right entry            */
  438. return (sft FAR *)&(lpCurSft -> sftt_table[SftIndex]);
  439. }
  442. static VOID FcbNextRecord(lpFcb)
  443. fcb FAR *lpFcb;
  444. {
  445. if(++lpFcb -> fcb_curec > 128)
  446. {
  447. lpFcb -> fcb_curec = 0;
  448. ++lpFcb -> fcb_cublock;
  449. }
  450. }
  453. BOOL FcbRead(lpXfcb, nErrorCode)
  454. xfcb FAR *lpXfcb;
  455. COUNT *nErrorCode;
  456. {
  457. sft FAR *s;
  458. LONG lPosit;
  459. COUNT nRead;
  460. psp FAR *p = MK_FP(cu_psp,0);
  462. /* Convert to fcb if necessary                                  */
  463. lpFcb = ExtFcbToFcb(lpXfcb);
  465. /* Get the SFT block that contains the SFT      */
  466. if((s = FcbGetSft(lpFcb -> fcb_sftno)) == (sft FAR *)-1)
  467. return FALSE;
  469. /* If this is not opened another error          */
  470. if(s -> sft_count == 0)
  471. return FALSE;
  473. /* Now update the fcb and compute where we need to position     */
  474. /* to.                                                          */
  475. lPosit = ((lpFcb -> fcb_cublock * 128) + lpFcb -> fcb_curec)
  476.  * lpFcb -> fcb_recsiz;
  477. if(dos_lseek(s -> sft_status, lPosit, 0) < 0)
  478. {
  479. *nErrorCode = FCB_ERR_EOF;
  480. return FALSE;
  481. }
  483. /* Do the read                                                  */
  484. nRead = dos_read(s -> sft_status,
  485.  p -> ps_dta, lpFcb -> fcb_recsiz);
  487. /* Now find out how we will return and do it.                   */
  488. if(nRead == lpFcb -> fcb_recsiz)
  489. {
  490. *nErrorCode = FCB_SUCCESS;
  491. FcbNextRecord(lpFcb);
  492. return TRUE;
  493. }
  494. else if(nRead < 0)
  495. {
  496. *nErrorCode = FCB_ERR_EOF;
  497. return TRUE;
  498. }
  499. else if(nRead == 0)
  500. {
  501. *nErrorCode = FCB_ERR_NODATA;
  502. return FALSE;
  503. }
  504. else
  505. {
  506. COUNT nIdx, nCount;
  507. BYTE FAR *lpDta;
  509. nCount = lpFcb -> fcb_recsiz - nRead;
  510. lpDta = (BYTE FAR *)&(p -> ps_dta[nRead]);
  511. for(nIdx = 0; nIdx < nCount; nIdx++)
  512. *lpDta++ = 0;
  513. *nErrorCode = FCB_ERR_EOF;
  514. FcbNextRecord(lpFcb);
  515. return FALSE;
  516. }
  517. }
  519. BOOL FcbWrite(lpXfcb, nErrorCode)
  520. xfcb FAR *lpXfcb;
  521. COUNT *nErrorCode;
  522. {
  523. sft FAR *s;
  524. LONG lPosit;
  525. COUNT nWritten;
  526. psp FAR *p = MK_FP(cu_psp,0);
  528. /* Convert to fcb if necessary                                  */
  529. lpFcb = ExtFcbToFcb(lpXfcb);
  531. /* Get the SFT block that contains the SFT      */
  532. if((s = FcbGetSft(lpFcb -> fcb_sftno)) == (sft FAR *)-1)
  533. return FALSE;
  535. /* If this is not opened another error          */
  536. if(s -> sft_count == 0)
  537. return FALSE;
  539. /* Now update the fcb and compute where we need to position     */
  540. /* to.                                                          */
  541. lPosit = ((lpFcb -> fcb_cublock * 128) + lpFcb -> fcb_curec)
  542.  * lpFcb -> fcb_recsiz;
  543. if(dos_lseek(s -> sft_status, lPosit, 0) < 0)
  544. {
  545. *nErrorCode = FCB_ERR_EOF;
  546. return FALSE;
  547. }
  549. /* Do the read                                                  */
  550. nWritten = dos_write(s -> sft_status,
  551.  p -> ps_dta, lpFcb -> fcb_recsiz);
  553. /* Now find out how we will return and do it.                   */
  554. if(nWritten == lpFcb -> fcb_recsiz)
  555. {
  556. lpFcb -> fcb_fsize = dos_getcufsize(s -> sft_status);
  557. FcbNextRecord(lpFcb);
  558. *nErrorCode = FCB_SUCCESS;
  559. return TRUE;
  560. }
  561. else if(nWritten <= 0)
  562. {
  563. *nErrorCode = FCB_ERR_WRITE;
  564. return TRUE;
  565. }
  566. *nErrorCode = FCB_ERR_WRITE;
  567. return FALSE;
  568. }
  571. BOOL FcbGetFileSize(lpXfcb)
  572. xfcb FAR *lpXfcb;
  573. {
  574. COUNT FcbDrive, FileNum;
  576. /* Build a traditional DOS file name                            */
  577. lpFcb = CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  579. /* check for a device                                           */
  580. /* if we have an extension, can't be a device                   */
  581. if(IsDevice(PriPathName) || (lpFcb -> fcb_recsiz == 0))
  582. {
  583. return FALSE;
  584. }
  585. FileNum = dos_open(PriPathName, O_RDONLY);
  586. if(FileNum >= 0)
  587. {
  588. LONG fsize;
  590. /* Get the size                                         */
  591. fsize = dos_getfsize(FileNum);
  593. /* compute the size and update the fcb                  */
  594. lpFcb -> fcb_rndm = fsize / lpFcb -> fcb_recsiz;
  595. if((fsize % lpFcb -> fcb_recsiz) != 0)
  596. ++lpFcb -> fcb_rndm;
  598. /* close the file and leave                             */
  599. return dos_close(FileNum) == SUCCESS;
  600. }
  601. else
  602. return FALSE;
  603. }
  606. BOOL FcbSetRandom(lpXfcb)
  607. xfcb FAR *lpXfcb;
  608. {
  609. LONG lPosit;
  611. /* Convert to fcb if necessary                                  */
  612. lpFcb = ExtFcbToFcb(lpXfcb);
  614. /* Now update the fcb and compute where we need to position     */
  615. /* to.                                                          */
  616. lpFcb -> fcb_rndm = (lpFcb -> fcb_cublock * 128)
  617.  + lpFcb -> fcb_curec;
  619. return TRUE;
  620. }
  623. BOOL FcbCalcRec(lpXfcb)
  624. xfcb FAR *lpXfcb;
  625. {
  626. LONG lPosit;
  628. /* Convert to fcb if necessary                                  */
  629. lpFcb = ExtFcbToFcb(lpXfcb);
  631. /* Now update the fcb and compute where we need to position     */
  632. /* to.                                                          */
  633. lpFcb -> fcb_cublock =  lpFcb -> fcb_rndm / 128;
  634. lpFcb -> fcb_curec =  lpFcb -> fcb_rndm % 128;
  636. return TRUE;
  637. }
  640. BOOL FcbRandomBlockRead(lpXfcb, nRecords, nErrorCode)
  641. xfcb FAR *lpXfcb;
  642. COUNT nRecords;
  643. COUNT *nErrorCode;
  644. {
  645. FcbCalcRec(lpXfcb);
  647. /* Convert to fcb if necessary                                  */
  648. lpFcb = ExtFcbToFcb(lpXfcb);
  650. do
  651. FcbRead(lpXfcb, nErrorCode);
  652. while ((--nRecords > 0) && (*nErrorCode == 0));
  654. /* Now update the fcb                                           */
  655. lpFcb -> fcb_rndm = lpFcb -> fcb_cublock * 128 + lpFcb -> fcb_curec;
  657. return TRUE;
  658. }
  661. BOOL FcbRandomBlockWrite(lpXfcb, nRecords, nErrorCode)
  662. xfcb FAR *lpXfcb;
  663. COUNT nRecords;
  664. COUNT *nErrorCode;
  665. {
  666. FcbCalcRec(lpXfcb);
  668. /* Convert to fcb if necessary                                  */
  669. lpFcb = ExtFcbToFcb(lpXfcb);
  671. do
  672. FcbWrite(lpXfcb, nErrorCode);
  673. while ((--nRecords > 0) && (*nErrorCode == 0));
  675. /* Now update the fcb                                           */
  676. lpFcb -> fcb_rndm = lpFcb -> fcb_cublock * 128 + lpFcb -> fcb_curec;
  678. return TRUE;
  679. }
  682. BOOL FcbRandomRead(lpXfcb, nErrorCode)
  683. xfcb FAR *lpXfcb;
  684. COUNT *nErrorCode;
  685. {
  686. UWORD uwCurrentBlock;
  687. UBYTE ucCurrentRecord;
  689. FcbCalcRec(lpXfcb);
  691. /* Convert to fcb if necessary                                  */
  692. lpFcb = ExtFcbToFcb(lpXfcb);
  694. uwCurrentBlock = lpFcb -> fcb_cublock;
  695. ucCurrentRecord = lpFcb -> fcb_curec;
  697. FcbRead(lpXfcb, nErrorCode);
  699. lpFcb -> fcb_cublock = uwCurrentBlock;
  700. lpFcb -> fcb_curec = ucCurrentRecord;
  701. return TRUE;
  702. }
  705. BOOL FcbRandomWrite(lpXfcb, nErrorCode)
  706. xfcb FAR *lpXfcb;
  707. COUNT *nErrorCode;
  708. {
  709. UWORD uwCurrentBlock;
  710. UBYTE ucCurrentRecord;
  712. FcbCalcRec(lpXfcb);
  714. /* Convert to fcb if necessary                                  */
  715. lpFcb = ExtFcbToFcb(lpXfcb);
  717. uwCurrentBlock = lpFcb -> fcb_cublock;
  718. ucCurrentRecord = lpFcb -> fcb_curec;
  720. FcbWrite(lpXfcb, nErrorCode);
  722. lpFcb -> fcb_cublock = uwCurrentBlock;
  723. lpFcb -> fcb_curec = ucCurrentRecord;
  724. return TRUE;
  725. }
  728. static sft FAR *FcbGetFreeSft(sft_idx)
  729. WORD FAR *sft_idx;
  730. {
  731. WORD sys_idx = 0;
  732. sfttbl FAR *sp;
  734. /* Get the SFT block that contains the SFT      */
  735. for(sp = sfthead; sp != (sfttbl FAR *)-1; sp = sp -> sftt_next)
  736. {
  737. REG WORD i;
  739. for(i = 0; i < sp -> sftt_count; i++)
  740. {
  741. if(sp -> sftt_table[i].sft_count == 0)
  742. {
  743. *sft_idx = sys_idx + i;
  744. return (sft FAR *)&sp -> sftt_table[sys_idx + i];
  745. }
  746. }
  747. sys_idx += i;
  748. }
  750. /* If not found, return an error                */
  751. return (sft FAR *)-1;
  752. }
  755. BOOL FcbCreate(lpXfcb)
  756. xfcb FAR *lpXfcb;
  757. {
  758. WORD sft_idx;
  759. sft FAR *sftp;
  760. struct dhdr FAR *dhp;
  761. COUNT FcbDrive;
  763. /* get a free system file table entry                           */
  764. if((sftp = FcbGetFreeSft((WORD FAR *)&sft_idx)) == (sft FAR *)-1)
  765. return DE_TOOMANY;
  767. /* Build a traditional DOS file name                            */
  768. lpFcb = CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  770. /* check for a device                                           */
  771. /* if we have an extension, can't be a device                   */
  772. if(IsDevice(PriPathName))
  773. {
  774. for(dhp = (struct dhdr FAR *)&nul_dev; dhp != (struct dhdr FAR *)-1; dhp = dhp -> dh_next)
  775. {
  776. if(FcbFnameMatch((BYTE FAR *)PriPathName, (BYTE FAR *)dhp -> dh_name, FNAME_SIZE, FALSE))
  777. {
  778. sftp -> sft_count += 1;
  779. sftp -> sft_mode = O_RDWR;
  780. sftp -> sft_attrib = 0;
  781. sftp -> sft_flags =
  782.   (dhp -> dh_attr & ~SFT_MASK) | SFT_FDEVICE | SFT_FEOF;
  783. sftp -> sft_psp = cu_psp;
  784. fbcopy(lpFcb -> fcb_fname, sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  785. sftp -> sft_dev = dhp;
  786. lpFcb -> fcb_sftno = sft_idx;
  787. lpFcb -> fcb_curec = 0;
  788. lpFcb -> fcb_recsiz = 0;
  789. lpFcb -> fcb_fsize = 0;
  790. lpFcb -> fcb_date = dos_getdate();
  791. lpFcb -> fcb_time = dos_gettime();
  792. lpFcb -> fcb_rndm = 0;
  793. return TRUE;
  794. }
  795. }
  796. }
  797. sftp -> sft_status = dos_creat(PriPathName, 0);
  798. if(sftp -> sft_status >= 0)
  799. {
  800. lpFcb -> fcb_drive = FcbDrive;
  801. lpFcb -> fcb_sftno = sft_idx;
  802. lpFcb -> fcb_curec = 0;
  803. lpFcb -> fcb_recsiz = 128;
  804. lpFcb -> fcb_fsize = 0;
  805. lpFcb -> fcb_date = dos_getdate();
  806. lpFcb -> fcb_time = dos_gettime();
  807. lpFcb -> fcb_rndm = 0;
  808. sftp -> sft_count += 1;
  809. sftp -> sft_mode = O_RDWR;
  810. sftp -> sft_attrib = 0;
  811. sftp -> sft_flags = 0;
  812. sftp -> sft_psp = cu_psp;
  813. fbcopy((BYTE FAR *)&lpFcb -> fcb_fname, (BYTE FAR *)&sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  814. return TRUE;
  815. }
  816. else
  817. return FALSE;
  818. }
  821. static fcb FAR *ExtFcbToFcb(xfcb FAR *lpExtFcb)
  822. {
  823. if(*((UBYTE FAR *)lpExtFcb) == 0xff)
  824. return &lpExtFcb -> xfcb_fcb;
  825. else
  826. return (fcb FAR *)lpExtFcb;
  827. }
  830. static fcb FAR *CommonFcbInit(lpExtFcb, pszBuffer, pCurDrive)
  831. xfcb FAR *lpExtFcb;
  832. BYTE *pszBuffer;
  833. COUNT *pCurDrive;
  834. {
  835. BYTE FAR *lpszFcbFname, *lpszFcbFext;
  836. COUNT nDrvIdx, nFnameIdx, nFextIdx;
  837. fcb FAR *lpFcb;
  839. /* convert to fcb if needed first                               */
  840. lpFcb = ExtFcbToFcb(lpExtFcb);
  842. /* Build a traditional DOS file name                            */
  843. FcbNameInit(lpFcb, pszBuffer, pCurDrive);
  845. /* and return the fcb pointer                                   */
  846. return lpFcb;
  847. }
  849. void FcbNameInit(lpFcb, pszBuffer, pCurDrive)
  850. fcb FAR *lpFcb;
  851. BYTE *pszBuffer;
  852. COUNT *pCurDrive;
  853. {
  854. BYTE FAR *lpszFcbFname, FAR *lpszFcbFext;
  855. COUNT nDrvIdx, nFnameIdx, nFextIdx;
  857. /* Build a traditional DOS file name                            */
  858. lpszFcbFname = (BYTE FAR *)lpFcb -> fcb_fname;
  859. if(lpFcb -> fcb_drive != 0)
  860. {
  861. *pCurDrive = lpFcb -> fcb_drive;
  862. pszBuffer[0] = 'A' + lpFcb -> fcb_drive - 1;
  863. pszBuffer[1] = ':';
  864. nDrvIdx = 2;
  865. }           
  866. else
  867. {
  868. *pCurDrive = default_drive + 1;
  869. nDrvIdx = 0;
  870. }
  872. for(nFnameIdx = 0; nFnameIdx < FNAME_SIZE; nFnameIdx++)
  873. {
  874. if(*lpszFcbFname != ' ')
  875. pszBuffer[nDrvIdx + nFnameIdx] = *lpszFcbFname++;
  876. else
  877. break;
  878. }
  880. lpszFcbFext = (BYTE FAR *)lpFcb -> fcb_fext;
  881. if(*lpszFcbFext != ' ')
  882. {
  883. pszBuffer[nDrvIdx + nFnameIdx++] = '.';
  884. for(nFextIdx = 0; nFextIdx < FEXT_SIZE; nFextIdx++)
  885. {
  886. if(*lpszFcbFext != ' ')
  887. pszBuffer[nDrvIdx + nFnameIdx + nFextIdx] =
  888.  *lpszFcbFext++;
  889. else
  890. break;
  891. }
  892. }
  893. else
  894. nFextIdx = 0;
  895. pszBuffer[nDrvIdx + nFnameIdx + nFextIdx] = '';
  896. }
  898. /* Ascii only file name match routines                  */
  899. static BOOL 
  900. FcbCharMatch (COUNT s, COUNT d, COUNT mode)
  901. {
  902. if(s >= 'a' && s <= 'z')
  903. s -= 'a' - 'A';
  904. if(d >= 'a' && d <= 'z')
  905. d -= 'a' - 'A';
  906. if(mode && s == '?' && (d >= 'A' && s <= 'Z'))
  907. return TRUE;
  908. return s == d;
  909. }
  912. static BOOL 
  913. FcbFnameMatch (BYTE FAR *s, BYTE FAR *d, COUNT n, COUNT mode)
  914. {
  915. while(n--)
  916. {
  917. if(!FcbCharMatch(*s++, *d++, mode))
  918. return FALSE;
  919. }
  920. return TRUE;
  921. }
  924. BOOL FcbOpen(lpXfcb)
  925. xfcb FAR *lpXfcb;
  926. {
  927. WORD sft_idx;
  928. sft FAR *sftp;
  929. struct dhdr FAR *dhp;
  930. COUNT FcbDrive;
  932. /* get a free system file table entry                           */
  933. if((sftp = FcbGetFreeSft((WORD FAR *)&sft_idx)) == (sft FAR *)-1)
  934. return DE_TOOMANY;
  936. /* Build a traditional DOS file name                            */
  937. lpFcb = CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  939. /* check for a device                                           */
  940. /* if we have an extension, can't be a device                   */
  941. if(IsDevice(PriPathName))
  942. {
  943. for(dhp = (struct dhdr FAR *)&nul_dev; dhp != (struct dhdr FAR *)-1; dhp = dhp -> dh_next)
  944. {
  945. if(FcbFnameMatch((BYTE FAR *)PriPathName, (BYTE FAR *)dhp -> dh_name, FNAME_SIZE, FALSE))
  946. {
  947. sftp -> sft_count += 1;
  948. sftp -> sft_mode = O_RDWR;
  949. sftp -> sft_attrib = 0;
  950. sftp -> sft_flags =
  951.   (dhp -> dh_attr & ~SFT_MASK) | SFT_FDEVICE | SFT_FEOF;
  952. sftp -> sft_psp = cu_psp;
  953. fbcopy(lpFcb -> fcb_fname, sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  954. sftp -> sft_dev = dhp;
  955. lpFcb -> fcb_sftno = sft_idx;
  956. lpFcb -> fcb_curec = 0;
  957. lpFcb -> fcb_recsiz = 0;
  958. lpFcb -> fcb_fsize = 0;
  959. lpFcb -> fcb_date = dos_getdate();
  960. lpFcb -> fcb_time = dos_gettime();
  961. lpFcb -> fcb_rndm = 0;
  962. return TRUE;
  963. }
  964. }
  965. }
  966. sftp -> sft_status = dos_open(PriPathName, O_RDWR);
  967. if(sftp -> sft_status >= 0)
  968. {
  969. lpFcb -> fcb_drive = FcbDrive;
  970. lpFcb -> fcb_sftno = sft_idx;
  971. lpFcb -> fcb_curec = 0;
  972. lpFcb -> fcb_recsiz = 128;
  973. lpFcb -> fcb_fsize = dos_getfsize(sftp -> sft_status);
  974. dos_getftime(sftp -> sft_status,
  975.  (date FAR *)&lpFcb -> fcb_date,
  976.  (time FAR *)&lpFcb -> fcb_time);
  977. lpFcb -> fcb_rndm = 0;
  978. sftp -> sft_count += 1;
  979. sftp -> sft_mode = O_RDWR;
  980. sftp -> sft_attrib = 0;
  981. sftp -> sft_flags = 0;
  982. sftp -> sft_psp = cu_psp;
  983. fbcopy((BYTE FAR *)&lpFcb -> fcb_fname, (BYTE FAR *)&sftp -> sft_name, FNAME_SIZE+FEXT_SIZE);
  984. return TRUE;
  985. }
  986. else
  987. return FALSE;
  988. }
  991. BOOL FcbDelete(lpXfcb)
  992. xfcb FAR *lpXfcb;
  993. {
  994. COUNT FcbDrive;
  996. /* Build a traditional DOS file name                            */
  997. CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  999. /* check for a device                                           */
  1000. /* if we have an extension, can't be a device                   */
  1001. if(IsDevice(PriPathName))
  1002. {
  1003. return FALSE;
  1004. }
  1005. else
  1006. {
  1007. BYTE FAR *lpOldDta = dta;
  1008. dmatch Dmatch;
  1010. dta = (BYTE FAR *)&Dmatch;
  1011. if(dos_findfirst(D_ALL, PriPathName[1] == ':' ? &PriPathName[2] : PriPathName) != SUCCESS)
  1012. {
  1013. dta = lpOldDta;
  1014. return FALSE;
  1015. }
  1016. do
  1017. {
  1018. if(dos_delete(Dmatch.dm_name) != SUCCESS)
  1019. {
  1020. dta = lpOldDta;
  1021. return FALSE;
  1022. }
  1023. }
  1024. while(dos_findnext() == SUCCESS);
  1025. dta = lpOldDta;
  1026. return TRUE;
  1027. }
  1028. }
  1031. BOOL FcbRename(lpXfcb)
  1032. xfcb FAR *lpXfcb;
  1033. {
  1034. rfcb FAR *lpRenameFcb;
  1035. COUNT FcbDrive;
  1037. /* Build a traditional DOS file name                            */
  1038. lpRenameFcb = (rfcb FAR *)CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  1040. /* check for a device                                           */
  1041. /* if we have an extension, can't be a device                   */
  1042. if(IsDevice(PriPathName))
  1043. {
  1044. return FALSE;
  1045. }
  1046. else
  1047. {
  1048. BYTE FAR *lpOldDta = dta;
  1049. dmatch Dmatch;
  1051. dta = (BYTE FAR *)&Dmatch;
  1052. if(dos_findfirst(D_ALL, PriPathName[1] == ':' ? &PriPathName[2] : PriPathName) != SUCCESS)
  1053. {
  1054. dta = lpOldDta;
  1055. return FALSE;
  1056. }
  1059. do
  1060. {
  1061. fcb LocalFcb;
  1062. BYTE *pToName, *pszFrom;
  1063. BYTE FAR *pFromPattern;
  1064. COUNT nIndex;
  1066. /* First, expand the find match into fcb style  */
  1067. /* file name entry                              */
  1068. /* Fill with blanks first                       */
  1069. for(pToName = LocalFcb.fcb_fname, nIndex = 0;
  1070.  nIndex < FNAME_SIZE; nIndex++)
  1071. {
  1072. *pToName++ = ' ';
  1073. }
  1074. for(pToName = LocalFcb.fcb_fext, nIndex = 0;
  1075.  nIndex < FEXT_SIZE; nIndex++)
  1076. {
  1077. *pToName++ = ' ';
  1078. }
  1080. /* next move in the file name while overwriting */
  1081. /* the filler blanks                            */
  1082. pszFrom = Dmatch.dm_name;
  1083. pToName = LocalFcb.fcb_fname;
  1084. for(nIndex = 0; nIndex < FNAME_SIZE; nIndex++)
  1085. {
  1086. if(*pszFrom != 0 && *pszFrom != '.')
  1087. *pToName++ = *pszFrom++;
  1088. else if(*pszFrom == '.')
  1089. {
  1090. ++pszFrom;
  1091. break;
  1092. }
  1093. else
  1094. break;
  1095. }
  1097. if(*pszFrom != '')
  1098. {
  1099. pToName = LocalFcb.fcb_fext;
  1100. for(nIndex = 0; nIndex < FEXT_SIZE; nIndex++)
  1101. {
  1102. if(*pszFrom != '')
  1103. *pToName++ = *pszFrom++;
  1104. else
  1105. break;
  1106. }
  1107. }
  1109. /* Overlay the pattern, skipping '?'            */
  1110. /* I'm cheating because this assumes that the   */
  1111. /* struct alignments are on byte boundaries     */
  1112. pToName = LocalFcb.fcb_fname;
  1113. for(pFromPattern = lpRenameFcb -> renNewName,
  1114.  nIndex = 0; nIndex < FNAME_SIZE + FEXT_SIZE; nIndex++)
  1115. {
  1116. if(*pFromPattern != '?')
  1117. *pToName++ = *pFromPattern++;
  1118. else
  1119. ++pFromPattern;
  1120. }
  1122. /* now to build a dos name again                */
  1123. LocalFcb.fcb_drive = 0;
  1124. FcbNameInit((fcb FAR *)&LocalFcb, PriPathName, &FcbDrive);
  1126. if(dos_rename(Dmatch.dm_name,
  1127.  PriPathName[1] == ':' ? &PriPathName[2] : PriPathName) != SUCCESS)
  1128. {
  1129. dta = lpOldDta;
  1130. return FALSE;
  1131. }
  1132. }
  1133. while(dos_findnext() == SUCCESS);
  1134. dta = lpOldDta;
  1135. return TRUE;
  1136. }
  1137. }
  1140. void MoveDirInfo(lpDmatch, lpDir)
  1141. dmatch FAR *lpDmatch;
  1142. struct dirent FAR *lpDir;
  1143. {
  1144. BYTE FAR *lpToName, FAR *lpszFrom;
  1145. COUNT nIndex;
  1147. /* First, expand the find match into dir style  */
  1148. /* file name entry                              */
  1149. /* Fill with blanks first                       */
  1150. for(lpToName = lpDir -> dir_name, nIndex = 0;
  1151.  nIndex < FNAME_SIZE; nIndex++)
  1152. {
  1153. *lpToName++ = ' ';
  1154. }
  1155. for(lpToName = lpDir -> dir_ext, nIndex = 0;
  1156.  nIndex < FEXT_SIZE; nIndex++)
  1157. {
  1158. *lpToName++ = ' ';
  1159. }
  1161. /* next move in the file name while overwriting */
  1162. /* the filler blanks                            */
  1163. lpszFrom = lpDmatch -> dm_name;
  1164. lpToName = lpDir -> dir_name;
  1165. for(nIndex = 0; nIndex < FNAME_SIZE; nIndex++)
  1166. {
  1167. if(*lpszFrom != 0 && *lpszFrom != '.')
  1168. *lpToName++ = *lpszFrom++;
  1169. else
  1170. break;
  1171. }
  1172.     
  1173. if(*lpszFrom != '')
  1174. {
  1175. if(*lpszFrom == '.')
  1176. ++lpszFrom;
  1177. lpToName = lpDir -> dir_ext;
  1178. for(nIndex = 0; nIndex < FEXT_SIZE; nIndex++)
  1179. {
  1180. if(*lpszFrom != '')
  1181. *lpToName++ = *lpszFrom++;
  1182. else
  1183. break;
  1184. }
  1185. }
  1186. for(nIndex = 0; nIndex < 10; nIndex++)
  1187. lpDir -> dir_reserved[nIndex] = 0;
  1188. lpDir -> dir_attrib = lpDmatch ->dm_attr_fnd;
  1189. lpDir -> dir_time = lpDmatch ->dm_time;
  1190. lpDir -> dir_date = lpDmatch ->dm_date;
  1191. lpDir -> dir_start = lpDmatch ->dm_cluster;
  1192. lpDir -> dir_size = lpDmatch ->dm_size;
  1193. }
  1196. BOOL FcbClose(lpXfcb)
  1197. xfcb FAR *lpXfcb;
  1198. {
  1199. sft FAR *s;
  1201. /* Convert to fcb if necessary                                  */
  1202. lpFcb = ExtFcbToFcb(lpXfcb);
  1204. /* Get the SFT block that contains the SFT      */
  1205. if((s = FcbGetSft(lpFcb -> fcb_sftno)) == (sft FAR *)-1)
  1206. return FALSE;
  1208. /* If this is not opened another error          */
  1209. if(s -> sft_count == 0)
  1210. return FALSE;
  1212. /* now just drop the count if a device, else    */
  1213. /* call file system handler                     */
  1214. if(s -> sft_flags & SFT_FDEVICE)
  1215. {
  1216. s -> sft_count -= 1;
  1217. return TRUE;
  1218. }
  1219. else
  1220. {
  1221. s -> sft_count -= 1;
  1222. if(s -> sft_count > 0)
  1223. return SUCCESS;
  1224. else
  1225. {
  1226. /* change time and set file size                */
  1227. dos_setftime(s -> sft_status,
  1228.  (date FAR *)&lpFcb -> fcb_date,
  1229.  (time FAR *)&lpFcb -> fcb_time);
  1230. dos_setfsize(s -> sft_status,
  1231.  lpFcb -> fcb_fsize);
  1232. return dos_close(s -> sft_status) == SUCCESS;
  1233. }
  1234. }
  1235. }
  1238. BOOL FcbFindFirst(lpXfcb)
  1239. xfcb FAR *lpXfcb;
  1240. {
  1241. BYTE FAR *lpOldDta;
  1242. BYTE FAR *lpDir;
  1243. COUNT nIdx, FcbDrive;
  1244. psp FAR *lpPsp = MK_FP(cu_psp,0);
  1246. /* First, move the dta to a local and change it around to match */
  1247. /* our functions.                                               */
  1248. lpDir = (BYTE FAR *)dta;
  1249. dta = (BYTE FAR *)&Dmatch;
  1251. /* Next initialze local variables by moving them from the fcb   */
  1252. lpFcb = CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  1253. if(lpXfcb -> xfcb_flag == 0xff)
  1254. {
  1255. wAttr = lpXfcb -> xfcb_attrib;
  1256. fbcopy(lpXfcb, lpDir, 7);
  1257. lpDir += 7;
  1258. }
  1259. else
  1260. wAttr = D_ALL;
  1262. *lpDir++ = PriPathName[0] - 'A';
  1263. if(dos_findfirst(wAttr, PriPathName) != SUCCESS)       
  1264. {
  1265. dta = lpPsp -> ps_dta;
  1266. return FALSE;
  1267. }
  1269. MoveDirInfo((dmatch FAR *)&Dmatch, (struct dirent FAR *)lpDir);
  1270. lpFcb -> fcb_dirclst = Dmatch.dm_cluster;
  1271. lpFcb -> fcb_diroff = Dmatch.dm_entry;
  1272. dta = lpPsp -> ps_dta;
  1273. return TRUE;
  1274. }
  1277. BOOL FcbFindNext(lpXfcb)
  1278. xfcb FAR *lpXfcb;
  1279. {
  1280. BYTE FAR *lpOldDta;
  1281. BYTE FAR *lpDir;
  1282. COUNT nIdx, FcbDrive;
  1283. psp FAR *lpPsp = MK_FP(cu_psp,0);
  1285. /* First, move the dta to a local and change it around to match */
  1286. /* our functions.                                               */
  1287. lpDir = (BYTE FAR *)dta;
  1288. dta = (BYTE FAR *)&Dmatch;
  1290. /* Next initialze local variables by moving them from the fcb   */
  1291. lpFcb = CommonFcbInit(lpXfcb, PriPathName, &FcbDrive);
  1292. if((xfcb FAR *)lpFcb != lpXfcb)
  1293. {
  1294. wAttr = lpXfcb -> xfcb_attrib;
  1295. fbcopy(lpXfcb, lpDir, 7);
  1296. lpDir += 7;
  1297. }
  1298. else
  1299. wAttr = D_ALL;
  1301. /* Reconstrct the dirmatch structure from the fcb               */
  1302. *lpDir++ = FcbDrive;
  1303. Dmatch.dm_drive = FcbDrive? FcbDrive - 1 : default_drive;
  1305. fbcopy(lpFcb -> fcb_fname, (BYTE FAR *)Dmatch.dm_name_pat, FNAME_SIZE+FEXT_SIZE);
  1306. upMem((BYTE FAR *)Dmatch.dm_name_pat, FNAME_SIZE+FEXT_SIZE);
  1307. Dmatch.dm_attr_srch = wAttr;
  1308. Dmatch.dm_entry = lpFcb -> fcb_diroff;
  1309. Dmatch.dm_cluster = lpFcb -> fcb_dirclst;
  1311. if(dos_findnext() != SUCCESS)
  1312. {
  1313. dta = lpPsp -> ps_dta;
  1314. return FALSE;
  1315. }
  1317. MoveDirInfo((dmatch FAR *)&Dmatch, (struct dirent FAR *)lpDir);
  1318. lpFcb -> fcb_dirclst = Dmatch.dm_cluster;
  1319. lpFcb -> fcb_diroff = Dmatch.dm_entry;
  1320. dta = lpPsp -> ps_dta;
  1321. return TRUE;
  1322. }
  1323. #endif