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

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

操作系统开发

开发平台：

Asm

BATCH.C：源码内容
  1. /*
  2. ;    File              : $Workfile: BATCH.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. ;    ENDLOG
  34. */
  36. /*
  37.  * 27 Oct 87 Improve GOTO command to ignore trailing white space, only
  38.  * match on the first 8 characters and only allow valid
  39.  * filename characters.
  40.  * 28 Oct 87 Correct duplicate prompt display when a batch file label
  41.  * is read and the echo flag is ON.
  42.  *  9 Nov 87 Change Batch file termination so that Output Redirection is
  43.  * correctly handled.
  44.  * 13 Jan 88 If prompt display is aborted because of a critical error
  45.  * the following prompt will be forced to "$n$g".
  46.  * 25 Jan 88 Support redirection on the FOR command correctly
  47.  * 24 Feb 88 Generate batch file parameter %0 correctly as WS200 install
  48.  * requires that the drive specifier be present. Garry Silvey
  49.  *  5 May 88 Batch paramater %0 is now a copied from the invoking command
  50.  * line.
  51.  * 18 May 88 Support the ESC_CHAR in the command line.
  52.  * 20 May 88 Disable MULTI_CHAR support in DOSPLUS when the user enters the
  53.  * first command.
  54.  * 26 May 88 Added STACK switch and support $q in prompt.
  55.  * 27 May 88 Added string undefs.
  56.  *  6 Jun 88 Call resident portion to do readline (SideKick+ problem)
  57.  * 23 Jun 88 Support CR only delimited batch files and if errorlevel ==
  58.  * syntax used in installation files.
  59.  *  6 Jul 88 Support the FOR ... CALL syntax correctly. (IMS)
  60.  * 17 Aug 88 Jump to labels followed by comments (Ashton Tate By-Line)
  61.  * 21 Sep 88 Use KEYIN_FLG to allow the default ECHO state to be ON.
  62.  * 16 Nov 88 Disable BACK_CHAR in Concurrent DOS.
  63.  * 21 Dec 88 Allow leading whitespace before labels
  64.  *  5 Jan 89 Support Quoted strings in Batch files.
  65.  * 18 Apr 89 Support Quoted strings in IF command
  66.  * 19 Apr 89 Quotes in IF command: "x == "x" parses, "x=x" == "x.. doesn't
  67.  * 24 Apr 89 Increase MAX_LINE to 128 for pctools ver 5
  68.  * 19 May 89 Take out support for quoted strings in IF command
  69.  * 05 Jun 89 Do not echo command or display the prompt during FOR command.
  70.  * Restore support for batch files with long lines.
  71.  * 02 Nov 89 batch_line bodge which substitutes 0xFF for 0x00 changed - we
  72.  * now substitute 'rn', then throw away rest of the line.
  73.  * 01 Dec 89 batch_line - trailing % at end of line is discarded
  74.  * 15 Dec 89 "if errorlevel -1" allowed
  75.  * 30 Jan 90 Added int2e_start and int2e_finish to save and restore
  76.  * important batch file variables to allow novell menu program
  77.  * to use int 2e to invoke batch files.
  78.  * 30 Jan 90 Forced batch data structures to appear on segment boundaries;
  79.  * Added dummy memory descriptor before batch structure;
  80.  * Put segment address of batch structure in batch_seg_ptr;
  81.  * All so novell can find and patch the drive letter of
  82.  * autoexec.bat during a remote boot.
  83.  *  6-Mar-90 Watcom C v 7.0
  84.  *  7-Mar-90 allow ESC_CHAR through unless followed by MULTI/BACK_CHAR
  85.  * 14-Mar-90 Reduce batch_buf to 32 bytes like wot dos is
  86.  * 20-Mar-90 Batch structures allocated by mem_alloc (ie. MS_M_ALLOC)
  87.  * rather than on heap. Batch file nesting no longer heap limited.
  88.  * 27-Mar-90 Allow "=", "==", "===" etc in "if errorlevel==n"
  89.  * 10-Apr-90 Make errorlevel 999 same as errorlevel 231 (mod 256)
  90.  *  8-May-90 Don't echo getcmd unless batch file (eg. "dir|more" shouldn't
  91.  * echo "C:>more")
  92.  * 23-May-90 batch_read no longer repeatedly deblanks line (which leads
  93.  * to the buffer happily wandering up memory).
  94.  * 30-May-90 "if ab de==ef" form doesn't generate syntax error
  95.  * 13-Jun-90 batch_line rejects unmatched "|" as syntax error
  96.  * 20-Sep-90 is_filechar() and is_pathchar() now take pointer instead of byte
  97.  * Changed batch_char() to return pointer instead of byte,
  98.  * renamed to batch_ptr().
  99.  * Amended make_label(), batch_start() and cmd_for() to check for
  100.  * DBCS lead bytes.
  101.  * 24-Sep-90 Add $m and $u option to PROMPT to display status of mail
  102.              and user name respectively
  103.  * 27-Sep-90 Add IF USERID <userid> COMMAND
  104.                        IF LOGINNAME <loginname> COMMAND
  105.                        IF GROUPNAME <groupname> COMMAND 
  106.                        IF ASK ["string"] <char> COMMAND
  107.                        .. AND .. OR .. to IF processing
  108.                        INPUT ["string"] <environment-variable>
  109.                        INPUTC ["string"] <environment-variable>
  110.  * 10-Oct-90 inherit batch files from TMP when TSR auto-loads CDOS.COM
  111.   (a bodge for Stellar)
  112.  * 25-Oct-90 inherit echoflg from TMP when TSR auto-loads CDOS.COM
  113.  * 31-Oct-90 change IF ASK command to IF KEY command
  115. DRDOS BUXTON
  116. ------------
  117.  * 25-Apr-91 '!' is now ignored during COMMAND /C processing.
  118.  * 28-May-91 leading white space is now ignored before labels.
  119.  * 09-Jun-91 Added GOSUB, RETURN and SWITCH commands.  
  120.  * 24-Jul-91 if batch_seg_ptr is poked to zero all batch processing is
  121.    terminated.
  122.  * 26-Jul-91 batch files are now read into a far buffer. This avoids
  123.    reading directly to seg FFFF if we happen to be there and so
  124.  solves some NOVELL problems.
  126.  * 18-Jun-92 Support ? in batch files as in config.sys.
  127.  * 23-Jun-92 $u in prompt causes LOGINNAME in environment to be displayed.
  128.  * 07-Jul-92 IF EXIST now finds hidden files. 
  129. */
  131. #include "defines.h"
  133. #include <string.h>
  134. #if defined(MWC) && defined(strlen)
  135. #undef strcmp /* These are defined as macros in string.h */
  136. #undef strcpy /* which are expanded in line under */
  137. #undef strlen /* Metaware C. These undefs avoid this. */
  138. #endif
  140. #include <portab.h>
  142. #if !defined(DOSPLUS)
  143. #include <ccpm.h>
  144. #endif
  146. #include "command.h"
  147. #include "toupper.h"
  148. #include "support.h"
  149. #include "dosif.h"
  150. #include "global.h"
  151. #include "dos.h"
  153. #include <setjmp.h>
  155. /*RG-01*/
  156. #if defined(CDOSTMP) || defined(CDOS)
  157. #include    <pd.h>
  158. #define PATH_LEN     65  /* max path length (null terminated) */
  159. EXTERN PD FAR * CDECL pd; /* Far pointer to Current PD */
  160. EXTERN VOID CDECL cmd_set(BYTE *);             /* COMINT.C */
  161. #if !defined (NOSECURITY) 
  162. #include    "security.h"
  163. #include    "login.h"
  164. #endif
  165. #endif
  166. /*RG-01-end*/
  168. EXTERN VOID CDECL cmd_pause();
  170. EXTERN BOOLEAN parse(BYTE *);
  172. EXTERN UWORD boot_key_scan_code; /* in COM.C */
  174. /*RG-03*/
  175. BOOLEAN if_context=FALSE;
  176. BOOLEAN ifcond=FALSE;
  177. /*RG-03-end*/
  179. EXTERN jmp_buf break_env;
  181. #define MAX_LINE 128 /* Maximum No of Chars in input line */
  183. #if defined(CPM)
  184. EXTERN UWORD user; /* USER Number variable for CPM.EXE */
  185. #endif
  186. EXTERN BYTE msg_prmeq[]; /* Static Environ String "PROMPT=" */
  188. #if 0
  189. #define FCONTROL struct fcc
  190. MLOCAL FCONTROL {
  191. BOOLEAN  sflg; /* FOR File Search Flag  */
  192. DTA  search; /* FOR Search structure  */
  193. BYTE  *files; /* FOR File list */
  194. BYTE  *cmd; /* FOR Command Line */
  195. BYTE  forvar; /* FOR variable char */
  196. };
  197. #endif 
  199. MLOCAL FCONTROL *forptr;
  201. #if 0
  202. #define BCONTROL struct bcc
  203. GLOBAL BCONTROL {
  204. BCONTROL FAR *bcontrol; /* Previous Batch Control Structure  */
  205. BOOLEAN  eof; /* End of File Flag      */
  206. LONG  offset; /* Offset in BATCH file       */
  207. LONG  ret_offset[4]; /* return offset from gosub          */
  208. BYTE  *batcmd; /* Batch File Input parameters      */
  209. UWORD  batshift; /* Shift Offset       */
  210. BYTE  batfile[MAX_PATHLEN]; /* Batch File Name      */
  211. UWORD  stream; /* Stream for this Batch File      */
  212. FCONTROL *fcontrol; /* Pointer to previous FOR command   */
  213. BYTE  *heap_start; /* Heap pointer before extra bytes   */
  214. WORD  heap_size; /* are added to shift to segment     */
  215. BYTE     save_area[1]; /* boundary. - EJH      */
  216. } FAR *batch, FAR *batch_save; /* Master Batch Control Stucture     */
  217. #endif
  219. /* Handle 255 is closed */
  220. #define CLOSED 0xff
  222. /* Keyboard  Variables */
  223. GLOBAL BYTE kbdbuf[MAX_LINE+2]= {0};/* Keyboard Input Buffer      */
  224. GLOBAL BYTE *kbdptr = kbdbuf+2; /* Keyboard Buffer Pointer      */
  225. MLOCAL BOOLEAN keyin_flg = FALSE; /* This flag is set to TRUE when the */
  226. /* initial command line buffer setup */
  227. /* by INIT() has been exhausted.     */
  228. MLOCAL WORD batchflg_save; /* Used during INT 2E handling.      */
  229. MLOCAL WORD echoflg_save; /* ditto above                       */
  230. GLOBAL WORD echoflg_save2; /* saves echo state when batch file  */
  231. /* execed.      */
  232. /*
  233.  * Batch file buffering control structures.
  234.  */ 
  235. MLOCAL LONG batch_off; /* Offset of buffered data in File */
  236. MLOCAL WORD batch_cnt = 0; /* Number of bytes in buffer    */
  237. MLOCAL BYTE batch_buf[32];
  238. MLOCAL BYTE batch_eof[] = "x1a"; /* End of file string */
  240. MLOCAL BYTE batch_sep[] = "t ;,="; /* Batch Command line option delimiters */
  242. EXTERN VOID CDECL cmd_ver(BYTE *); /* COMINT.C Display Version */
  243. EXTERN VOID docmd(BYTE *, BOOLEAN); /* COM.C     */
  244. EXTERN VOID CDECL int_break(VOID); /* COM.C     */
  246. GLOBAL BOOLEAN getcmd(BYTE *);
  247. GLOBAL VOID for_end();
  248. GLOBAL VOID batch_start(BYTE *, BYTE *, BYTE *);
  249. GLOBAL VOID batch_end(VOID);
  250. GLOBAL VOID batch_close(VOID);
  251. MLOCAL VOID for_in(BYTE *);
  252. MLOCAL WORD batch_open(VOID);
  253. MLOCAL VOID batch_read(BYTE *, BOOLEAN);
  254. MLOCAL VOID batch_line(BYTE *, BOOLEAN);
  255. MLOCAL BYTE *batch_ptr(VOID);
  256. MLOCAL VOID prompt(VOID);
  257. MLOCAL BOOLEAN novell_extension(BYTE *, BYTE *);
  259. #if !defined(CDOSTMP)
  260. EXTERN UWORD FAR *batch_seg_ptr; /* For novell remote boot. see CSTART.ASM */
  261. #endif
  263. #if defined(CDOS) || defined(CDOSTMP)
  264. #define TmpPspEchoFlgPtr 0x58 /* Magic location to keep echo flag */
  265. #define TmpPspDataSeg 0x5a /* Magic location to keep Data Seg */
  266. #define TmpPspBatchSeg 0x5c /* Magic location to keep Batch Ptr */
  267. #define TmpPspMpad 0x5e /* Magic location to keep unlinked MPAD */
  268. #endif
  269. #if defined(CDOS)
  270. typedef struct _mpad
  271. {
  272. UWORD link; /* address of next MPAD */
  273. UWORD start; /* seg of allocation unit */
  274. UWORD length; /* length in paras */
  275. UWORD res0x06; /* reserved */
  276. UWORD xios; /* Process id */
  277. } MPAD;
  278. GLOBAL VOID inherit_TMP_state(VOID);
  279. #endif
  281. /*.pa*/
  282. GLOBAL BOOLEAN getcmd(line) /* read command line */
  283. BYTE *line;
  284. {
  285. BYTE *s;
  286. BOOLEAN quote = FALSE;
  287. BOOLEAN cancel_prompt = FALSE;
  288. #if defined(DOSPLUS)
  289. WORD i;
  290. BYTE cmd_name[16];
  291. #endif
  293. back_flag = FALSE; /* Disable BackGround Processing*/
  295. *line = '';
  297. FOREVER {
  298.     if(for_flag) { /* If Processing a FOR command */
  299. for_in(line); /* then call then use the FOR_IN*/
  300. return NO;   /* routine to fill the keyboard */
  301.     } /* buffer and then return */
  303.     if(!batchflg) /* If no batch processing then  */
  304.         break; /* skip further tests */
  305. batch_restart:
  306.     
  307. #if defined(DOSPLUS)
  308.     if (!*batch_seg_ptr) { /* if batch_seg_ptr has been set to */
  309.      batch_endall(); /* zero terminate all batch files   */
  310. return NO;
  311.     }
  312. #endif
  313.     
  314.     if(batchflg && batch->eof) {  /* Close the batch file if at */
  315. batch_end();   /* the end of the file. */
  316.         if(batchflg == 0)   /* BREAK if batch processing */
  317.    return NO;   /* is complete.  */
  318.         continue;
  319.     }     
  321.     if(!batch_open()) /* Open the file and read a line*/
  322. return YES; /* from the file */
  324.     batch_read(line, NO); /* Read Line */
  326.     if(batch->eof) /* If the end of the batch file */
  327.         batch_close(); /* has been detected then close */
  328. /* the file. */
  330.     if (*line == '?' || boot_key_scan_code == 0x4200) {
  331.         optional_line(line);
  332.     }
  334.     if(*line == '@') { /* If first character in the */
  335. strcpy(line, line+1); /* command line is '@' donot */
  336. return NO; /* echo the command and move the*/
  337.     } /* string down 1 character. */
  339.     if (!cancel_prompt) {
  340. if(crlfflg && echoflg)
  341.     crlf();
  342. prompt();
  343.     }
  344.     return echoflg;
  345. }
  347. if(!*kbdptr) { /* Set the Keyboard Input flag  */
  348.     keyin_flg = TRUE; /* after a initial command line */
  349. /* buffer has been exhausted */
  350. #if 1
  351.     if (c_option) { /* insert an EXIT command if we */
  352. kbdptr = &kbdbuf[2];    /* are processing a /C command  */
  353. strcpy(&kbdbuf[2],"exit");
  354.      }
  355. #endif
  356. }
  358. if (!*kbdptr) { /* Check for existing line      */
  361. /* NEIL */
  362.     if(crlfflg && echoflg)
  363. crlf();
  364. /* NEIL end */
  365.     prompt(); /* issue command line prompt */
  366.     allow_pexec = FALSE;
  368.     /* $x in prompt string may cause batchflg to be set. */
  369.     /* If so we must jump to batch processing code.  */
  370.     if (batchflg) {
  371.      cancel_prompt = TRUE;
  372. goto batch_restart;
  373.     }
  374.     
  375.     kbdptr = ""; /* Force KBDPTR to point to ''*/
  376. /* in case we get ABORTED and */
  377. /* drop through here again. */
  378.     kbdbuf[0] = MAX_LINE; /* set max. input length */
  379.     kbdbuf[kbdbuf[1]+2] = 'r'; /* Terminate current line. */
  380. #if defined(CDOSTMP)
  381.     system(C_READSTR, kbdbuf); /* read a line */
  382. #else
  384.     readline(kbdbuf);
  385. #endif
  387.     crlf();
  388.     
  389.             kbdbuf[kbdbuf[1] + 2]=''; /* terminate input */
  390.     kbdptr = kbdbuf + 2;
  391. }
  393. s = kbdptr;
  395. while(*s) {
  396.     if(*s == '"') /* Check for a " character and  */
  397. quote = !quote;  /* update the flag correctly */
  399. #if !defined(DOSPLUS)
  400.     if(*s == ESC_CHAR && /* If the Escape character has  */
  401.        !quote && /* been specified then do not */
  402.        ((*(s+1) == MULTI_CHAR) || (*(s+1) == BACK_CHAR))) {
  403. *line++ = *++s; /* process the following char. */
  404. s++;
  405. continue;
  406.     }
  407. #endif
  409. #if defined(DOSPLUS) /* Disable MULTI_CHAR support   */
  410.     if(!(keyin_flg||c_option||k_option))
  411.      /* after the init command line  */
  412. #endif /* has been exhausted. */
  413.         if(*s == MULTI_CHAR && /* If a Multiple command char */
  414.         !quote) { /* and the QUOTE flag is FALSE */
  415.     s++; /* then break the command here */
  416.     break; /* and save the rest of the line*/
  417.         } /* for next time. */
  419. #if FALSE /* defined(CDOSTMP) */
  420.     if(*s == BACK_CHAR && /* If a Back Ground processing */
  421. !quote) { /* and the QUOTE flag is FALSE */
  422. s++; /* then treat as for MULTI_CHAR */
  423. back_flag = TRUE; /* except that the current      */
  424. break; /* command is executed in the   */
  425.     } /* background. */
  426. #endif
  427.     if(*s == PIPE_CHAR && /* If a Pipe enable character */
  428. !quote) { /* and the QUOTE flag is FALSE */
  429. s++; /* then break the command here */
  430. pipe_out = YES;  /* and save the rest of the line*/
  431. break; /* for next time. */
  432.     }
  434.     copy_char(&line, &s); /* Just save the character */
  435. }
  437. *line = ''; /* Terminate the Buffer  */
  438. kbdptr = deblank(s); /* Copy the possibly null length*/
  439. return NO;   /* string to KBDBUF for next    */
  440. /* next invocation and save CCP */
  441. }
  443. MLOCAL VOID for_in(line)   /* A FOR command is currently */
  444. BYTE *line;  /* executing so build the line */
  445. { /* from the internal FOR data */
  446. BYTE *s,*t; /* initialized by CMD_FOR */
  447. BYTE *bp1, *fp;
  448. WORD i;
  450. FOREVER {
  451.     fp = forptr->files;  /* Get the next string and stop     */
  452.     if(strlen(fp) == 0) { /* if its the zero length string    */
  453. *line = ''; /* which marks the end of the FOR   */
  454. crlfflg = YES; /* search list.      */
  455. for_end();
  456. return;
  457.     }
  459.     if(!iswild(fp)) { /* If not an ambiguous file  */
  460. forptr->sflg = NO; /* then update the FOR      */
  461. forptr->files += strlen(fp)+1; /* pointer to the next file  */
  462. break; /* in the search list.      */
  463.     }
  465.     if(forptr->sflg) /* Search for the next file  */
  466. i = ms_x_next(&forptr->search); /* file on the disk if      */
  467.     else /* FOR_SFLG otherwise get first */
  468. i = ms_x_first(fp, ATTR_RO, &forptr->search);
  470.     if(i < 0) {  /* If the search failed      */
  471. forptr->sflg = NO; /* then update the FOR      */
  472. forptr->files += strlen(fp)+1; /* pointer to the next file  */
  473. continue; /* in the search list.      */
  474.     } /* and get the next  entry   */
  476.     fp = (BYTE *) heap();
  477.     strip_path(forptr->files, fp); /* Extract the Path      */
  478.     strcat(fp, forptr->search.fname); /* and then add the matching */
  479.     forptr->sflg = YES;  /* filename and update the   */
  480.     strupr(fp);  /* variables.      */
  481.     break; /* Force name to uppercase   */
  482. }
  484.   s = forptr->cmd;
  485.   t = line;
  486.   while (*s && (t - line) < MAX_LINE) { /* Copy the command   */
  487.       if(*s == '%' && *(s+1) == forptr->forvar) { /* line looking for  */
  488.   s += 2;  /* the imbedded %c and insert*/
  489.   bp1 = fp; /* the current substition    */
  490.   while(*bp1 && (t - line) < MAX_LINE) /* string pointed at by FP   */
  491.       copy_char(&t, &bp1);
  492.   continue;
  493.       }
  494.  
  495.       copy_char(&t, &s);
  496.   }
  497.  
  498.   *t = '';   /* and terminate the string */
  499. }
  501. /*.pa*/
  502. /*
  503.  * BATCH FILE CONTROL ROUTINES
  504.  * ===========================
  505.  *
  506.  * The following routines provide the interface from COMMAND.COM to
  507.  * a batch file. BATCH_START sets up all the local variables to enable
  508.  * batch processing while BATCH_END terminates batch processing. BATCH_READ
  509.  * reads a line of data from the batch file and expands it to contain the
  510.  * command line variables and variables from the environment.
  511.  */
  512. GLOBAL VOID batch_start(argv0, path, tail)
  513. BYTE *argv0; /* Invoking Command */ 
  514. BYTE *path; /* Complete filename */
  515. BYTE *tail; /* Command Line Options */
  516. {
  517. BYTE *s2;
  518. BYTE dirbuf[MAX_PATHLEN];
  519. WORD i;
  521. if(batchflg) /* If a batch file is currently */
  522.     batch_close(); /* close it. So minimum number */
  523. /* of handles are used.  */
  525. s2 = path; /* Save the original Path */
  526. if((path = d_check(path)) == NULL)  /* Check that the file */
  527.     return;     /* exists. */
  529. batch_new(); /* new incarnation of batch */
  531. forptr = (FCONTROL *) NULL; /* Disable current FOR control */
  532. for_flag = NO; /* and Global FOR flag */
  534. /*
  535.  * Generate the full path specification for the batch file
  536.  * and store in the batch control information. If the user
  537.  * has specified the full path use it otherwise determine the
  538.  * full path using ms_x_curdir.
  539.  */
  540. if (ddrive != -1 && *path != *pathchar) {
  541.     ms_x_curdir(ddrive+1, dirbuf);
  542.     sprintf(heap(), "%c:%s%s%s%s", ddrive + 'A',
  543.  pathchar,
  544.  dirbuf,
  545.  (*dirbuf ? pathchar : ""),
  546.  path);
  547. }
  548. else if (ddrive != -1)
  549.     sprintf(heap(), "%c:%s", ddrive + 'A', path);
  550. else
  551.     ms_x_expand(heap(), path);
  553. for (i=0; i<MAX_PATHLEN; i++) /* save the batch pathname */
  554.     batch->batfile[i] = heap()[i];
  555. batch->batfile[MAX_PATHLEN-1] = 0;
  557. /*
  558.  * Copy the invoking command and the individual elements
  559.  * of the command line into a buffer ready for processing
  560.  */
  561. batch->batcmd = (BYTE *)heap(); /* Initialize Parameter Buffer */
  562. strcpy(heap(), argv0); /* Copy the invoking command */
  563. heap_get(strlen(heap())+1); /* and protect the buffer */
  565. while(*tail) { /* While there are command line */
  566.     s2 = (BYTE *)heap(); /* parameters copy them  */
  567.     while(*tail && strchr(batch_sep, *tail))
  568. tail = skip_char(tail);
  570.     while(*tail && !strchr(batch_sep, *tail))
  571. copy_char(&s2, &tail);
  573.     *s2++ = '';
  574.     heap_get(strlen(heap()) + 1);
  575. }
  577. *(WORD *)heap_get(2) = 0; /* Double NULL is a terminator  */
  578. /* for command line params  */
  580. if(in_flag & REDIR_ACTIVE) /* If Input redirection has been */
  581.     in_flag |= REDIR_BATCH; /* enabled for this command force*/
  582. /* it on for the complete command*/
  584. if(out_flag & REDIR_ACTIVE) /* If Output redirection has been*/
  585.     out_flag |= REDIR_BATCH; /* enabled for this command force*/
  586. /* it on for the complete command*/
  589. batchflg++; /* increment batch flag */
  591. crlfflg  = YES; /* print CR/LF after this  */
  592. }
  594. GLOBAL VOID batch_endall() /* This terminates BATCH */
  595. { /* processing by closing ALL */
  596. while(batchflg) { /* active batch files */
  597.     batch_end();
  598. }
  599. }
  601. GLOBAL VOID batch_end() /* This function is called for */
  602. { /* both NORMAL and ABNORMAL */
  603. if(batchflg == 0) /* termination of batch file */
  604.     return; /* processing */
  606. boot_key_scan_code = 0;
  608. batch_close(); /* Close the Batch file  */
  609. for_end(); /* Terminate Any FOR command */
  610. batch_old(); /* Restore the previous batch  */
  611. /*  control structures to heap */
  612. if(--batchflg == 0) {
  613.     *batch_seg_ptr = 0;
  614.     echoflg = echoflg_save2; /* Restore the original ECHO */
  615.     crlfflg = YES; /* flag and set CR/LF flag when */
  616. } /* returning to the keyboard. */
  617. }
  620. MLOCAL BOOLEAN batch_open()
  621. {
  622. WORD h, i;
  623. BYTE *name;
  625. if(batch->eof) { /* If the End of the batch file */
  626.     batch_end(); /* was discovered last time then*/
  627.     return FALSE; /* End Batch file input and exit*/
  628. }
  630. if(batch->stream != CLOSED)
  631.     return batch->stream;
  633. name = heap();
  635. for (i=0; i<MAX_PATHLEN; i++)
  636.     name[i] = batch->batfile[i];
  637. while ((h = ms_x_open(name, OPEN_READ)) < 0) {
  638.     err_flag = TRUE;
  639.     eprintf(MSG_BATMISS, name); /* prompt for batch file    */
  640.     heap_get(strlen(name)+1);
  641.     cmd_pause("");
  642.     heap_set(name);
  643. }
  644. err_flag = FALSE;
  645. batch->stream = h;
  646. return TRUE;
  647. }
  649. GLOBAL VOID batch_close()
  650. {
  651. if(batchflg != 0 && 
  652.        batch->stream != CLOSED) { /* Check if the batch file  */
  653.     batch_cnt = 0; /* currently open if YES    */
  654.     ms_x_close(batch->stream); /* then flush the internal  */
  655.     batch->stream = CLOSED; /* buffer and close file.   */
  656. }
  657. }
  659. #if defined(DOSPLUS)
  661. GLOBAL VOID inherit_batch_file(bc)
  662. BCONTROL FAR *bc;
  663. {
  664. WORD i;
  665. BYTE FAR *p_heap;
  666. BYTE *l_heap;
  668. /* inherit any parent batch file first */
  669. if (bc->bcontrol) inherit_batch_file(bc->bcontrol);
  671. /* create a new batch structure */
  672. batch_new();
  674. batch->offset = bc->offset; /* continue at same offset */
  675. for (i=0;i<4;i++) batch->ret_offset[i] = bc->ret_offset[i];
  676. batch->batshift = bc->batshift;
  678. for (i=0; i<MAX_PATHLEN; i++) /* get the batch pathname */
  679.     batch->batfile[i] = bc->batfile[i];
  680. batch->batfile[MAX_PATHLEN-1] = 0;
  682. /* get command line */
  684. p_heap = MK_FP(*parent_psp+16,bc->batcmd);
  685. l_heap = heap();
  687. while (1) {
  688.      while(*p_heap) *l_heap++ = *p_heap++;
  689.      *l_heap++ = *p_heap++;
  690.      if (*p_heap == 0) {
  691.          *l_heap = 0;
  692.  break;
  693.      }
  694. }
  695. heap_get(l_heap-heap());
  697. batchflg++;
  698. }
  701. GLOBAL VOID inherit_parent_state()
  702. {
  703. UWORD FAR *p;
  704. BCONTROL FAR *bc;
  705. UWORD root_psp;
  707. root_psp = *parent_psp;
  708. while(1) {
  709.     p = MK_FP(root_psp-1,8);
  710.     if (p[0] == 0x4F43 && p[1] == 0x4D4D &&
  711.         p[2] == 0x4E41 && p[3] == 0x0044) break;
  713.     p = MK_FP(root_psp,0x16);
  714.     root_psp = *p;
  715. }               
  718. p = MK_FP(root_psp+16,batch_seg_ptr);
  719. #if 0
  720. printf("batch_seg_ptr = %04X:%04Xn",p);
  721. printf("parent batch_seg_ptr = %04Xn",*p); 
  722. #endif
  723. if (*p == 0 || *p == 0xFFFF) return;
  725. bc = MK_FP(*p,0);
  727. inherit_batch_file(bc);
  729. *p = 0;
  731. p = MK_FP(root_psp+16,&echoflg);
  732. echoflg = *p;
  733. }
  734. #endif
  736. GLOBAL VOID batch_new()
  737. /* save current batch file heap contexts to high memory */
  738. {
  739. BYTE   *hp_start;
  740. WORD hp_size;
  741. UWORD i;
  742. BCONTROL FAR *bc;
  743. #if defined(CDOSTMP)
  744. UWORD FAR *ptr;
  745. #endif
  747. if (batchflg != 0)
  748.     hp_start = batch->heap_start;
  749. else
  750.     hp_start = heap();
  752. hp_size = heap() - hp_start;
  754. i = (sizeof(BCONTROL) + hp_size + 15)/16;
  755. mem_alloc(&bc, &i, i, i); /* allocate new batch structure */
  757. if (i == 0) { /* if we can't allocate one */
  758.     longjmp(break_env, IA_HEAP);/* then pretend heap has run out*/
  759. } /* to force termination.        */
  761. bc->bcontrol = batch; /* Link to Previous Structure */
  762. batch = bc; /* make this current batch struc*/
  763. batch->eof = NO; /* Have not found the EOF yet */
  764. batch->offset = 0L; /* start at beginning of File */
  765. for (i=0;i<4;i++) batch->ret_offset[i] = 0L;
  766. batch->batshift = 0; /* No Shift Factor */
  767. batch->stream = CLOSED; /* Batch file is not open */
  768. batch->fcontrol = forptr; /* Save current FOR control */
  769. batch->heap_start = hp_start; /* Save original heap */
  770. batch->heap_size = hp_size;
  772. for (i=0; i < hp_size; i++) {
  773.     batch->save_area[i] = hp_start[i];
  774. }
  776. heap_set(hp_start); /* free up heap used by old batch */
  778. #if defined(CDOSTMP)
  779. ptr = MK_FP(pd->P_PSP, TmpPspEchoFlgPtr);
  780. *ptr = (UWORD)&echoflg;
  781. ptr = (UWORD FAR *) &ptr; /* coerce a FAR * to local data */
  782. i = FP_SEG(ptr); /* so we can get local data segment */
  783. ptr = MK_FP(pd->P_PSP, TmpPspDataSeg);
  784. *ptr = i; /* save local data segment */
  785. ptr = MK_FP(pd->P_PSP, TmpPspBatchSeg);
  786. *ptr = (UWORD)(((ULONG)batch) >> 16);
  787. #else
  788. /* Get segment address of batch and put it where novell */
  789. /* can find it. */
  791. *batch_seg_ptr = (UWORD)(((ULONG)batch) >> 16);
  792. #endif
  793. }
  796. MLOCAL VOID batch_old()
  797. /* restore current batch file heap contents from high memory */
  798. {
  799. BCONTROL FAR *bc;
  800. UWORD i;
  801. #if defined(CDOSTMP)
  802. UWORD FAR *ptr;
  803. #endif
  805. heap_set(batch->heap_start+batch->heap_size);
  806. for (i=0; i<batch->heap_size; i++) {
  807.     batch->heap_start[i] = batch->save_area[i];
  808. }
  809. bc = batch;
  810. forptr = batch->fcontrol; /* Restore the previous for */
  811. for_flag = (BOOLEAN) forptr; /*  control structures  */
  812. batch = batch->bcontrol; /* restore ptr to previous batch */
  813. mem_free(&bc); /* free up batch memory */
  814. #if defined(CDOSTMP)
  815. ptr = MK_FP(pd->P_PSP, TmpPspBatchSeg);
  816. *ptr = (UWORD)(((ULONG)batch) >> 16);
  817. #endif
  818. }
  820. /*
  821.  * Read lines repeatedly from the batch file until a line in 
  822.  * the correct format is read from the batch file or the EOF
  823.  * has been reached.
  824.  */
  825. MLOCAL VOID batch_read(line, goto_flg)
  826. BYTE *line; /* Command Line Buffer */
  827. BOOLEAN goto_flg; /* Goto Command Flag */
  828. {
  829. BYTE *l; /* we need to deblank line */
  830. do {
  831.     batch_line(line, goto_flg); /* Read the next line from  */
  832.     l = deblank(line); /* the batch file and return*/
  833.     if(*l != ';') {
  834. if(goto_flg && *l == ':') /* a line in the correct    */
  835.     return; /* format.     */
  837. if(!goto_flg && *l != ':')
  838.     return;
  839.     }
  840. } while(!batch->eof);
  841. }
  843. /*
  844.  * Read one line from the batch file and place the expanded data into
  845.  * the buffer LINE.
  846.  */
  847. MLOCAL VOID batch_line(line, goto_flg)
  848. BYTE *line; /* Command Line Buffer */
  849. BOOLEAN goto_flg; /* Goto Command Flag */
  850. {
  851. REG WORD i;
  852. REG BYTE *s;
  853. WORD n, env_start;
  854. BYTE c, *bp;
  855. BYTE env_str[128];
  856. BOOLEAN quote = FALSE;
  857. LONG old_offset;
  858. int j;
  860. env_start = NULL; /* Copy the environment into a  */
  862. #if 0
  863. /* 'eject any line starting with 'rem' */
  864. old_offset = batch->offset;
  865. i=0;
  866. do{
  867.  switch(c=*batch_ptr()){
  868.  case  0x1a: 
  869.             batch->eof = YES; /* We have come to the end  */
  870.                 c = 'r'; /* of the batch file so set */
  871.                  break; /* flag and mark end of line*/
  872.    default:
  873.      if (i < MAX_LINE)
  874. line[i++] = c;
  875.      if (dbcs_lead(c)) {
  876.  if ((c = *batch_ptr()) >= ' ' && i < MAX_LINE)
  877.      line[i++] = c;
  878. }
  879.  }/*switch*/
  880. }while(c!='r');
  882. if (*batch_ptr() != 'n')  batch->offset--;
  883.   line[i]=0;
  884. j=0;
  885. while(line[j]){
  886. if (line[j] != ' ')
  887. break;
  888. j++;
  889. }
  890. if (( strlwr(line[j])   == 'r') &&
  891.          ( strlwr(line[j+1]) == 'e') &&
  892.          ( strlwr(line[j+2]) == 'm') &&
  893.          ( strlwr(line[j+3]) == ' ')){
  894. if (echoflg)
  895. printf("%sn",line);
  896. line[0]='';  
  897. return;
  898. }
  900. batch->offset = old_offset;
  901. batch->eof    = NO;
  903. #endif
  904. /*rbf-end*/
  906. /* process line */
  907. i = 0;
  908. do {
  909.       switch(c = *batch_ptr()) {
  910. case '': /* In OS/2 install.bat file  */
  911. #if 0
  912.     if (i < MAX_LINE) /* "ECHO " displays blank  */
  913. line[i++] = 'r'; /* line - so we insert a CR  */
  914.     while (c != 'r') { /* then swallow rest of line */
  915. c = *batch_ptr(); /* read next character - if  */
  916. if (c == 0x1a) /* it's an EOF mark then use */
  917.     goto end_of_file; /* end-of-file code else end */
  918.     } /* up falling into 'r' code */
  919. #else
  920.     c = *batch_ptr();
  921.     if ((c == 'r') && (i < MAX_LINE))
  922. line[i++] = 'r';
  923. #endif
  925. case 'r': /* carriage return */
  926.     if(*batch_ptr() != 'n') /*  skip line feed */
  927. batch->offset--; /* if present    */
  928.     break;
  930. case '"': /* Support Quoted strings   */
  931.     quote = !quote; /* in batch files.     */
  932.     goto save_it;
  934. case PIPE_CHAR:  /* Handle Piped Output     */
  935.     if(goto_flg || quote) /* Ignore this character if */
  936. goto save_it; /* we are searching for a   */
  937. /* Label or Quote.     */
  938.     line[i] = '';
  939.     c = *deblank(line); /* normal case we just      */
  940.     if ((c !='') && (c != ':') && following_command()) {
  941. c = 'r'; /* simulate a CR and set    */
  942. pipe_out = YES; /* Pipe Output flag.     */
  943.     } else if (c == ':') { /* if it's a label */
  944.      for(;(c != 'r') && (c != 0x1A); c = *batch_ptr())
  945.     if (c == 0x1A) /* eat rest of the line     */
  946. batch->eof = YES;
  947. if(*batch_ptr() != 'n')/*  skip line feed */
  948.     batch->offset--; /* if present    */
  949. c = 'r';
  950.     } else { /* if it's a syntax error    */
  951. swallow_line(line); /* discard the rest of line  */
  952. i = 0; /* start again with new line */
  953.     }
  954.     break;
  956. case '%': /* The following code checks to see if the   */
  957. /* string starting at line[env_start-1] is   */
  958. /* define in the environment if it is then   */
  959. /* its definition replaces it in the input   */
  960. /* line. Otherwise no change is made.      */
  961.     if(env_start) {
  962. env_start--;
  963. line[i] = '';  /* Terminate Input   */
  964. strcpy(env_str, line+env_start);/* Copy the String   */
  965. strupr(env_str); /* and force string  */
  966. bp = (BYTE *)heap(); /* into Uppercase    */
  967. i = env_start;
  968. env_start = NULL;
  970. strcat(env_str,"=");
  971. if (env_scan(env_str,bp)) {
  972.     if (novell_extension(env_str,bp)) break;
  973. }
  975. while(*bp && i < MAX_LINE-1)
  976.     line[i++] = *bp++;
  977. break;
  978.     }
  979.     
  980.     c = *batch_ptr();
  981.     if (c == 'r') {
  982. batch->offset--; /* rewind to point to 'r'   */
  983.      break; /* then break to normal code */
  984.     }
  985.     if (c < '0' || c > '9') { /* if not a parameter      */
  986. if(c != '%') /* or a '%' character      */
  987.     env_start = i+1; /* save its start address in */
  988. goto save_it; /* the string and wait for   */
  989.     } /* the terminating '%'      */
  990.     
  991.     n = c - '0' + batch->batshift;     /* get parameter # 0-9 and   */
  992. /* add in SHIFT offset      */
  993.     s = batch->batcmd;
  994.     while(n-- && strlen(s)) /* skip all other parameters */
  995. s += strlen(s)+1; /*   before the one we want  */
  997.     if((strlen(s) + i) >= MAX_LINE) /* Break if Greater than MAX_LINE*/
  998. break;
  999.     strcpy (line + i, s); /* get the substitution */
  1000.     i += strlen (s); /* add in its size */
  1001.     break;
  1003. case 0x1a:
  1004.     end_of_file:
  1005.     batch->eof = YES; /* We have come to the end  */
  1006.     c = 'r'; /* of the batch file so set */
  1007.     break; /* flag and mark end of line*/
  1009.  default:
  1010.     save_it:
  1011.     if (i < MAX_LINE)
  1012. line[i++] = c;
  1013.     if (dbcs_lead(c)) {
  1014. if ((c = *batch_ptr()) >= ' ' && i < MAX_LINE)
  1015.     line[i++] = c;
  1016.     }
  1017. }
  1018. } while (c != 'r'); /* repeat until CR    */
  1020. line[i] = '';  /* Terminate the line and  */
  1022. if(batch->eof)
  1023.     return;
  1025. #if 0 /* not DOS compatible */
  1026. if(*batch_ptr() == 0x1A) /* Check if the next this  */
  1027.     batch->eof = YES; /* the end of the file if  */
  1028. else /* YES then set the flag   */
  1029.     batch->offset--; /* force the character to  */
  1030. #endif /* be re-read next time    */
  1031. return;  /* return to the caller    */
  1032. }
  1034. MLOCAL BOOLEAN following_command()
  1035. /* return true if we have a possible command on the rest of the line */
  1036. {
  1037. LONG old_offset;
  1038. BOOLEAN res = FALSE;
  1039. BYTE *s;
  1041. old_offset = batch->offset; /* save batch offset */
  1042. while (TRUE) {
  1043.     s = batch_ptr(); /* look ahead at batch file */
  1044.     if (*s == 'r' || *s == 0x1a || (!dbcs_lead(*s) && *s == PIPE_CHAR))
  1045. break;
  1046.     if (!is_blank(s)) {
  1047.         res = TRUE; /* possible command if we   */
  1048. break; /* hit non whitespace char  */
  1049.     }
  1050.     if (dbcs_lead(*s)) {
  1051. s = batch_ptr();
  1052. if (*s == 'r' || *s == 0x1a)
  1053.     break;
  1054.     }
  1055. }
  1056. batch->offset = old_offset; /* restore batch offset */
  1057. return res;
  1058. }
  1060. MLOCAL VOID swallow_line(s)
  1061. BYTE *s;
  1062. /* there is a syntax error on this line - swallow it and say so */
  1063. {
  1064. BYTE c;
  1066. prompt(); /* possibly echo the prompt */
  1067. if (echoflg) /* echo to screen if wanted */
  1068.     printf("%s%c",s,PIPE_CHAR);
  1070. do {
  1071.     c = *batch_ptr();
  1072.     if (c ==  0x1a) {
  1073. c = 'r'; /* pretend to be end of line*/
  1074. batch->eof = YES; /* We have come to the end  */
  1075. break; /* flag and mark end of line*/
  1076.     }
  1077.     if (echoflg) /* echo to screen if wanted */
  1078. putc(c);
  1079. } while (c != 'r');
  1080. if (echoflg)
  1081.     putc('n');
  1083. if (*batch_ptr() != 'n') /*  skip line feed */
  1084.    batch->offset--; /* if present    */
  1086. eprintf(MSG_SYNTAX); /* report syntax error */
  1087. }
  1089. /*
  1090.  * In order to improve performance of the batch file processing
  1091.  * the Batch file is read in blocks of BATCH_BUF characters.
  1092.  * and the routine BATCH_CHAR then returns a pointer to a character
  1093.  * from the buffer (filling the buffer if required).
  1094.  */
  1095. MLOCAL BYTE *batch_ptr()
  1096. {
  1097. BYTE FAR *buf;
  1098. UWORD bufsize;
  1099. UWORD i;
  1101. if(batch->eof)
  1102.     return(batch_eof);
  1103.     
  1104. if (batch->offset < batch_off ||
  1105. batch->offset >= (batch_off + (LONG) (batch_cnt - 1))) {
  1107.     batch_off = batch->offset;
  1108.     ms_x_lseek (batch->stream, batch->offset, 0);
  1109.     batch_cnt = far_read(batch->stream, gp_far_buff, sizeof(batch_buf));
  1110.     if(batch_cnt <= 0) {
  1111. batch->eof = YES;
  1112. return(batch_eof);
  1113.     }
  1114.     for (i=0; i<sizeof(batch_buf); i++) batch_buf[i] = gp_far_buff[i];
  1115. }
  1116. return(&batch_buf[(UWORD) (batch->offset++ - batch_off)]);
  1117. }
  1120. /*.pa*/
  1121. /*
  1122.  * BATCH FILE COMMANDS
  1123.  * ===================
  1124.  *
  1125.  * The following commands are used almost entirely in BATCH files and
  1126.  * have little or no meaning outside that environment.
  1127.  */
  1128. GLOBAL VOID CDECL cmd_shift ()
  1129. {
  1130. batch->batshift++; /* Increment the Shift Offset */
  1131. }
  1134. MLOCAL WORD label_ignore_char(s)
  1135. BYTE *s;
  1136. {
  1137. if (*s == '=') return(1);
  1138. if (*s == ';') return(1);
  1139. if (*s == ',') return(1);
  1140. if (*s == ' ') return(1);
  1141. return(0);
  1142. }
  1144. /*
  1145.  * Extract the first a valid characters from the label and then
  1146.  * zero terminate the resulting string.
  1147.  */
  1148. MLOCAL BYTE * make_label(label)
  1149. BYTE *label;  
  1150. {
  1151. REG BYTE *bp;
  1152. UWORD i;
  1154. label = deblank(label); /* remove leading white space */
  1155. while (label_ignore_char(label))
  1156.     label = skip_char(label);
  1158. bp = label;
  1160. while (is_filechar(bp)) /* skip over valid chars      */
  1161.     bp = skip_char(bp);
  1163. *bp = ''; /* make label zero terminated */
  1164. return label;
  1165. }
  1167. GLOBAL VOID CDECL cmd_goto (label)   /* goto label in batch file */
  1168. REG BYTE    *label;
  1169. {
  1170. UWORD i;
  1171. BYTE *bp, s[MAX_LINE+2];  /* Allocate buffer for Batch Input  */
  1173. if (!batchflg) /* if not in batch mode      */
  1174.     return; /* this command is ignored     */
  1176. if(*label == ':') /* Ignore any leading ':'     */
  1177.     label++;
  1179. label = make_label(label); /* Convert to Label Format     */
  1181. batch->offset = 0L; /* rewind the batch file     */
  1182. batch->eof = NO; /* So it cannot be EOF     */
  1184. if(!batch_open()) /* Check the Batch file is open     */
  1185.     return; /* and stop if the function fails.  */
  1187. while(!batch->eof) { /* while not end of file read next  */
  1188.     batch_read(s, YES);  /* line and return the next command  */
  1189.     bp = deblank(s);
  1190.     if((*bp == ':') && !strnicmp(make_label(bp+1),label, 8))
  1191. return;
  1192. }
  1194. batch_end(); /* Stop any further batch file    */
  1195. crlfflg = YES; /* processing and print the error  */
  1196. eprintf(MSG_LABEL, label);
  1197. }
  1200. GLOBAL VOID CDECL cmd_gosub (label)   /* gosub label in batch file */
  1201. REG BYTE    *label;
  1202. {
  1203. UWORD i;
  1204. BYTE *bp, s[MAX_LINE+2];  /* Allocate buffer for Batch Input  */
  1206. if (!batchflg) /* if not in batch mode      */
  1207.     return; /* this command is ignored     */
  1209. if (batch->ret_offset[3] != 0L) {
  1210. batch_end();
  1211. crlfflg = YES;
  1212. eprintf(MSG_GOSUB);
  1213. return;
  1214. }
  1216. if(*label == ':') /* Ignore any leading ':'     */
  1217.     label++;
  1219. label = make_label(label); /* Convert to Label Format     */
  1221. i = 0;
  1222. while (batch->ret_offset[i] != 0L) i++;
  1223. batch->ret_offset[i] = batch->offset;
  1225. batch->offset = 0L; /* rewind the batch file     */
  1226. batch->eof = NO; /* So it cannot be EOF     */
  1228. if(!batch_open()) /* Check the Batch file is open     */
  1229.     return; /* and stop if the function fails.  */
  1231. while(!batch->eof) { /* while not end of file read next  */
  1232.     batch_read(s, YES);  /* line and return the next command  */
  1233.     bp = deblank(s);
  1234.     if((*bp == ':') && !strnicmp(make_label(bp+1),label, 8))
  1235. return;
  1236. }
  1238. batch_end(); /* Stop any further batch file    */
  1239. crlfflg = YES; /* processing and print the error  */
  1240. eprintf(MSG_LABEL, label);
  1241. }
  1243. GLOBAL VOID CDECL cmd_return()
  1244. {
  1245. UWORD i;
  1247. if (!batchflg) return;
  1248. if (batch->ret_offset[0] == 0L) {
  1249. batch_end();
  1250. crlfflg = YES;
  1251. eprintf(MSG_RETURN);
  1252. return;
  1253. }
  1254. i = 0;
  1255. while ((batch->ret_offset[i] != 0L)&&(i<4)) i++;
  1256. batch->offset = batch->ret_offset[i-1];
  1257. batch->ret_offset[i-1] = 0L;
  1258. }
  1260. #if SWITCH_ENABLED
  1261. GLOBAL VOID CDECL cmd_switch(list)
  1262. REG BYTE *list;
  1263. {
  1264. BYTE *list_start;
  1265. BYTE *label;
  1266. WORD i,j;
  1267. BYTE c;
  1269. if (!batchflg) return;
  1270. list_start = list;
  1272. switch_retry:
  1273. list = list_start;
  1274. i = psp_poke(STDIN,1);
  1276. #if defined(CDOSTMP)
  1277. c =(BYTE) bdos(C_RAWIO, 0xFD); /* Get a character from console */
  1279. if ((c==0) ||(dbcs_lead(c)))
  1280.     bdos(C_RAWIO, 0xFD); /* skip second byte in DBCS pair */
  1281. #else
  1282. c = (BYTE) msdos(MS_C_RAWIN, 0);/* Get a character from console */
  1283. if ((c==0) || (dbcs_lead(c)))
  1284.     msdos(MS_C_RAWIN, 0); /* skip second byte in DBCS pair */
  1285. #endif
  1286. psp_poke(STDIN,i);
  1288. if (c==0x03) int_break(); /* check for CTRL-C */
  1289. if (c==0x0d) c = '1'; /* return gives default of 1 */
  1291. i = (WORD) (c - '1');
  1292. if (i<0 || i>8) goto switch_retry; /* ignore invalid keys */
  1294. j = 0;
  1295. while (j<i) {
  1296. while (*list != ',' && *list != 0) list++;
  1297. if (*list == 0) goto switch_retry;
  1298. j++;
  1299. list++;
  1300. list = deblank(list);
  1301. }
  1302. label = list;
  1303. while (*list != ',' && *list != 0) list++;
  1304. *list = 0;
  1305. cmd_gosub(label);
  1306. }
  1307. #endif
  1310. /*.pa*/
  1311. /*
  1312.  * The IF command supports the following syntax:-
  1313.  *
  1314.  * IF [NOT] string1 == string2 COMMAND
  1315.  * IF [NOT] ERRORLEVEL n COMMAND
  1316.  * IF [NOT] EXIST filename COMMAND
  1317. /*RG-02-
  1318.  * IF [NOT] USERID n COMMAND
  1319.  * IF [NOT] LOGINNAME string COMMAND
  1320.  * IF [NOT] GROUPNAME string COMMAND
  1321.  * IF [NOT] KEY ["string"] char COMMAND
  1322.  *
  1323.  */
  1324. #if defined(CDOSTMP) || defined(CDOS)
  1325. MLOCAL BYTE *if_opt[] = {"exist", "direxist", "errorlevel", "key", "userid", "loginname", "groupname", NULL };
  1326. #else
  1327. MLOCAL BYTE *if_opt[] = {"exist", "direxist", "errorlevel", NULL };
  1328. #endif
  1329. /*RG-02-end*/
  1331. MLOCAL UWORD if_index(cmd)
  1332. BYTE **cmd;
  1333. {
  1334. UWORD i, j;
  1336. for(i = 0; if_opt[i]; i++) { /* Scan Through the option   */
  1337.     j = strlen(if_opt[i]); /* list and return the index */
  1338. /* of the matching option    */
  1339.     if(strnicmp(*cmd, if_opt[i], j)) /* and update the string     */
  1340.         continue; /* pointer.      */
  1341.     *cmd = deblank(*cmd+j);
  1343.     while(*(*cmd) == '=') /* Remove any "=" string     */
  1344.         (*cmd)++; /* present in the command    */
  1345.     *cmd = deblank(*cmd); /* Used by many install files*/
  1346.     break;
  1347. }
  1349. return i;
  1350. }
  1352. #define OP_EQ 0
  1353. #define OP_NE 1
  1354. #define OP_LE 2
  1355. #define OP_LT 3
  1356. #define OP_GE 4
  1357. #define OP_GT 5
  1359. MLOCAL WORD get_operator(op)
  1360. BYTE *op;
  1361. {
  1362. if (op[0] == '=') return(OP_EQ);
  1363. if (op[0] == '!' && op[1] == '=') return(OP_NE);
  1364. if (op[0] == '<') {
  1365.     if (op[1] == '>') return(OP_NE);
  1366.     if (op[1] == '=') return(OP_LE);
  1367.     return(OP_LT);
  1368. }
  1369. if (op[0] == '>') {
  1370.     if (op[1] == '=') return(OP_GE);
  1371.     return(OP_GT);
  1372. }
  1373. return(-1);
  1374. }
  1376. MLOCAL LONG get_decimal(s)
  1377. BYTE *s;
  1378. {
  1379. LONG total = 0;
  1381. if (*s == '#') s++;
  1383. while (*s>='0' && *s<='9') {
  1384.     total *= 10;
  1385.     total += (LONG) (*s-'0');
  1386.     s++;
  1387. }
  1389. return(total);
  1390. }
  1392. MLOCAL BOOLEAN CDECL test_cond(cptr)
  1393. BYTE **cptr;
  1394. {
  1395. BYTE *cmd,*str1, *str2, *ptr;
  1396. DTA search;
  1397. BOOLEAN not, cond, neg,is_user;
  1398. BYTE level;
  1399.         BYTE    c[]=" n";
  1400.         WORD attr;
  1401. UWORD   userid;
  1402. LONG val1,val2;
  1404.         cmd=*cptr;
  1405.         not = cond = NO; /* Initialise the Flags     */
  1407. if(!strnicmp(cmd = deblank(cmd), "not", 3)) {
  1408.     not = YES;
  1409.     cmd = deblank(cmd+3);
  1410. }
  1412. switch(if_index(&cmd)) {
  1414.     /*
  1415.      * EXIST Option extract the possibly ambiguous filename
  1416.      * and check if it exists.
  1417.      */
  1418.     case 0:
  1419. cmd = deblank(get_filename(heap(), cmd, YES));
  1420. cond = !ms_x_first(heap(), ATTR_STD|ATTR_HID, &search);
  1421. break;
  1423.     /*
  1424.      * DIREXIST Option checks if the given directory exists
  1425.      */
  1426.     case 1:
  1427. cmd = deblank(get_filename(heap(), cmd, YES));
  1428. attr = ms_x_chmod(heap(), ATTR_ALL, 0);
  1429. if (attr < 0) cond = FALSE;
  1430. else cond = (attr & 0x10);
  1431. break;
  1433.     /*
  1434.      * ERRORLEVEL Option extract the decimal number from the
  1435.      * command line.
  1436.      */
  1437.     case 2:
  1438. level = 0;
  1439. neg = FALSE;
  1441. if(*cmd =='-') {
  1442.     neg = TRUE;
  1443.     cmd++;
  1444. }
  1446. if(!isdigit(*cmd)) { /* SYNTAX error if the     */ 
  1447.     syntax(); /* first character is not a */
  1448.     return FALSE; /* digit.     */
  1449. }
  1451. while(isdigit(*cmd))
  1452.     level = level * 10 + (*cmd++ - '0');
  1454. level = level & 0x00FF;
  1456. if (neg) level = -level;
  1458.         cond = (level<=(err_ret & 0x00FF)); 
  1459. break;
  1462. /*RG-02*/
  1463. #if !defined(NOXBATCH)
  1464. #if (defined(CDOSTMP) || defined(CDOS))
  1465.     /*
  1466.      * KEY ["string"] [==] [""] Search for the string "string" and
  1467.              *  display it if it exists, then read a key and echo it.
  1468.              *  However, if the string to match is null "" then do a keyboard
  1469.              *  status check and return TRUE if there is no key there
  1470.      */
  1471.     case 3:
  1472.     cmd = deblank(cmd);
  1473.                 ptr=cmd;
  1474.                 if (display_string(&ptr)!=0)
  1475.                     return FALSE;
  1477.              cmd = deblank(ptr); 
  1478.         while(*cmd == '=') /* Remove any "=" string     */
  1479.             cmd++;
  1481.         cmd = deblank(cmd);
  1482.                 if ((*cmd==0)||(*(cmd+1)!=' ')) { /* check for condition */
  1483.               syntax();
  1484.                     return FALSE;
  1485.                 }
  1487.                 /* read a character from the keyboard */
  1488.              c[0]=bdos(C_RAWIO, 0xFD); /* Get a character from console */
  1490.                 /* echo the char typed */
  1491.         if (echoflg)  /* echo to screen if wanted */
  1492.     putc(c[0]);
  1493.         crlf(); /* print cr/lf */
  1494.                 
  1495.                 /* check if it matches */
  1496.                 if((tolower(c[0])==*cmd)||(toupper(c[0])==*cmd))
  1497.                     cond=TRUE;
  1498.                 else 
  1499.                     cond=FALSE;
  1501.                 /* skip the condition */
  1502.         while (*cmd!=' ')
  1503.                     cmd++; /* skip the char */
  1504.         
  1505.     break;
  1507. #endif
  1508. #if !defined (NOSECURITY) && (defined(CDOSTMP) || defined(CDOS))
  1509.     /*
  1510.      * USERID Option extract the 4 digit hex user id
  1511.      * and check if it is us.
  1512.      */
  1513.     case 4:
  1514.                 if (!login_enabled())
  1515.                     return FALSE;
  1516.     cmd = deblank(cmd);
  1517.         if(aschextobin(cmd)==get_user_on_station())
  1518.                     cond=TRUE;
  1519.                 else
  1520.                     cond=FALSE;
  1521.                 
  1522.                 do {   /* skip past the user id */
  1523.                     if ((*cmd>='0' && *cmd<='9')
  1524.                         ||(tolower(*cmd)>='a' && tolower(*cmd)<='f'))
  1525.                         cmd++; /* skip the hex digit */
  1526.                     else {
  1527.                     syntax();
  1528.             return FALSE;
  1529.                     }
  1530.         } while (*cmd!=' ');
  1531. break;
  1533.             /*
  1534.      * LOGINNAME Option extract the loginname and check if it is us.
  1535.      */
  1536.     case 5:
  1537.                 if (!login_enabled())
  1538.                     return FALSE;
  1539.                 is_user=TRUE;
  1541.             /*
  1542.      * GROUPNAME Option extract the loginname and check if it is us.
  1543.      */
  1544.     case 6:
  1545.                 if (!login_enabled())
  1546.                     return FALSE;
  1547.     cmd = deblank(cmd);
  1548.                 if(aschextobin(user_info.userid)!=get_user_on_station()) {
  1549.             if(get_user_info(get_user_on_station())!=0) {
  1550.                         syntax();
  1551.                         is_user=cond=FALSE;
  1552. return FALSE;
  1553.                     }
  1554.                 }
  1555.                 if((is_user==TRUE)&&(strncmp(strlwr(cmd),strlwr(user_info.loginname),strlen(user_info.loginname))==0)) {
  1556.                     cond=TRUE;
  1557.                     cmd+=strlen(user_info.loginname);
  1558.                 }
  1559.                 else if((is_user!=TRUE)&&(strncmp(strlwr(cmd),strlwr(user_info.groupname),strlen(user_info.groupname))==0)) {
  1560.                     cond=TRUE;
  1561.                     cmd+=strlen(user_info.groupname);
  1562.                 }
  1563.                 else {
  1564.                     cond=FALSE;
  1565.             while (*cmd!=' ')
  1566.                         cmd++; /* skip the name */
  1567.                 }
  1568.                 if (*cmd!=' ') {
  1569.                     is_user=cond=FALSE;
  1570.                 }
  1571.                 is_user=FALSE;
  1572. break;
  1574. #endif
  1575. #endif /*NOXBATCH*/
  1576. /*RG-02-end*/            
  1577.             /*
  1578.      * String comparison option.
  1579.      */
  1580.     default:
  1581. str1 = cmd; /* Extract String 1     */
  1583. while ((!is_blank(cmd)) && (*cmd != '=') &&
  1584.        ((*cmd != '!') || (cmd[1]!= '=')) &&
  1585.        (*cmd != '<') && (*cmd != '>')) {
  1587.     cmd = skip_char(cmd);
  1588. }
  1590. str2 = cmd;
  1591. cmd = deblank(cmd);
  1593. attr = get_operator(cmd++);
  1595. if (attr == -1) {
  1596.     syntax();
  1597.     return(FALSE);
  1598. }
  1600. *str2 = 0;
  1602. if (*cmd == '=' || *cmd == '>') cmd++;
  1604. cmd = deblank(cmd);
  1605. str2 = cmd;
  1606. while (!is_blank(cmd)) cmd = skip_char(cmd);
  1607. *cmd++ = 0;
  1609. if (*str1 == '#') {
  1610.     val1 = get_decimal(str1);
  1611.     val2 = get_decimal(str2);    
  1612.     switch(attr) {
  1613.       case OP_EQ: cond = (val1==val2); break;
  1614.       case OP_NE: cond = (val1!=val2); break;
  1615.       case OP_LT: cond = (val1<val2); break;
  1616.       case OP_LE: cond = (val1<=val2); break;
  1617.       case OP_GT: cond = (val1>val2); break;
  1618.       case OP_GE: cond = (val1>=val2); break;
  1619.     }
  1620. }
  1621. else switch(attr) {
  1622. case OP_EQ:
  1623.     cond = (strcmp(str1,str2) == 0);
  1624.     break;
  1625. case OP_NE:
  1626.     cond = (strcmp(str1,str2) != 0);
  1627.     break;
  1628. case OP_LT:
  1629.     cond = (strcmp(str1,str2) < 0);
  1630.     break;
  1631. case OP_LE:
  1632.     cond = (strcmp(str1,str2) <= 0);
  1633.     break;
  1634. case OP_GT:
  1635.     cond = (strcmp(str1,str2) > 0);
  1636.     break;
  1637. case OP_GE:
  1638.     cond = (strcmp(str1,str2) >= 0);
  1639.     break;
  1640. }
  1641. break;
  1642. }
  1644. if(not)  /* if negated condition     */
  1645.     cond = !cond;
  1647.         *cptr=cmd;
  1648.         return cond; /* write result back */
  1649. }
  1651. #if !defined(NOXBATCH)
  1652. BOOLEAN is_it_or(BYTE *cmd)
  1653. {
  1654. cmd--;
  1655. if ((*cmd != 0) && (*cmd != 't') && (*cmd != ' '))
  1656.     return FALSE;
  1657.         cmd++;
  1658. if (strnicmp(cmd, "or", 2) != 0)
  1659.     return FALSE;
  1660. cmd+=2;    
  1661. if ((*cmd != 't') && (*cmd != ' '))
  1662.     return FALSE;
  1663. return TRUE;
  1664. }
  1665. #endif
  1666. GLOBAL VOID CDECL cmd_if(cmd)
  1667. BYTE *cmd;
  1668. {
  1669.         BOOLEAN cond;
  1670.         
  1671. ifcond=cond=test_cond(&cmd);
  1673. if(!*deblank(cmd)) { /* and return a SYNTAX error*/
  1674.     syntax(); /* if it is empty.     */
  1675.     return;
  1676. }
  1677.         if(!cond) {
  1678. #if !defined(NOXBATCH)
  1679.     while (!is_it_or(cmd) &&
  1680.        (*cmd != 0)) {
  1681.         if (strnicmp(cmd,"ECHO",4)==0) return;       
  1682.         cmd++;
  1683.     }
  1684.             if (*cmd==0) return; /* no OR's so quit now */
  1685.     
  1686.     if_context = TRUE;
  1687.     
  1688.     docmd(deblank(cmd), YES); /* New command starts at "or" */
  1689.             
  1690. #endif
  1691.         }
  1692. else {
  1693.     cmd = deblank(cmd);
  1695.     if (strnicmp(cmd,"AND",3)) {
  1696. if (parse(cmd)) return;   /* IF won't have been 'parsed' for */
  1697.   /* > or < redirectors so do it now */
  1698.     }
  1700.     if_context = TRUE;
  1701.        /* Execute command if the    */
  1702.     docmd(cmd, YES);              /* condition flag is TRUE    */
  1703. }
  1704.         if_context=FALSE;
  1705. }
  1707. /*RG-03*/
  1708. #if !defined(NOXBATCH)
  1709. GLOBAL VOID CDECL cmd_or(cmd)
  1710. BYTE *cmd;
  1711. {
  1712.         BOOLEAN cond;
  1713.         BYTE    *org_cmd;
  1714.         
  1715.         cond=test_cond(&cmd);
  1716. if(!*deblank(cmd)) { /* and return a SYNTAX error*/
  1717.     syntax(); /* if it is empty.     */
  1718.     return;
  1719. }
  1720.         if(!cond) {
  1721.             org_cmd = cmd; /* now look for "OR" */
  1722.     while (!is_it_or(cmd) &&
  1723.    (*cmd != 0)) {
  1724. if (strnicmp(cmd,"ECHO",4)==0) while(*cmd) cmd++;
  1725. else cmd++;
  1726.     }
  1727.             if (*cmd==0) { /* oh dear, no ORs */
  1728.                 if (ifcond) /* but so far so good, so do command anyway */
  1729.            docmd(deblank(org_cmd), YES); 
  1730.                 return;
  1731.             }
  1732.     docmd(deblank(cmd), YES); /* New command starts at "or" */
  1733.             return;
  1734.         }
  1735. else {
  1736.             cmd = deblank(cmd);
  1737.     
  1738.     if (strnicmp(cmd,"AND",3)) {
  1739.         if (parse(cmd)) return;   /* IF won't have been 'parsed' for */
  1740.   /* > or < redirectors so do it now */
  1741.     }
  1742.     
  1743.     ifcond=cond;                 /* Execute command if the    */
  1744.     docmd(cmd, YES);      /* condition flag is TRUE    */
  1745.         }
  1746. }
  1747. #endif /*NOXBATCH*/
  1748. /*RG-03-end*/
  1751. GLOBAL VOID CDECL cmd_for(s)
  1752. BYTE *s;
  1753. {
  1754. FCONTROL *fc;
  1755. BYTE *bp1;
  1757. fc = (FCONTROL *) heap_get(sizeof(FCONTROL));
  1759. /* Allocate Control Struct  */
  1760. if(forptr) /* and prevent nesting of  */
  1761.     goto for_error; /* FOR Command.     */
  1763. s = deblank(s);  /* Remove leading blanks   */
  1764. if ((*s++ != '%') || /* Get the FOR variable    */
  1765.     (fc->forvar = *s++) < ' ') /* character and save    */
  1766.     goto for_error;
  1768. if(strnicmp(s = deblank(s), "in", 2)) /* Check for the correct   */
  1769.     goto for_error; /* command syntax.    */
  1771. s = deblank(s+2);
  1772. if (*s++ != '(')
  1773.     goto for_error;
  1775. fc->files = (BYTE *)heap(); /* Allocate FOR parameter  */
  1776. while(*s && *s != ')') { /* buffer and scan the    */
  1777.     bp1 = (BYTE *)heap(); /* command line generating */
  1778. /* zero terminated strings */
  1779.     while(strchr(batch_sep, *s)) /* Skip any separators    */
  1780. s = skip_char(s);
  1782.     while(   *s != ')' && /* then copy all valid    */
  1783.      !strchr(batch_sep, *s)) /* characters into buffer  */
  1784.        /* then zero terminate    */
  1785. copy_char(&bp1, &s);
  1787.     *bp1++ = '';
  1788.     heap_get(strlen(heap()) + 1); /* Preserve String     */
  1789. }
  1791. *(BYTE *)heap_get(1) = '';  /* Final String is zero     */
  1792. /* bytes in length     */
  1794. s = deblank(s);
  1795. if(*s++ != ')')
  1796.     goto for_error;
  1798. if(strnicmp(s = deblank(s), "do", 2))
  1799.     goto for_error;
  1801. if(in_flag & REDIR_ACTIVE) /* If Input redirection has been */
  1802.     in_flag |= REDIR_FOR; /* enabled for this command force*/
  1803. /* it on for the complete command*/
  1805. if(out_flag & REDIR_ACTIVE) /* If Output redirection has been*/
  1806.     out_flag |= REDIR_FOR; /* enabled for this command force*/
  1807. /* it on for the complete command*/
  1809. fc->cmd = (BYTE *)heap_get(strlen(s = deblank(s+2)) +1);
  1810. strcpy(fc->cmd, s);
  1812. fc->sflg = NO; /* File matching inactive  */
  1813. for_flag = YES;  /* Turn FOR processing ON  */
  1814. forptr = fc; /* Save control Structure  */
  1815. return;
  1817. for_error: /* When a Syntax error occurs */
  1818. heap_set((BYTE *) fc); /* restore the heap and print */
  1819. syntax(); /* an error message. */
  1820. return;
  1821. }
  1823. GLOBAL VOID for_end()
  1824. {
  1825. if(for_flag) {
  1826.     heap_set((BYTE *) forptr); /* Terminate FOR processing */
  1827.     forptr = (FCONTROL *) NULL; /* restore the HEAP and reset */
  1828.     for_flag = NO; /* control flags. */
  1829. }
  1830. }
  1832. /*.pa*/
  1833. /*
  1834.  * This command generates the displayed prompt based on the contents
  1835.  * of the string PROMPT= in the environment. Otherwise the default
  1836.  * prompt string DEFAULT_PROMPT is used.
  1837.  */
  1839. MLOCAL BOOLEAN prompt_flg = FALSE; /* Prompt Flag  */
  1841. MLOCAL VOID prompt() /* display command line prompt */
  1842. {
  1843. REG BYTE *cp;
  1844. BYTE  buf[MAX_PATHLEN];
  1845. BYTE  c;
  1846. #if !STACK
  1847. BYTE  cpbuf[MAX_ENVLEN];
  1848. #endif
  1849. /*rbf*/
  1850. #if 1
  1851. BYTE prmptcpbuf[MAX_ENVLEN];
  1852. REG BYTE *prmptcp = prmptcpbuf;
  1853. #endif
  1855. if(!echoflg) /* Return if No Echo */
  1856.     return;
  1860. #if defined(CPM)
  1861. cp = heap();
  1862. strcpy(cp, "[CPM] $u$p$g");
  1863. #else
  1864. if(env_scan(msg_prmeq, cp = (BYTE *)heap()))
  1865.     strcpy(cp, DEFAULT_PROMPT);
  1866. #endif
  1868. if(prompt_flg) /* If the previous Prompt display   */
  1869.     strcpy(cp, "$n$g"); /* terminated due to a Critical     */
  1870. /* then just display the default    */
  1871. prompt_flg = TRUE; /* drive.     */
  1873. #if STACK
  1874. cp = stack(strlen(cp) + 1);
  1875. #else
  1876. cp = &cpbuf[0];
  1877. #endif
  1878. strcpy(cp, heap());
  1880. while((c = *cp++) != 0) { /* get next character */
  1881.     if (c != '$') /* if not '$', print as is */
  1882. putc (c);
  1883.     else {
  1884. c = *cp++;
  1885. switch(tolower(c)) { /* else get next character */
  1886.  case '': /* Treat "$" as an invalid      */
  1887.      cp--; /* prompt command sequence     */
  1888.      break;
  1889.  case 't': /* print current time */
  1890.     disp_systime();
  1891.     break;
  1892.  case 'd': /* print current date */
  1893.     disp_sysdate();
  1894.     break;
  1895.  case 'p': /* print current path */
  1896.     if (ms_x_curdir(drive+1, buf) < 0)
  1897.         printf(MSG_DRV_INVALID);
  1898.     else
  1899.         printf("%c:%s%s", drive+'A', pathchar, buf);
  1900.     break;
  1901.  case 'v': /* print version number */
  1902.     cmd_ver("");
  1903.     break;
  1904.  case 'n': /* print default drive */
  1905.     putc((BYTE) drive+'A');
  1906.     break;
  1907.  case 'g': /* print ">" */
  1908.     putc ('>');
  1909.     break;
  1910.  case 'l': /* print "<" */
  1911.     putc ('<');
  1912.     break;
  1913.  case 'b': /* print "|" */
  1914.     putc ('|');
  1915.     break;
  1916.  case 'q': /* print "=" */
  1917.     putc ('=');
  1918.     break;
  1919.  case '_': /* print CR,LF */
  1920.     crlf();
  1921.     break;
  1922.  case 'h': /* print backspace, space, backspace */
  1923.     printf("b b");
  1924.     break;
  1925.  case 'e': /* print ESC character */
  1926.     putc ('33');
  1927.     break;
  1928. /*RG-01 */ 
  1930. #if !defined(NOXBATCH)
  1931. #if !defined (NOSECURITY) 
  1932. #if defined(CDOSTMP) || defined(CDOS)
  1933.  case 'm': /* print mail status */
  1934.                 if (login_enabled()) {
  1935.                     if(chk_mail()) { /* we have mail */
  1936.                 if(env_scan("MAIL=", heap())) 
  1937.                             printf(MSG_UHAVEMAIL);
  1938.                         else
  1939.                             printf("%s",heap());
  1940.                     }
  1941.                 }
  1942.     break;
  1944.  case 'u': /* Display the User Name */
  1945.                 if (login_enabled()) {
  1946.                     if((aschextobin(user_info.userid)!=get_user_on_station())||(strlen(user_info.userid)==0)) {
  1947.                 if(get_user_info(get_user_on_station())!=0) 
  1948.                 printf("#%04X",get_user_on_station());
  1949.                         else
  1950.                 printf("%s",user_info.loginname);
  1951.                     }
  1952.                     else
  1953.             printf("%s",user_info.loginname);
  1954.                 }
  1955.                 break;
  1956. #endif
  1957. #endif
  1958. #endif /*NOXBATCH*/
  1959. /*RG-01-end*/
  1960. #if defined(CPM)
  1961.  case 'u': /* Display the User Number */
  1962.     printf("%d", user);
  1963.     break;
  1964. #endif
  1965. #if defined(DOSPLUS)
  1966.  case 'u':
  1967.     if (!env_scan("LOGINNAME=",heap()))
  1968.         printf("%s",heap());
  1969.     break;
  1970. #endif     
  1971.  case '$':
  1972.     putc ('$');  /* print single '$' */
  1973.     break;
  1974.  case 'x':
  1975.     if ((allow_pexec)&&(!batchflg)) prompt_exec();
  1976.     break;
  1977.  default: /* Otherwise the character */
  1978.     break;
  1979. }
  1980.     }
  1981. }
  1983. prompt_flg = FALSE; /* Prompt display completed OK */
  1984. }
  1987. #if !defined(CDOSTMP)
  1988. /* The following functions are called by the int2e_handler function in
  1989.  * COM.C. If a program is run from a batch file and calls INT 2E to
  1990.  * execute a new batch file the original batch file must NOT be terminated.
  1991.  * Therefore batch and batchflg must be saved, set to zero, and then
  1992.  * restored when INT 2E returns. - EJH 
  1993.  */
  1994.  
  1995. GLOBAL VOID int2e_start()
  1996. {
  1997. batchflg_save = batchflg;
  1998. batchflg = 0;
  1999. batch_save = batch;
  2000. echoflg_save = echoflg;
  2001. echoflg = ECHO_ON;
  2002. }
  2004. GLOBAL VOID int2e_finish()
  2005. {
  2006. batchflg = batchflg_save;
  2007. batch = batch_save;
  2008. echoflg = echoflg_save;
  2009. }
  2011. #endif
  2013. #if defined(CDOS)
  2014. MLOCAL VOID map_user_page(UWORD window_page, UWORD physical_page)
  2015. {
  2016. UWORD pblk[3];
  2017. pblk[0] = window_page;
  2018. pblk[1] = physical_page;
  2019. pblk[2] = 0;
  2020. bdos(181, pblk);
  2021. }
  2024. MLOCAL BYTE FAR * map_pd_mem(UWORD ppd, UWORD wp, UWORD seg, UWORD offset)
  2025. {
  2026. /* Map memory for another process into our memory space so we examine it */
  2027. UWORD base_seg;
  2028. UWORD page;
  2029. PD FAR * pdptr;
  2030. UWORD sysdat;
  2031. UWORD mptbl;
  2032. UWORD FAR * ptr;
  2033. UWORD mp_off;
  2034. UWORD i;
  2035. MPAD FAR * mp;
  2038. sysdat = FP_SEG(pd);
  2039. ptr = MK_FP(sysdat, 0xc8);
  2040. /* DEBUG */
  2041. if (*ptr == 0) /* for DEBUG under XM assume non-banked system */
  2042.     return(MK_FP(seg, offset));
  2043. /* DEBUG */
  2044. ptr = MK_FP(sysdat, *ptr + 8);
  2045. mptbl = *ptr;
  2047. /* get segment of 4k page to map */
  2048. base_seg = (seg + (offset+15)/16) & 0xff00;
  2051. /* now find physical page to map */
  2053. pdptr = (PD FAR *) MK_FP(sysdat, ppd);
  2055. for (mp_off = pdptr->P_MPAR; mp_off !=0;) {
  2056.     mp = MK_FP(sysdat, mp_off);
  2057.     mp_off = mp->link;
  2058.     if ((base_seg >= mp->start) && 
  2059. (base_seg < (mp->start + mp->length))) {
  2060. page = mp->xios;
  2061. for (i = 0; i < ((base_seg - mp->start)/1024); i++){
  2062.     ptr = MK_FP(mptbl, page*2);
  2063.     page = *ptr;
  2064. }
  2065. page = 4*page + (((base_seg - mp->start)/0x0100) & 3);
  2066. map_user_page(wp, page);
  2067. return(MK_FP(wp*0x0100,(seg*16+offset) & 0x0fff));
  2068.     }
  2069. }
  2071. /* not found in mpad's - must be non-banked address */
  2072. return(MK_FP(seg, offset));
  2073. }
  2075. MLOCAL VOID ip_poke(UWORD ppd, UWORD wp, UWORD seg, UWORD offset, UBYTE val)
  2076. {
  2077. UBYTE FAR *ptr;
  2079. ptr = map_pd_mem(ppd, wp, seg, offset);
  2080. *ptr = val;
  2081. }
  2083. MLOCAL UBYTE ip_peek(UWORD ppd, UWORD wp, UWORD seg, UWORD offset)
  2084. {
  2085. UBYTE FAR *ptr;
  2087. ptr = map_pd_mem(ppd, wp, seg, offset);
  2088. return(*ptr);
  2089. }
  2091. MLOCAL UWORD ip_peek_word(UWORD ppd, UWORD wp, UWORD seg, UWORD offset)
  2092. {
  2093. return (ip_peek(ppd, wp, seg, offset) + 
  2094. 256*ip_peek(ppd, wp, seg, offset+1));
  2095. }
  2097. GLOBAL VOID inherit_TMP_state(VOID)
  2098. /* inherit batch files */
  2099. /* NB. This is bodged - we don't inherit FOR state, or redirection */
  2100. {
  2101. PD FAR *parent;
  2102. UWORD batch_seg;
  2103. UWORD tmp_mpad;
  2104. UWORD mp_off;
  2105. MPAD FAR * mp;
  2106. VOID FAR *window;
  2107. UWORD win_page;
  2108. UWORD i;
  2110. parent = (PD FAR *) MK_FP(FP_SEG(pd), pd->P_PARENT);
  2112. /* verify our parent is a Tmp, forget if it isn't */
  2113. if ((parent->P_NAME[0] != 'T') ||
  2114.     (parent->P_NAME[1] != 'm') ||
  2115.     (parent->P_NAME[2] != 'p'))
  2116.     return;
  2118. /* allocate a 4k aligned window to bank data into */
  2119. i = 2*4096/16;
  2120. mem_alloc(&window, &i, i, i);
  2121. if (i==0)
  2122.     return;
  2123. win_page = (FP_SEG(window) + 0x0100) / 0x100;
  2125. batch_seg = ip_peek_word(pd->P_PARENT, win_page,
  2126. parent->P_PSP, TmpPspBatchSeg);
  2128. /* do we have any batch files to inherit */
  2129. if (batch_seg) {
  2131.             echoflg = (BOOLEAN)ip_peek_word(pd->P_PARENT, win_page,
  2132. ip_peek_word(pd->P_PARENT, win_page,
  2133.     parent->P_PSP, TmpPspDataSeg),
  2134. ip_peek_word(pd->P_PARENT, win_page,
  2135.     parent->P_PSP, TmpPspEchoFlgPtr));
  2137. /* recover Tmp's hidden mpads */
  2139.     tmp_mpad = ip_peek_word(pd->P_PARENT, win_page,
  2140. parent->P_PSP, TmpPspMpad);
  2142.     for (mp_off = parent->P_MPAR; mp_off != 0;) {
  2143. mp  = MK_FP(FP_SEG(parent), parent->P_MPAR);
  2144. mp_off  = mp->link;
  2145.     }
  2147.     mp->link = tmp_mpad;
  2148.     inherit_batch_file(pd->P_PARENT, win_page, batch_seg);
  2149.     mp->link = 0; /* unlink again */
  2150. }
  2151. map_user_page(0, 0); /* force user page to be unmapped */
  2152. bdos(141,0); /* dispatch to re-map TPA memory */
  2153. mem_free(&window); /* free the window */
  2154. }
  2156. MLOCAL VOID inherit_batch_file(UWORD ppd, UWORD win_page, UWORD batch_seg)
  2157. {
  2158. UBYTE FAR * dst;
  2159. BCONTROL FAR *save0;
  2160. FCONTROL *save1;
  2161. BYTE  *save2;
  2162. WORD  save3;
  2163. UWORD i;
  2164. UWORD data_seg;
  2165. PD FAR *parent;
  2169. /* if we are in a nested batch file, inherit older batch file first */
  2170. i = ip_peek_word(ppd, win_page, batch_seg, 2);
  2172. if (i != 0)
  2173.     inherit_batch_file( ppd, win_page, i);
  2175. batch_new(); /* new incarnation of batch */
  2177. save0 = batch->bcontrol; save1 = batch->fcontrol;
  2178. save2 = batch->heap_start; save3 = batch->heap_size;
  2180. dst = (BYTE FAR *) batch; /* copy batch structure */
  2181. for (i=0; i<sizeof(BCONTROL); i++) /* from parental PD */
  2182.     dst[i] = ip_peek(ppd, win_page, batch_seg, i);
  2184. /* now terminate parental batch processing by poking EOF */
  2185. ip_poke(ppd, win_page,
  2186. batch_seg, (UWORD) &batch->eof - (UWORD) &batch->bcontrol,
  2187. (UBYTE) TRUE);
  2189. /*
  2190.  * Copy the invoking command and the individual elements 
  2191.  * of the command line into a buffer ready for processing
  2192.  */
  2194. parent = (PD FAR *) MK_FP(FP_SEG(pd), pd->P_PARENT);
  2195. data_seg = ip_peek_word(pd->P_PARENT, win_page,
  2196. parent->P_PSP, TmpPspDataSeg);
  2198. i = (UWORD) batch->batcmd;
  2199. batch->batcmd = (BYTE *)heap(); /* Initialize Parameter Buffer */
  2201. while (ip_peek_word(ppd, win_page, data_seg, i) != 0)
  2202. *(BYTE *)heap_get(1) = ip_peek(ppd, win_page, data_seg, i++);
  2204. *(WORD *)heap_get(2) = 0; /* Double NULL is a terminator  */
  2205. /* for command line params  */
  2207. batch->bcontrol = save0; batch->fcontrol = save1;
  2208. batch->heap_start = save2; batch->heap_size = save3;
  2210. batchflg++; /* increment batch flag */
  2212. crlfflg  = YES; /* print CR/LF after this  */
  2213. }
  2214. #endif
  2217. EXTERN N_CMD novell_ext_list[];
  2219. EXTERN BYTE FAR * CDECL farptr(BYTE *);
  2220. EXTERN BYTE FAR * CDECL cgroupptr(BYTE *);
  2222. EXTERN BOOLEAN CDECL call_novell(BYTE *, BYTE *, WORD);
  2223. EXTERN BOOLEAN CDECL nov_station(WORD *);
  2224. EXTERN WORD    CDECL nov_connection();
  2227. MLOCAL BOOLEAN novell_extension(src,dst)
  2228. BYTE *src;
  2229. BYTE *dst;
  2230. /*
  2231.  * Check if src string is a novell string to be expanded. eg login_name.
  2232.  * if so, put expansion in dst.
  2233.  */
  2234. {
  2235. N_CMD FAR *n_cmd_p;
  2236. BYTE  FAR *cpf; 
  2237. WORD i;
  2239. for (i=0;src[i] && src[i]!='=';i++);
  2240. src[i] = 0;
  2242. n_cmd_p = (N_CMD FAR *)farptr((BYTE *)&novell_ext_list[0]);
  2244. while(n_cmd_p->string) {
  2246.     cpf = cgroupptr(n_cmd_p->string);
  2248.     for(i=0; (cpf[i]==src[i]) && src[i]; i++);
  2250.     if(cpf[i]==src[i]) {
  2251.         (*n_cmd_p->func)(dst);
  2252.      return(0);
  2253.     }
  2254.     
  2255.     n_cmd_p++;
  2256. }
  2257. return(1);
  2258. }
  2262. GLOBAL VOID CDECL get_login_name(dst)
  2263. BYTE *dst;
  2264. {
  2265. struct s_nov_e346_in {
  2266.     WORD len;
  2267.     BYTE code;
  2268. } nov_e346_in;
  2269. struct s_nov_e346_out {
  2270.     WORD len;
  2271.     BYTE level;
  2272.     LONG id;
  2273. } nov_e346_out;
  2274. struct s_nov_e336_in {
  2275.     WORD len;
  2276.     BYTE code;
  2277.     LONG id;
  2278. } nov_e336_in;
  2279. struct s_nov_e336_out {
  2280.     WORD len;
  2281.     LONG id;
  2282.     WORD type;
  2283.     BYTE name[48];
  2284. } nov_e336_out;
  2286. nov_e346_in.len  = 1;
  2287. nov_e346_in.code = 0x46;
  2288. nov_e346_out.len = 5;
  2289. nov_e346_out.id = -1L;
  2290. call_novell((BYTE *)&nov_e346_in, (BYTE *)&nov_e346_out, 0xE3);
  2292. if (nov_e346_out.id == -1L) {
  2293.     *dst = 0;
  2294.     return;
  2295. }
  2297. nov_e336_in.len  = 5;
  2298. nov_e336_in.code = 0x36;
  2299. nov_e336_in.id   = nov_e346_out.id;
  2300. nov_e336_out.len = 54;
  2301. call_novell((BYTE *)&nov_e336_in, (BYTE *)&nov_e336_out, 0xE3);
  2303. strcpy(dst,nov_e336_out.name);
  2305. }
  2307. GLOBAL VOID CDECL get_pstation(dst)
  2308. BYTE *dst;
  2309. {
  2310. WORD sn[3];
  2312. if (nov_station(sn)) {
  2313.     *dst = 0;
  2314.     return;
  2315. }
  2317. sprintf(dst,"%04X%04X%04X",sn[0],sn[1],sn[2]);
  2318. }
  2321. GLOBAL VOID CDECL get_full_name(dst)
  2322. BYTE *dst;
  2323. {
  2324. /* scan bindery */
  2325. struct s_nov_e337_in {
  2326. WORD len;
  2327. BYTE code;
  2328. LONG last_object_id;
  2329. WORD object_type;
  2330. BYTE object_name_len;
  2331. BYTE object_name[48];
  2332. } nov_e337_in;
  2334. struct s_nov_e337_out {
  2335. WORD len;
  2336. LONG object_id;
  2337. WORD object_type;
  2338. BYTE object_name[48];
  2339. BYTE object_flag;
  2340. BYTE object_security;
  2341. BYTE object_has_properties;
  2342. } nov_e337_out;
  2345. /* scan property */
  2346. struct s_nov_e33c_in {
  2347. WORD len;
  2348. BYTE code;
  2349. WORD object_type;
  2350. BYTE object_name_len;
  2351. BYTE object_name[48];
  2352. LONG sequence_num;
  2353. BYTE property_name_len;
  2354. BYTE property_name[16];
  2355. } nov_e33c_in;
  2357. struct s_nov_e33c_out {
  2358. WORD  len;
  2359. BYTE property_name[16];
  2360. BYTE property_flags;
  2361. BYTE property_security;
  2362. LONG sequence_num;
  2363. BYTE property_has_value;
  2364. BYTE more_properties;
  2365. } nov_e33c_out;
  2368. /* read property */
  2369. struct s_nov_e33d_in {
  2370. WORD  len;
  2371. BYTE code;
  2372. WORD object_type;
  2373. BYTE object_name_len;
  2374. BYTE object_name[48];
  2375. BYTE segment_num;
  2376. BYTE property_name_len;
  2377. BYTE property_name[16];
  2378. } nov_e33d_in;
  2380. struct s_nov_e33d_out {
  2381. WORD len;
  2382. BYTE property_value[128];
  2383. BYTE more_segments;
  2384. BYTE property_flags;
  2385. } nov_e33d_out;
  2387. int res;
  2391. get_login_name(nov_e337_in.object_name);
  2392. nov_e337_in.object_name_len = strlen(nov_e337_in.object_name);
  2393. if (!nov_e337_in.object_name_len){
  2394. *dst = 0;
  2395. return;
  2396. }
  2398. nov_e337_in.code = 0x37;
  2399. nov_e337_in.len = sizeof(struct s_nov_e337_in) - 2;
  2400. nov_e337_out.len = sizeof(struct s_nov_e337_out) -2 ;
  2401. nov_e337_in.last_object_id = -1L;
  2402. nov_e337_in.object_type = 0x0100;  /*user*/
  2405. for(;;){
  2406. res = call_novell((BYTE *)&nov_e337_in, (BYTE *)&nov_e337_out, 0xe3 );
  2407. if ( res == 0xfc )
  2408. break;
  2409. else if ( res ){
  2410. *dst= 0;
  2411. return;
  2412. }
  2414. if ( nov_e337_out.object_has_properties ){
  2415.    nov_e33c_in.code = 0x3c;
  2416.    nov_e33c_in.len = sizeof(struct s_nov_e33c_in) - 2;
  2417.    nov_e33c_out.len = sizeof(struct s_nov_e33c_out) - 2;
  2418.    nov_e33c_in.object_type = nov_e337_out.object_type;
  2419.    nov_e33c_in.object_name_len = sizeof( nov_e33c_in.object_name );
  2420.    strcpy( nov_e33c_in.object_name, nov_e337_out.object_name );
  2421.    nov_e33c_in.sequence_num = -1L;
  2422.    nov_e33c_in.property_name_len = 1;
  2423.    nov_e33c_in.property_name[0] = '*';
  2425.    for(;;){
  2426.           res = call_novell( (BYTE *)&nov_e33c_in, (BYTE *)&nov_e33c_out, 0xe3 );
  2427.   if ( res == 0xfb )
  2428. break;
  2429.   else if ( res ){
  2430. *dst = 0;
  2431. return;
  2432. }
  2434.   if ( nov_e33c_out.property_has_value ){
  2435. nov_e33d_in.code = 0x3d;
  2436. nov_e33d_in.len = sizeof (struct s_nov_e33d_in) - 2;
  2437. nov_e33d_out.len = sizeof (struct s_nov_e33d_out) - 2;
  2438. nov_e33d_in.object_type = nov_e337_out.object_type;
  2439. nov_e33d_in.object_name_len = sizeof( nov_e33d_in.object_name );
  2440. strcpy( nov_e33d_in.object_name, nov_e337_out.object_name );
  2441. nov_e33d_in.segment_num = 1;
  2442. nov_e33d_in.property_name_len = strlen( nov_e33c_out.property_name );
  2443. strcpy(nov_e33d_in.property_name, nov_e33c_out.property_name );
  2444. for(;;){
  2445. res = call_novell( (BYTE *)&nov_e33d_in, (BYTE *)&nov_e33d_out, 0xe3);
  2446. if ( res == 0xec )
  2447. break;
  2448. else if ( res ){
  2449. *dst = 0;
  2450. return;
  2451. }
  2453. if (!strcmp(nov_e33c_out.property_name,"IDENTIFICATION")){
  2454. strcpy(dst,nov_e33d_out.property_value);
  2455. return;
  2456. }
  2457. nov_e33d_in.segment_num++;
  2458. }/*for*/
  2459.           }/*if*/
  2460.       nov_e33c_in.sequence_num = nov_e33c_out.sequence_num;
  2461.   }/*for*/
  2462.     nov_e337_in.last_object_id = nov_e337_out.object_id;
  2463.     }/*if*/
  2464. }/*for*/
  2465. }
  2469. GLOBAL VOID CDECL get_hour(dst)
  2470. BYTE *dst;
  2471. {
  2472. SYSTIME  time;
  2474. ms_gettime(&time);
  2476. if (time.hour > 12) time.hour -= 12;
  2477. if (time.hour == 0) time.hour = 12;
  2479. sprintf(dst,"%d",time.hour);
  2480. }
  2482. GLOBAL VOID CDECL get_hour24(dst)
  2483. BYTE *dst;
  2484. {
  2485. SYSTIME  time;
  2487. ms_gettime(&time);
  2489. sprintf(dst,"%02d",time.hour);
  2490. }
  2492. GLOBAL VOID CDECL get_minute(dst)
  2493. BYTE *dst;
  2494. {
  2495. SYSTIME  time;
  2497. ms_gettime(&time);
  2499. sprintf(dst,"%02d",time.min);
  2500. }
  2502. GLOBAL VOID CDECL get_second(dst)
  2503. BYTE *dst;
  2504. {
  2505. SYSTIME  time;
  2507. ms_gettime(&time);
  2509. sprintf(dst,"%02d",time.sec);
  2510. }
  2512. GLOBAL VOID CDECL get_am_pm(dst)
  2513. BYTE *dst;
  2514. {
  2515. SYSTIME time;
  2516. BYTE FAR *p;
  2518. ms_gettime(&time);
  2520. if (time.hour >= 12) p = cgroupptr(PM_TIME);
  2521. else      p = cgroupptr(AM_TIME);
  2523. while (*p) *dst++ = *p++;
  2524. *dst = 0;
  2525. }
  2527. GLOBAL VOID CDECL get_greeting(dst)
  2528. BYTE *dst;
  2529. {
  2530. SYSTIME time;
  2531. BYTE FAR *p;
  2533. ms_gettime(&time);
  2535. if (time.hour < 12)
  2536.     p = cgroupptr(GREETING_MORNING);
  2537. else if (time.hour < 17)
  2538.     p = cgroupptr(GREETING_AFTERNOON);
  2539. else
  2540.     p = cgroupptr(GREETING_EVENING);
  2542. while (*p) *dst++ = *p++;
  2543. *dst = 0;
  2544. }
  2546. GLOBAL VOID CDECL get_year(dst)
  2547. BYTE *dst;
  2548. {
  2549. SYSDATE date;
  2551. ms_getdate(&date);
  2553. sprintf(dst,"%d",date.year);
  2554. }
  2556. GLOBAL VOID CDECL get_short_year(dst)
  2557. BYTE *dst;
  2558. {
  2559. SYSDATE date;
  2561. ms_getdate(&date);
  2563. sprintf(dst,"%d",date.year%100);
  2564. }
  2566. GLOBAL VOID CDECL get_month(dst)
  2567. BYTE *dst;
  2568. {
  2569. SYSDATE date;
  2571. ms_getdate(&date);
  2573. sprintf(dst,"%d",date.month);
  2574. }
  2576. GLOBAL VOID CDECL get_month_name(dst)
  2577. BYTE *dst;
  2578. {
  2579. SYSDATE date;
  2580. BYTE *m;
  2582. ms_getdate(&date);
  2584. switch(date.month) {
  2585. case 1:  m = JAN_M; break;
  2586. case 2:  m = FEB_M; break;
  2587. case 3:  m = MAR_M; break;
  2588. case 4:  m = APR_M; break;
  2589. case 5:  m = MAY_M; break;
  2590. case 6:  m = JUN_M; break;
  2591. case 7:  m = JUL_M; break;
  2592. case 8:  m = AUG_M; break;
  2593. case 9:  m = SEP_M; break;
  2594. case 10: m = OCT_M; break;
  2595. case 11: m = NOV_M; break;
  2596. case 12: m = DEC_M; break;
  2597. }
  2599. sprintf(dst,"%s",m);
  2600. }
  2605. GLOBAL VOID CDECL get_day(dst)
  2606. BYTE *dst;
  2607. {
  2608. SYSDATE date;
  2610. ms_getdate(&date);
  2612. sprintf(dst,"%d",date.day);
  2613. }
  2615. GLOBAL VOID CDECL get_nday_of_week(dst)
  2616. BYTE *dst;
  2617. {
  2618. SYSDATE date;
  2620. ms_getdate(&date);
  2622. sprintf(dst,"%d",date.dow+1);
  2623. }
  2625. GLOBAL VOID CDECL get_day_of_week(dst)
  2626. BYTE *dst;
  2627. {
  2628. SYSDATE date;
  2630. ms_getdate(&date);
  2632. sprintf(dst,"%s",day_names(date.dow));
  2633. }
  2635. GLOBAL VOID CDECL get_os_version(dst)
  2636. BYTE *dst;
  2637. {
  2638. env_scan("VER=",dst);
  2639. }
  2641. GLOBAL VOID CDECL get_connection(dst)
  2642. BYTE *dst;
  2643. {
  2644. int i;
  2646. i = nov_connection();
  2647. if (i==-1) {
  2648.     *dst = 0;
  2649.     return;
  2650. }
  2652. sprintf(dst,"%d",i);
  2653. }