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

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

操作系统开发

开发平台：

DOS

ENV.C：源码内容
  1. /****************************************************************/
  2. /* */
  3. /*       env.c */
  4. /* */
  5. /*     command.com Environment Support  */
  6. /* */
  7. /*   August 9, 1991 */
  8. /* */
  9. /* Copyright (c) 1995 */
  10. /* Pasquale J. Villani */
  11. /* All Rights Reserved */
  12. /* */
  13. /* This file is part of DOS-C. */
  14. /* */
  15. /* DOS-C is free software; you can redistribute it and/or */
  16. /* modify it under the terms of the GNU General Public License */
  17. /* as published by the Free Software Foundation; either version */
  18. /* 2, or (at your option) any later version. */
  19. /* */
  20. /* DOS-C is distributed in the hope that it will be useful, but */
  21. /* WITHOUT ANY WARRANTY; without even the implied warranty of */
  22. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See */
  23. /* the GNU General Public License for more details. */
  24. /* */
  25. /* You should have received a copy of the GNU General Public */
  26. /* License along with DOS-C; see the file COPYING.  If not, */
  27. /* write to the Free Software Foundation, 675 Mass Ave, */
  28. /* Cambridge, MA 02139, USA. */
  29. /****************************************************************/
  32. /* $Log:   C:/dos-c/src/command/env.c_v  $
  33.  * 
  34.  *    Rev 1.3   31 Jan 1998  8:02:22   patv
  35.  * Re-written for improved environment handling.  Also fixed EnvSetVar bug.
  36.  *
  37.  *    Rev 1.2   29 Aug 1996 13:06:52   patv
  38.  * Bug fixes for v0.91b
  39.  *
  40.  *    Rev 1.1   01 Sep 1995 18:04:36   patv
  41.  * First GPL release.
  42.  *
  43.  *    Rev 1.0   02 Jul 1995 10:01:54   patv
  44.  * Initial revision.
  45.  */
  46. /* $EndLog$ */
  48. #include "../../hdr/portab.h"
  49. #include "globals.h"
  50. #include "proto.h"
  52. #ifdef VERSION_STRINGS
  53. static BYTE *RcsId = "$Header:   C:/dos-c/src/command/env.c_v   1.3   31 Jan 1998  8:02:22   patv  $";
  54. #endif
  56. BOOL EnvClearVar(BYTE *pszName);
  57. COUNT EnvSizeUp(VOID);
  58. VOID EnvCopy(BYTE FAR *lpszDest, BYTE FAR *lpszSrc);
  60. COUNT EnvSizeUp(VOID)
  61. {
  62. UWORD uNewEnv;
  63. BOOL bError;
  64. BYTE FAR *lpszSrc = lpEnviron;
  65. COUNT nSize = 0;
  67. while('' != *lpszSrc)
  68. {
  69. while(*lpszSrc)
  70. lpszSrc++, ++nSize;
  71. ++lpszSrc, ++nSize;
  72. }
  73. /* Count the terminating entry */
  74. lpszSrc++, ++nSize;
  77. /* Count the invocation part */
  78. ((UWORD FAR *)lpszSrc)++;
  79. nSize += sizeof(UWORD);
  80. while(*lpszSrc)
  81. lpszSrc++, ++nSize;
  83. /* Count the terminating null ... */
  84. nSize++;
  86. /* and return the count. */
  87. return nSize;
  88. }
  91. BOOL EnvAlloc(COUNT nSize)
  92. {
  93. COUNT nKlicks;
  94. BOOL bError;
  95. UWORD uSeg;
  97. /* Check for error */
  98. if(nSize <= EnvSizeUp())
  99. return FALSE;
  101. /* Do the allocation, then copy the environment */
  102. nKlicks = (nSize + PARASIZE - 1)/PARASIZE;
  103. uSeg = DosAllocMem(nKlicks, (BOOL FAR *)&bError);
  104. if(!bError)
  105. {
  106. EnvCopy(MK_FP(uSeg, 0), lpEnviron);
  107. DosFreeMem(FP_SEG(lpEnviron), &bError);
  108. if(bError)
  109. {
  110. DosFreeMem(uSeg, &bError);
  111. return FALSE;
  112. }
  113. lpEnviron = MK_FP(uSeg, 0);
  114. return TRUE;
  115. }
  116. else
  117. return FALSE;
  118. }
  121. BOOL EnvFree(BYTE FAR *lpMem)
  122. {
  123. UWORD uSeg;
  124. BOOL bError;
  126. uSeg = FP_SEG(lpMem);
  127. DosFreeMem(uSeg, (BOOL FAR *)bError);
  128. return !bError;
  129. }
  132. BYTE *EnvLookup(pszName)
  133. BYTE *pszName;
  134. {
  135. BYTE FAR *lpszString;
  136. static BYTE szNameBuffer[MAX_CMDLINE];
  137. BYTE *pszLclString;
  138. COUNT nNameLen;
  140. strcpy(szNameBuffer, pszName);
  141. nNameLen = strlen(pszName);
  142. for(pszLclString = szNameBuffer; *pszLclString != ''; pszLclString++)
  143. *pszLclString = toupper(*pszLclString);
  145. lpszString = lpEnviron;
  146. while('' != *lpszString)
  147. {
  148. if((0 == fstrncmp(lpszString, (BYTE FAR *)szNameBuffer, nNameLen))
  149. || (0 == fstrncmp(lpszString, (BYTE FAR *)pszName, nNameLen)))
  150. {
  151. /* Match, skip the variable name */
  152. while(*lpszString && '=' != *lpszString)
  153. ++lpszString;
  154. ++lpszString;
  155. /* Now copy var into static buffer */
  156. for(pszLclString = szNameBuffer; *lpszString; )
  157. {
  158. *pszLclString++ = *lpszString++;
  159. }
  160. *pszLclString = '';
  161. return szNameBuffer;
  162. }
  163. else
  164. {
  165. while(*lpszString)
  166. *lpszString++;
  167. ++lpszString;
  168. }
  169. }
  170. return (BYTE *)0;
  171. }
  174. BOOL EnvClearVar(BYTE *pszName)
  175. {
  176. COUNT nNameLen, uArenaSeg;
  177. UWORD uNewEnv;
  178. BYTE FAR *lpszSrc, FAR *lpszDest;
  179. BOOL bError;
  180. BYTE szNameBuffer[MAX_CMDLINE], *pszLclString;
  181. mcb FAR *lpArena;
  183. strcpy(szNameBuffer, pszName);
  184. for(pszLclString = szNameBuffer; *pszLclString != ''; pszLclString++)
  185. *pszLclString = toupper(*pszLclString);
  186. nNameLen = strlen(pszName);
  187. lpszSrc = lpEnviron;
  188. uArenaSeg = FP_SEG(lpEnviron) - 1;
  189. lpArena = MK_FP(uArenaSeg, 0);
  190. uNewEnv = DosAllocMem(lpArena -> m_size, (BOOL FAR *)&bError);
  191. if(bError)
  192. return FALSE;
  193. lpszDest = MK_FP(uNewEnv, 0);
  195. /* Copy the old environment into the new and skip the one we */
  196. /* want to delete. */
  197. while('' != *lpszSrc)
  198. {
  199. if((0 == fstrncmp(lpszSrc, (BYTE FAR *)szNameBuffer, nNameLen))
  200. || (0 == fstrncmp(lpszSrc, (BYTE FAR *)pszName, nNameLen)))
  201. {
  202. /* Match, skip the source */
  203. while(*lpszSrc)
  204. ++lpszSrc;
  205. ++lpszSrc;
  206. }
  207. else
  208. {
  209. while(*lpszSrc)
  210. *lpszDest++ = *lpszSrc++;
  211. ++lpszSrc;
  212. *lpszDest++ = '';
  213. }
  214. }
  215. /* Copy the terminating entry */
  216. *lpszDest++ = *lpszSrc++;
  219. /* Copy the invocation part */
  220. *((UWORD FAR *)lpszDest)++ = *((UWORD FAR *)lpszSrc)++;
  221. while(*lpszSrc)
  222. *lpszDest++ = *lpszSrc++;
  224. /* and finally null terminate. */
  225. *lpszDest++ = '';
  227. EnvCopy(lpEnviron, MK_FP(uNewEnv, 0));
  228. DosFreeMem(uNewEnv, (BOOL FAR *)&bError);
  229. return !bError;
  230. }
  233. VOID EnvCopy(BYTE FAR *lpszDest, BYTE FAR *lpszSrc)
  234. {
  235. UWORD uNewEnv;
  236. BOOL bError;
  238. while('' != *lpszSrc)
  239. {
  240. while(*lpszSrc)
  241. *lpszDest++ = *lpszSrc++;
  242. ++lpszSrc;
  243. *lpszDest++ = '';
  244. }
  245. /* Copy the terminating entry */
  246. *lpszDest++ = *lpszSrc++;
  249. /* Copy the invocation part */
  250. *((UWORD FAR *)lpszDest)++ = *((UWORD FAR *)lpszSrc)++;
  251. while(*lpszSrc)
  252. *lpszDest++ = *lpszSrc++;
  254. /* and finally null terminate. */
  255. *lpszDest++ = '';
  256. }
  259. BOOL EnvSetVar(BYTE *pszName, BYTE *pszValue)
  260. {
  261. BYTE *pszOldVal;
  263. /* See if it's already defined.  If it is, then we have a */
  264. /* operation.  Otherwise, we do an append. */
  265. pszOldVal = EnvLookup(pszName);
  266. if(pszOldVal) /* Replace operation */
  267. {
  268. COUNT nSize, nNameLen;
  269. UWORD uEnvSize;
  270. psp FAR *lpPsp;
  271. mcb FAR *lpArena;
  272. UWORD uNewEnv, uArenaSeg;
  273. BYTE FAR *lpszSrc, FAR *lpszDest;
  274. BOOL bError;
  275. BYTE szNameBuffer[MAX_CMDLINE], *pszLclString;
  277. if((strlen(pszName)+strlen(pszValue)+2-strlen(pszOldVal))
  278.  >= EnvSizeUp())
  279. return FALSE;
  281. strcpy(szNameBuffer, pszName);
  282. nNameLen = strlen(szNameBuffer);
  283. for(pszLclString = szNameBuffer; *pszLclString != ''; pszLclString++)
  284. *pszLclString = toupper(*pszLclString);
  285. lpszSrc = lpEnviron;
  286. uArenaSeg = FP_SEG(lpEnviron) - 1;
  287. lpArena = MK_FP(uArenaSeg, 0);
  288. uNewEnv = DosAllocMem(lpArena -> m_size, (BOOL FAR *)&bError);
  289. if(bError)
  290. return FALSE;
  291. lpszDest = MK_FP(uNewEnv, 0);
  293. /* Copy the old environment into the new and append the */
  294. /* new one. */
  295. while('' != *lpszSrc)
  296. {
  297. if((0 == fstrncmp(lpszSrc, (BYTE FAR *)szNameBuffer, nNameLen))
  298. || (0 == fstrncmp(lpszSrc, (BYTE FAR *)pszName, nNameLen)))
  299. {
  300. /* Copy in the new string */
  301. for(pszLclString = szNameBuffer; *pszLclString; )
  302. *lpszDest++ = *pszLclString++;
  303. *lpszDest++ = '=';
  304. for(pszLclString = pszValue; *pszLclString; )
  305. *lpszDest++ = *pszLclString++;
  306. *lpszDest++ = '';
  308. /* Skip past the source */
  309. while(*lpszSrc)
  310. lpszSrc++;
  311. ++lpszSrc;
  312. }
  313. else
  314. {
  315. while(*lpszSrc)
  316. *lpszDest++ = *lpszSrc++;
  317. ++lpszSrc;
  318. *lpszDest++ = '';
  319. }
  320. }
  322. /* Copy the terminating entry */
  323. *lpszDest++ = *lpszSrc++;
  325. /* Copy the invocation part */
  326. *((UWORD FAR *)lpszDest)++ = *((UWORD FAR *)lpszSrc)++;
  327. while(*lpszSrc)
  328. *lpszDest++ = *lpszSrc++;
  330. /* and finally null terminate. */
  331. *lpszDest++ = '';
  333. EnvCopy(lpEnviron, MK_FP(uNewEnv, 0));
  334. DosFreeMem(uNewEnv, (BOOL FAR *)&bError);
  335. return !bError;
  336. }
  337. else /* Append operation */
  338. {
  339. COUNT nSize;
  340. UWORD uEnvSize;
  341. psp FAR *lpPsp;
  342. mcb FAR *lpArena;
  343. UWORD uNewEnv, uArenaSeg;
  344. BYTE FAR *lpszSrc, FAR *lpszDest;
  345. BOOL bError;
  346. BYTE szNameBuffer[MAX_CMDLINE], *pszLclString;
  348. if((strlen(pszName)+strlen(pszValue)+2) >= EnvSizeUp())
  349. return FALSE;
  351. strcpy(szNameBuffer, pszName);
  352. for(pszLclString = szNameBuffer; *pszLclString != ''; pszLclString++)
  353. *pszLclString = toupper(*pszLclString);
  354. lpszSrc = lpEnviron;
  355. uArenaSeg = FP_SEG(lpEnviron) - 1;
  356. lpArena = MK_FP(uArenaSeg, 0);
  357. uNewEnv = DosAllocMem(lpArena -> m_size, (BOOL FAR *)&bError);
  358. if(bError)
  359. return FALSE;
  360. lpszDest = MK_FP(uNewEnv, 0);
  362. /* Copy the old environment into the new and append the */
  363. /* new one. */
  364. while('' != *lpszSrc)
  365. {
  366. while(*lpszSrc)
  367. *lpszDest++ = *lpszSrc++;
  368. ++lpszSrc;
  369. *lpszDest++ = '';
  370. }
  372. /* Append the new one. */
  373. for(pszLclString = szNameBuffer; *pszLclString; )
  374. *lpszDest++ = *pszLclString++;
  375. *lpszDest++ = '=';
  376. for(pszLclString = pszValue; *pszLclString; )
  377. *lpszDest++ = *pszLclString++;
  378. *lpszDest++ = '';
  380. /* Copy the terminating entry */
  381. *lpszDest++ = *lpszSrc++;
  383. /* Copy the invocation part */
  384. *((UWORD FAR *)lpszDest)++ = *((UWORD FAR *)lpszSrc)++;
  385. while(*lpszSrc)
  386. *lpszDest++ = *lpszSrc++;
  388. /* and finally null terminate. */
  389. *lpszDest++ = '';
  391. EnvCopy(lpEnviron, MK_FP(uNewEnv, 0));
  392. DosFreeMem(uNewEnv, (BOOL FAR *)&bError);
  393. return !bError;
  394. }
  395. return TRUE;
  396. }
  399. BOOL EnvDump(VOID)
  400. {
  401. BYTE FAR *lpszEnv;
  402. BYTE *pszLclBuffer;
  403. COUNT nCount;
  405. for(lpszEnv = lpEnviron; *lpszEnv != ''; )
  406. {
  407. static BYTE szBuffer[MAX_CMDLINE];
  409. for(pszLclBuffer = szBuffer, nCount = 0;
  410.  nCount < MAX_CMDLINE; nCount++)
  411. {
  412. *pszLclBuffer++ = *lpszEnv++;
  413. if(!*lpszEnv)
  414. break;
  415. }
  416. *pszLclBuffer++ = '';
  417. ++lpszEnv;
  418. printf("%sn", szBuffer);
  419. }
  420. return TRUE;
  421. }