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

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

操作系统开发

开发平台：

DOS

CMD.C：源码内容
  1. /****************************************************************/
  2. /* */
  3. /*        cmd.c */
  4. /* */
  5. /*      command.com Top Level Driver  */
  6. /* */
  7. /*   August 9, 1991 */
  8. /* */
  9. /*      Copyright (c) 1995, 1996 */
  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. /* $Logfile:   C:/dos-c/src/command/cmd.c_v  $ */
  34. /* $Log:   C:/dos-c/src/command/cmd.c_v  $ 
  35.  * 
  36.  *    Rev 1.4   31 Jan 1998  8:12:30   patv
  37.  * Put preprocessor switch for version strings and changed log strings
  38.  * 
  39.  *    Rev 1.3   29 Aug 1996 13:07:04   patv
  40.  * Bug fixes for v0.91b
  41.  * 
  42.  *    Rev 1.2   19 Feb 1996  3:18:54   patv
  43.  * Added NLS, int2f and config.sys processing
  44.  * 
  45.  *    Rev 1.1   01 Sep 1995 18:04:34   patv
  46.  * First GPL release.
  47.  * 
  48.  *    Rev 1.0   02 Jul 1995 10:01:48   patv
  49.  * Initial revision.
  50.  */
  51. /* $EndLog$ */
  53. #include <ctype.h>
  54. #include "../../hdr/portab.h"
  55. #define MAIN
  56. #include "globals.h"
  57. #include "proto.h"
  59. #ifdef VERSION_STRINGS
  60. static BYTE *RcsId = "$Header:   C:/dos-c/src/command/cmd.c_v   1.4   31 Jan 1998  8:12:30   patv  $";
  61. #endif
  63. #ifdef PROTO
  64. struct table
  65. {
  66. BYTE *entry;
  67. BOOL (*func)(COUNT, BYTE **);
  68. };
  69. #else
  70. struct table
  71. {
  72. BYTE *entry;
  73. BOOL (*func)();
  74. };
  75. #endif
  77. #ifdef PROTO
  78. struct table *lookup(struct table *, BYTE *);
  79. VOID err_report(COUNT);
  80. VOID put_prompt(BYTE *);
  81. VOID Redirect(BYTE *, BYTE *, BYTE *, BOOL *);
  82. VOID RestoreIO(COUNT, COUNT);
  83. #else
  84. struct table *lookup();
  85. VOID err_report();
  86. VOID put_prompt();
  87. VOID Redirect();
  88. VOID RestoreIO();
  89. #endif
  91. BOOL ExecCmd();
  92. BOOL prompt();
  93. BOOL cmd_path();
  94. BOOL cmd_exit();
  95. BOOL type();
  96. BOOL cd();
  97. BOOL copy();
  98. BOOL del();
  99. BOOL ren();
  100. BOOL mkdir();
  101. BOOL rmdir();
  102. BOOL cmd_time();
  103. BOOL cmd_date();
  104. BOOL verify();
  105. BOOL ver();
  106. BOOL cmd_break();
  107. BOOL  batch();
  108. BOOL label_bat();
  109. BOOL pause_bat();
  110. BOOL call_bat();
  111. BOOL echo_bat();
  112. BOOL echo_dot_bat();
  113. BOOL for_bat();
  114. BOOL if_bat();
  115. BOOL rem_bat();
  116. BOOL shift_bat();
  117. BOOL goto_bat();
  118. BOOL set_bat();
  120. /* External cmmands */
  122. struct table  commands[] =
  123. {
  124. {"break", cmd_break},
  125. {"copy", copy},
  126. {"cd", cd},
  127. {"chdir", cd},
  128. {"date", cmd_date},
  129. {"del", del},
  130. {"dir", dir},
  131. {"erase", del},
  132. {"exit", cmd_exit},
  133. {"mkdir", mkdir},
  134. {"md", mkdir},
  135. {"path", cmd_path},
  136. {"prompt", prompt},
  137. {"ren", ren},
  138. {"rmdir", rmdir},
  139. {"rd", rmdir},
  140. {"time", cmd_time},
  141. {"type", type},
  142. {"verify", verify},
  143. {"ver", ver},
  144. {"if", if_bat},
  145. {"label", label_bat},
  146. {"pause", pause_bat},
  147. {"call", call_bat},
  148. {"echo", echo_bat},
  149. {"echo.", echo_dot_bat},
  150. {"echo+", echo_dot_bat},
  151. {"echo"", echo_dot_bat},
  152. {"echo/", echo_dot_bat},
  153. {"echo[", echo_dot_bat},
  154. {"echo]", echo_dot_bat},
  155. {"echo:", echo_dot_bat},
  156. {"for", for_bat},
  157. {"rem", rem_bat},
  158. {"shift", shift_bat},
  159. {"goto", goto_bat},
  160. {"set", set_bat},
  161. {"", ExecCmd}
  162. };
  164. static COUNT argc;
  165. static BYTE *argv[NPARAMS];
  167. static BOOL pflag, bootup = FALSE;
  169. VOID main()
  170. {
  171. COUNT nread;
  172. BOOL bool_FLAG = FALSE;
  173. BOOL cflag;
  174. BYTE FAR *cmd_tail;
  175. BYTE *p_ptr;
  176. extern UWORD _psp;
  177. psp FAR *p;
  178. COUNT driveno = -1;
  179. BYTE pattern[MAX_CMDLINE] = "";
  180. BYTE path[MAX_CMDLINE] = "", esize[MAX_CMDLINE] = "";
  182. /* Initialize the interpreter */
  183. p = MK_FP(_psp, 0);
  184. switchchar = '/';
  185. batch_FLAG = FALSE;
  186. argv[0] = args[0];
  187. argv[1] = (BYTE *)0;
  188. args[0][0] = '';
  189. *tail = '';
  190. lpEnviron = (BYTE FAR *)MK_FP(p -> ps_environ, 0);
  191. cmd_tail = MK_FP(_psp, 0x81);
  192. fstrncpy((BYTE FAR *)tail, cmd_tail, 0x7f);
  194. pflag = cflag = FALSE;
  195. dosopt("$d$p*[e:pc]+", (BYTE FAR *)tail,
  196. &driveno, path, pattern, esize, &pflag, &cflag);
  198. /* Get the passed-in Environment size and make certain we */
  199. /* allocate enough space */
  200. EnvSize = EnvSizeUp();
  201. if(EnvSize < ENV_DEFAULT)
  202. EnvSize = ENV_DEFAULT;
  203. if(*esize != '')
  204. {
  205. COUNT size = atoi(esize);
  207. bool_FLAG = EnvAlloc(size);
  208. EnvSize = size;
  209. }
  210. else
  211. bool_FLAG = EnvAlloc(EnvSize);
  213. if(!bool_FLAG)
  214. error_message(OUT_ENV_SPACE);
  216. /* Check what PROMPT is set in env to over ride default  */
  217. p_ptr = EnvLookup("PROMPT");
  218. if(p_ptr != (BYTE *)0)
  219. scopy(p_ptr, prompt_string);
  220. else
  221. scopy(dflt_pr_string, prompt_string);
  223. /* Check what PATH is set in env to over ride default  */
  224. p_ptr = EnvLookup("PATH");
  225. if(p_ptr != (BYTE *)0)
  226. scopy(p_ptr, path);
  227. else
  228. scopy(dflt_path_string, path);
  229. if(!cflag)
  230. {
  231. if(pflag)
  232. {
  233. /* Special MS-DOS compatability initialization, */
  234. /* all command shells terminate onto */
  235. /* themselves, but we always terminate at the */
  236. /* root shell. If anyone complains, we'll */
  237. /* change it. */
  238. #ifndef DEBUG
  239. p -> ps_parent = _psp;
  240. #endif
  242. /* Try to exec autoexec.bat */
  243. bootup = TRUE;
  244. *tail = '';
  245. if(!batch(".\autoexec.bat", tail))
  246. {
  247. *tail = '';
  248. cmd_date(1, argv);
  249. cmd_time(1, argv);
  250. bootup = FALSE;
  251. }
  252. }
  253. else
  254. {
  255. /* Announce our version */
  256. printf(ANNOUNCE, copyright);
  257. #ifdef SHWR
  258. printf("**** Shareware version ****nPlease register your copy.n");
  259. #else
  260. printf("nn");
  261. #endif
  262. }
  264. FOREVER
  265. {
  266. default_drive = DosGetDrive();
  267. put_prompt(prompt_string);
  268. if((nread = DosRead(STDIN, (BYTE FAR *)cmd_line, MAX_CMDLINE)) < 0)
  269. continue;
  270. do_command(nread);
  271. }
  272. }
  273. else
  274. {
  275. BYTE FAR *p;
  277. default_drive = DosGetDrive();
  278. for(p = cmd_tail; *p != 'r'; p++)
  279. {
  280. if(*p == '/' && (*(p + 1) == 'c' || *(p + 1) == 'C'))
  281. break;
  282. }
  283. p += 2;
  284. fstrncpy((BYTE FAR *)cmd_line, p, 0x7f);
  285. for(nread = 0; *p != 'r'; nread++, p++)
  286. ;
  287. ++nread;
  288. do_command(nread);
  289. }
  290. }
  293. VOID Redirect(cmd_line, Input, Output, AppendMode)
  294. BYTE *cmd_line, *Input, *Output;
  295. BOOL *AppendMode;
  296. {
  297. BYTE LocalBuffer[MAX_CMDLINE], *lp, *dp = cmd_line;
  299. /* First - create an image, since we'll be copying back into */
  300. /* the original buffer. */
  301. strcpy(LocalBuffer, cmd_line);
  303. /* Next, start looking for redirect symbols. */
  304. lp = skipwh(LocalBuffer);
  305. while(*lp != '')
  306. {
  307. switch(*lp)
  308. {
  309. case '<':
  310. lp = scan(++lp, Input);
  311. break;
  313. case '>':
  314. if(*(lp + 1) == '>')
  315. {
  316. ++lp;
  317. *AppendMode = TRUE;
  318. }
  319. lp = scan(++lp, Output);
  320. break;
  322. default:
  323. *dp++ = *lp++;
  324. break;
  325. }
  326. }
  327. *dp = '';
  328. }
  331. VOID do_command(nread)
  332. COUNT nread;
  333. {
  334. REG struct table *p;
  335. REG BYTE *lp;
  336. COUNT index = 0;
  337. BYTE Input[MAX_CMDLINE], Output[MAX_CMDLINE];
  338. BOOL AppendMode;
  339. COUNT OldStdin = -1, OldStdout = -1, ErrorCode;
  340. BOOL IORedirected = FALSE;
  342. if(nread <= 0)
  343. return;
  344. cmd_line[nread] = '';
  346. /* Pre-scan the command line and look for any re-directs */
  347. *Input = *Output = '';
  348. AppendMode = FALSE;
  349. Redirect(cmd_line, Input, Output, &AppendMode);
  350. IORedirected = (*Input != '' || *Output != '');
  351. if(*Input != '')
  352. {
  353. COUNT Handle;
  355. if(!DosDupHandle(STDIN, (COUNT FAR *)&OldStdin, (COUNT FAR *)&ErrorCode))
  356. {
  357. RestoreIO(OldStdin, -1);
  358. error_message(INTERNAL_ERR);
  359. return;
  360. }
  362. Handle = DosOpen((BYTE FAR *)Input, O_RDWR);
  363. if((Handle < 0) || (!DosForceDupHandle(Handle, STDIN, (COUNT FAR *)&ErrorCode)))
  364. {
  365. RestoreIO(OldStdin, -1);
  366. error_message(INTERNAL_ERR);
  367. return;
  368. }
  369. DosClose(Handle);
  370. }
  372. if(*Output != '')
  373. {
  374. COUNT Handle;
  376. if(!DosDupHandle(STDOUT, (COUNT FAR *)&OldStdout, (COUNT FAR *)&ErrorCode))
  377. {
  378. RestoreIO(-1, OldStdout);
  379. error_message(INTERNAL_ERR);
  380. return;
  381. }
  383. if(AppendMode)
  384. {
  385. if((Handle = DosOpen((BYTE FAR *)Output, O_RDWR)) < 0)
  386. {
  387. RestoreIO(-1, OldStdout);
  388. error_message(INTERNAL_ERR);
  389. return;
  390. }
  391. DosSeek(Handle, 2, 0l);
  392. }
  393. else
  394. Handle = DosCreat((BYTE FAR *)Output, D_NORMAL | D_ARCHIVE);
  396. if((Handle < 0) || (!DosForceDupHandle(Handle, STDOUT, (COUNT FAR *)&ErrorCode)))
  397. {
  398. RestoreIO(-1, OldStdout);
  399. error_message(INTERNAL_ERR);
  400. return;
  401. }
  402. DosClose(Handle);
  403. }
  405. for(argc = 0; argc < 16; argc++)
  406. {
  407. argv[argc] = (BYTE *)0;
  408. args[argc][0] = '';
  409. }
  410. lp = scanspl(cmd_line, args[0], '/');
  412. if(args[0][0] == '@')
  413. {
  414. at_FLAG = TRUE;
  415. index++;
  416. }
  417. else
  418. at_FLAG = FALSE;
  420. /* If preceeded by a @, swallow it, it was taken care of */
  421. /* elsewhere.  Also, change case so that our command verb is */
  422. /* case sensitive. */
  423. while(args[0][index] != '')
  424. {
  426. if(at_FLAG)
  427. args[0][index-1] = tolower(args[0][index]);
  428. else
  429. args[0][index] = tolower(args[0][index]);
  430. index++;
  431. }
  432. if(at_FLAG)
  433. args[0][index-1] = '';
  435. argv[0] = args[0];
  436. /* this kludge is for an MS-DOS wart emulation */
  437. tail = skipwh(lp);
  439. for(argc = 1; argc < NPARAMS; argc++)
  440. {
  441. lp = scan(lp, args[argc]);
  442. if(*args[argc] == '')
  443. break;
  444. else
  445. argv[argc] = args[argc];
  446. }
  448. if(*argv[0] != '')
  449. {
  450. /* Look for just a drive change command, and execute */
  451. /* it if found. */
  452. if(argv[0][1] == ':' && argv[0][2] == NULL)
  453. {
  454. BYTE c = argv[0][0];
  456. if(c >= 'a' && c <= 'z')
  457. c = c - 'a' + 'A';
  458. if(c >= 'A' && c <= 'Z')
  459. DosSetDrive(c - 'A');
  460. }
  462. /* It may be a help command request. */
  463. else if((argv[1][0] == switchchar) &&
  464.  (argv[1][1] == '?'))
  465. {
  466. strcpy(tail, " ");
  467. strcat(tail, argv[0]);
  468. strcat(tail, "rn");
  469. argc = 2;
  470. argv[1] = argv[0];
  471. argv[0] = "help";
  472. argv[2] = 0;
  473. ExecCmd(argc, argv);
  474. if(IORedirected)
  475. RestoreIO(OldStdin, OldStdout);
  476. }
  477. /* do a normal command execution */
  478. else
  479. {
  480. p = lookup(commands, argv[0]);
  481. (*(p -> func))(argc, argv);
  482. if(IORedirected)
  483. RestoreIO(OldStdin, OldStdout);
  484. }
  485. }
  486. }
  489. BOOL prompt(argc, argv)
  490. WORD argc;
  491. BYTE *argv[];
  492. {
  493. BYTE *p;
  494. BYTE *cmd = "PROMPT";
  496. if(argc == 1)
  497. {
  498. p = EnvLookup(cmd);
  499. if(p != (BYTE *)0)
  500. scopy(p, prompt_string);
  501. else
  502. {
  503. scopy(dflt_pr_string, prompt_string);
  504. EnvClearVar(cmd);
  505. }
  506. }
  507. else
  508. {
  509. /* Trim trailing newline */
  510. for(p = tail; (*p != 'r') && (*p != 'n'); p++)
  511. ;
  512. *p = '';
  514. /* should be scopy(argv[1], &pr_string[1]); but to */
  515. /* emulate an MS-DOS wart, is */
  516. scopy(tail, prompt_string);
  518. /* Now set the environment variable for all children to */
  519. /* see. */
  520. EnvSetVar(cmd, prompt_string);
  521. }
  522. return TRUE;
  523. }
  526. struct table *lookup(p, token)
  527. struct table *p;
  528. BYTE *token;
  529. {
  530. while(*(p -> entry) != '')
  531. {
  532. if(strcmp(p -> entry, token) == 0)
  533. break;
  534. else
  535. ++p;
  536. }
  537. return p;
  538. }
  541. VOID RestoreIO(DupStdin, DupStdout)
  542. {
  543. COUNT ErrorCode;
  545. if(DupStdin >= 0)
  546. {
  547. if(!DosForceDupHandle(DupStdin, STDIN, (COUNT FAR *)&ErrorCode))
  548. error_message(INTERNAL_ERR);
  549. DosClose(DupStdin);
  550. }
  552. if(DupStdout >= 0)
  553. {
  554. if(!DosForceDupHandle(DupStdout, STDOUT, (COUNT FAR *)&ErrorCode))
  555. error_message(INTERNAL_ERR);
  556. DosClose(DupStdout);
  557. }
  558. }
  561. BOOL ExecCmd(argc, argv)
  562. COUNT argc;
  563. BYTE *argv[];
  564. {
  565. exec_blk exb;
  566. COUNT err;
  567. BYTE tmppath[64];
  568. COUNT idx;
  569. BOOL ext = FALSE;
  570. BYTE *extp;
  571. COUNT len;
  572. BYTE *lp;
  573. CommandTail CmdTail;
  574. fcb fcb1, fcb2;
  575. static BYTE *extns[2] =
  576. {
  577. ".com",
  578. ".exe"
  579. };
  580. static BYTE *batfile = ".bat";
  581. BYTE PathString[MAX_CMDLINE];
  582. BYTE Path[MAX_CMDLINE], *pPath;
  584. /* Build the path string and create the full string that */
  585. /* includes "." so that the current directory is searched */
  586. /* first.  Note that Path is initialized outside the loop. */
  587. strcpy(Path, ".\");
  588. strcpy(PathString, EnvLookup("PATH"));
  589. pPath = PathString;
  591. do
  592. {
  593. /* Build a path to the command. */
  594. if(*pPath == ';')
  595. ++pPath;
  596. strcpy(tmppath, Path);
  597. if(*tmppath != '' && !((tmppath[strlen(tmppath) - 1] != '\') == 0))
  598. strcat(tmppath, "\");
  599. strcat(tmppath, argv[0]);
  601. /* batch processing */
  602. /* search for an extension in the specification */
  603. for(idx = len = strlen(argv[0]) ; idx > 0 && idx > (len - FEXT_SIZE - 2); --idx)
  604. {
  605. if(argv[0][idx] == '.')
  606. {
  607. ext = TRUE;
  608. extp = &argv[0][idx];
  609. break;
  610. }
  611. }
  613. /* If no extension was found, the entire path was */
  614. /* specified and we do not append an extension. */
  615. if(!ext)
  616. {
  617. strcat(tmppath, batfile);
  618. extp = batfile;
  619. }
  621. /* if it ends with a '.bat' (either user supplied or */
  622. /* previously added), try to run as a batch. */
  623. if((strcmp(extp, batfile) == 0) && batch(tmppath, tail))
  624. {
  625. if(pflag && bootup)
  626. bootup = FALSE;
  627. return TRUE;
  628. }
  630. /* tail comes in as a string with trailing newline.  */
  631. /* Convert it to a return only and put it into CmdTail */
  632. /* format */
  633. CmdTail.ctCount = (argc > 1) ? strlen(tail) : 1;
  634. strcpy(CmdTail.ctBuffer, " ");
  635. strcpy(&CmdTail.ctBuffer[1], (argc > 1) ? tail : "");
  636. CmdTail.ctBuffer[CmdTail.ctCount] = '';
  637. if(CmdTail.ctCount < LINESIZE)
  638. CmdTail.ctBuffer[CmdTail.ctCount] = '';
  639. rtn_errlvl = 0;
  640. exb.exec.env_seg = FP_SEG(lpEnviron);
  641. exb.exec.cmd_line = (CommandTail FAR *)&CmdTail;
  643. #if 0
  644. if(argc > 1)
  645. {
  646. DosParseFilename((BYTE FAR *)argv[1], (fcb FAR *)&fcb1, 0);
  647. exb.exec.fcb_1 = (fcb FAR *)&fcb1;
  648. }
  649. else
  650. exb.exec.fcb_1 = (fcb FAR *)0;
  651. if(argc > 2)
  652. {
  653. exb.exec.fcb_2 = (fcb FAR *)&fcb2;
  654. DosParseFilename((BYTE FAR *)argv[2], (fcb FAR *)&fcb2, 0);
  655. }
  656. else
  657. exb.exec.fcb_2 = (fcb FAR *)0;
  658. #else
  659. exb.exec.fcb_1 = (fcb FAR *)0;
  660. exb.exec.fcb_2 = (fcb FAR *)0;
  661. #endif
  663. for(idx = 0; idx < 2; idx++)
  664. {
  665. strcpy(tmppath, Path);
  666. if(*tmppath != '' && !((tmppath[strlen(tmppath) - 1] != '\') == 0))
  667. strcat(tmppath, "\");
  668. strcat(tmppath, argv[0]);
  669. if(!ext)
  670. {
  671. strcat(tmppath, extns[idx]);
  672. extp = extns[idx];
  673. }
  674. if(!(strcmp(extp, extns[idx]) == 0))
  675. continue;
  676. if((rtn_errlvl = err = DosExec((BYTE FAR *)tmppath, (exec_blk FAR *)&exb)) != SUCCESS)
  677. {
  678. switch(err)
  679. {
  680. case DE_FILENOTFND:
  681. continue;
  683. case DE_INVLDFUNC:
  684. rtn_errlvl = INV_FUNCTION_PARAM;
  685. goto errmsg;
  687. case DE_PATHNOTFND:
  688. rtn_errlvl = PATH_NOT_FOUND;
  689. goto errmsg;
  691. case DE_TOOMANY:
  692. rtn_errlvl = TOO_FILES_OPEN;
  693. goto errmsg;
  695. case DE_ACCESS:
  696. rtn_errlvl = ACCESS_DENIED;
  697. goto errmsg;
  699. case DE_NOMEM:
  700. rtn_errlvl = INSUFF_MEM;
  701. goto errmsg;
  703. default:
  704. rtn_errlvl = EXEC_ERR;
  705. errmsg:
  706. error_message(rtn_errlvl);
  707. return FALSE;
  708. }
  709. }
  710. else
  711. {
  712. rtn_errlvl = DosRtnValue() & 0xff;
  713. return TRUE;
  714. }
  715. }
  716. if(err < 0 || idx == 2)
  717. {
  718. if(!(err == DE_FILENOTFND || idx == 2))
  719. {
  720. error_message(EXEC_FAIL);
  721. return FALSE;
  722. }
  723. continue;
  724. }
  725. }
  726. while(*Path = '', pPath = scanspl(pPath, Path, ';'), *Path != '');
  727. error_message(BAD_CMD_FILE_NAME);
  728. return FALSE;
  729. }
  732. BOOL cmd_exit(argc, argv)
  733. COUNT argc;
  734. BYTE FAR *argv[];
  735. {
  736. #ifndef DEBUG
  737. /* Don't exit from a permanent shell */
  738. if(pflag)
  739. return TRUE;
  740. #endif
  742. /* If no values passed, return errorvalue = 0 */
  743. if(argc == 1)
  744. DosExit(0);
  746. /* otherwise return what the user asked for */
  747. else
  748. {
  749. COUNT ret_val;
  750. static BYTE nums[] = "0123456789";
  751. BYTE FAR *p;
  753. for(ret_val = 0, p = argv[1]; isdigit(*p); p++)
  754. {
  755. COUNT j;
  757. for(j = 0; j < 10; j++)
  758. if(nums[j] == *p)
  759. break;
  760. ret_val += j;
  761. }
  762. DosExit(ret_val);
  763. }
  764.         return TRUE;
  765. }
  768. VOID sto(c)
  769. COUNT c;
  770. {
  771. BYTE ch[1];
  773. *ch = c;
  774. DosWrite(STDOUT, (BYTE FAR *)ch, 1);
  775. }