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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
COMINT.C
资源名称：drdossrc.zip　[点击查看]
上传用户：xiaogehua
上传日期：2007-01-08
资源大小：1183k
文件大小：56k
源码类别：

操作系统开发

开发平台：

Asm

COMINT.C：源码内容
  1. /*
  2. ;    File              : $Workfile: COMINT.C$
  3. ;
  4. ;    Description       :
  5. ;
  6. ;    Original Author   : DIGITAL RESEARCH
  7. ;
  8. ;    Last Edited By    : $CALDERA$
  9. ;
  10. ;-----------------------------------------------------------------------;
  11. ;    Copyright Work of Caldera, Inc. All Rights Reserved.
  12. ;      
  13. ;    THIS WORK IS A COPYRIGHT WORK AND CONTAINS CONFIDENTIAL,
  14. ;    PROPRIETARY AND TRADE SECRET INFORMATION OF CALDERA, INC.
  15. ;    ACCESS TO THIS WORK IS RESTRICTED TO (I) CALDERA, INC. EMPLOYEES
  16. ;    WHO HAVE A NEED TO KNOW TO PERFORM TASKS WITHIN THE SCOPE OF
  17. ;    THEIR ASSIGNMENTS AND (II) ENTITIES OTHER THAN CALDERA, INC. WHO
  18. ;    HAVE ACCEPTED THE CALDERA OPENDOS SOURCE LICENSE OR OTHER CALDERA LICENSE
  19. ;    AGREEMENTS. EXCEPT UNDER THE EXPRESS TERMS OF THE CALDERA LICENSE
  20. ;    AGREEMENT NO PART OF THIS WORK MAY BE USED, PRACTICED, PERFORMED,
  21. ;    COPIED, DISTRIBUTED, REVISED, MODIFIED, TRANSLATED, ABRIDGED,
  22. ;    CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED, RECAST,
  23. ;    TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF
  24. ;    CALDERA, INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT
  25. ;    AUTHORIZATION COULD SUBJECT THE PERPETRATOR TO CRIMINAL AND
  26. ;    CIVIL LIABILITY.
  27. ;-----------------------------------------------------------------------;
  28. ;
  29. ;    *** Current Edit History ***
  30. ;    *** End of Current Edit History ***
  31. ;
  32. ;    $Log$
  33. ;
  34. ;    ENDLOG
  35. */
  37. #include "defines.h"
  38. #include <string.h>
  40. #if defined(MWC) && defined(strlen)
  41. #undef strcmp /* These are defined as macros in string.h */
  42. #undef strcpy /* which are expaneded in line under */
  43. #undef strlen /* Metaware C. These undefs avoid this. */
  44. #endif
  46. #include <portab.h>
  47. #include <mserror.h>
  49. #if !defined(DOSPLUS)
  50. #include <pd.h>
  51. #include <ccpm.h>
  52. #include <sysdat.h>
  53. #endif
  55. #include "command.h" /* COMMAND Definitions */
  56. #include "dos.h"  /* MSDOS Functions */
  57. #include "dosif.h" /* DOS interface definitions  */
  58. #include "toupper.h"
  59. #include "support.h" /* Support routines  */
  60. #include "global.h"
  62. /*RG-00-*/
  63. #if !defined(NOXBATCH)
  64. #if !defined(NOSECURITY) && (defined(CDOSTMP) || defined(CDOS))
  65. #define PATH_LEN     65  /* max path length (null terminated) */
  66. #include "security.h"
  67. #include "login.h"
  68. #include "txlogin.h"
  69. #endif
  70. #endif /*NOXBATCH*/
  71. /*RG-00-end*/
  73. EXTERN VOID CDECL restore_error_mode();
  75. EXTERN VOID batch_start(BYTE *, BYTE *, BYTE *);
  76. EXTERN VOID batch_end(VOID); /* BATCH.C */
  77. EXTERN VOID batch_close(VOID); /* BATCH.C */
  79. MLOCAL VOID erase(BYTE *, BOOLEAN); /* COMINT.C */
  80. MLOCAL BYTE * date_format(UWORD); /* COMINT.C */
  81. MLOCAL BOOLEAN check_date(BYTE *); /* COMINT.C */
  82. MLOCAL BOOLEAN check_time(BYTE *); /* COMINT.C */
  83. MLOCAL VOID show_crlf(BOOLEAN); /* COMINT.C */
  85. /*RG-02-*/
  86. #if !defined(NOXBATCH)
  87. GLOBAL VOID CDECL cmd_pauseerr(BYTE *);    /* COMINT.C */
  88. /*RG-02-end*/
  89. #endif
  90. GLOBAL VOID CDECL cmd_pause(BYTE *);    /* COMINT.C */
  91. GLOBAL VOID CDECL cmd_set(BYTE *); /* COMINT.C */
  92. GLOBAL VOID CDECL cmd_vol(BYTE *); /* COMINT.C */
  94. EXTERN WORD CDECL findfile(BYTE *, UWORD *); /* DOSIF.A86 || COM.C */
  95. EXTERN VOID CDECL int_break(VOID); /* COM.C */
  96. EXTERN VOID docmd(BYTE *, BOOLEAN); /* COM.C */
  98. #if defined(CPM)
  99. EXTERN UWORD CDECL cpm_de_init(VOID); /* CP/M Clean-Up Routine*/
  100. #endif
  103. MLOCAL WORD linesleft; /* Remaining lines on Screen */
  104. MLOCAL WORD ret; /* general BDOS return code */
  107. #if defined(CDOSTMP) || defined(CDOS)
  108. /*.pa*/
  109. /*
  110.  * USER BEWARE
  111.  *
  112.  * A process descriptor exists in both DOS Plus and Concurrent
  113.  * DOS. But is an internal Structure in DOS Plus and should only
  114.  * be used with the upmost care.
  115.  */
  116. EXTERN PD FAR * CDECL pd; /* Far pointer to Current PD */
  118. /*
  119.  * The following command will enable APPEND processing and set
  120.  * path searched by the BDOS on every OPEN function call.
  121.  *
  122.  * APPEND[=][d:]path[[;[d:]path]..] | [;] [/X|/E]
  123.  *
  124.  * APPEND without any command line options will display the current
  125.  * search path while APPEND ; will remove the Search Path and disable
  126.  * the APPEND facility.
  127.  *
  128.  * /E Forces the search path to be saved in the environment under
  129.  * Concurrent DOS this is always true and this flag is ignored.
  130.  *
  131.  * /X Forces APPEND to be active for the SEARCH FIRST(0x11), 
  132.  * FIND FIRST(0x4E) and EXEC(0x4B) functions. In addition
  133.  * to the normal functions FCB OPEN(0x0F), FCB FileSize(0x23)
  134.  * and OPEN(0x3D).
  135.  * /B Forces APPEND to provide batch command compatible output
  136.  *          that when redirected to a file, can be used to regenerate a
  137.  *          given append state.
  138.  */
  140. MLOCAL BYTE msg_appeq  [] = "APPEND="; /* Static Environment String */
  142. /*RG-03*/
  143. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  144. #define APPEND_BAT (flags & 4) /* /B Append Option */
  145. #endif
  146. /*RG-03-end*/
  147. #define APPEND_X (flags & 2) /* /X Append Option */
  148. #define APPEND_E (flags & 1) /* /E Append Option */
  150. GLOBAL VOID CDECL cmd_append(path)
  151. REG BYTE *path;
  152. {
  153. REG BYTE *s;
  154. UWORD  flags; /* Command Flags     */
  155. #if !STACK
  156. BYTE  sbuf[MAX_ENVLEN];
  157. #endif
  159. #if defined(CDOS) || defined(CDOSTMP)
  160. if (f_check (path, "exb", &flags, NO)) /* Check for valid Flags    */
  161. #else
  162.         if (f_check (path, "ex", &flags, NO)) /* Check for valid Flags    */
  163. #endif
  164.             return;
  166. zap_spaces(path); /* Remove White Space     */
  167. if(!*path && !APPEND_X) {
  168.     if(env_scan(msg_appeq, s = (BYTE *)heap())) /* look for current value   */
  169.     s = NULLPTR;
  171.     if(s && (pd->P_SFLAG & PSF_APPEND)) { /* If a path exists and the */
  172.     printf(msg_appeq); /* Append bit is set in the */
  173.     puts(s);
  174.     }
  175. /*RG-03*/
  176.             else  { /* PD then display path     */
  177. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  178.                 if (APPEND_BAT)
  179.                     printf("APPEND=");
  180.                 else
  181. #endif
  182.                     printf(MSG_APPEND);
  183.             }
  184. /*RG-03-end*/
  186.     crlfflg = YES;
  187.     return; 
  188. }
  190. pd->P_SFLAG |= APPEND_X ? PSF_XAPPEND : 0;
  192. if(*path == '=' || *path == ';')/* Skip Leading '=' or ';' chars    */
  193.     path++; /* and disable the APPEND command   */
  194. /* if no path is specified.     */
  196. if(*path) { /* Assign APPEND Path     */
  197.     pd->P_SFLAG |= PSF_APPEND; /* Set the APPEND and XAPPEND Bits  */
  199. #if STACK
  200.     s = stack(strlen(msg_appeq) + strlen(path) + 1);
  201. #else
  202.     s = &sbuf[0];
  203. #endif
  204.     strcpy(s, msg_appeq); /* build command line for "SET"  */
  205.     strcat(s, strupr(path)); /* Force Path to UPPER case     */
  206.     cmd_set(s);  /* set new path using "SET"     */
  207. }
  208. else if(!APPEND_X) { /* Disable APPEND Processing     */
  209.     pd->P_SFLAG &= ~(PSF_APPEND | PSF_XAPPEND);
  210.     cmd_set(msg_appeq);
  211. }     
  212. }
  213. #endif
  215. #if !defined(EXT_SUBST)
  217. /*.pa*/
  218. /************************************************************************/
  219. /* */
  220. /* ASSIGN (x [=] y ...) [/a][/b] */
  221. /* */
  222. /* This command forces future references to the X: to physically */
  223. /* reference the Y: drive. */
  224. /* */
  225. /* When no command line parameters are given then all assignments */
  226. /* are removed. If the /A option is used the current drive  */
  227. /* assignments are displayed. For the purpose of the display and */
  228. /* remove functions an "ASSIGNed" drives is any physical drive */
  229. /* which does not reference itself. */
  230. /* */
  231. /************************************************************************/
  233. /*
  234.  * ASSIGN_DRV returns TRUE if the drive pointed to by BP
  235.  * is a valid physical drive.
  236.  */
  237. MLOCAL BOOLEAN assign_drv(bp)
  238. BYTE *bp;
  239. {
  240. if(!d_check(bp))
  241.     return FALSE;
  242.     
  243. if(physical_drvs() & (1L << ddrive))
  244.     return TRUE;
  246. e_check(ED_DRIVE);
  247. return FALSE;
  248. }
  251. /*RG-03*/
  252. #define ASSIGN_BAT (flags & 2) /* Display Current Assignments in batch form */
  253. /*RG-03-end*/
  254. #define ASSIGN_ALL (flags & 1) /* Display Current Assignments */
  256. GLOBAL VOID CDECL cmd_assign(s)
  257. REG BYTE *s;
  258. {
  259. BYTE temp[7]; /* Temporary Command Buffer */
  260. BYTE path[MAX_PATHLEN];
  261. BYTE src, dst;
  262. ULONG vec,pvec,lvec,nvec;
  263. UWORD drv;
  264. UWORD flags; /* Command Flags */
  265. WORD    ret; /* General purpose variable */
  267. if (f_check (s, "ab", &flags, NO)) /* Check for Flags if any are   */
  268.             return;   /* invalid then don't do it     */
  270. pvec = physical_drvs();
  271. lvec = logical_drvs();
  273. /*
  274.  * Display the current drive assignments. 
  275.  */
  276. /*RG-03*/
  277. if((ASSIGN_ALL)||(ASSIGN_BAT))
  278.         {
  279.     vec = 1L;
  280.     drv = 0;
  281.     while(drv < 26) {
  282.     if((lvec & vec) && (pdrive(drv) != drv)) {
  283.                     if (ASSIGN_BAT)
  284.             printf("ASSIGN %c = %cn", drv+'A', pdrive(drv)+'A');
  285.                     else
  286. /*RG-03-end*/
  287.             printf("%c: => %c:n", drv+'A', pdrive(drv)+'A');
  288.                 }
  289.     vec <<= 1;
  290.     drv++;
  291.     }
  292.     return;
  293. }
  295. /*
  296.  * Remove ALL drive assignments. 
  297.  */
  298. s = deblank(s); /* If no command line options */
  299. if(!*s) { /* are given then remove the */
  300.      /* current assignments. */
  301.     vec = 1L;
  302.     drv = 0;     
  303.     while(drv < 26) {
  304. if((lvec & vec) && (pdrive(drv) != drv)) {
  305.     sprintf(temp, "%c:=%c:", drv+'A', drv+'A');
  306.     ms_x_chdir(temp);
  307. }
  308. vec <<= 1;
  309. drv++;
  310.     }
  311.     return;
  312. }
  314. /*
  315.  * Scan the command line and make all the drive assignments
  316.  * specified by the user.
  317.  */
  318. do {
  319.     dst = *s++; /* Get the Destinaion */
  320.     s = deblank(s);
  321.     if(*s == '=') /* Skip the optional '='  */
  322.         s = deblank(s+1); /* character and get the source */
  324.     if(!*s) { /* if no second drive has been */
  325. syntax(); /* specified the return error */
  326. return;
  327.     }
  329.     src = *s++;
  330.     sprintf(temp, "%c:=%c:", dst, src);
  332. #if defined(DOSPLUS)
  333.     nvec = network_drvs();
  334.     if ((nvec & (1L << (toupper(src)-'A')))
  335.           || (nvec & (1L << (toupper(dst)-'A')))) {
  336.      eprintf(MSG_NETASSIGN); /* if either is remote */
  337.      return; /* complain and exit */
  338.     }
  339. #endif
  340.     if(assign_drv(temp) && assign_drv(temp+3)) {
  341.      ret = ms_x_chdir(temp);
  342. if (ret) {
  343.     e_check(ret);
  344.       return;
  345. }
  346.     }
  347.     else
  348. return;
  350.     sprintf (path, "%c:%c", dst, *pathchar);
  351.     ms_x_curdir (tolower(src) - 'a'+1, path+3);
  352.      /* set dst drive to cur path on */
  353. /* source */
  354.     ms_x_chdir (path);
  356.     s = deblank(s); /* Deblank the renmainder of */
  357. } while(*s); /* command line and repeat */
  358. }
  359. #endif
  362. /*
  363.  * The CALL command accepts the name of a batch file with an
  364.  * optional parameter list. Any current batch processing is
  365.  * halted and the new batch file is used until the EOF is reached
  366.  * or an EXIT command is executed. Control then passes back to
  367.  * the original Batch file.
  368.  */
  370. EXTERN UWORD CDECL heap_size(VOID);
  372. GLOBAL VOID CDECL cmd_call(line)
  373. REG BYTE *line;
  374. {
  375. BYTE path[MAX_FILELEN];
  376. UWORD loadtype;
  377. BYTE argv0[MAX_FILELEN];
  378. BYTE *s;
  380. heap_get(0); /* check for stack overflow */
  382. s = get_filename(path, deblank(line), NO);
  384. strcpy(argv0, path);
  385. strlwr(path);
  387. if((ret = findfile(path, &loadtype)) >= 0) {
  388.     if(loadtype == BAT_FILETYPE) { /* treat .BAT differently */
  389. batch_start(argv0, path, s); /* nested batch files */
  390. return;
  391.     }
  392. }
  394. line = deblank(line);
  396. docmd(line,YES); /* call normal code */
  397. }
  399. /*
  400.  * Display the current directory assignment of a logical drive
  401.  * Currently the Absolute path is specified with the physical drive
  402.  */
  403. /*RG-03*/
  404. #define CHDIR_BAT (flags & 2) /* Display dir in command line compatible form */
  406. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  407. MLOCAL VOID display_cd(drv,flags)
  408. #else
  409. MLOCAL VOID display_cd(drv)
  410. #endif
  411. REG WORD drv;
  412. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  413. UWORD flags; /* Command Flags */
  414. #endif
  415. {
  416. BYTE dispbuf[MAX_PATHLEN];
  417. WORD ret;
  419. dispbuf[0] = (BYTE) (drv + 'A'); /* Display the path of the */
  420. dispbuf[1] = ':'; /* requested drive    */
  421. dispbuf[2] = *pathchar;
  423. ret = ms_x_curdir(drv+1, dispbuf+3);
  424. if (ret < 0) return;
  426. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  427.         if (CHDIR_BAT)
  428.             printf ("CHDIR %sn", dispbuf);
  429.         else
  430. #endif
  431.             printf ("%sn", dispbuf);
  432. }
  433. /*RG-03-end*/
  436. #define CHDIR_ALL (flags & 1) /* Display Current Assignments */
  438. GLOBAL VOID CDECL cmd_cd(s)
  439. REG BYTE *s;
  440. {
  441. BYTE *cp;
  442. ULONG login; /* Login Vector  */
  443. WORD    ret; /* General purpose variable */
  444. UWORD flags; /* Command Flags */
  446. /*rbf remove trailing spaces from string 's'*/
  447. char *p = s;
  449. while ( (*p!=' ') && *p)
  450. p++;
  451. *p=0;
  452. /*rbf-end*/
  454. #if defined(CDOS) || defined(CDOSTMP)
  455.         if (f_check (s, "ab", &flags, NO)) /* Check for valid Flags    */
  456. #else
  457.         if (f_check (s, "a", &flags, NO)) /* Check for valid Flags    */
  458. #endif
  459.             return;   /* invalid then don't do it     */
  461. if(CHDIR_ALL) { /* Display the current drive */
  463.     for(ret = 0; ret < 26; ret++)
  464. /*RG-03*/
  465. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  466. display_cd(ret,flags);
  467. #else
  468.                 display_cd(ret);
  469. #endif
  470. /*RG-03-end*/
  472.     return;
  473. }
  475. cp = s = deblank(strlwr(s)); /* Deblank after the Flag Check   */
  477. if(*(s+1) == ':') { /* check for a drive specifier   */
  478.     ddrive = *s - 'a'; /* Get the drive letter and check */
  479.     s = deblank(s+2); /* that it is a valid drive and   */
  480. /* is not the LOAD Drive.   */
  482.     if(INVALID_DRV(ddrive)) {
  483. e_check(ED_DRIVE);
  484. return;
  485.     }
  486. }
  487. else
  488.     ddrive = drive; /* Use the default drive   */
  490. if(*s == '=') {  /* Floating Drive Assignment   */
  491.     if(*++s) { /* Check source drive if spec.   */
  492.      if((s = d_check(s)) == 0)/* Abort if an illegal drive is   */
  493.     return;  /* selected.   */
  495. if(!*s) /* If the command is of the form  */
  496.     strcpy(s, ".");  /* x:=y: then append a "."   */
  497.     }
  498. }
  499. else if(!*s) { /* Display the selected drives   */
  500.     if(d_check(cp)) /* current sub-directory.   */
  501. /*RG-03-*/
  502. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  503. display_cd(ddrive,flags);
  504. #else
  505. display_cd(ddrive);
  506. #endif
  507. /*RG-03-end*/
  508.     return;
  509. }
  511. if (*cp == '.') {
  512. while (cp[1] == 32) {
  513. ret = 1;
  514. while (cp[ret]) {
  515. cp[ret] = cp[ret+1];
  516. ret++;
  517. }
  518. }
  519. }
  520. /* Make the drive Assignment   */
  521. if (!d_check(cp)) ddrive = -1;
  522. e_check(ddrive != -1 ? ms_x_chdir(cp) : ED_DRIVE);
  523. }
  526. #if !defined(EXT_SUBST)
  528. /*.pa*/
  529. #define SUBST_DEL (flags & 1)
  530. /*RG-03-*/
  531. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  532. #define SUBST_BAT (flags & 2)
  533. #endif
  534. /*RG-03-end*/
  536. GLOBAL VOID CDECL cmd_subst(s)
  537. BYTE *s;
  538. {
  539. BYTE cp[MAX_FILELEN+3]; /* CHDIR Path Buffer */
  540. BYTE root[4];
  541. ULONG login; /* Logical Drive Vector */
  542. UWORD flags; /* Command Flags */
  543. UWORD drv;
  544. WORD i;
  546. #if defined(CDOS) || defined(CDOSTMP)
  547. if(f_check(s, "db", &flags, NO)) /* Check for Flags if any are   */
  548. #else
  549.         if(f_check(s, "d", &flags, NO)) /* Check for Flags if any are   */
  550. #endif
  551.     return; /* invalid then don't do it     */
  553. s = deblank(strlwr(s)); /* Deblank after the Flag Check   */
  555. if(!*s) { /* If the command line is blank   */
  556.     login = logical_drvs(); /* then display the assignments   */
  557.      /* for all the logical drives   */
  559.     for(drv = 0; drv < 26; drv++, login >>= 1)
  560. if(login & 1L) {
  561.     sprintf(root,"%c:\", drv+'A');
  562.     ms_x_expand(cp, root);
  563. /*RG-03*/
  564. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  565.                 if(SUBST_BAT)
  566.         printf("SUBST %c: %sn", drv + 'A',cp);
  567.                 else
  568. #endif
  569. /*RG-03-end*/
  570.         printf("%c: => %sn", drv + 'A',cp);
  571. }
  573.     return;
  574. }
  576. if(*(s+1) == ':') { /* Check for a drive specifier   */
  577.     ddrive = *s - 'a'; /* Get the drive letter and check */
  578.     s = deblank(s+2); /* that it is a valid drive and   */
  579. /* is not the LOAD Drive.   */
  581.     if(INVALID_DRV(ddrive)) {
  582. e_check(ED_DRIVE);
  583. return;
  584.     }
  585. }
  586. else {
  587.     syntax(); /* If no drive is specified then  */
  588.     return; /* return after displaying a   */
  589. }      /* syntax error message   */
  591. #if defined(DOSPLUS)
  592. if(network_drvs() & (1L << ddrive)) { /* if requested drive is  */
  593.     eprintf(MSG_NETSUBST); /* remote then complain   */
  594.     return; /* and don't do anything  */
  595. }
  596. #endif
  597. sprintf(cp, "%c:=", ddrive+'A'); /* Prepare CHDIR command   */
  599. if(!SUBST_DEL) { /* Check for the Delete Flag   */
  600.     strcat(cp, s);
  601.     if((s = d_check(s)) == 0) /* Abort if an illegal drive   */
  602. return;  /* is selected.    */
  604.     if(!*s) { /* If no PATH is specified then   */
  605. printf(MSG_INOP); /* display display error message. */
  606. return;
  607.     }
  608. }
  610. e_check(ms_x_chdir(cp)); /* Make the drive Assignment   */
  611. }
  612. #endif
  614. /*.pa*/
  615. /*
  616.  * DATE [DD/MM/YY]
  617.  *
  618.  * Display or Set the current date making full use of the DOS
  619.  * international system call.
  620.  */
  622. GLOBAL VOID CDECL cmd_date(s)
  623. BYTE *s;
  624. {
  625. BYTE buffer[18]; /* Local Input Buffer */
  627. if (*s) {
  628.     if(check_date(s))
  629. return;
  630.     printf (INV_DATE);
  631. }
  632. else {
  633.     printf (CUR_DATE);
  634.     disp_sysdate();
  635. }
  637. FOREVER {
  638.     printf (NEW_DATE, date_format(country.dt_fmt));
  639.     buffer[0] = sizeof(buffer) -2; /* Set maximum string length */
  640.     system(MS_C_READSTR, buffer);
  641.     crlf ();
  643.     if (buffer[1] == 0)  /* Check for 0 length input */
  644. return;  /* and return if so */
  646.     buffer [buffer[1]+2] = '';
  647.     if (check_date (buffer+2))
  648. return;
  650.     printf (INV_DATE);
  651. }
  652. }
  655. MLOCAL BYTE * date_format(fmt)
  656. UWORD fmt;
  657. {
  658.     switch (fmt)
  659.     {
  660.     case 1: return EURO_DATE;
  661.     case 2: return JAP_DATE;
  662.     default: break;
  663.     }
  665.     return US_DATE;
  666. }
  670. /*
  671.  * Parse the string pointed to by s and check for a valid date
  672.  * specification. If the date has been specified correctly then
  673.  * set the system date.
  674.  */
  676. MLOCAL BYTE date_sep[] = "/.-";
  678. MLOCAL BOOLEAN check_date(s)
  679. BYTE *s;
  680. {
  681. SYSDATE date;
  682. WORD p1, p2, p3; /* Input Parameters */
  684. deblank(s); /* Remove spaces */
  686. if (!getdigit (&p1, &s) ||
  687.     !strchr(date_sep, *s++) ||
  688.     !getdigit (&p2, &s) ||
  689.     !strchr(date_sep, *s++) ||
  690.     !getdigit (&p3, &s))
  691. {
  692.     return NO;
  693. }
  695. switch (country.dt_fmt) {
  696.  case 1: /* European Format dd/mm/yy */
  697.     date.day = p1;
  698.     date.month = p2;
  699.     date.year = p3;
  700.     break;
  702.  case 2: /* Japanese Format yy/mm/dd */
  703.     date.day = p3;
  704.     date.month = p2;
  705.     date.year = p1;
  706.     break;
  708.  default: /* US Format mm/dd/yy */
  709.     date.day = p2;
  710.     date.month = p1;
  711.     date.year = p3;
  712.     break;
  713. }
  715. if (date.year >= 80 && date.year <= 99)
  716.    date.year += 1900;
  718. return !ms_setdate(&date);
  719. }
  722. /*.pa*/
  723. /*
  724.  * DEL [d:][path][filename][.ext]
  725.  *
  726.  * Erase a file(s) as specified by the path if no path is given
  727.  * erase all files on the default|specified drive.
  728.  */
  729. GLOBAL VOID CDECL cmd_del(path)
  730. BYTE *path;
  731. {
  732. erase (path, NO); /* erase files, don't confirm */
  733. }
  735. #define DIR_DIR (0x0001) /* Display Directory Files */
  736. #define DIR_SYS (0x0002) /* Display System Files    */
  737. #define DIR_ALL (0x0004) /* Display ALL Files    */
  738. #define DIR_WIDE (0x0008) /* Wide Directory Listing  */
  739. #define DIR_LONG (0x0010) /* Long Directory Listing  */
  740. #define DIR_PAGE (0x0020) /* Page Output    */
  741. #define DIR_REM (0x0040) /* Remember these Options  */
  742. #define DIR_CHANGE (0x0080) /* Change the Default Opts */
  743. #define DIR_NOPAGE (0x0100) /* No Paging of Output    */
  744. #define DIR_2COLS (0x0200) /* double column listing   */
  745. #define OPT(x) (flags & x) /* Return Flag Conditions  */
  747. MLOCAL UWORD dir_default = DIR_DIR | DIR_LONG;
  749. MLOCAL UWORD dir_flags(flags)
  750. REG UWORD flags;
  751. {
  752. if(OPT(DIR_NOPAGE)) /* Force DIR_PAGE to be cleared */
  753.     flags &= ~DIR_PAGE; /* if NOPAGE has be selected */
  755. if(OPT(DIR_LONG)) { /* Force DIR_WIDE to be cleared */
  756.     flags &= ~DIR_WIDE; /* if the LONG format has been */
  757.     flags &= ~DIR_2COLS; /* selected. */
  758. }
  760. if(OPT(DIR_2COLS)) {
  761.     flags &= ~DIR_LONG;
  762.     flags &= ~DIR_WIDE;
  763. }
  765. if(page_wid < 76) /* Check the screen is wide */
  766.     flags &= ~DIR_WIDE; /* enough to display directory */
  767.     
  768. if(page_wid < 78)
  769.     flags &= ~DIR_2COLS;
  771. if(OPT(DIR_DIR))
  772.     flags &= ~DIR_SYS;
  773. /* Check if the new options  */
  774. if(OPT((DIR_CHANGE|DIR_REM))) { /* should become the default */ 
  775.     dir_default = flags & ~(DIR_CHANGE|DIR_REM);
  776. }
  778. if (flags) return(flags);
  779. else       return(dir_default);
  780. }
  783. GLOBAL VOID CDECL cmd_dir (cmd)
  784. REG BYTE *cmd;
  785. {
  786. WORD  nfiles, system, others, i;
  787. LONG  nfree = 0L;
  788. DTA  search;
  789. BYTE  path[MAX_FILELEN];
  790. BYTE  s[MAX_PATHLEN], temp[3];
  791. BYTE  *ext, *memory;
  792. UWORD  free, secsiz, nclust;
  793. UWORD  flags;
  795. if(f_check (cmd, "dsawlprcn2", &flags, NO)) /* if any bad flags */
  796.     return; /*    don't do it   */
  798. flags = dir_flags(flags); /* Manipulate the flags to remove   */
  799. /* duplication and conflicts     */
  800. if(OPT(DIR_CHANGE)) /* Just change the default values   */
  801.     return; /* then return to the caller     */
  803. get_filename(path, deblank(cmd), YES); /* Extract the filename     */
  805. if (path[0]=='.' && path[1]=='.' && path[2]=='.' && path[3]=='')
  806. {
  807.    path[0]='*';
  808.    path[2]='';
  809. }
  810. if (d_check(path) == NULLPTR) return;/* get out now if invalid drive */
  811. if (ddrive != -1)
  812. {
  813.     strcpy(s,"d:"); s[0] = (BYTE) (ddrive + 'A');
  814.     append_slash(s);
  815.     ms_x_curdir(ddrive+1,s+3); /* get the current dir */
  816. }
  817. else
  818.     ms_x_expand(s,path);
  820. ext = fptr(path);
  821. if(*ext == '.' && strcmp(dotdot+1, ext) && strcmp(dotdot, ext)) {
  822.     strcpy(heap(), ext);
  823.     strcpy(ext, "*");
  824.     strcat(ext, heap());
  825. }
  827. #if defined(PASSWORD)
  828. *(BYTE *)heap() = ''; /* Remove the Password    */
  829. memory = strchr(ext, *pwdchar); /* if one has been used    */
  830. if(memory) { /* and save on the heap    */
  831.     strcpy(heap(), memory);
  832.     *memory = '';
  833. }
  834. #endif
  836. while(*ext && !strchr(ext, '.')) { /* If a filename has been   */
  837.     if(!iswild(ext)) { /* specified and it does not*/
  839. #if defined(PASSWORD)
  840.       if (ddrive != -1 && ms_x_chdir(s) < 0) {
  841. /* if cd to current dir fails then current dir must be password     */
  842. /* protected. So let's do the next bit the non-novell way.     */
  844. /* This method of determining if the user has specified a directory */
  845. /* DOES NOT work on NOVELL drives.     */
  847. ret = ms_x_chmod(path, 0, 0); /* contain a '.'. Skip if   */
  848. if(ret > 0 && (ret & ATTR_DIR)) /* a path was specified.    */
  849.     break; /* Otherwise append ".*".   */
  851.       }
  852.       else {
  853. #endif
  854. /* This method of determining if the user has specified a directory */
  855. /* DOES work on NOVELL drives.     */
  857. /* But not when the current directory is password protected!        */
  859. #if defined(PASSWORD)
  860. if (memory) strcpy(memory,heap());  /* reattach password */
  861. #endif
  862. if (ddrive != -1)
  863. {
  864.     ret = ms_x_chdir(path);  /* try to cd to path specified */
  865. #if defined(PASSWORD)
  866.     if (memory) *memory = 0; /* remove password again */
  867. #endif
  868.     if (ret >= 0) {  /* if there wasn't an error... */
  869. ms_x_chdir(s);  /* ...restore original directory... */
  870. break;  /* ...and get the hell out */
  871.     }
  872. }
  873. else
  874. {
  875.     ret = ms_x_chmod(path,0,0);
  876.     if (ret >= 0 && (ret & ATTR_DIR)) break; 
  877. }
  878. #if defined(PASSWORD)
  879.       }
  880. #endif
  881.     }
  882.     strcat(ext, ".*");          /* append ".*" to pathname */
  883. }
  885. #if defined(PASSWORD)
  886. strcat(ext, heap()); /* Reattach the Password    */
  887. #endif
  889. if(nofiles(path, ATTR_ALL, NO, YES))  /* if no files/dirs or error*/
  890.     return; /* then we can't do this    */
  892. if (ddrive != -1)
  893. {
  894.     strcpy (temp, "d:"); /* Display the drive Volume */
  895.     temp[0] = (BYTE) (ddrive+'A'); /* label using the VOL command */
  896.     cmd_vol(temp);
  897. }
  898. else
  899.     show_crlf(OPT(DIR_PAGE));
  901. #if 0
  902. /* this has been done earlier */
  903. strcpy(s, "d:"); s[0] = (BYTE) (ddrive + 'A');
  904. append_slash(s);
  905. ms_x_curdir(ddrive+1, s+3); /* Get the current dir */
  906. #endif
  908. strip_path(path, memory = (BYTE *)heap());/* Get the Path Spec and  */
  909. if((i = strlen(memory)) > /* Remove the Trailing      */
  910. (memory[1] == ':' ? 3 : 1)) /* Path Character.     */
  911. memory[--i] = '';
  913. if(i == 0 || (i == 2 && memory[1] == ':')) {
  914.     printf (MSG_DIR, temp, s+3); /* DIR of current Directory  */
  915. }
  916. else
  917. {
  918.   if (ddrive == -1 || ms_x_chdir(s) < 0) { /* assume this means pword protected */
  919.     ext = memory+strlen(memory)+1;
  920.     ms_x_expand(ext,memory);
  921.     if (ddrive != -1)
  922.       printf(MSG_DIR, temp, ext+3);
  923.     else
  924.       printf(MSG_DIR,"",ext+1);
  925.   }
  926.   else {
  927.     ms_x_chdir(memory);  /* Change the directory      */
  928.     ms_x_curdir(ddrive+1, memory); /* Get the current directory */
  929.     ms_x_chdir(s); /* Restore the directory     */
  930.     printf (MSG_DIR, temp, memory);
  931.   }
  932. }
  934. others = 0; /* assume no SYS/DIR files */
  935. nfiles = 0; /* initialize file count */
  936. linesleft = page_len - 4; /* lines until pause */
  938. system = OPT(DIR_SYS) ? ATTR_SYS : 0;
  940. ret = ms_x_first(path, ATTR_ALL, &search);
  942. if(!ret && (search.fattr & ATTR_DEV)) /* Check if the user has     */
  943.     ret = ED_FILE; /* specified a device then   */
  944. /* generate an error.      */
  945. while(!ret) {
  946.     if(!OPT(DIR_ALL) && (search.fattr & ATTR_SYS) != system) {
  947. /* not the correct file type*/
  948. others++; /* remember others do exist */
  949. ret = ms_x_next(&search); /* get the next file and    */
  950. continue; /* continue the display     */
  951.     }
  953.     ext = strchr(search.fname, '.'); /* Get the file extension   */
  954.     if(ext && ext != search.fname) /* set the extension to NULL*/
  955. *ext++ = ''; /* if no '.' exists or this */
  956.     else /* is the ".." or "." entry.*/
  957. ext = "";
  959.     if(OPT(DIR_WIDE)) {
  960. if ((nfiles % 5) == 0)
  961.     show_crlf(OPT(DIR_PAGE));
  963. printf ("%c:%c%-9s%-3s",
  964. (nfiles % 5) ? ' ' : ddrive + 'A',
  965. (search.fattr & ATTR_DIR) ? *pathchar : ' ',
  966. search.fname, ext);
  967.     }
  968.     else {
  969. if (OPT(DIR_2COLS)) {
  970.     if ((nfiles % 2) == 0) show_crlf(OPT(DIR_PAGE));
  971. }
  972. else
  973.     show_crlf(OPT(DIR_PAGE));
  974. printf("%-9s%-3s", search.fname, ext);
  975. if (search.fattr & ATTR_DIR)
  976.     printf(" <DIR>   ");
  977. else
  978.     printf ("%9lu", search.fsize);
  980. if(search.fdate) {    /* if timestamp exists */
  981.     printf (" "); disp_filedate (search.fdate);
  982.     printf (" "); disp_filetime (search.ftime);
  983.     if ((OPT(DIR_2COLS)) && (nfiles%2 == 0)) printf ("   ");
  984. }
  985. else {
  986.     if ((OPT(DIR_2COLS)) && (nfiles%2 == 0)) printf("ttt");
  987. }
  988.     }
  989.     nfiles ++;
  990.     ret = ms_x_next(&search);
  991. }
  993. if(others + nfiles == 0) { /* If no matching files then exit  */
  994.     e_check(ED_FILE); /* after displaying File Not Found */
  995. }
  997. if(ddrive != -1 && (ret = ms_drv_space(ddrive+1, &free, &secsiz, &nclust)) < 0) {
  998.     /*e_check(ED_PATH);*/
  999.     /*return;*/
  1000.     ret = 0; /* This prevents 'Invalid directory...' when looking */
  1001.      /* at a PNW login drive. */
  1002. }
  1004. show_crlf(OPT(DIR_PAGE));
  1005. nfree = (LONG)ret * (LONG)free * (LONG)secsiz;
  1006. if (ddrive != -1)
  1007.     printf ("%9d %s%10ld %s", nfiles, MSG_FILES, nfree, MSG_FREE);
  1008. else
  1009.     printf ("%9d %s", nfiles, MSG_FILES);
  1010. show_crlf(OPT(DIR_PAGE));
  1012. if(others) /* if others do exist, tell them */
  1013.     printf (MSG_EXIST, system ? MSG_NSYS : MSG_NDIR);
  1014. }
  1017. GLOBAL VOID CDECL cmd_echo(s, o)
  1018. REG BYTE *s; /* Deblanked Command Line */
  1019. REG BYTE *o; /* Original Untainted Commmand */
  1020. {
  1022. if (*o) o++; /* delete 1 whitespace or   */
  1023. /* punctuation char from the*/
  1024. /* original command line    */
  1025. s = deblank(s);
  1027. switch(onoff(s)) { /* if "ECHO=on/off"     */
  1028.     case YES: /* ECHO = ON     */
  1029. echoflg = ECHO_ON;
  1030. break;
  1032.     case NO: /* ECHO = OFF     */
  1033. echoflg = ECHO_OFF;
  1034. break;
  1036.     default:
  1037. if(*s || (o != s && batchflg)) { /* if command line   */
  1038.     puts(o); /* display string    */
  1039.          crlf();
  1040. }
  1041. else
  1042.          printf (MSG_ECHO, /* print current     */
  1043.      echoflg ? MSG_ON : MSG_OFF); /* echo status      */
  1044. break;
  1045. }
  1046. }
  1047. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  1048. /*RG-02-*/
  1049. GLOBAL VOID CDECL cmd_echoerr(s, o)
  1050. REG BYTE *s; /* Deblanked Command Line */
  1051. REG BYTE *o; /* Original Untainted Commmand */
  1052. {
  1053.         BOOLEAN  err_save;
  1055.         err_save=err_flag;
  1056. err_flag = TRUE;
  1057.         cmd_echo(s,o);
  1058. err_flag = err_save;
  1059. }
  1060. #endif
  1061. /*RG-02-end*/
  1064. GLOBAL VOID CDECL cmd_exit(cmd)
  1065. BYTE *cmd;
  1066. {
  1067. err_ret = 0;
  1069. if(*deblank(cmd)) /* If a number has be     */
  1070.     check_num(cmd, 0, 255, &err_ret); /* specified use this for  */
  1071.      /* the exit code.    */
  1072. if(batchflg) { /* If processing a batch file     */
  1073.     batch_end(); /* then exit batch file      */
  1074. #if defined(CDOSTMP)
  1075.     return;
  1076. #endif
  1077. }
  1079. #if defined(CDOSTMP)      
  1080. bdos(C_DETACH, 0); /* Allow another process to attach */
  1081. bdos(P_DISPATCH, 0); /* to the console if they are    */
  1082. bdos(C_ATTACH, 0); /* waiting in the background.    */
  1084. #else
  1085. if(execed) { /* If command.com has been execed   */
  1086.     *parent_psp = save_parent;
  1088.     ms_set_break(break_flag); /* then return to the invoking prog */
  1089.      /* Otherwise ignore the command     */
  1091. #if defined(CPM) /* Clean-Up the CPM disk handling   */
  1092.     cpm_de_init(); /* code before we terminate.     */
  1093. #endif
  1094.     restore_error_mode();
  1095.     restore_term_addr(); /* restore the PSP terminate address*/
  1096.     ms_x_exit(err_ret); /* If we return from the EXIT call  */
  1097.     execed = NO; /* then this must be the root     */
  1098.     printf("Hellon");
  1099. } /* process. Invoked without '/P'    */
  1100. #endif
  1101. }
  1104. GLOBAL VOID CDECL cmd_md(s)
  1105. REG BYTE *s;
  1106. {
  1107. /*BYTE  path[MAX_FILELEN];*/
  1109. crlfflg = YES;
  1110. #if 0
  1111. get_filename(path, deblank(s), FALSE); /* Pathname  */
  1113. if(!d_check(path))
  1114.     return;
  1115. #endif
  1116. if((ret = ms_x_mkdir(s)) != 0) { /* if any errors occurred    */
  1117.     if (ret == ED_DRIVE) /* if invalid drive      */
  1118. e_check(ret); /*    then say so      */
  1119.     else /* else use standard formula */
  1120. eprintf(MSG_MKDIR); /* Unable to create directory*/
  1121.     return;
  1122. }
  1124. crlfflg = NO;
  1125. }
  1128. /*.pa*/
  1129. /*
  1130.  * PATH [[d:]path[[;[d:]path]..]] | [;]
  1131.  *
  1132.  * Display or set the command search path in environment.
  1133.  */
  1134. GLOBAL BYTE msg_patheq [] = "PATH="; /* Static Environment String   */
  1136. GLOBAL VOID CDECL cmd_path(path)
  1137. REG BYTE *path;
  1138. {
  1139. REG BYTE *s;
  1140. #if !STACK
  1141. BYTE  sbuf[MAX_ENVLEN];
  1142. #endif
  1144. zap_spaces(path); /* Remove all white space     */
  1145. if(!*path) {
  1146.     if(env_scan(msg_patheq, s = (BYTE *)heap()))
  1147. printf(MSG_PATH); /* If no path exists then    */
  1148.     else { /* display "NO PATH" otherwise */
  1149. printf(msg_patheq); /* display the current path  */
  1150. /*printf("%.122sn",s);*/
  1151. printf(path_template,s);
  1152.     }
  1153.     crlfflg = YES;
  1154.     return;
  1155. }
  1157. if(*path == '=' || *path == ';')/* Skip Leading '=' or ';' chars    */
  1158.     path++; /* then set the PATH     */
  1160. #if STACK
  1161. s = stack(strlen(msg_patheq) + strlen(path) + 1);
  1162. #else
  1163. s = &sbuf[0];
  1164. #endif
  1165. strcpy(s, msg_patheq); /* build command line for "SET"   */
  1166. strcat(s, strupr(path));
  1167. cmd_set(s);  /* set new path using "SET"     */
  1168. }
  1170. GLOBAL VOID CDECL cmd_pause(msg)
  1171. BYTE *msg;
  1172. {
  1173. BYTE c;
  1175. if (*msg) printf("%sn",msg);
  1177. batch_close(); /* Close Any Batch files in case */
  1178. /* the user is going to swap the */
  1179. /* disk with the batch file.  */
  1180. printf(MSG_PAUSE); /* prompt to hit any key */
  1182. #if defined(CDOSTMP)
  1183. c =(BYTE) bdos(C_RAWIO, 0xFD); /* Get a character from console */
  1185. if ((c==0) ||(dbcs_lead(c)))
  1186.     bdos(C_RAWIO, 0xFD); /* skip second byte in DBCS pair */
  1187. #else
  1188. c = (BYTE) msdos(MS_C_RAWIN, 0);/* Get a character from console */
  1189. if ((c==0) || (dbcs_lead(c)))
  1190.     msdos(MS_C_RAWIN, 0); /* skip second byte in DBCS pair */
  1191. #endif
  1193. sprintf(heap(), "%s", MSG_PAUSE); /* Copy MSG_PAUSE into  */
  1194. printf("r%*sr", strlen(heap()), "");  /* Data Segment and  */
  1195. /* then calculate length*/
  1197. if(c == 0x03) /* Control C Check */
  1198.     int_break();
  1199. }
  1201. /*
  1202.  * This PAUSE command will output the prompt string to STDOUT regardless
  1203.  * of its destination. However it will ensure that the character is read
  1204.  * from the console device by "POKING" the PSP.
  1205.  */
  1206. GLOBAL VOID CDECL cmd_stdin_pause(void)
  1207. {
  1208. UWORD in_h,stderr_h;
  1209. BYTE c;
  1211. batch_close(); /* Close Any Batch files in case */
  1212. /* the user is going to swap the */
  1213. /* disk with the batch file.  */
  1214. printf(MSG_PAUSE); /* prompt to hit any key */
  1216. stderr_h = psp_poke(STDERR,1);
  1217. in_h = psp_poke(STDIN, stderr_h); /* Get the Real Console */
  1218. psp_poke(STDERR,stderr_h);
  1220. #if defined(CDOSTMP)
  1221. c =(BYTE) bdos(C_RAWIO, 0xFD); /* Get a character from console */
  1223. if ((c==0) ||(dbcs_lead(c)))
  1224.     bdos(C_RAWIO, 0xFD); /* skip second byte in DBCS pair */
  1225. #else
  1226. c = (BYTE) msdos(MS_C_RAWIN, 0);/* Get a character from console */
  1227. if ((c==0) || (dbcs_lead(c)))
  1228.     msdos(MS_C_RAWIN, 0); /* skip second byte in DBCS pair */
  1229. #endif
  1231. psp_poke(STDIN, in_h); /* restore original handle  */
  1233. sprintf(heap(), "%s", MSG_PAUSE); /* Copy MSG_PAUSE into  */
  1234. printf("r%*sr", strlen(heap()), "");  /* Data Segment and  */
  1235. /* then calculate length*/
  1237. if(c == 0x03) /* Control C Check */
  1238.     int_break();
  1239. }
  1241. #if !defined(NOXBATCH) && (defined(CDOS) || defined(CDOSTMP))
  1242. /*
  1243.  * The PAUSE command will output the prompt string to STDOUT regardless
  1244.  * of its destination. However it will ensure that the character is read
  1245.  * from the console device by "POKING" the PSP.
  1246.  */
  1247. GLOBAL VOID CDECL cmd_pauseerr()
  1248. {
  1249.         BOOLEAN  err_save;
  1251.         err_save=err_flag;
  1252. err_flag = TRUE;
  1253.         cmd_pause();
  1254. err_flag = err_save;
  1255. }
  1256. #endif
  1257. /*RG-02-end*/
  1259. /*.pa*/
  1260. /*
  1261.  * PROMPT [prompt-text]
  1262.  *
  1263.  * Set the system prompt as specified by the prompt text if no 
  1264.  * prompt text is specified then the default $n$g is used.
  1265.  */
  1266. GLOBAL BYTE msg_prmeq  [] = "PROMPT="; /* Static Environment String */
  1268. GLOBAL VOID CDECL cmd_prompt(s)
  1269. REG BYTE    *s;
  1270. {
  1271. REG BYTE *bp;
  1272. #if !STACK
  1273. BYTE  bpbuf[MAX_ENVLEN];
  1274. #endif
  1276. if (!*s) /* if no string */
  1277.     s = DEFAULT_PROMPT;  /* use the default */
  1279. while ((*s == '=') || (*s == ' ')) s++;
  1281. #if STACK
  1282. bp = stack(strlen(msg_prmeq) + strlen(s) + 1);
  1283. #else
  1284. bp = &bpbuf[0];
  1285. #endif
  1286. strcpy(bp, msg_prmeq); /* environment variable */
  1287. strcat(bp, s); /* add new value */
  1288. cmd_set(bp); /* update environment */
  1289. }
  1292. GLOBAL VOID CDECL cmd_rem ()
  1293. {
  1294. crlfflg = 0;
  1295. /* Make sure REM turns off pipes too */
  1296. /* You can't do this !!!!! MSDOS allows "REM | DIR" etc - IJ */
  1297. #if 0
  1298. pipe_in=pipe_out=NO;
  1299. #endif
  1300. }
  1304. #define REN_CHECK (flags & 1)
  1306. GLOBAL VOID CDECL cmd_ren(s)
  1307. REG BYTE *s;
  1308. {
  1309. BYTE  srcfile[MAX_FILELEN], dstfile[MAX_FILELEN];
  1310. BYTE  pattern[MAX_FILELEN-MAX_PATHLEN];  
  1311. BYTE  *enddir;
  1312. #if defined(PASSWORD)
  1313. BYTE *password;
  1314. #endif
  1315. DTA  search;
  1316. UWORD flags;
  1317. WORD attr;
  1318. #if !STACK
  1319. BYTE passbuf[MAX_FILELEN];
  1320. #endif
  1321.         char lastchar;
  1322.         unsigned length;
  1324. if(f_check(s, "c", &flags, NO)) /* Check the selected flags */
  1325.     return; /* and return on error     */
  1327. s = get_filename(srcfile, deblank(s), TRUE); /* Source Filename  */
  1329. s = get_filename(dstfile, deblank(s), TRUE); /* Destination File */
  1331. length = strlen(dstfile);
  1332. lastchar = dstfile[ length-1];
  1333.         
  1334. if (dbcs_expected()){
  1335.  if ( (length > 2) && (!dbcs_lead(dstfile[length-2])) ){
  1336. /*
  1337. if ( (lastchar == ':') || (lastchar == '\') ){
  1338. */
  1339. if (lastchar == ':'){
  1340. printf(msg_invalid_file);
  1341. return;
  1342. }
  1343.  }
  1344. }
  1345. else{
  1346. /*
  1347. if ( (lastchar == ':') || (lastchar == '\') ){
  1348. */
  1349. if (lastchar == ':'){
  1350. printf(msg_invalid_file);
  1351. return;
  1352.     }
  1353. }
  1355. if (!iswild(srcfile)) {
  1356.     attr = ms_x_chmod(srcfile,0,0);
  1357.     if ((attr > 0) && (attr & ATTR_DIR)) {
  1359. /* Don't try to rename directories. Leave it to RENDIR. */
  1361. printf(MSG_USE_RENDIR);
  1362. return;
  1363.     }
  1364. }
  1366. if(nofiles(srcfile, ATTR_ALL, YES, NO)) /* if no source files then  */
  1367.     return; /* error message and stop   */
  1369. if(nofiles(dstfile, ATTR_ALL, NO, NO)) /* Check the Destination    */
  1370.     return; /* path exists     */
  1372. if(fptr(srcfile) != srcfile && fptr(dstfile) == dstfile) {
  1373.     strcpy(heap(), dstfile); /* If no path is specified  */
  1374.     strip_path(srcfile, dstfile); /* on the NewFile then force*/
  1375.     strcat(dstfile, heap()); /* use the OldFile Path.    */
  1376. /* Because of the Holy Grail*/
  1377. } /* of MS-DOS compatiblity.  */
  1379. enddir = fptr(srcfile);  /* Isolate source filename  */
  1380. #if defined(PASSWORD)
  1381. password = strchr(enddir, *pwdchar); /* Check for Source password*/
  1382. if(password) { /* and save in internal buf.*/
  1383. #if STACK
  1384.     password = stack(strlen(password)+1);
  1385. #else
  1386.     password = &passbuf[0];
  1387. #endif
  1388.     strcpy(password, strchr(enddir, *pwdchar));
  1389. }
  1390. #endif
  1392. strcpy(pattern, fptr(dstfile));  /* Save the destination     */
  1393. /* match pattern.     */
  1395. ms_x_first (srcfile, (ATTR_STD&(~ATTR_SYS)), &search);
  1396. do {
  1397.     strcpy(enddir, search.fname); /* append file name to path */
  1399.     if(REN_CHECK) { /* confirm option active?   */
  1400. printf(MSG_ERAQ, srcfile); /* then prompt the user and */
  1401. if(!yes(YES, NO)) /* act on the reponse     */
  1402.     continue;
  1403.     }
  1405.     strcpy(fptr(dstfile), pattern); /* Assert the Destination   */
  1406.     repwild(srcfile, dstfile); /* pattern.     */
  1408. #if defined(PASSWORD)
  1409.     if(password) /* Append the password to   */
  1410. strcat(srcfile, password); /* the sorce file if one    */
  1411. /* has been specified.     */
  1412. #endif
  1414.     if((ret = ms_x_rename(srcfile, dstfile)) < 0) {
  1415. crlfflg = YES;
  1416. #if defined(CDOSTMP) || defined(CDOS)
  1417. if((ret == ED_ACCESS) &&
  1418.    (ms_x_first(dstfile, ATTR_ALL, &search) >= 0))
  1419. #else
  1420. if(ret == ED_ACCESS)
  1421. #endif
  1422.     eprintf(MSG_REN);
  1423. else
  1424.     e_check(ret);
  1425. return;
  1426.     }
  1427. } while(!ms_x_next(&search)); /* get the next file */
  1428. }
  1431. /*.pa*/
  1432. /*
  1433.  *
  1434.  */
  1435. GLOBAL VOID CDECL cmd_rd(s)
  1436. REG BYTE *s;
  1437. {
  1438. /*BYTE  path[MAX_FILELEN];*/
  1440. crlfflg = YES;
  1441. #if 0
  1442. get_filename(path, deblank(s), FALSE); /* Pathname  */
  1444. if(!d_check(path))
  1445.     return;
  1446. #endif
  1447. if((ret = ms_x_rmdir(s)) != 0) { /* if can't remove directory */
  1448.     if(ret == ED_DIR || ret == ED_FILE || ret == ED_ACCESS)
  1449.      /* because its in use by     */
  1450. eprintf(MSG_RMDIR); /* by another process or is  */
  1451.     else /* empty then print special  */
  1452. e_check(ret); /* message other wise use    */
  1453.     return; /* standard error handler    */
  1454. }
  1456. crlfflg = NO;
  1457. }
  1460. GLOBAL VOID CDECL cmd_set(s)
  1461. BYTE *s;
  1462. {
  1463. BYTE  c;
  1464. REG BYTE *key;
  1465. BYTE *t;
  1466. WORD  i;
  1468. if(!*s) { /* if no cmd, display env */
  1469.     for(i=0; !env_entry(key = (BYTE *)heap(), i); i++) {
  1470.         puts(key); /* Print the Environment   */
  1471. crlf(); /* variables directly to   */
  1472.     } /* avoid size problems.    */
  1473.     return;
  1474. }
  1475. /* else need to set env var */
  1477. /* msdos removes leading blanks, commas, semicolons and equal signs,
  1478. but keeps spaces in the variable name (SPR 770044) JBM */
  1480. /* remove any spaces before the equals sign
  1481. key = s;
  1482. while (*s && (*s != '=')) {
  1483. if (*s == 32 || *s == 9) {
  1484. t = s;
  1485. while (*t++) *(t-1) = *t;
  1486. }
  1487. if (*s == '=') break;
  1488. s++;
  1489. }
  1490. */
  1491. key = s;
  1492. while (*s && (*s == 0x20 || *s == 0x09 || *s == ',' || *s == ';' || *s == '=')) {
  1493. t = s;
  1494. while (*t++) *(t-1) = *t;
  1495. }
  1497. s = key;
  1498. while (*s && (*s != '=')) /* look for end of variable */
  1499.     s ++;
  1501. if (!*s || key == s) { /* If no key has been specified */
  1502.     syntax(); /* or the '=' is missing return */
  1503.     return;
  1504. } /* a syntax error. */
  1506. s++;
  1508. #if 0
  1509. /* msdos doesn't do this */
  1511. /* remove any space after the equals sign */
  1512. while (*s == 32 || *s == 9) {
  1513. t = s;
  1514. while (*t++) *(t-1) = *t;
  1515. }
  1516. #endif
  1518. c = *s; /* Save Character */
  1519. *s = ''; /* terminate keyword */
  1520. strupr (key); /* make keyword upper case  */
  1521. if(env_del(key) < 0) { /* remove it first */
  1522.     printf(MSG_ENVERR);  /* check for an error. */
  1523.     crlfflg = YES;
  1524.     return;
  1525. }
  1526. if((*s-- = c) != 0) { /* Add the definition to the end*/
  1527. /* of the environment if the new*/
  1528.     if(env_ins(key)) { /* definition is not NULL */
  1529. printf(MSG_ENVFULL); /* check for an error. */
  1530. crlfflg = YES;
  1531. return;
  1532.     }
  1533. }
  1534. }
  1537. /*.pa*/
  1538. /*
  1539.  * Displays or Sets the current system time 
  1540.  */
  1541. #define TIME_CON (flags & 1)
  1543. GLOBAL VOID CDECL cmd_time(s)
  1544. REG BYTE *s;
  1545. {
  1546. BYTE buffer[18]; /* Local Input Buffer */
  1547. UWORD flags; /* Continuous Display */
  1549. if(f_check (s, "c", &flags, NO)) /* Check for valid Flags    */
  1550.     return;
  1552. if(TIME_CON) {
  1553.     crlfflg = YES;
  1554.     printf(CUR_TIME); /* Display the Message */ 
  1556.     FOREVER {
  1557. disp_systime (); /* Display the Current Time  */
  1558. printf("bbbbbbbbbbb"); /* BackSpace over the Time */
  1559. #if defined(CDOSTMP)
  1560. if(bdos(C_RAWIO, 0xFE))  /* check for a character     */
  1561.     return; /* and return if one typed   */
  1562. #else
  1563. if(msdos(MS_C_STAT, 0) & 0xFF) { /*  Check for a character   */
  1564.     msdos(MS_C_RAWIN, 0xFF);  /* read it and return to the*/
  1565.     return;  /* main routine.      */
  1566. }
  1567. #endif
  1568.     }
  1569. }
  1571. if(*s) {
  1572.     if (check_time(s))
  1573. return;
  1574.     printf(INV_TIME);
  1575. }
  1576. else {
  1577.     printf(CUR_TIME);
  1578.     disp_systime ();
  1579. }
  1581. FOREVER {
  1582.     printf (NEW_TIME);
  1583.     buffer[0] = sizeof(buffer)-2; /* Set maximum string length */
  1584.     system(MS_C_READSTR, buffer);
  1585.     crlf ();
  1587.     if (!buffer[1]) /* Check for 0 length input */
  1588. return;  /* and return if so */
  1590.     buffer[buffer[1]+2] = '';
  1591.     if (check_time (buffer+2))
  1592. return;
  1594.     printf (INV_TIME);
  1595. }
  1596. }
  1598. /*.pa*/
  1599. /*
  1600.  *
  1601.  */
  1602. GLOBAL VOID CDECL cmd_truename(s)
  1603. REG BYTE *s;
  1604. {
  1605. BYTE  path[MAX_FILELEN];
  1607. *path = 0;
  1609. /* expand path, current directory if none specified */
  1610. if (*s)
  1611. ret = ms_x_expand(path, s);
  1612. else
  1613. ret = ms_x_expand(path, ".");
  1615. /* if we get an error report it, otherwise display expanded path */
  1616. if (ret)
  1617. e_check(ret);
  1618. else
  1619. printf(path);
  1620. }
  1623. /*
  1624.  * Parse the string pointed to by s and check for a valid date
  1625.  * specification. If the time has been specified correctly then
  1626.  * set the system time.
  1627.  */
  1628. MLOCAL BYTE    hour_sep[] = ":.";
  1629. MLOCAL BYTE    sec_sep[]  = ".,";
  1631. MLOCAL BOOLEAN check_time(s)
  1632. BYTE *s;
  1633. {
  1634. SYSTIME time;
  1635. WORD hour, min, sec, hsec;
  1637. min = sec = hsec = 0; /* Seconds and Hundredths are optional */
  1638. /* and default to zero when omitted */
  1639. zap_spaces(s); /* Remove all spaces from command   */
  1641. if (!getdigit (&hour, &s))
  1642.     return NO;
  1644. while(*s) { /* if more than HH */
  1645.     if (!strchr(hour_sep,*s)) return NO; /* Check for Minute */
  1646.     s++;
  1647.     if (!getdigit (&min, &s)) return NO;
  1649.     if (!*s) break;
  1650.     
  1651.     if (!strchr(hour_sep,*s)) break; /* Check for Seconds */
  1652.     s++;
  1653.     if (!getdigit (&sec, &s)) break;
  1655.     if (!*s) break;
  1656.     
  1657.     if (!strchr(sec_sep,*s)) break;
  1658.     s++;
  1659.     if (!getdigit (&hsec, &s)) break;
  1661.     break;
  1662. }
  1664. if (*s) {
  1665.     *s = toupper(*s);
  1666.     if (*s == 'P' && hour != 12) hour += 12;
  1667.             if (*s == 'A' && hour == 12) hour = 0;
  1668. }
  1670. time.hour = hour;
  1671. time.min  = min;
  1672. time.sec  = sec;
  1673. time.hsec = hsec;
  1675. return !ms_settime(&time);
  1676. }
  1678. #define BUFSIZE 256 /* SHOW_FILE buffer size */
  1680. MLOCAL VOID show_crlf(paging)
  1681. BOOLEAN paging;
  1682. {
  1683. crlf();
  1684. if(paging && (--linesleft == 0)) {
  1685.     cmd_pause("");
  1686.     linesleft = page_len - 1;
  1687. }
  1688. }
  1690. /*
  1691.  * Read from channel h until the first Control-Z or the endof file
  1692.  * has been reached. The display is paged if the PAGE_MODE flag is
  1693.  * true otherwise the information is displayed continuous using
  1694.  * the standard flow control.
  1695.  */
  1696. /*RG-00-make this one public*/
  1697. /* MLOCAL VOID show_file(h, paging) */
  1698. VOID show_file(h, paging)
  1699. /*RG-00-end*/
  1700. UWORD h; /* Channel for File access */
  1701. BOOLEAN paging;  /* Page Mode Flag    */
  1702. {
  1703. BYTE FAR *cp; /* pointer to end of path   */
  1704. BYTE FAR *ptr; /* temporary address for printing */
  1705. BYTE FAR *buf; /* Input Buffer    */
  1706. UWORD bufsize;
  1707. WORD  n;
  1708. /*BOOLEAN  lfflg = NO;*/ /* Last character a LineFeed   */
  1709. BOOLEAN  eof = FALSE; /* End of File Flag   */
  1710. UWORD scr_width;
  1711. UWORD nchars    = 0;
  1712. UWORD stderr_h,in_h;
  1714. scr_width = get_scr_width();
  1716. mem_alloc(&show_file_buf,&bufsize,BUFSIZE,BUFSIZE);
  1717. buf = show_file_buf;
  1719. while (!eof && (n = far_read (h, buf, BUFSIZE)) > 0) {
  1721.     cp = ptr = buf;
  1722.     while (n) {  /* while more data */
  1724. while (n && /* while more data */
  1725.       (*cp != 0x1a) && /* and not EOF Char */
  1726.       (*cp != 'n') && /* and Linefeed Char */
  1727.       (nchars<scr_width)) {     
  1728. if (*cp == 9) nchars = (nchars&-8)+7;
  1729. n--; cp++; nchars++; /* count chars, next */
  1730. }
  1732. if (cp != ptr) { /* if any ordinary data */
  1733.     far_write(STDOUT, ptr, (UWORD) (cp-ptr));
  1734.      /* write to CON:        */
  1735.     ptr = cp; /* flush the rest */
  1736.     /*lfflg = NO;*/
  1737. }
  1739. if(n == 0) /* if end of data */
  1740.     break;
  1742. if(*cp == 0x1a) { /* If ^Z then set */
  1743.     eof = TRUE;  /* EOF flag to TRUE */
  1744.     break; /* and stop printing */
  1745. }
  1747. if (*cp == 'n') {
  1748.     ms_x_write(STDOUT,"n",1); /* Display a LF */
  1749.     /*lfflg = YES;*/ /* Set the LineFeed Flag*/
  1750.     n--; /* count LF */
  1751.     ptr = ++cp; /* point past it */
  1752. }
  1754.         if(paging && (--linesleft == 0)) {
  1756.     cmd_stdin_pause();
  1758.     linesleft = page_len - 1;
  1759. }
  1760.         nchars = 0;
  1761.     }
  1762. }
  1764. mem_free(&show_file_buf);
  1765. }
  1767. /*.pa*/
  1768. /*
  1769.  *
  1770.  */
  1771. #define TYPE_PAGE (flags & 1)
  1773. GLOBAL VOID CDECL cmd_type(cmd)
  1774. REG BYTE *cmd;
  1775. {
  1776. WORD  ret, h; /* file handle   */
  1777. BYTE path[MAX_FILELEN]; /* Path and File Name   */
  1778. BYTE *files; /* pointer to file spec    */
  1779. #if defined(PASSWORD)
  1780. BYTE *password;
  1781. #endif
  1782. DTA search;  /* Local Search Buffer   */
  1783. UWORD flags; /* only one switch permitted   */
  1784. BOOLEAN wild_flag = FALSE; /* Wild Card Type   */
  1785. BYTE passbuf[MAX_FILELEN];
  1787. if(f_check(cmd, "p", &flags, NO))       /* if any bad flags */
  1788.     return; /*    don't do it */
  1790. get_filename(path, deblank(cmd), YES); /* Extract the Filename     */
  1792. if(d_check(path) == NULLPTR) /* Check if the specified   */
  1793.     return; /* drive is valid     */
  1795. files = fptr(path); /* isolate the filename     */
  1796. #if defined(PASSWORD)
  1797. password = strchr(files, *pwdchar); /* Check for Source password*/
  1798. if(password) { /* and save in internal buf.*/
  1799.     strcpy(passbuf, password);
  1800.     *password = 0; /* discard path password */
  1801.     password = &passbuf[0]; /* and use local copy */
  1802. }
  1803. #endif
  1805. if(iswild(files))
  1806.     wild_flag = TRUE;
  1808. linesleft = page_len - 1; /* Initialize the paging     */
  1809. /* variable used by SHOW_?   */
  1811. /*
  1812.  * For wild card searches we must initialise search.fname
  1813.  * with an initial ms_x_first for the DO/WHILE loop.
  1814.  */
  1816. if (wild_flag) {
  1817.     search.fattr = ATTR_STD;
  1818.     ret = ms_x_first(path, ATTR_STD, &search);
  1820.     if (ret < 0) {
  1821.      e_check(ret); /* if we can't find anything */
  1822. return; /* we'd better say so */
  1823.     }
  1824. }
  1826. do {
  1827.     if (wild_flag)
  1828. strcpy(files, search.fname);   /* make it full pathname     */
  1829.     strcpy(heap(), path);
  1831. #if defined(PASSWORD)
  1832.     if(password)
  1833.         strcat(heap(), password);
  1834. #endif
  1836.     h = ms_x_open(heap(), OPEN_READ); /* Open file in sharing mode */
  1837.     if(h == ED_SHAREFAIL || h == ED_ACCESS) /* if fails with a   */
  1838.         h = ms_x_open(heap(), 0); /* sharing violation then try*/
  1839. /* opening with compatibilty */
  1840.     if(h < 0) { /* mode.      */
  1841. e_check(h);
  1842. return;
  1843.     }
  1845.     if (wild_flag) { /* if wild card type */
  1846. strupr(path); /* Display UpperCase Filename */
  1847. show_crlf(TYPE_PAGE); /* Print a CRLF with PAGING flag*/
  1848. revon(); printf ("%s:", path); revoff();
  1849. show_crlf(TYPE_PAGE); /* Print a CRLF with PAGING flag*/
  1850.     }
  1852.     show_file(h, TYPE_PAGE); /* Output the File to the Screen */
  1853.     ms_x_close(h); /* Close the File */
  1854. } while (wild_flag && (ms_x_next(&search) >= 0));
  1855. }
  1857. /*
  1858.  * Displays the data read from Channel 0 until the end of file or 
  1859.  * Control-Z. If no output redirection is inforce then MORE pages
  1860.  * the display using the CMD_PAUSE function.
  1861.  *
  1862.  * MORE will only enable PAGING if the output device is the CONSOLE
  1863.  * otherwise paging is disabled.
  1864.  */
  1865. GLOBAL VOID CDECL cmd_more()
  1866. {
  1867. linesleft = page_len -1; /* Set the Page length and */
  1868. show_file(STDIN, YES); /* display STDIN till EOF  */
  1869. /* or a Control-Z    */
  1870. }
  1872. /*.pa*/
  1873. /*
  1874.  *
  1875.  */
  1876. GLOBAL VOID CDECL cmd_ver()
  1877. {
  1878. printf(MSG_VERSION, (env_scan("VER=", heap()) ? "" : heap()));
  1879. printf(MSG_CPYRIGHT);
  1880. #if !defined(FINAL)
  1881. if(!env_scan("BETA=", heap()))
  1882.     printf("%sn", heap());
  1883. #endif
  1884. }
  1886. GLOBAL VOID CDECL cmd_vol(path)
  1887. BYTE *path;
  1888. {
  1889. BYTE *s;
  1890. BYTE temp[7];
  1891. DTA search;
  1892. WORD ret,i;
  1893. BYTE label[12];
  1895. strcpy(temp,d_slash_stardotstar);
  1897. if ((path = d_check(path)) == 0)
  1898.     return;
  1899. if (ddrive == -1) return;
  1901. temp[0] = (BYTE) (ddrive+'A');
  1903. ret = ms_x_first(temp, ATTR_LBL, &search);
  1904. if (ret == ED_DRIVE)
  1905.     e_check(ret); /* display error if invalid drive */
  1906. else {
  1907.     printf(MSG_LBL, ddrive+'A');
  1909.     if (ret)
  1910. printf(MSG_NOLBL);
  1911.     else {
  1912. s = search.fname;
  1913. for (i = 0; *s && (i < 8); i++)
  1914.     label[i] = (*s == '.') ? ' ' : *s++;
  1916. if (*s == '.') s++;       /* if there was a '.' skip it */
  1917. for (; *s && (i < 11); ) label[i++] = *s++; /* copy the rest */
  1918. label[i] = '';         /* null terminate label */
  1920. printf(MSG_OKLBL, label);
  1921.     }
  1922.     crlf();
  1923. }
  1924. }
  1926. /*.pa*/
  1927. /*
  1928.  *
  1929.  */
  1930. GLOBAL VOID CDECL cmd_delq(path)   /* erase files with query */
  1931. BYTE *path;
  1932. {
  1933. erase (path, YES); /* erase files, confirm deletes */
  1934. }
  1936. EXTERN BYTE FAR * CDECL farptr(BYTE *);
  1937. #define YES_CHAR (*farptr(YES_NO+0))
  1938. #define NO_CHAR (*farptr(YES_NO+1))
  1940. #define ERASE_CONFIRM (flags & 3)
  1941. #define ERASE_SYS (flags & 4)
  1943. MLOCAL VOID erase(s, confirm)
  1944. BYTE *s;
  1945. BOOLEAN  confirm;
  1946. {
  1947. BYTE path[MAX_FILELEN]; /* FileName Buffer     */
  1948. BYTE answer[20]; /* Yes/No string     */
  1949. BYTE  *files; /* pointer to file spec     */
  1950. #if defined(PASSWORD)
  1951. BYTE *password;
  1952. #endif
  1953. UWORD flags; /* only one switch permitted*/
  1954. DTA search;  /* Local Search Buffer     */
  1955. UWORD attr; /* Erase Search Attributes  */
  1956. #if !STACK
  1957. BYTE passbuf[MAX_FILELEN];
  1958. #endif
  1959. #if !(defined (CDOSTMP))
  1960. BYTE savepath[MAX_PATHLEN+1];
  1961. BYTE newpath[MAX_PATHLEN+2]; /* including trailing      */
  1962. BYTE fcb[37];
  1963. WORD ret;
  1964. WORD i;
  1965. #endif
  1967. if(f_check(s, "cps", &flags, NO))      /* if any bad flags return  */
  1968.     return;
  1970. get_filename(path, s, YES); /* Extract the Filename     */
  1971. if(strlen(path) == 0) { /* and check for 0 length   */
  1972.     printf(MSG_NEEDFILE); /* path caused by invalid   */
  1973.     crlfflg = YES; /* filename characters in   */
  1974.     return; /* the command line.     */
  1975. }
  1977. if ((strcmp(path,dotdot+1) == 0) || (strcmp(path,dotdot) == 0)) {
  1978. strcat(path,d_slash_stardotstar+2);
  1979. }
  1981. /* Neil's bodge */
  1982. /* del d:. should be the same as del d:*.* */
  1983. if (strlen(path)==3 && path[1] == ':' && path[2] == '.') {
  1984.     path[2] = 0;
  1985.     strcat(path,d_slash_stardotstar+3);
  1986. }
  1987. /* end of Neil's bodge */
  1989. attr = ATTR_STD & ~ATTR_SYS; /* Prevent SYS files from   */
  1990. attr |= ERASE_SYS ? ATTR_SYS : 0; /* being deleted unless the */
  1991. /* /S option is specified.  */
  1993. if(nofiles(path, attr, YES, YES)) /* if no files or error     */
  1994.     return; /*    then we can't do this */
  1996. files = fptr(path); /* isolate the filename     */
  1998. #if defined(PASSWORD)
  1999. password = strchr(files, *pwdchar); /* Check for Source password*/
  2000. if(password) { /* and save in internal buf.*/
  2001. #if STACK
  2002.     password = stack(strlen(password)+1);
  2003. #else
  2004.     password = &passbuf[0];
  2005. #endif
  2006.     strcpy(password, strchr(files, *pwdchar));
  2007. }
  2008. #endif
  2010. confirm |= ERASE_CONFIRM; /* DELQ implies "/c" switch */
  2011. if (!confirm && /* if not confirming anyway */
  2012.     (!strncmp(files, "*", 1)&& /* and all files specified  */
  2013.     strstr(files, ".*"))) /* ie * at start of name & ext */
  2014. {
  2015.     printf(MSG_ERAALL);    /* "Are you sure (Y/N)? " */
  2016.     answer[0] = sizeof(answer)-2; /* max. one character   */
  2017.     answer[1] = 0;   /* no command recall permitted */
  2018.     system (MS_C_READSTR, answer);/* read the response */
  2019.     crlf();
  2020.     if ((answer[2] & 0xdf) != YES_CHAR) {
  2021.      crlfflg = YES; /* if not 'Y' or 'y' given */
  2022. return; /* then return   */
  2023.     }
  2024. }
  2026. if(!confirm && ERASE_SYS && /* If no confirmation is required */
  2027. #if !(defined (CDOSTMP))
  2028.    !iswild(path) && /* and this is an ambigous file   */
  2029. #endif
  2030.    !ms_x_unlink(path)) /* specification and all the files*/
  2031.     return; /* are deleted without error then */
  2032. /* return to the calling function */
  2033. /* otherwise delete files   */
  2034. /* individually.   */
  2036. #if !(defined (CDOSTMP))
  2037. /* use fcb delete if no confirm and system files are not to be   */
  2038. /* deleted, since it's much quicker. Any problems, go and do it the  */
  2039. /* standard way so we can report on problem files.   */
  2041. d_check (path);
  2042. if (ddrive != -1 && (!confirm) && (!ERASE_SYS)
  2043. #if defined(PASSWORD)
  2044. && (!password)
  2045. #endif
  2046. ) {
  2047.     if (!d_check (path))
  2048.         return;
  2050.     if ((ms_f_parse (fcb, files, 0)) < 0) /* set up fname in fcb  */
  2051.         goto fcbdel_end;
  2052.     *fcb = ddrive+1;
  2054.     strcpy (savepath, "d:\"); /* get curpath on relevant drive  */
  2055.     *savepath = ddrive + 'A';
  2056.     ms_x_curdir (ddrive+1, savepath+3);
  2057.     
  2058.     strncpy (newpath, path, files - path);
  2059.      /* extract new path */
  2060.     newpath[files - path] = '';
  2062.     if ((i = strlen (newpath)) > (newpath[1] == ':' ? 3 : 1))
  2063.         newpath[--i] = ''; /* remove trailing backslash */
  2065.     if (! ((i == 0) || ((i == 2) && (newpath[1] == ':'))) )
  2066.         if (ms_x_chdir (newpath))
  2067.     goto fcbdel_end;
  2069.     ret = ms_f_delete (fcb);
  2070.     ms_x_chdir (savepath);
  2071.     
  2072.     if (!ret)
  2073.         return; /* all done   */
  2074. fcbdel_end:
  2075.     ;
  2076. }
  2077. #endif
  2078.     
  2079. if (ms_x_first(path, attr, &search)) return;
  2080. do {
  2081.     strcpy(files, search.fname); /* make it full file name */
  2082.     strcpy(heap(), path); /* copy to an internal    */
  2083. #if defined(PASSWORD)
  2084.     if(password) /* buffer and append the  */
  2085. strcat(heap(), password); /* password if present   */
  2086. #endif
  2088.     if(confirm) {
  2089. printf(MSG_ERAQ, path);
  2090. if(!yes(YES, NO))
  2091.     continue;
  2092.     }
  2094.     if((ret = ms_x_unlink(heap())) != 0) {
  2095. printf(MSG_ERA, path);
  2096. e_check(ret);
  2097. crlf();
  2098.     }
  2099. } while (!ms_x_next (&search));
  2100. }
  2102. #if defined(DOSPLUS)
  2103. /*
  2104.  * The HILOAD command accepts a trailing command line.
  2105.  * It will attempt to execute the command line, running any programs
  2106.  * specified in high memory.
  2107.  */
  2108. GLOBAL VOID CDECL cmd_hiload(s)
  2109. REG BYTE *s;
  2110. {
  2111. int region, i;
  2113. s = deblank(s);
  2114. if (*s == 0) {
  2115.     printf(msg_inop);
  2116.     return;
  2117. }
  2119. global_in_hiload++;
  2121. if (global_in_hiload == 1) {
  2122.     global_link  = get_upper_memory_link();
  2123.     global_strat = get_alloc_strategy();
  2124.     region = 1;
  2126.     set_upper_memory_link(1);
  2128.     /* Look out for /L:r1[,s1][;r2[,s2]...] */
  2129.     /* We parse r1, and discard the rest */
  2131.     if ((s[0]==*switchar)&&(toupper(s[1])=='L')&&(s[2]==':')&&isdigit(s[3])){
  2132. region = s[3]-'0'; /* assume region is 1 digit */
  2133. s += 4; /* skip what we parsed */
  2134. while ((*s==';') || (*s==',') || isdigit(*s))
  2135. s++;
  2136. s = deblank(s); /* deblank rest of line */
  2137.     }
  2139.     /* discard any /S we find (really we should minimise) */
  2140.     if ((s[0]==*switchar) && (toupper(s[1])=='S')) {
  2141. s += 2; /* skip the /S */
  2142. s = deblank(s); /* deblank rest of line */
  2143.     }
  2145.     /* only bother if we have upper memory and are forcing location */
  2146.     if ((region > 1) && (get_upper_memory_link() != 0)) {
  2147. set_alloc_strategy(0x40); /* First fit high only */
  2148. for(i=1;i<region;i++) /* allocate regions to skip */
  2149. hidden_umb[i] = alloc_region();
  2150.     }
  2152.     set_alloc_strategy(0x80); /* First fit high */
  2153. }
  2155. docmd(s,YES); /* call normal code */
  2157. if (global_in_hiload == 1) {
  2158.     for(i=1;i<10;i++) { /* free up any UMB's we have */
  2159. if (hidden_umb[i]) {
  2160. free_region(hidden_umb[i]);
  2161. hidden_umb[i] = 0;
  2162. }
  2163.     }
  2165.     set_upper_memory_link(global_link);
  2166.     set_alloc_strategy(global_strat);
  2167. }
  2168. global_in_hiload --; /* all back as before */
  2169. }
  2171. #endif