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

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

操作系统开发

开发平台：

DOS

DOSNAMES.C：源码内容
  1. /****************************************************************/
  2. /* */
  3. /*    dosnames.c */
  4. /*      DOS-C */
  5. /* */
  6. /*    Generic parsing functions for file name specifications */
  7. /* */
  8. /* Copyright (c) 1994 */
  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. /* */
  29. /****************************************************************/
  31. #include "../../hdr/portab.h"
  33. /* $Logfile:   C:/dos-c/src/fs/dosnames.c_v  $ */
  34. #ifdef VERSION_STRINGS
  35. static BYTE *dosnamesRcsId = "$Header:   C:/dos-c/src/fs/dosnames.c_v   1.8   22 Jan 1998  4:09:00   patv  $";
  36. #endif
  38. /* $Log:   C:/dos-c/src/fs/dosnames.c_v  $
  39.  * 
  40.  *    Rev 1.8   22 Jan 1998  4:09:00   patv
  41.  * Fixed pointer problems affecting SDA
  42.  * 
  43.  *    Rev 1.7   04 Jan 1998 23:14:38   patv
  44.  * Changed Log for strip utility
  45.  * 
  46.  *    Rev 1.6   03 Jan 1998  8:36:04   patv
  47.  * Converted data area to SDA format
  48.  * 
  49.  *    Rev 1.5   16 Jan 1997 12:46:36   patv
  50.  * pre-Release 0.92 feature additions
  51.  * 
  52.  *    Rev 1.4   29 May 1996 21:15:12   patv
  53.  * bug fixes for v0.91a
  54.  * 
  55.  *    Rev 1.3   19 Feb 1996  3:20:08   patv
  56.  * Added NLS, int2f and config.sys processing
  57.  * 
  58.  *    Rev 1.2   01 Sep 1995 17:48:44   patv
  59.  * First GPL release.
  60.  * 
  61.  *    Rev 1.1   30 Jul 1995 20:50:26   patv
  62.  * Eliminated version strings in ipl
  63.  * 
  64.  *    Rev 1.0   02 Jul 1995  8:05:56   patv
  65.  * Initial revision.
  66.  *
  67.  */ 
  68. /* $EndLog$ */
  70. #include "globals.h"
  72. #define PathSep(c) ((c)=='/'||(c)=='\')
  73. #define DriveChar(c) (((c)>='A'&&(c)<='Z')||((c)>='a'&&(c)<='z'))
  75. static BOOL bFileChar(UCOUNT uChar);
  76. VOID XlateLcase (BYTE *szFname, COUNT nChars);
  77. VOID DosTrimPath (BYTE FAR *lpszPathNamep);
  80. static BOOL bFileChar(UCOUNT uChar)
  81. {
  82. BYTE *pszValChar = "."/\[]:|<>+=;,", *pszPtr;
  84. /* Null is not a valid character */
  85. if(NULL == uChar)
  86. return FALSE;
  88. /* Loop through invalid character set */
  89. for (pszPtr = pszValChar; *pszPtr != NULL; pszPtr++)
  90. if(uChar == *pszPtr)
  91. return FALSE;
  93. /* Not in excluded set, it's ok. */
  94. return TRUE;
  95. }
  98. /* Should be converted to a portable version after v1.0 is released. */
  99. VOID
  100. XlateLcase (BYTE *szFname, COUNT nChars)
  101. {
  102. while(nChars--)
  103. {
  104. if(*szFname >= 'a' && *szFname <= 'z')
  105. *szFname -= ('a' - 'A');
  106. ++szFname;
  107. }
  108. }
  111. VOID
  112. SpacePad(BYTE *szString, COUNT nChars)
  113. {
  114. REG COUNT i;
  116. for(i = strlen(szString); i < nChars; i++)
  117. szString[i] = ' ';
  118. }
  121. COUNT
  122. ParseDosName(BYTE FAR *lpszFileName,
  123.      COUNT *pnDrive,
  124.      BYTE *pszDir,
  125.      BYTE *pszFile,
  126.      BYTE *pszExt)
  127. {
  128. COUNT nDirCnt, nFileCnt, nExtCnt;
  129. BYTE FAR *lpszLclDir, FAR *lpszLclFile, FAR *lpszLclExt;
  132. /* Initialize the users data fields */
  133. if(pszDir)
  134. *pszDir = '';
  135. if(pszFile)
  136. *pszFile = '';
  137. if(pszExt)
  138. *pszExt = '';
  139. lpszLclFile = lpszLclExt = lpszLclDir = 0;
  140. nDirCnt = nFileCnt = nExtCnt = 0;
  142. /* Start by cheking for a drive specifier ... */
  143. if(DriveChar(*lpszFileName) && ':' == lpszFileName[1])
  144. {
  145. /* found a drive, fetch it and bump pointer past drive */
  146. /* NB: this code assumes ASCII */
  147. if(pnDrive)
  148. {
  149. *pnDrive = *lpszFileName - 'A';
  150. if(*pnDrive > 26)
  151. *pnDrive -= ('a' - 'A');
  152. }
  153. lpszFileName += 2;
  154. }
  155. else
  156. {
  157. if(pnDrive)
  158. {
  159. *pnDrive = -1;
  160. }
  161. }
  162. if(!pszDir && !pszFile && !pszExt)
  163. return SUCCESS;
  165. /* Now see how long a directory component we have.  We've */
  166. /* initialized the count before and moved the passed in pointer */
  167. /* past the optional drive component.  Now, we initialize the */
  168. /* directory count variable to a one if and only if we see a */
  169. /* leading root drive specifier because we can't be certain */
  170. /* that what follows is a directory until we see at least a */
  171. /* single path seperator.  So we count to the end and work */
  172. /* backwards to the last seperator subtracting one for each */
  173. /* character until we see one (seperator). */
  174. lpszLclDir = lpszFileName;
  175. while(bFileChar(*lpszFileName)
  176.    || PathSep(*lpszFileName)
  177.    || '.' == *lpszFileName)
  178. {
  179. ++nDirCnt;
  180. ++lpszFileName;
  181. }
  182. if(nDirCnt > 1)
  183. {
  184. while(lpszFileName >lpszLclDir)
  185. {
  186. BYTE cChar = *--lpszFileName;
  188. if(PathSep(cChar))
  189. break;
  190. --nDirCnt;
  191. }
  192. /* Once we've moved the pointer back, we want to bump */
  193. /* it past the seperator. */
  194. if(PathSep(*lpszFileName))
  195. ++lpszFileName;
  196. }
  198. /* Parse out the file name portion. */
  199. lpszLclFile = lpszFileName;
  200. while(bFileChar(*lpszFileName) && '.' != *lpszFileName)
  201. {
  202. ++nFileCnt;
  203. ++lpszFileName;
  204. }
  206. /* Now we have pointers set to the directory portion and the */
  207. /* file portion.  Now determine the existance of an extension. */
  208. lpszLclExt = lpszFileName;
  209. if('.' == *lpszFileName)
  210. {
  211. lpszLclExt = ++lpszFileName;
  212. while(bFileChar(*lpszFileName))
  213. {
  214. ++nExtCnt;
  215. ++lpszFileName;
  216. }
  217. }
  219. /* Fix lengths to maximums allowed by MS-DOS. */
  220. if(nDirCnt > PARSE_MAX)
  221. nDirCnt = PARSE_MAX;
  222. if(nFileCnt > FNAME_SIZE)
  223. nFileCnt = FNAME_SIZE;
  224. if(nExtCnt > FEXT_SIZE)
  225. nExtCnt = FEXT_SIZE;
  227. /* Finally copy whatever the user wants extracted to the user's */
  228. /* buffers. */
  229. if(pszDir)
  230. {
  231. fbcopy(lpszLclDir, (BYTE FAR *)pszDir, nDirCnt);
  232. pszDir[nDirCnt] = '';
  233. }
  234. if(pszFile)
  235. {
  236. fbcopy(lpszLclFile, (BYTE FAR *)pszFile, nFileCnt);
  237. pszFile[nFileCnt] = '';
  238. }
  239. if(pszExt)
  240. {
  241. fbcopy(lpszLclExt, (BYTE FAR *)pszExt, nExtCnt);
  242. pszExt[nExtCnt] = '';
  243. }
  245. /* Clean up before leaving */
  246. if(pszDir)
  247. DosTrimPath(pszDir);
  249. return SUCCESS;
  250. }
  253. COUNT
  254. ParseDosPath(BYTE FAR *lpszFileName,
  255.      COUNT *pnDrive,
  256.      BYTE *pszDir,
  257.      BYTE *pszCurPath)
  258. {
  259. COUNT nDirCnt, nPathCnt;
  260. BYTE FAR *lpszLclDir, *pszBase = pszDir;
  263. /* Initialize the users data fields */
  264. *pszDir = '';
  265. lpszLclDir = 0;
  266. nDirCnt = nPathCnt = 0;
  268. /* Start by cheking for a drive specifier ... */
  269. if(DriveChar(*lpszFileName) && ':' == lpszFileName[1])
  270. {
  271. /* found a drive, fetch it and bump pointer past drive */
  272. /* NB: this code assumes ASCII */
  273. if(pnDrive)
  274. {
  275. *pnDrive = *lpszFileName - 'A';
  276. if(*pnDrive > 26)
  277. *pnDrive -= ('a' - 'A');
  278. }
  279. lpszFileName += 2;
  280. }
  281. else
  282. {
  283. if(pnDrive)
  284. {
  285. *pnDrive = -1;
  286. }
  287. }
  289. lpszLclDir = lpszFileName;
  290. if(!PathSep(*lpszLclDir))
  291. {
  292. strncpy(pszDir, pszCurPath, PARSE_MAX);
  293. nPathCnt = strlen(pszCurPath);
  294. if(!PathSep(pszDir[nPathCnt - 1]) && nPathCnt < PARSE_MAX)
  295. pszDir[nPathCnt++] = '\';
  296. if(nPathCnt > PARSE_MAX)
  297. nPathCnt = PARSE_MAX;
  298. pszDir += nPathCnt;
  299. }
  301. /* Now see how long a directory component we have.   */
  302. while(bFileChar(*lpszFileName)
  303.    || PathSep(*lpszFileName)
  304.    || '.' == *lpszFileName)
  305. {
  306. ++nDirCnt;
  307. ++lpszFileName;
  308. }
  310. /* Fix lengths to maximums allowed by MS-DOS. */
  311. if((nDirCnt + nPathCnt)> PARSE_MAX)
  312. nDirCnt = PARSE_MAX - nPathCnt;
  314. /* Finally copy whatever the user wants extracted to the user's */
  315. /* buffers. */
  316. if(pszDir)
  317. {
  318. fbcopy(lpszLclDir, (BYTE FAR *)pszDir, nDirCnt);
  319. pszDir[nDirCnt] = '';
  320. }
  322. /* Clean up before leaving */
  323. DosTrimPath((BYTE FAR *)pszBase);
  325. /* Before returning to the user, eliminate any useless */
  326. /* trailing "\." since the path prior to this is sufficient. */
  327. nPathCnt = strlen(pszBase);
  328. if(2 == nPathCnt)   /* Special case, root */
  329. {
  330. if(!strcmp(pszBase, "\."))
  331. pszBase[1] = '';
  332. }
  333. else if(2 < nPathCnt)
  334. {
  335. if(!strcmp(&pszBase[nPathCnt - 2], "\."))
  336. pszBase[nPathCnt - 2] = '';
  337. }
  339. return SUCCESS;
  340. }
  343. BOOL
  344. IsDevice (BYTE *pszFileName)
  345. {
  346. REG struct dhdr FAR *dhp = (struct dhdr FAR *)&nul_dev;
  347. BYTE szName[FNAME_SIZE];
  349. /* break up the name first */
  350. ParseDosName((BYTE FAR *)pszFileName,
  351.  (COUNT *)0, TempBuffer, szName, (BYTE *)0);
  352. SpacePad(szName, FNAME_SIZE);
  354. /* Test 1 - does it start with a dev or /dev */
  355. if((strcmp(szName, "/dev") == 0)
  356.  || (strcmp(szName, "\dev") == 0))
  357. return TRUE;
  359. /* Test 2 - is it on the device chain? */
  360. for(; -1l != (LONG)dhp; dhp = dhp -> dh_next)
  361. {
  362. COUNT nIdx;
  364. /* Skip if not char device */
  365. if(!(dhp -> dh_attr & ATTR_CHAR))
  366. continue;
  368. /* now compare */
  369. for(nIdx = 0; nIdx < FNAME_SIZE; ++nIdx)
  370. {
  371. if(dhp -> dh_name[nIdx] != szName[nIdx])
  372. break;
  373. }
  374. if(nIdx >= FNAME_SIZE)
  375. return TRUE;
  376. }
  378. return FALSE;
  379. }
  382. VOID
  383. DosTrimPath (BYTE FAR *lpszPathNamep)
  384. {
  385. BYTE FAR *lpszLast, FAR *lpszNext, FAR *lpszRoot = (BYTE FAR *)0;
  386. COUNT nChars, flDotDot;
  388. /* First, convert all '/' to ''.  Look for root as we scan */
  389. if(*lpszPathNamep == '\')
  390. lpszRoot = lpszPathNamep;
  391. for(lpszNext = lpszPathNamep; *lpszNext; ++lpszNext)
  392. {
  393. if(*lpszNext == '/')
  394. *lpszNext = '\';
  395. if(!lpszRoot &&
  396.  *lpszNext == ':' && *(lpszNext + 1) == '\')
  397. lpszRoot = lpszNext + 1;
  398. }
  400. for(lpszLast = lpszNext = lpszPathNamep, nChars = 0;
  401.   *lpszNext != '' && nChars < NAMEMAX; )
  402. {
  403. /* Initialize flag for loop. */
  404. flDotDot = FALSE;
  406. /* If we are at a path seperator, check for extra path */
  407. /* seperator, '.' and '..' to reduce. */
  408. if(*lpszNext == '\')
  409. {
  410. /* If it's '', just move everything down one. */
  411. if(*(lpszNext + 1) == '\')
  412. fstrncpy(lpszNext, lpszNext + 1, NAMEMAX);
  413. /* also check for '.' and '..' and move down */
  414. /* as appropriate. */
  415. else if(*(lpszNext + 1) == '.')
  416. {
  417. if(*(lpszNext + 2) == '.'
  418.  && !(*(lpszNext + 3)))
  419. {
  420. /* At the end, just truncate */
  421. /* and exit. */
  422. if(lpszLast == lpszRoot)
  423. *(lpszLast + 1) = '';
  424. else
  425. *lpszLast = '';
  426. return;
  427. }
  429. if(*(lpszNext + 2) == '.'
  430.  && *(lpszNext + 3) == '\')
  431. {
  432. fstrncpy(lpszLast, lpszNext + 3, NAMEMAX);
  433. /* bump back to the last */
  434. /* seperator. */
  435. lpszNext = lpszLast;
  436. /* set lpszLast to the last one */
  437. if(lpszLast <= lpszPathNamep)
  438. continue;
  439. do
  440. {
  441. --lpszLast;
  442. }
  443. while(lpszLast != lpszPathNamep
  444.  && *lpszLast != '\');
  445. flDotDot = TRUE;
  446. }
  447. /* Note: we skip strange stuff that */
  448. /* starts with '.' */
  449. else if(*(lpszNext + 2) == '\')
  450. {
  451. fstrncpy(lpszNext, lpszNext + 2, NAMEMAX);
  452. }
  453. /* If we're at the end of a string, */
  454. /* just exit. */
  455. else if(*(lpszNext + 2) == NULL)
  456. return;
  457. }
  458. else
  459. {
  460. /* No '.' or '' so mark it and bump */
  461. /* past */
  462. lpszLast = lpszNext++;
  463. continue;
  464. }
  466. /* Done.  Now set last to next to mark this */
  467. /* instance of path seperator. */
  468. if(!flDotDot)
  469. lpszLast = lpszNext;
  470. }
  471. else
  472. /* For all other cases, bump lpszNext for the */
  473. /* next check */
  474. ++lpszNext;
  475. }
  476. }