home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #20 / NN_1992_20.iso / spool / comp / sources / misc / 3943 < prev    next >
Encoding:
Text File  |  1992-09-13  |  57.1 KB  |  2,571 lines
  1. Newsgroups: comp.sources.misc
  2. Path: sparky!kent
  3. From: wht@n4hgf.Mt-Park.GA.US (Warren Tucker)
  4. Subject:  v32i051:  ecu - ECU Asynchronous Communications v3.20, Part16/40
  5. Message-ID: <1992Sep13.153623.5576@sparky.imd.sterling.com>
  6. Followup-To: comp.sources.d
  7. X-Md4-Signature: 771020a5e60609547dc6deacc2689351
  8. Sender: kent@sparky.imd.sterling.com (Kent Landfield)
  9. Organization: Sterling Software
  10. References: <csm-v32i036=ecu.141245@sparky.IMD.Sterling.COM>
  11. Date: Sun, 13 Sep 1992 15:36:23 GMT
  12. Approved: kent@sparky.imd.sterling.com
  13. Lines: 2556
  14.  
  15. Submitted-by: wht@n4hgf.Mt-Park.GA.US (Warren Tucker)
  16. Posting-number: Volume 32, Issue 51
  17. Archive-name: ecu/part16
  18. Environment: SCO,XENIX,ISC,SUNOS,SYSVR4,HDB,Curses
  19. Supersedes: ecu: Volume 21, Issue 53-89
  20.  
  21. ---- Cut Here and feed the following to sh ----
  22. #!/bin/sh
  23. # this is ecu320.16 (part 16 of ecu320)
  24. # do not concatenate these parts, unpack them in order with /bin/sh
  25. # file fasiintf.c continued
  26. #
  27. if test ! -r _shar_seq_.tmp; then
  28.     echo 'Please unpack part 1 first!'
  29.     exit 1
  30. fi
  31. (read Scheck
  32.  if test "$Scheck" != 16; then
  33.     echo Please unpack part "$Scheck" next!
  34.     exit 1
  35.  else
  36.     exit 0
  37.  fi
  38. ) < _shar_seq_.tmp || exit 1
  39. if test ! -f _shar_wnt_.tmp; then
  40.     echo 'x - still skipping fasiintf.c'
  41. else
  42. echo 'x - continuing file fasiintf.c'
  43. sed 's/^X//' << 'SHAR_EOF' >> 'fasiintf.c' &&
  44. X    return(txt);
  45. X
  46. X}    /* end of msr_text */
  47. X
  48. X/*+-------------------------------------------------------------------------
  49. X    mcr_text(mcr)
  50. X--------------------------------------------------------------------------*/
  51. Xchar *
  52. Xmcr_text(mcr)
  53. Xuchar mcr;
  54. X{
  55. X    static char txt[32];
  56. X
  57. X    txt[0] = '*';
  58. X    txt[1] = 0;
  59. X    if(!mcr)
  60. X    {
  61. X        strcat(txt,"NULL*");
  62. X        return(txt);
  63. X    }
  64. X    if(mcr & MC_SET_DTR) strcat(txt,"DTR*");
  65. X    if(mcr & MC_SET_RTS) strcat(txt,"RTS*");
  66. X    if(mcr & MC_SET_OUT1) strcat(txt,"OUT1*");
  67. X    if(mcr & MC_SET_OUT2) strcat(txt,"OUT2*");
  68. X    if(mcr & MC_SET_LOOPBACK) strcat(txt,"LOOPBACK*");
  69. X    return(txt);
  70. X
  71. X}    /* end of mcr_text */
  72. X
  73. X/*+-------------------------------------------------------------------------
  74. X    lcr_text(lcr)
  75. X--------------------------------------------------------------------------*/
  76. Xchar *
  77. Xlcr_text(lcr)
  78. Xuchar lcr;
  79. X{
  80. X    static char txt[64];
  81. X
  82. X    sprintf(txt,"*%ddb*",(lcr & LC_WORDLEN_MASK) + 5);
  83. X    strcat(txt,(lcr & LC_STOPBITS_LONG) ? "2" : "1");
  84. X    strcat(txt,"sb*");
  85. X    if(lcr & LC_ENABLE_PARITY)
  86. X    {
  87. X        strcat(txt,"PARITY*");
  88. X        if(lcr & LC_STICK_PARITY)
  89. X            strcat(txt,(lcr & LC_EVEN_PARITY) ? "MARK*" : "SPACE*");
  90. X        else
  91. X            strcat(txt,(lcr & LC_EVEN_PARITY) ? "EVEN*" : "ODD*" );
  92. X    }
  93. X    else
  94. X        strcat(txt,"NOPAR*");
  95. X    if(lcr & LC_SET_BREAK_LEVEL)
  96. X        strcat(txt,"SETBREAK*");
  97. X    if(lcr & LC_ENABLE_DIVISOR)
  98. X        strcat(txt,"ENABDIV*");
  99. X    return(txt);
  100. X
  101. X}    /* end of lcr_text */
  102. X
  103. X/*+-------------------------------------------------------------------------
  104. X    ier_text(ier)
  105. X--------------------------------------------------------------------------*/
  106. Xchar *
  107. Xier_text(ier)
  108. Xuchar ier;
  109. X{
  110. X    static char txt[32];
  111. X
  112. X    txt[0] = '*';
  113. X    txt[1] = 0;
  114. X    if(!ier)
  115. X    {
  116. X        strcat(txt,"NULL*");
  117. X        return(txt);
  118. X    }
  119. X    if(ier & IE_RECV_DATA_AVAILABLE) strcat(txt,"RDAV*");
  120. X    if(ier & IE_XMIT_HOLDING_BUFFER_EMPTY) strcat(txt,"TBMT*");
  121. X    if(ier & IE_LINE_STATUS) strcat(txt,"LS*");
  122. X    if(ier & IE_MODEM_STATUS) strcat(txt,"MS*");
  123. X    return(txt);
  124. X
  125. X}    /* end of ier_text */
  126. X
  127. X/*+-------------------------------------------------------------------------
  128. X    display_fasi(fip)
  129. X--------------------------------------------------------------------------*/
  130. Xvoid
  131. Xdisplay_fasi(fip)
  132. Xstruct fas_info *fip;
  133. X{
  134. X
  135. X    pprintf("base address: %04x irq=%u ",fip->port_0.addr,fip->vec);
  136. X    pputs("device is ");
  137. X    if(fip->device_flags.s & DF_DEVICE_IS_NS16550A)
  138. X        pputs("16550\n");
  139. X    else if(fip->device_flags.s & DF_DEVICE_IS_I82510)
  140. X        pputs("82510\n");
  141. X    else
  142. X        pputs("16450\n");
  143. X    pprintf("MSR=%s   ",msr_text(fip->msr));
  144. X    pprintf("MCR=%s\n",mcr_text(fip->mcr));
  145. X    pprintf("LCR=%s   ",lcr_text(fip->lcr));
  146. X    pprintf("IER=%s\n",ier_text(fip->ier));
  147. X    pprintf("recv ring cnt=%u  ",fip->recv_ring_cnt);
  148. X    pprintf("xmit ring cnt=%u  ",fip->xmit_ring_cnt);
  149. X    pprintf("xmit fifo size=%u\n",fip->xmit_fifo_size);
  150. X    pprintf("characters received    =%12lu\n",fip->characters_received);
  151. X    pprintf("characters transmitted =%12lu\n",fip->characters_transmitted);
  152. X    pprintf("modem status events    =%12lu\n",fip->modem_status_events);
  153. X    pprintf("overrun errors=%lu  ",fip->overrun_errors);
  154. X    pprintf("framing errors=%lu  ",fip->framing_errors);
  155. X    pprintf("parity errors=%lu\n",fip->parity_errors);
  156. X    pprintf("rings detected=%lu  ",fip->rings_detected);
  157. X    pprintf("breaks detected=%lu\n",fip->breaks_detected);
  158. X    pprintf("xmtr flow off XON/XOFF=%lu  RTS/CTS=%lu\n",
  159. X        fip->xmtr_sw_flow_count,fip->xmtr_hw_flow_count);
  160. X    pprintf("rcvr flow off XON/XOFF=%lu  RTS/CTS=%lu\n",
  161. X        fip->rcvr_sw_flow_count,fip->rcvr_hw_flow_count);
  162. X
  163. X}    /* end of display_fasi */
  164. X
  165. X/*+-------------------------------------------------------------------------
  166. X    fasi_msr() - return modem status register contents
  167. X--------------------------------------------------------------------------*/
  168. Xuchar
  169. Xfasi_msr()
  170. X{
  171. X    ulong ltmp = 0;
  172. X
  173. X    return((uchar)ioctl(shm->Liofd,FASIC_MCR,(char *)<mp));
  174. X    return(ltmp);
  175. X}    /* end of fasi_msr */
  176. X
  177. X/*+-------------------------------------------------------------------------
  178. X    fasi_line_errors() - return UART error count
  179. X--------------------------------------------------------------------------*/
  180. Xulong
  181. Xfasi_line_errors()
  182. X{
  183. X    struct fas_info finfo,*fip = &finfo;
  184. X
  185. X    memset((char *)fip,0,sizeof(*fip));
  186. X
  187. X    if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
  188. X        return(0);
  189. X    return(fip->parity_errors + fip->framing_errors + fip->overrun_errors);
  190. X
  191. X}    /* end of fasi_line_errors */
  192. X
  193. X/*+-------------------------------------------------------------------------
  194. X    fasi_rings_detected() - return number of RI trailing edges
  195. X--------------------------------------------------------------------------*/
  196. Xulong
  197. Xfasi_rings_detected()
  198. X{
  199. X    struct fas_info finfo,*fip = &finfo;
  200. X
  201. X    memset((char *)fip,0,sizeof(*fip));
  202. X
  203. X    if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
  204. X        return(0);
  205. X    return(fip->rings_detected);
  206. X
  207. X}    /* end of fasi_rings_detected */
  208. X
  209. X/*+-------------------------------------------------------------------------
  210. X    fasi_breaks_detected() - return number of BREAKs detected
  211. X--------------------------------------------------------------------------*/
  212. Xulong
  213. Xfasi_breaks_detected()
  214. X{
  215. X    struct fas_info finfo,*fip = &finfo;
  216. X
  217. X    memset((char *)fip,0,sizeof(*fip));
  218. X
  219. X    if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
  220. X        return(0);
  221. X    return(fip->breaks_detected);
  222. X
  223. X}    /* end of fasi_breaks_detected */
  224. X
  225. X/*+-------------------------------------------------------------------------
  226. X    pcmd_fasi(param)
  227. Xfasi [-switches] <str-cmd>>
  228. X
  229. Xwhere <str-cmd> is 'd[isplay]'
  230. X                or 'r[eset]'
  231. X
  232. Xfasi 'd'
  233. Xfasi 'r'
  234. X--------------------------------------------------------------------------*/
  235. Xint
  236. Xpcmd_fasi(param)
  237. XESD *param;
  238. X{
  239. X    int erc;
  240. X    char switches[8];
  241. X    ESD *tesd = (ESD *)0;
  242. X    struct fas_info finfo,*fip = &finfo;
  243. X    char ident_str[128];
  244. X
  245. X    memset((char *)fip,0,sizeof(*fip));
  246. X
  247. X    get_switches(param,switches,sizeof(switches));
  248. X    if(!(tesd = esdalloc(64)))
  249. X        return(eNoMemory);
  250. X    if(!(erc = gstr(param,tesd,1)))
  251. X    {
  252. X        skip_cmd_break(tesd);
  253. X        switch(to_lower(*(tesd->pb + tesd->index)))
  254. X        {
  255. X            case 'd':    /* display */
  256. X                if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
  257. X                {
  258. X                    pperror("ioctl FASIC_SIP");
  259. X                    erc = eFATAL_ALREADY;
  260. X                }
  261. X                else
  262. X                    display_fasi(fip);
  263. X                if((ioctl(shm->Liofd,FASIC_DVR_IDENT,ident_str)) < 0)
  264. X                {
  265. X                    pperror("ioctl FASIC_DVR_IDENT");
  266. X                    erc = eFATAL_ALREADY;
  267. X                }
  268. X                else
  269. X                    pprintf("driver:  '%s'\n",ident_str);
  270. X                if((ioctl(shm->Liofd,FASIC_SPACE_IDENT,ident_str)) < 0)
  271. X                {
  272. X                    pperror("ioctl FASIC_SPACE_IDENT");
  273. X                    erc = eFATAL_ALREADY;
  274. X                }
  275. X                else
  276. X                    pprintf("space.c: '%s'\n",ident_str);
  277. X                break;
  278. X
  279. X            case 'r':    /* reset */
  280. X                if((ioctl(shm->Liofd,FASIC_RESET_STAT,(char *)0)) < 0)
  281. X                {
  282. X                    pperror("ioctl FASIC_RESET_STAT");
  283. X                    erc = eFATAL_ALREADY;
  284. X                }
  285. X                else if(proctrace)
  286. X                    pputs("statistics reset\n");
  287. X                break;
  288. X
  289. X            default:
  290. X                pputs("invalid subcommand '");
  291. X                pputs(tesd->pb);
  292. X                pputs("'\n");
  293. X                erc = eFATAL_ALREADY;
  294. X                break;
  295. X        }
  296. X    }
  297. X
  298. X    if(tesd)
  299. X        esdfree(tesd);
  300. X    return(erc);
  301. X
  302. X}    /* end of pcmd_fasi */
  303. X
  304. X/*+-------------------------------------------------------------------------
  305. X    icmd_fasi(narg,arg)
  306. X--------------------------------------------------------------------------*/
  307. Xvoid
  308. Xicmd_fasi(narg,arg)
  309. Xint narg;
  310. Xchar **arg;
  311. X{
  312. X    struct fas_info finfo,*fip = &finfo;
  313. X    char ident_str[128];
  314. X
  315. X    memset((char *)fip,0,sizeof(*fip));
  316. X
  317. X    if((narg > 1) && (to_lower(*arg[1]) == 'r'))
  318. X    {
  319. X        if((ioctl(shm->Liofd,FASIC_RESET_STAT,(char *)0)) < 0)
  320. X        {
  321. X            pperror("   ioctl FASIC_RESET_STAT");
  322. X            return;
  323. X        }
  324. X        ff(se,"  fasi statistics reset\r\n");
  325. X    }
  326. X    else
  327. X    {
  328. X        if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
  329. X        {
  330. X            pperror("   ioctl FASIC_SIP");
  331. X            return;
  332. X        }
  333. X        ff(se,"\r\n");
  334. X        display_fasi(fip);
  335. X        if((ioctl(shm->Liofd,FASIC_DVR_IDENT,ident_str)) < 0)
  336. X            pperror("ioctl FASIC_DVR_IDENT");
  337. X        else
  338. X            pprintf("driver:  '%s'\n",ident_str);
  339. X        if((ioctl(shm->Liofd,FASIC_SPACE_IDENT,ident_str)) < 0)
  340. X            pperror("ioctl FASIC_SPACE_IDENT");
  341. X        else
  342. X            pprintf("space.c: '%s'\n",ident_str);
  343. X    }
  344. X
  345. X}    /* end of icmd_fasi */
  346. X
  347. X#endif /* FASI */
  348. X
  349. X/* vi: set tabstop=4 shiftwidth=4: */
  350. X/* end of fasiintf.c */
  351. SHAR_EOF
  352. echo 'File fasiintf.c is complete' &&
  353. chmod 0644 fasiintf.c ||
  354. echo 'restore of fasiintf.c failed'
  355. Wc_c="`wc -c < 'fasiintf.c'`"
  356. test 9450 -eq "$Wc_c" ||
  357.     echo 'fasiintf.c: original size 9450, current size' "$Wc_c"
  358. rm -f _shar_wnt_.tmp
  359. fi
  360. # ============= feval.c ==============
  361. if test -f 'feval.c' -a X"$1" != X"-c"; then
  362.     echo 'x - skipping feval.c (File already exists)'
  363.     rm -f _shar_wnt_.tmp
  364. else
  365. > _shar_wnt_.tmp
  366. echo 'x - extracting feval.c (Text)'
  367. sed 's/^X//' << 'SHAR_EOF' > 'feval.c' &&
  368. X/*+-------------------------------------------------------------------------
  369. X    feval.c - integer and string function evaluation
  370. X    wht@n4hgf.Mt-Park.GA.US
  371. X
  372. X    feval_int(param,&int_returned) where 'int' here means long ECU $i int
  373. X    feval_str(param,&esd_to_be_plugged)
  374. X
  375. X  These routines are called with param.index as follows:
  376. X
  377. X         !nnnnn       nnn is name of function
  378. X          ^
  379. X          |
  380. X
  381. X  Defined functions:
  382. X    feval_int(param,value)
  383. X    feval_str(param,result_esd)
  384. X    strfunc_left(param,scratch_esd,result_esd)
  385. X    strfunc_right(param,scratch_esd,result_esd)
  386. X
  387. X--------------------------------------------------------------------------*/
  388. X/*+:EDITS:*/
  389. X/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
  390. X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
  391. X/*:05-07-1992-15:04-wht@n4hgf-bug in FIconn code */
  392. X/*:04-25-1992-14:28-wht@n4hgf-%conn returns -1 if no line open */
  393. X/*:04-25-1992-13:19-wht@n4hgf-%line succeeds even if line not open */
  394. X/*:03-01-1992-13:28-wht@n4hgf-come up to modern times ... enum for FI/FS  */
  395. X/*:02-14-1992-16:37-wht@n4hgf-add uname */
  396. X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
  397. X/*:07-14-1991-18:18-wht@n4hgf-new ttygets functions */
  398. X/*:06-29-1991-16:33-wht@n4hgf-use cuserid() instead of getlogin() */
  399. X/*:03-16-1991-15:23-wht@n4hgf-add %nice */
  400. X/*:01-31-1991-16:10-wht@n4hgf-was freeing tesd1 twice in feval_str */
  401. X/*:12-24-1990-04:31-wht@n4hgf-experimental fasi driver functions */
  402. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  403. X
  404. X#include "ecu.h"
  405. X#include "ecuerror.h"
  406. X#include "esd.h"
  407. X#include "proc.h"
  408. X#include "var.h"
  409. X#include "ecutty.h"
  410. X#include <sys/utsname.h>
  411. X
  412. X#if defined(FASI)
  413. Xchar *msr_text();
  414. X#endif
  415. X
  416. Xenum FI_codes
  417. X{
  418. X    FIZERO,
  419. X    FIargc,
  420. X    FIbaud,
  421. X    FIbrdet,
  422. X    FIcolors,
  423. X    FIcols,
  424. X    FIconn,
  425. X    FIcsec,
  426. X    FIctoi,
  427. X    FIcurx,
  428. X    FIcury,
  429. X    FIesecs,
  430. X    FIfasi,
  431. X    FIfatime,
  432. X    FIfmode,
  433. X    FIfmtime,
  434. X    FIfsize,
  435. X    FIftell,
  436. X    FIgid,
  437. X    FIinstr,
  438. X    FIisalnum,
  439. X    FIisalpha,
  440. X    FIisascii,
  441. X    FIischr,
  442. X    FIiscntrl,
  443. X    FIisdigit,
  444. X    FIisdir,
  445. X    FIisgraph,
  446. X    FIislower,
  447. X    FIisprint,
  448. X    FIispunct,
  449. X    FIisreg,
  450. X    FIisspace,
  451. X    FIisupper,
  452. X    FIisxdigit,
  453. X    FIlen,
  454. X    FIlgetc,
  455. X    FIlines,
  456. X    FIlnerr,
  457. X    FImatch,
  458. X    FImhack,
  459. X    FImsr,
  460. X    FInice,
  461. X    FIpid,
  462. X    FIrchr,
  463. X    FIrchrc,
  464. X    FIridet,
  465. X    FIrinstr,
  466. X    FIshmid,
  467. X    FIstoi,
  468. X    FIuid,
  469. X    FIxchr,
  470. X    FIxchrc,
  471. X    FI____end
  472. X};
  473. X
  474. XKEYTAB feval_int_tbl[] =
  475. X{
  476. X    {"argc",FIargc},
  477. X    {"baud",FIbaud},
  478. X#if defined(FASI)
  479. X    {"brdet",FIbrdet},
  480. X#endif
  481. X    {"colors",FIcolors},
  482. X    {"cols",FIcols},
  483. X    {"conn",FIconn},
  484. X    {"csec",FIcsec},
  485. X    {"ctoi",FIctoi},
  486. X    {"curx",FIcurx},
  487. X    {"cury",FIcury},
  488. X    {"esecs",FIesecs},
  489. X    {"fasi",FIfasi},
  490. X    {"fatime",FIfatime},
  491. X    {"fmode",FIfmode},
  492. X    {"fmtime",FIfmtime},
  493. X    {"fsize",FIfsize},
  494. X    {"ftell",FIftell},
  495. X    {"gid",FIgid},
  496. X    {"instr",FIinstr},
  497. X    {"isalnum",FIisalnum},
  498. X    {"isalpha",FIisalpha},
  499. X    {"isalpha",FIisalpha},
  500. X    {"isascii",FIisascii},
  501. X    {"ischr",FIischr},
  502. X    {"iscntrl",FIiscntrl},
  503. X    {"isdigit",FIisdigit},
  504. X    {"isdir",FIisdir},
  505. X    {"isgraph",FIisgraph},
  506. X    {"islower",FIislower},
  507. X    {"isprint",FIisprint},
  508. X    {"ispunct",FIispunct},
  509. X    {"isreg",FIisreg},
  510. X    {"isspace",FIisspace},
  511. X    {"isupper",FIisupper},
  512. X    {"isxdigit",FIisxdigit},
  513. X    {"len",FIlen},
  514. X#if defined(FASI)
  515. X    {"lnerr",FIlnerr},
  516. X#endif
  517. X    {"lgetc",FIlgetc},
  518. X    {"lines",FIlines},
  519. X    {"match",FImatch},
  520. X    {"mhack",FImhack},
  521. X#if defined(FASI)
  522. X    {"msr",FImsr},
  523. X#endif
  524. X    {"nice",FInice},
  525. X    {"pid",FIpid},
  526. X    {"rchr",FIrchr},
  527. X    {"rchrc",FIrchrc},
  528. X#if defined(FASI)
  529. X    {"ridet",FIridet},
  530. X#endif
  531. X    {"rinstr",FIrinstr},
  532. X    {"shmid",FIshmid},
  533. X    {"stoi",FIstoi},
  534. X    {"uid",FIuid},
  535. X    {"xchr",FIxchr},
  536. X    {"xchrc",FIxchrc},
  537. X    {(char *)0,0}
  538. X};
  539. X
  540. Xenum FS_codes
  541. X{
  542. X    FSZERO,
  543. X    FSargv,
  544. X    FSbasename,
  545. X    FScgetc,
  546. X    FScgets,
  547. X    FSchr,
  548. X    FSdate,
  549. X    FSdatez,
  550. X    FSday,
  551. X    FSdayz,
  552. X    FSdir,
  553. X    FSdirpart,
  554. X    FSedate,
  555. X    FSenvvar,
  556. X    FSerrstr,
  557. X    FSetime,
  558. X    FSfilepart,
  559. X    FSfmodestr,
  560. X    FSitos,
  561. X    FSleft,
  562. X    FSline,
  563. X    FSlogname,
  564. X    FSmid,
  565. X    FSmonth,
  566. X    FSmonthz,
  567. X    FSmsrtext,
  568. X    FSrdesc,
  569. X    FSright,
  570. X    FSrname,
  571. X    FSrtel,
  572. X    FSscreen,
  573. X    FStime,
  574. X    FStimes,
  575. X    FStimez,
  576. X    FStimezs,
  577. X    FStty,
  578. X    FSuname,
  579. X    FS____end
  580. X};
  581. X
  582. XKEYTAB feval_str_tbl[] =
  583. X{
  584. X    {"argv",FSargv},
  585. X    {"basename",FSbasename},
  586. X    {"cgetc",FScgetc},
  587. X    {"cgets",FScgets},
  588. X    {"chr",FSchr},
  589. X    {"date",FSdate},
  590. X    {"datez",FSdatez},
  591. X    {"day",FSday},
  592. X    {"dir",FSdir},
  593. X    {"dirpart",FSdirpart},
  594. X    {"edate",FSedate},
  595. X    {"envvar",FSenvvar},
  596. X    {"errstr",FSerrstr},
  597. X    {"etime",FSetime},
  598. X    {"filepart",FSfilepart},
  599. X    {"fmodestr",FSfmodestr},
  600. X    {"getenv",FSenvvar},
  601. X    {"itos",FSitos},
  602. X    {"left",FSleft},
  603. X    {"line",FSline},
  604. X    {"logname",FSlogname},
  605. X    {"mid",FSmid},
  606. X    {"month",FSmonth},
  607. X#if defined(FASI)
  608. X    {"msrtext",FSmsrtext},
  609. X#endif
  610. X    {"rdesc",FSrdesc},
  611. X    {"right",FSright},
  612. X    {"rname",FSrname},
  613. X    {"rtelno",FSrtel},
  614. X    {"screen",FSscreen},
  615. X    {"time",FStime},
  616. X    {"times",FStimes},
  617. X    {"timez",FStimez},
  618. X    {"timezs",FStimezs},
  619. X    {"tty",FStty},
  620. X    {"uname",FSuname},
  621. X    {(char *)0,0}
  622. X};
  623. X
  624. Xextern char curr_dir[];
  625. Xextern int proctrace;
  626. Xextern PCB *pcb_stack[];
  627. Xextern struct timeb starting_timeb;
  628. Xextern uint tcap_LINES;
  629. Xextern uint tcap_COLS;
  630. X
  631. Xextern int shm_shmid;
  632. X
  633. Xchar *day_of_week_list = "SunMonTueWedThuFriSat";
  634. Xchar *month_name_list = "JanFebMarAprMayJunJulAugSepOctNovDec";
  635. X
  636. X/*+-------------------------------------------------------------------------
  637. X    erc = feval_int(param,&int_returned);
  638. XFunctions (parameter types are expressed by the usage of variables)
  639. X--------------------------------------------------------------------------*/
  640. Xfeval_int(param,value)
  641. XESD *param;
  642. Xlong *value;
  643. X{
  644. Xregister erc;
  645. Xregister keyword_token;
  646. XESD *tesd1 = (ESD *)0;
  647. XESD *tesd2 = (ESD *)0;
  648. Xulong int1;
  649. Xchar s32[32];
  650. Xstruct timeb now_timeb;
  651. Xint nice();
  652. X
  653. X    if(erc = get_alphanum_zstr(param,s32,sizeof(s32)))
  654. X    {
  655. X        erc = eInvalidFunction;
  656. X        goto RETURN;
  657. X    }
  658. X
  659. X    keyword_token = keyword_lookup(feval_int_tbl,s32);
  660. X    switch(keyword_token)
  661. X    {
  662. X/* LEN($S0)         length of $S0 */
  663. X    case FIlen:
  664. X        if(!(tesd1 = esdalloc(256)))
  665. X        {
  666. X            erc = eNoMemory;
  667. X            goto RETURN;
  668. X        }
  669. X        if(erc = skip_paren(param,1))
  670. X            goto RETURN;
  671. X        if(erc = gstr(param,tesd1,1))
  672. X            goto RETURN;
  673. X        if(erc = skip_paren(param,0))
  674. X            goto RETURN;
  675. X        *value = (long)tesd1->cb;
  676. X        break;
  677. X
  678. X/* INSTR($S0,$S1)   index of first occurrence of $S1 in $S0, -1 if none */
  679. X    case FIinstr:
  680. X        if(!(tesd1 = esdalloc(256)))
  681. X        {
  682. X            erc = eNoMemory;
  683. X            goto RETURN;
  684. X        }
  685. X        if(!(tesd2 = esdalloc(256)))
  686. X        {
  687. X            erc = eNoMemory;
  688. X            goto RETURN;
  689. X        }
  690. X        if(erc = skip_paren(param,1))
  691. X            goto RETURN;
  692. X        if(erc = gstr(param,tesd1,1))
  693. X            goto RETURN;
  694. X        if(erc = skip_comma(param))
  695. X            goto RETURN;
  696. X        if(erc = gstr(param,tesd2,1))
  697. X            goto RETURN;
  698. X        if(erc = skip_paren(param,0))
  699. X            goto RETURN;
  700. X
  701. X        *value = (long)ulindex(tesd1->pb,tesd2->pb);
  702. X        break;
  703. X
  704. X/* RINSTR($S0,$S1)   index of last occurrence of $S1 in $S0, -1 if none */
  705. X    case FIrinstr:
  706. X        if(!(tesd1 = esdalloc(256)))
  707. X        {
  708. X            erc = eNoMemory;
  709. X            goto RETURN;
  710. X        }
  711. X        if(!(tesd2 = esdalloc(256)))
  712. X        {
  713. X            erc = eNoMemory;
  714. X            goto RETURN;
  715. X        }
  716. X        if(erc = skip_paren(param,1))
  717. X            goto RETURN;
  718. X        if(erc = gstr(param,tesd1,1))
  719. X            goto RETURN;
  720. X        if(erc = skip_comma(param))
  721. X            goto RETURN;
  722. X        if(erc = gstr(param,tesd2,1))
  723. X            goto RETURN;
  724. X        if(erc = skip_paren(param,0))
  725. X            goto RETURN;
  726. X
  727. X        *value = (long)ulrindex(tesd1->pb,tesd2->pb);
  728. X        break;
  729. X
  730. X    case FImatch:
  731. X        if(!(tesd1 = esdalloc(256)))
  732. X        {
  733. X            erc = eNoMemory;
  734. X            goto RETURN;
  735. X        }
  736. X        if(!(tesd2 = esdalloc(256)))
  737. X        {
  738. X            erc = eNoMemory;
  739. X            goto RETURN;
  740. X        }
  741. X        if(erc = skip_paren(param,1))
  742. X            goto RETURN;
  743. X        if(erc = gstr(param,tesd1,1))
  744. X            goto RETURN;
  745. X        if(erc = skip_comma(param))
  746. X            goto RETURN;
  747. X        if(erc = gstr(param,tesd2,1))
  748. X            goto RETURN;
  749. X        if(erc = skip_paren(param,0))
  750. X            goto RETURN;
  751. X
  752. X        erc = regexp_operation(tesd1->pb,tesd2->pb,value);
  753. X        break;
  754. X
  755. X    case FImhack:
  756. X        ftime(&now_timeb);
  757. X        *value = ((now_timeb.time - starting_timeb.time) * 1000) +
  758. X                (now_timeb.millitm - starting_timeb.millitm);
  759. X        erc = 0;
  760. X        break;
  761. X
  762. X    case FIesecs:
  763. X        ftime(&now_timeb);
  764. X        *value = now_timeb.time;
  765. X        erc = 0;
  766. X        break;
  767. X
  768. X    case FIargc:
  769. X        if(!proc_level)
  770. X        {
  771. X            pputs("not executing procedure\n");
  772. X            erc = eFATAL_ALREADY;
  773. X            break;
  774. X        }
  775. X        *value = (long)pcb_stack[proc_level - 1]->argc;
  776. X        break;
  777. X
  778. X    case FIcolors:
  779. X        if(erc = ifunc_colors(value))
  780. X            goto RETURN;
  781. X        break;
  782. X
  783. X    case FIftell:
  784. X        if(erc = ifunc_ftell(param,value))
  785. X            goto RETURN;
  786. X        break;
  787. X
  788. X    case FIfmode:
  789. X        if(erc = ifunc_fmode(param,value))
  790. X            goto RETURN;
  791. X        break;
  792. X
  793. X    case FIfsize:
  794. X        if(erc = ifunc_fsize(param,value))
  795. X            goto RETURN;
  796. X        break;
  797. X
  798. X    case FIfmtime:
  799. X        if(erc = ifunc_fmtime(param,value))
  800. X            goto RETURN;
  801. X        break;
  802. X
  803. X    case FIfatime:
  804. X        if(erc = ifunc_fatime(param,value))
  805. X            goto RETURN;
  806. X        break;
  807. X
  808. X    case FIischr:
  809. X        if(erc = ifunc_ischr(param,value))
  810. X            goto RETURN;
  811. X        break;
  812. X
  813. X    case FIisdir:
  814. X        if(erc = ifunc_isdir(param,value))
  815. X            goto RETURN;
  816. X        break;
  817. X
  818. X    case FIisreg:
  819. X        if(erc = ifunc_isreg(param,value))
  820. X            goto RETURN;
  821. X        break;
  822. X
  823. X    case FIbaud:
  824. X        *value = (long)shm->Lbaud;
  825. X        erc = 0;
  826. X        break;
  827. X
  828. X    case FIpid:
  829. X        *value = (long)getpid();
  830. X        erc = 0;
  831. X        break;
  832. X
  833. X    case FIcsec:
  834. X        *value = (shm->Lconnected) ? shm->Loff_hook_time : -1;
  835. X        erc = 0;
  836. X        break;
  837. X
  838. X    case FIconn:
  839. X        if(shm->Liofd < 0)
  840. X            *value = -1;
  841. X        else
  842. X            *value = (long)(shm->Lconnected) ? (long)shm->Liofd : 0;
  843. X        erc = 0;
  844. X        break;
  845. X
  846. X    case FIxchr:
  847. X        *value = shm->xmit_chars;
  848. X        erc = 0;
  849. X        break;
  850. X
  851. X    case FIxchrc:
  852. X        *value = shm->xmit_chars_this_connect;
  853. X        erc = 0;
  854. X        break;
  855. X
  856. X    case FIrchr:
  857. X        *value = shm->rcvd_chars;
  858. X        erc = 0;
  859. X        break;
  860. X
  861. X    case FIrchrc:
  862. X        *value = shm->rcvd_chars_this_connect;
  863. X        erc = 0;
  864. X        break;
  865. X
  866. X/* LGETC($I0) get char from line, waiting for $I0 msec
  867. Xreturns  character read or -1 if none read in time */
  868. X    case FIlgetc:
  869. X        if(erc = skip_paren(param,1))
  870. X            goto RETURN;
  871. X        if(erc = gint(param,&int1))
  872. X            goto RETURN;
  873. X        if(erc = skip_paren(param,0))
  874. X            goto RETURN;
  875. X        *value = (long)lgetc_timeout(int1);
  876. X        if(zero_length_read_detected)
  877. X        {
  878. X            zero_length_read_detected = 0;
  879. X            erc = eProcAttn_DCDloss;
  880. X        }
  881. X        break;
  882. X
  883. X    case FIctoi:
  884. X        if(!(tesd1 = esdalloc(256)))
  885. X        {
  886. X            erc = eNoMemory;
  887. X            goto RETURN;
  888. X        }
  889. X        if(erc = skip_paren(param,1))
  890. X            goto RETURN;
  891. X        if(erc = gstr(param,tesd1,1))
  892. X            goto RETURN;
  893. X        if(erc = skip_paren(param,0))
  894. X            goto RETURN;
  895. X        if(tesd1->cb == 0)
  896. X            *value = -1;
  897. X        else
  898. X            *value = (long)((unsigned)0xFF & (unsigned)tesd1->pb[0]);
  899. X        break;
  900. X
  901. X    case FIstoi:
  902. X        if(!(tesd1 = esdalloc(256)))
  903. X        {
  904. X            erc = eNoMemory;
  905. X            goto RETURN;
  906. X        }
  907. X        if(erc = skip_paren(param,1))
  908. X            goto RETURN;
  909. X        if(erc = gstr(param,tesd1,1))
  910. X            goto RETURN;
  911. X        if(erc = skip_paren(param,0))
  912. X            goto RETURN;
  913. X
  914. X        tesd1->index = 0;
  915. X        skip_cmd_break(tesd1);
  916. X        *value = 0;
  917. X        gint_constant(tesd1,value);
  918. X        break;
  919. X
  920. X    case FIcurx:
  921. X        *value = (long)shm->cursor_x;
  922. X        break;
  923. X
  924. X    case FIcury:
  925. X        *value = (long)shm->cursor_y;
  926. X        break;
  927. X
  928. X    case FIshmid:
  929. X        *value = (long)shm_shmid;
  930. X        break;
  931. X
  932. X    case FIisalpha:
  933. X    case FIisupper:
  934. X    case FIislower:
  935. X    case FIisdigit:
  936. X    case FIisxdigit:
  937. X    case FIisspace:
  938. X    case FIispunct:
  939. X    case FIisalnum:
  940. X    case FIisprint:
  941. X    case FIisgraph:
  942. X    case FIiscntrl:
  943. X    case FIisascii:
  944. X        if(!(tesd1 = esdalloc(256)))
  945. X        {
  946. X            erc = eNoMemory;
  947. X            goto RETURN;
  948. X        }
  949. X        if(erc = skip_paren(param,1))
  950. X            goto RETURN;
  951. X        if(erc = gstr(param,tesd1,1))
  952. X            goto RETURN;
  953. X        if(erc = skip_paren(param,0))
  954. X            goto RETURN;
  955. X        if(!tesd1->cb)
  956. X        {
  957. X            *value = 0;
  958. X            goto RETURN;
  959. X        }
  960. X        switch(keyword_token)
  961. X        {
  962. X            case FIisalpha:
  963. X                *value = !!isalpha(*tesd1->pb);
  964. X                break;
  965. X            case FIisupper:
  966. X                *value = !!isupper(*tesd1->pb);
  967. X                break;
  968. X            case FIislower:
  969. X                *value = !!islower(*tesd1->pb);
  970. X                break;
  971. X            case FIisdigit:
  972. X                *value = !!isdigit(*tesd1->pb);
  973. X                break;
  974. X            case FIisxdigit:
  975. X                *value = !!isxdigit(*tesd1->pb);
  976. X                break;
  977. X            case FIisspace:
  978. X                *value = !!isspace(*tesd1->pb);
  979. X                break;
  980. X            case FIispunct:
  981. X                *value = !!ispunct(*tesd1->pb);
  982. X                break;
  983. X            case FIisalnum:
  984. X                *value = !!isalnum(*tesd1->pb);
  985. X                break;
  986. X            case FIisprint:
  987. X                *value = !!isprint(*tesd1->pb);
  988. X                break;
  989. X            case FIisgraph:
  990. X                *value = !!isgraph(*tesd1->pb);
  991. X                break;
  992. X            case FIiscntrl:
  993. X                *value = !!iscntrl(*tesd1->pb);
  994. X                break;
  995. X            case FIisascii:
  996. X                *value = !!isascii(*tesd1->pb);
  997. X                break;
  998. X        }
  999. X        break;
  1000. X
  1001. X    case FIlines:
  1002. X        *value = (long)tcap_LINES;
  1003. X        break;
  1004. X
  1005. X    case FIcols:
  1006. X        *value = (long)tcap_COLS;
  1007. X        break;
  1008. X
  1009. X#if defined(FASI)
  1010. X    case FIfasi:
  1011. X        *value = 1;
  1012. X        break;
  1013. X    case FImsr:
  1014. X        *value = (long)fasi_msr();
  1015. X        break;
  1016. X    case FIlnerr:
  1017. X        *value = (long)fasi_line_errors();
  1018. X        break;
  1019. X    case FIridet:
  1020. X        *value = (long)fasi_rings_detected();
  1021. X        break;
  1022. X    case FIbrdet:
  1023. X        *value = (long)fasi_breaks_detected();
  1024. X        break;
  1025. X#else
  1026. X    case FIfasi:
  1027. X        *value = 0;
  1028. X        break;
  1029. X#endif
  1030. X
  1031. X    case FInice:
  1032. X        *value = (long)nice(0) + 20;
  1033. X        erc = 0;
  1034. X        break;
  1035. X
  1036. X    case FIuid:
  1037. X        *value = (long)getuid();
  1038. X        erc = 0;
  1039. X        break;
  1040. X
  1041. X    case FIgid:
  1042. X        *value = (long)getgid();
  1043. X        erc = 0;
  1044. X        break;
  1045. X
  1046. X    default:
  1047. X        erc = eInvalidFunction;
  1048. X    }   /* end of keyword lookup erc switch statement */
  1049. X
  1050. XRETURN:
  1051. X    if(tesd1)
  1052. X        esdfree(tesd1);
  1053. X    if(tesd2)
  1054. X        esdfree(tesd2);
  1055. X    return(erc);
  1056. X
  1057. X}   /* end of feval_int() */
  1058. X
  1059. X/*+------------------------------------------------------------------
  1060. X    strfunc_left(param,&scratch_esd,&result_esd)
  1061. X-------------------------------------------------------------------*/
  1062. Xint
  1063. Xstrfunc_left(param,scratch_esd,result_esd)
  1064. XESD *param;
  1065. XESD *scratch_esd;
  1066. XESD *result_esd;
  1067. X{
  1068. Xregister erc;
  1069. Xint itmp;
  1070. Xlong ltmp;
  1071. X
  1072. X    if(erc = skip_paren(param,1))
  1073. X        return(erc);
  1074. X    if(erc = gstr(param,scratch_esd,1))
  1075. X        return(erc);
  1076. X    if(erc = skip_comma(param))
  1077. X        return(erc);
  1078. X    if(erc = gint(param,<mp))
  1079. X        return(erc);
  1080. X    itmp = (int)ltmp;
  1081. X    if(itmp < 0)
  1082. X        return(eBadParameter);
  1083. X    if(erc = skip_paren(param,0))
  1084. X        return(erc);
  1085. X    /* take min of param and .cb */
  1086. X    itmp = (itmp < scratch_esd->cb) ? itmp : scratch_esd->cb;
  1087. X    if(itmp > (result_esd->maxcb - result_esd->cb) )
  1088. X        return(eBufferTooSmall);
  1089. X    memcpy(&result_esd->pb[result_esd->cb],
  1090. X        scratch_esd->pb,itmp);
  1091. X    result_esd->cb += itmp;
  1092. X    return(erc);
  1093. X}   /* end of strfunc_left() */
  1094. X
  1095. X/*+-------------------------------------------------------------------------
  1096. X    erc = strfunc_right(param,&scratch_esd,&result_esd)
  1097. X--------------------------------------------------------------------------*/
  1098. Xint
  1099. Xstrfunc_right(param,scratch_esd,result_esd)
  1100. XESD *param;
  1101. XESD *scratch_esd;
  1102. XESD *result_esd;
  1103. X{
  1104. Xregister erc;
  1105. Xint itmp;
  1106. Xlong ltmp;
  1107. X
  1108. X    if(erc = skip_paren(param,1))
  1109. X        return(erc);
  1110. X    if(erc = gstr(param,scratch_esd,1))
  1111. X        return(erc);
  1112. X    if(erc = skip_comma(param))
  1113. X        return(erc);
  1114. X    if(erc = gint(param,<mp))
  1115. X        return(erc);
  1116. X    itmp = (int)ltmp;
  1117. X    if(itmp < 0)
  1118. X        return(eBadParameter);
  1119. X    if(erc = skip_paren(param,0))
  1120. X        return(erc);
  1121. X
  1122. X/* take min of param and .cb */
  1123. X    itmp = (itmp < scratch_esd->cb) ? itmp : scratch_esd->cb;
  1124. X    if(itmp > (result_esd->maxcb - result_esd->cb) )
  1125. X        return(eBufferTooSmall);
  1126. X    memcpy(&result_esd->pb[result_esd->cb],
  1127. X        &scratch_esd->pb[scratch_esd->cb - itmp],itmp);
  1128. X    result_esd->cb += itmp;
  1129. X    return(0);
  1130. X
  1131. X}   /* end of strfunc_right() */
  1132. X
  1133. X/*+-------------------------------------------------------------------------
  1134. X    erc = feval_str(param,&esd_to_be_plugged);
  1135. X    results are APPENDED to 'result_esd'
  1136. X--------------------------------------------------------------------------*/
  1137. Xfeval_str(param,result_esd)
  1138. XESD *param;
  1139. XESD *result_esd;
  1140. X{
  1141. Xregister erc;
  1142. Xregister itmp;
  1143. Xint int1,int2;
  1144. Xchar s64[64];
  1145. Xchar *cptr;
  1146. Xlong ltmp;
  1147. Xlong ltmp2;
  1148. Xlong ltmp3;
  1149. XESD *tesd1;
  1150. XESD *tesd2 = (ESD *)0;
  1151. Xchar *get_ttyname();
  1152. Xchar *getenv();
  1153. Xchar *cuserid();
  1154. Xchar *get_elapsed_time();
  1155. Xchar *mode_map();
  1156. X
  1157. X    if(!(tesd1 = esdalloc(128)))
  1158. X        return(eNoMemory);
  1159. X
  1160. X    if(erc = get_alphanum_zstr(param,s64,sizeof(s64)-1))
  1161. X    {
  1162. X        esdfree(tesd1);
  1163. X        return(eInvalidFunction);
  1164. X    }
  1165. X
  1166. X    erc = 0;
  1167. X    itmp=keyword_lookup(feval_str_tbl,s64);
  1168. X    switch(itmp)
  1169. X    {
  1170. X/* LEFT($S0,$I0)   return leftmost $I0 characters of $S0 */
  1171. X    case FSleft:
  1172. X        erc = strfunc_left(param,tesd1,result_esd);
  1173. X        break;
  1174. X
  1175. X/* RIGHT($S0,$I0)   return rightmost $I0 characters of $S0 */
  1176. X    case FSright:
  1177. X        erc = strfunc_right(param,tesd1,result_esd);
  1178. X        break;
  1179. X
  1180. X/* MID($S0,$I0,$I1)   return middle $I1 chars of $S0 starting at $I0 */
  1181. X    case FSmid:
  1182. X        if(erc = skip_paren(param,1))
  1183. X            break;
  1184. X        if(erc = gstr(param,tesd1,1))
  1185. X            break;
  1186. X        if(erc = skip_comma(param))
  1187. X            break;
  1188. X        if(erc = gint(param,<mp))
  1189. X            break;
  1190. X        int1 = (int)ltmp;
  1191. X        if(int1 < 0)
  1192. X        {
  1193. X            erc = eBadParameter;
  1194. X            break;
  1195. X        }
  1196. X        if(erc = skip_cmd_break(param))
  1197. X            break;
  1198. X        if(param->pb[param->index] == ')') /* if we find a ')' instead of ... */
  1199. X        {                                  /* 2nd int param, default to max */
  1200. X            ++param->index;
  1201. X            int2 = 256;
  1202. X        }
  1203. X        else
  1204. X        {
  1205. X            if(erc = skip_comma(param))
  1206. X                break;
  1207. X            if(erc = gint(param,<mp))
  1208. X                break;
  1209. X            int2 = (int)ltmp;
  1210. X            if(int2 < 0)
  1211. X            {
  1212. X                erc = eBadParameter;
  1213. X                break;
  1214. X            }
  1215. X            if(erc = skip_paren(param,0))
  1216. X                break;
  1217. X        }
  1218. X
  1219. X        if(int1 >= tesd1->cb) /* if initial index past end of string */
  1220. X            break;
  1221. X        itmp = tesd1->cb - int1;
  1222. X        itmp = (int2 < itmp) ? int2 : itmp;
  1223. X        cptr = tesd1->pb + int1;
  1224. X        goto CPTR_ITMP_COMMON;
  1225. X
  1226. X/* ARGV($I0) */
  1227. X    case FSargv:
  1228. X        if(!proc_level)
  1229. X        {
  1230. X            pputs("not executing procedure\n");
  1231. X            erc = eFATAL_ALREADY;
  1232. X            break;
  1233. X        }
  1234. X        if(erc = skip_paren(param,1))
  1235. X            break;
  1236. X        if(erc = gint(param,<mp))
  1237. X            break;
  1238. X        if(erc = skip_paren(param,0))
  1239. X            break;
  1240. X        itmp = (long)pcb_stack[proc_level - 1]->argc; /* arg count */
  1241. X        if((int)ltmp > itmp - 1)
  1242. X        {
  1243. X            if(proctrace)
  1244. X            {
  1245. X                pprintf("WARNING: %%argc=%d, %%argv(%ld) null\n",
  1246. X                    itmp,ltmp);
  1247. X            }
  1248. X            break;
  1249. X        }
  1250. X        cptr = (pcb_stack[proc_level - 1])->argv[(int)ltmp];
  1251. X        itmp = strlen(cptr);
  1252. X        goto CPTR_ITMP_COMMON;
  1253. X
  1254. X    case FSdir:
  1255. X        cptr = curr_dir;
  1256. X        itmp = strlen(curr_dir);
  1257. X        goto CPTR_ITMP_COMMON;
  1258. X
  1259. X    case FSetime:
  1260. X        if(erc = skip_paren(param,1))
  1261. X            break;
  1262. X        if(erc = gint(param,<mp))
  1263. X            break;
  1264. X        if(erc = skip_paren(param,0))
  1265. X            break;
  1266. X        cptr = get_elapsed_time(ltmp);
  1267. X        itmp = strlen(cptr);
  1268. X        goto CPTR_ITMP_COMMON;
  1269. X
  1270. X    case FSerrstr:
  1271. X        if(erc = skip_paren(param,1))
  1272. X            break;
  1273. X        if(erc = gint(param,<mp))
  1274. X            break;
  1275. X        if(erc = skip_paren(param,0))
  1276. X            break;
  1277. X        cptr = errno_text((int)ltmp);
  1278. X        itmp = strlen(cptr);
  1279. X        goto CPTR_ITMP_COMMON;
  1280. X
  1281. X    case FSenvvar:
  1282. X        if(erc = skip_paren(param,1))
  1283. X            break;
  1284. X        if(erc = gstr(param,tesd1,1))
  1285. X            break;
  1286. X        if(erc = skip_paren(param,0))
  1287. X            break;
  1288. X        if(!(cptr = getenv(tesd1->pb)))
  1289. X            break;
  1290. X        itmp = strlen(cptr);
  1291. X        goto CPTR_ITMP_COMMON;
  1292. X
  1293. X    case FSlogname:
  1294. X        if(!(cptr = cuserid((char *)0)))
  1295. X            break;
  1296. X        itmp = strlen(cptr);
  1297. X        goto CPTR_ITMP_COMMON;
  1298. X
  1299. X    case FSfmodestr:
  1300. X        if(erc = skip_paren(param,1))
  1301. X            break;
  1302. X        if(erc = gint(param,<mp))
  1303. X            break;
  1304. X        if(erc = skip_paren(param,0))
  1305. X            break;
  1306. X        cptr = mode_map((ushort)ltmp,(char *)0);
  1307. X        itmp = strlen(cptr);
  1308. X        goto CPTR_ITMP_COMMON;
  1309. X
  1310. X    case FStty:
  1311. X        cptr = get_ttyname();
  1312. X        itmp = strlen(cptr);
  1313. X        goto CPTR_ITMP_COMMON;
  1314. X
  1315. X    case FSuname:
  1316. X    {
  1317. X        struct utsname utsn;
  1318. X#ifdef M_SYSV /* SCO */
  1319. X        FILE *fp = fopen("/etc/systemid","r");
  1320. X        if(fp)
  1321. X        {
  1322. X            s64[0] = 0;
  1323. X            fgets(s64,sizeof(s64),fp);
  1324. X            fclose(fp);
  1325. X            if(itmp = strlen(s64))
  1326. X            {
  1327. X                if(*(cptr = s64 + itmp - 1) == '\n')
  1328. X                    *cptr = 0,itmp--;
  1329. X                strip_trail_break(s64);
  1330. X                cptr = s64;
  1331. X                itmp = strlen(cptr);
  1332. X                goto CPTR_ITMP_COMMON;
  1333. X            }
  1334. X        }
  1335. X#endif
  1336. X        if(uname(&utsn) == -1)
  1337. X        {
  1338. X            pperror("uname");
  1339. X            erc = eFATAL_ALREADY;
  1340. X            break;
  1341. X        }
  1342. X        cptr = utsn.sysname;
  1343. X        itmp = strlen(cptr);
  1344. X        goto CPTR_ITMP_COMMON;
  1345. X    } /* end of case FSuname */
  1346. X
  1347. X    case FSrname:
  1348. X        if(!shm->Lconnected)
  1349. X            break;
  1350. X        cptr = shm->Lrname;
  1351. X        itmp = strlen(shm->Lrname);
  1352. X        goto CPTR_ITMP_COMMON;
  1353. X
  1354. X    case FSrdesc:
  1355. X        if(!shm->Lconnected)
  1356. X            break;
  1357. X        cptr = shm->Ldescr;
  1358. X        itmp = strlen(shm->Ldescr);
  1359. X        goto CPTR_ITMP_COMMON;
  1360. X
  1361. X    case FSrtel:
  1362. X        if(!shm->Lconnected)
  1363. X            break;
  1364. X        cptr = shm->Ltelno;
  1365. X        itmp = strlen(shm->Ltelno);
  1366. X        goto CPTR_ITMP_COMMON;
  1367. X
  1368. X    case FSline:
  1369. X        cptr = shm->Lline;
  1370. X        itmp = strlen(shm->Lline);
  1371. X        goto CPTR_ITMP_COMMON;
  1372. X
  1373. X    case FSmonth:
  1374. X    case FSmonthz:
  1375. X        cptr = &month_name_list[(get_month(itmp == FSmonthz) - 1) * 3];
  1376. X        itmp = 3;
  1377. X        goto CPTR_ITMP_COMMON;
  1378. X
  1379. X    case FSday:
  1380. X    case FSdayz:
  1381. X        cptr = &day_of_week_list[get_day(itmp == FSdayz) * 3];
  1382. X        itmp = 3;
  1383. X        goto CPTR_ITMP_COMMON;
  1384. X
  1385. X    case FSscreen:
  1386. X        if(erc = skip_paren(param,1))
  1387. X            break;
  1388. X        if(erc = gint(param,<mp))        /* y */
  1389. X            break;
  1390. X        if(ltmp > 42)
  1391. X        {
  1392. X            erc = eBadParameter;
  1393. X            break;
  1394. X        }
  1395. X        if(erc = skip_comma(param))
  1396. X            break;
  1397. X        if(erc = gint(param,<mp2))    /* x */
  1398. X            break;
  1399. X        if(ltmp2 > 79)
  1400. X        {
  1401. X            erc = eBadParameter;
  1402. X            break;
  1403. X        }
  1404. X        if(erc = skip_comma(param))
  1405. X            break;
  1406. X        if(erc = gint(param,<mp3))    /* len */
  1407. X            break;
  1408. X        if(erc = skip_paren(param,0))
  1409. X            break;
  1410. X
  1411. X        int1 = ((int)ltmp * 80) + (int)ltmp2;    /* screen position */
  1412. X        itmp = (int)ltmp3;                        /* length */
  1413. X        int2 = sizeof(shm->screen) - int1;        /* size from y,x to end */
  1414. X        if(itmp > int2)
  1415. X            itmp = int2;
  1416. X        cptr = ((char *)shm->screen) + int1;
  1417. X        goto CPTR_ITMP_COMMON;
  1418. X
  1419. X    case FSbasename:
  1420. X        if(!(tesd2 = esdalloc(32)))
  1421. X            return(eNoMemory);
  1422. X        if(erc = skip_paren(param,1))
  1423. X            break;
  1424. X        if(erc = gstr(param,tesd1,1))
  1425. X            break;
  1426. X        if(erc = skip_comma(param))
  1427. X            break;
  1428. X        if(erc = gstr(param,tesd2,1))
  1429. X            break;
  1430. X        if(erc = skip_paren(param,0))
  1431. X            break;
  1432. X        cptr = tesd1->pb;
  1433. X        itmp = tesd1->cb;
  1434. X        if((tesd1->cb >= tesd2->cb) &&
  1435. X            !strcmp(cptr + tesd1->cb - tesd2->cb,tesd2->pb))
  1436. X        {
  1437. X            itmp -= tesd2->cb;
  1438. X        }
  1439. X        goto CPTR_ITMP_COMMON;
  1440. X
  1441. X    case FSdirpart:
  1442. X        if(erc = skip_paren(param,1))
  1443. X            break;
  1444. X        if(erc = gstr(param,tesd1,1))
  1445. X            break;
  1446. X        if(erc = skip_paren(param,0))
  1447. X            break;
  1448. X        if(cptr = strrchr(tesd1->pb,'/'))
  1449. X            itmp = cptr - tesd1->pb;
  1450. X        else
  1451. X            itmp = tesd1->cb;
  1452. X        cptr = tesd1->pb;
  1453. X        goto CPTR_ITMP_COMMON;
  1454. X
  1455. X    case FSfilepart:
  1456. X        if(erc = skip_paren(param,1))
  1457. X            break;
  1458. X        if(erc = gstr(param,tesd1,1))
  1459. X            break;
  1460. X        if(erc = skip_paren(param,0))
  1461. X            break;
  1462. X        if(cptr = strrchr(tesd1->pb,'/'))
  1463. X            itmp = strlen(++cptr);
  1464. X        else
  1465. X        {
  1466. X            cptr = tesd1->pb;
  1467. X            itmp = tesd1->cb;
  1468. X        }
  1469. X        goto CPTR_ITMP_COMMON;
  1470. X
  1471. X#if defined(FASI)
  1472. X    case FSmsrtext:
  1473. X        cptr = msr_text(fasi_msr());
  1474. X        itmp = strlen(cptr);
  1475. X        goto CPTR_ITMP_COMMON;
  1476. X#endif
  1477. X
  1478. XCPTR_ITMP_COMMON:
  1479. X        if( itmp > (result_esd->maxcb - result_esd->cb))
  1480. X        {
  1481. X            erc = eBufferTooSmall;
  1482. X            break;
  1483. X        }
  1484. X        memcpy(&result_esd->pb[result_esd->cb],cptr,itmp);
  1485. X        result_esd->cb += itmp;
  1486. X        break;
  1487. X
  1488. X    case FSedate:
  1489. X        if(erc = skip_paren(param,1))
  1490. X            break;
  1491. X        if(erc = gint(param,<mp))
  1492. X            break;
  1493. X        if(erc = skip_paren(param,0))
  1494. X            break;
  1495. X        if(19 > (result_esd->maxcb - result_esd->cb))
  1496. X        {
  1497. X            erc = eBufferTooSmall;
  1498. X            break;
  1499. X        }
  1500. X        epoch_secs_to_str(ltmp,3,&result_esd->pb[result_esd->cb]);
  1501. X        result_esd->cb += 19;
  1502. X        break;
  1503. X
  1504. X    case FStime:
  1505. X        if(5 > (result_esd->maxcb - result_esd->cb))
  1506. X        {
  1507. X            erc = eBufferTooSmall;
  1508. X            break;
  1509. X        }
  1510. X        get_tod(0,&result_esd->pb[result_esd->cb]);
  1511. X        result_esd->cb += 5;
  1512. X        break;
  1513. X
  1514. X    case FStimes:
  1515. X        if(8 > (result_esd->maxcb - result_esd->cb))
  1516. X        {
  1517. X            erc = eBufferTooSmall;
  1518. X            break;
  1519. X        }
  1520. X        get_tod(1,&result_esd->pb[result_esd->cb]);
  1521. X        result_esd->cb += 8;
  1522. X        break;
  1523. X
  1524. X    case FStimez:
  1525. X        if(5 > (result_esd->maxcb - result_esd->cb))
  1526. X        {
  1527. X            erc = eBufferTooSmall;
  1528. X            break;
  1529. X        }
  1530. X        get_tod(6,&result_esd->pb[result_esd->cb]);
  1531. X        result_esd->cb += 5;
  1532. X        break;
  1533. X
  1534. X    case FStimezs:
  1535. X        if(8 > (result_esd->maxcb - result_esd->cb))
  1536. X        {
  1537. X            erc = eBufferTooSmall;
  1538. X            break;
  1539. X        }
  1540. X        get_tod(7,&result_esd->pb[result_esd->cb]);
  1541. X        result_esd->cb += 8;
  1542. X        break;
  1543. X
  1544. X    case FSdate:
  1545. X        if(10 > (result_esd->maxcb - result_esd->cb))
  1546. X        {
  1547. X            erc = eBufferTooSmall;
  1548. X            break;
  1549. X        }
  1550. X        get_tod(5,&result_esd->pb[result_esd->cb]);
  1551. X        result_esd->cb += 10;
  1552. X        break;
  1553. X
  1554. X    case FSdatez:
  1555. X        if(10 > (result_esd->maxcb - result_esd->cb))
  1556. X        {
  1557. X            erc = eBufferTooSmall;
  1558. X            break;
  1559. X        }
  1560. X        get_tod(8,&result_esd->pb[result_esd->cb]);
  1561. X        result_esd->cb += 10;
  1562. X        break;
  1563. X
  1564. X    case FScgets:
  1565. X        erc = ttygets_esd(result_esd,TG_CRLF,1);
  1566. X        break;
  1567. X
  1568. X    case FScgetc:
  1569. X        if(result_esd->cb == result_esd->maxcb)
  1570. X        {
  1571. X            erc = eBufferTooSmall;
  1572. X            break;
  1573. X        }
  1574. X        result_esd->pb[result_esd->cb] = ttygetc(0);
  1575. X        result_esd->cb++;
  1576. X        break;
  1577. X
  1578. X    case FSchr:
  1579. X        if(erc = skip_paren(param,1))
  1580. X            break;
  1581. X        if(erc = gint(param,<mp))
  1582. X            break;
  1583. X        if(!ltmp)
  1584. X        {
  1585. X            pputs("cannot use %chr(0)\n");
  1586. X            return(eFATAL_ALREADY);
  1587. X        }
  1588. X        if(erc = skip_paren(param,0))
  1589. X            break;
  1590. X        if(result_esd->cb == result_esd->maxcb )
  1591. X        {
  1592. X            erc = eBufferTooSmall;
  1593. X            break;
  1594. X        }
  1595. X        result_esd->pb[result_esd->cb] = (char)ltmp;
  1596. X        result_esd->cb++;
  1597. X        break;
  1598. X
  1599. X    case FSitos:
  1600. X        if(erc = skip_paren(param,1))
  1601. X            break;
  1602. X        if(erc = gint(param,<mp))
  1603. X            break;
  1604. X        s64[0] = 0;
  1605. X        if(!skip_comma(param))
  1606. X        {
  1607. X            if(erc = get_numeric_zstr(param,s64 + 1,sizeof(s64) - 4))
  1608. X                strcpy(s64 + 1,"1");
  1609. X            if(((itmp = atoi(s64 + 1)) < 0) ||
  1610. X                (itmp > (result_esd->maxcb - result_esd->cb)))
  1611. X            {
  1612. X                erc = eBufferTooSmall;
  1613. X                break;
  1614. X            }
  1615. X            s64[0] = '%';
  1616. X            if(ulindex(param->pb + param->index,"x") == 0)
  1617. X            {
  1618. X                param->index++;
  1619. X                strcat(s64,"lx");
  1620. X            }
  1621. X            else if(ulindex(param->pb + param->index,"o") == 0)
  1622. X            {
  1623. X                param->index++;
  1624. X                strcat(s64,"lo");
  1625. X            }
  1626. X            else if(ulindex(param->pb + param->index,"d") == 0)
  1627. X            {
  1628. X                param->index++;
  1629. X                strcat(s64,"ld");
  1630. X            }
  1631. X            else if(erc)
  1632. X                break;
  1633. X            else
  1634. X                strcat(s64,"ld");
  1635. X        }
  1636. X        if(erc = skip_paren(param,0))
  1637. X            break;
  1638. X        sprintf(tesd1->pb,s64[0] ? s64 : "%ld",ltmp);
  1639. X        tesd1->cb = strlen(tesd1->pb);
  1640. X        if(result_esd->maxcb - result_esd->cb < tesd1->cb)
  1641. X        {
  1642. X            erc = eBufferTooSmall;
  1643. X            break;
  1644. X        }
  1645. X        strcpy(&result_esd->pb[result_esd->cb],tesd1->pb);
  1646. X        result_esd->cb += tesd1->cb;
  1647. X        break;
  1648. X
  1649. X
  1650. X    default:
  1651. X        erc = eInvalidFunction;
  1652. X        break;
  1653. X    }   /* end of keyword lookup erc switch statement */
  1654. X
  1655. X    esd_null_terminate(result_esd);
  1656. X    esdfree(tesd1);
  1657. X    if(tesd2)
  1658. X        esdfree(tesd2);
  1659. X    return(erc);
  1660. X
  1661. X}   /* end of feval_str() */
  1662. X
  1663. X/* vi: set tabstop=4 shiftwidth=4: */
  1664. X/* end of feval.c */
  1665. SHAR_EOF
  1666. chmod 0644 feval.c ||
  1667. echo 'restore of feval.c failed'
  1668. Wc_c="`wc -c < 'feval.c'`"
  1669. test 25046 -eq "$Wc_c" ||
  1670.     echo 'feval.c: original size 25046, current size' "$Wc_c"
  1671. rm -f _shar_wnt_.tmp
  1672. fi
  1673. # ============= feval.h ==============
  1674. if test -f 'feval.h' -a X"$1" != X"-c"; then
  1675.     echo 'x - skipping feval.h (File already exists)'
  1676.     rm -f _shar_wnt_.tmp
  1677. else
  1678. > _shar_wnt_.tmp
  1679. echo 'x - extracting feval.h (Text)'
  1680. sed 's/^X//' << 'SHAR_EOF' > 'feval.h' &&
  1681. X/*+-------------------------------------------------------------------------
  1682. X    feval.h
  1683. X    wht@n4hgf.Mt-Park.GA.US
  1684. X--------------------------------------------------------------------------*/
  1685. X/*+:EDITS:*/
  1686. X/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
  1687. X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
  1688. X/*:03-27-1992-16:21-wht@n4hgf-re-include protection for all .h files */
  1689. X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
  1690. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  1691. X
  1692. X#ifndef _feval_h
  1693. X#define _feval_h
  1694. X
  1695. X#define FIinstr        1
  1696. X#define FIlen        2
  1697. X#define FIstoi        3
  1698. X#define FIctoi        4
  1699. X#define FIbaud        5
  1700. X#define FIconn        6
  1701. X#define FIcsec        7
  1702. X#define FIpid        8
  1703. X#define FIrchr        9
  1704. X#define FIrchrc        10
  1705. X#define FIxchr        11
  1706. X#define FIxchrc        12
  1707. X#define FIlgetc        13
  1708. X#define FIargc        14
  1709. X#define FIftell        15
  1710. X#define FIfmode        16
  1711. X#define FIisdir        17
  1712. X#define FIisreg        18
  1713. X#define FIischr        19
  1714. X#define FIfatime    20
  1715. X#define FIfmtime    21
  1716. X#define FIfsize        22
  1717. X#define FIcolors    23
  1718. X
  1719. X
  1720. XKEYTAB feval_int_tbl[] =
  1721. X{
  1722. X    {"argc",FIargc},
  1723. X    {"baud",FIbaud},
  1724. X    {"colors",FIcolors},
  1725. X    {"conn",FIconn},
  1726. X    {"csec",FIcsec},
  1727. X    {"ctoi",FIctoi},
  1728. X    {"fatime",FIfatime},
  1729. X    {"fmode",FIfmode},
  1730. X    {"fmtime",FIfmtime},
  1731. X    {"fsize",FIfsize},
  1732. X    {"ftell",FIftell},
  1733. X    {"instr",FIinstr},
  1734. X    {"ischr",FIischr},
  1735. X    {"isdir",FIisdir},
  1736. X    {"isreg",FIisreg},
  1737. X    {"len",FIlen},
  1738. X    {"lgetc",FIlgetc},
  1739. X    {"pid",FIpid},
  1740. X    {"rchr",FIrchr},
  1741. X    {"rchrc",FIrchrc},
  1742. X    {"stoi",FIstoi},
  1743. X    {"xchr",FIxchr},
  1744. X    {"xchrc",FIxchrc},
  1745. X    {(char *)0,0}
  1746. X};
  1747. X
  1748. X#define FSleft        2
  1749. X#define FSright        3
  1750. X#define FSmid        4
  1751. X#define FSdate        5
  1752. X#define FSmonth        6
  1753. X#define FSday        7
  1754. X#define FScgets        9
  1755. X#define FScgetc        10
  1756. X#define FSitos        11
  1757. X#define FSchr        12
  1758. X#define FSdir        13
  1759. X#define FStty        14
  1760. X#define FSrdesc        15
  1761. X#define FSrname        16
  1762. X#define FSline        17
  1763. X#define FSrtel        18
  1764. X#define FSargv        19
  1765. X#define FStime        20
  1766. X#define FStimes        21
  1767. X#define FSedate        22
  1768. X#define FSetime        23
  1769. X#define FSgetenv    24
  1770. X#define FSgetlogin    25
  1771. X
  1772. X
  1773. XKEYTAB feval_str_tbl[] =
  1774. X{
  1775. X    {"argv",FSargv},
  1776. X    {"cgetc",FScgetc},
  1777. X    {"cgets",FScgets},
  1778. X    {"chr",FSchr},
  1779. X    {"date",FSdate},
  1780. X    {"day",FSday},
  1781. X    {"dir",FSdir},
  1782. X    {"edate",FSedate},
  1783. X    {"etime",FSetime},
  1784. X    {"getenv",FSgetenv},
  1785. X    {"getlogin",FSgetlogin},
  1786. X    {"itos",FSitos},
  1787. X    {"left",FSleft},
  1788. X    {"line",FSline},
  1789. X    {"mid",FSmid},
  1790. X    {"month",FSmonth},
  1791. X    {"rdesc",FSrdesc},
  1792. X    {"right",FSright},
  1793. X    {"rname",FSrname},
  1794. X    {"rtelno",FSrtel},
  1795. X    {"time",FStime},
  1796. X    {"times",FStimes},
  1797. X    {"tty",FStty},
  1798. X    {(char *)0,0}
  1799. X};
  1800. X
  1801. X#endif /* _feval_h */
  1802. X
  1803. X/* vi: set tabstop=4 shiftwidth=4: */
  1804. X/* end of feval.h */
  1805. SHAR_EOF
  1806. chmod 0644 feval.h ||
  1807. echo 'restore of feval.h failed'
  1808. Wc_c="`wc -c < 'feval.h'`"
  1809. test 2461 -eq "$Wc_c" ||
  1810.     echo 'feval.h: original size 2461, current size' "$Wc_c"
  1811. rm -f _shar_wnt_.tmp
  1812. fi
  1813. # ============= funckeymap.c ==============
  1814. if test -f 'funckeymap.c' -a X"$1" != X"-c"; then
  1815.     echo 'x - skipping funckeymap.c (File already exists)'
  1816.     rm -f _shar_wnt_.tmp
  1817. else
  1818. > _shar_wnt_.tmp
  1819. echo 'x - extracting funckeymap.c (Text)'
  1820. sed 's/^X//' << 'SHAR_EOF' > 'funckeymap.c' &&
  1821. X/* #define NONANSI_DEBUG */
  1822. X/*+-----------------------------------------------------------------
  1823. X    funckeymap.c - keyboard function key -> ECU internal
  1824. X    wht@n4hgf.Mt-Park.GA.US
  1825. X
  1826. X  Defined functions:
  1827. X    fkmap_command(argc,argv)
  1828. X    funckeymap(buf,buflen)
  1829. X    funckeymap_define(bufptr)
  1830. X    funckeymap_display(fp)
  1831. X    funckeymap_display_single(tkde,fp)
  1832. X    funckeymap_init()
  1833. X    funckeymap_read(name)
  1834. X
  1835. X------------------------------------------------------------------*/
  1836. X/*+:EDITS:*/
  1837. X/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
  1838. X/*:08-30-1992-23:06-wht@n4hgf-add fkmap_command */
  1839. X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
  1840. X/*:08-28-1991-14:51-wht@n4hgf2-look correctly for funckeymap in ECULIBDIR */
  1841. X/*:08-26-1991-05:45-wht@n4hgf2-# got included in key def */
  1842. X/*:08-06-1991-13:19-wht@n4hgf-allow any code as first in key sequence */
  1843. X/*:08-03-1991-14:44-wht@n4hgf-look for funckeymap in ECULIBDIR too */
  1844. X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
  1845. X/*:03-20-1991-03:06-root@n4hgf-no Metro Link problems here */
  1846. X/*:03-20-1991-01:04-root@n4hgf-diagnose Metro Link xterm differences */
  1847. X/*:01-10-1991-23:15-wht@n4hgf-string overflow rptd by spooley@compulink.co.uk */
  1848. X/*:12-01-1990-12:51-wht@n4hgf-creation, borrowing from and using ecufkey.c */
  1849. X
  1850. X#include "ecu.h"
  1851. X#include "ecuerror.h"
  1852. X#include "ecukey.h"
  1853. X#include "ecufkey.h"
  1854. X#include "ecuxkey.h"
  1855. X#include "ecufork.h"
  1856. X
  1857. Xextern int tty_not_char_special;
  1858. Xextern char *dash_f_funckeytype;
  1859. X
  1860. XKDE funckeymap_table[KDE_COUNT];
  1861. Xchar funckeymap_name[32] = "";
  1862. X#if defined(NONANSI_DEBUG)
  1863. Xstatic FILE *nadbg = (FILE *)0;
  1864. X#endif
  1865. X
  1866. X/*+-------------------------------------------------------------------------
  1867. X    funckeymap_init() - initialize function key mapping (recognition)
  1868. X--------------------------------------------------------------------------*/
  1869. Xvoid
  1870. Xfunckeymap_init()
  1871. X{
  1872. X    register itmp;
  1873. X    register KDE *tkde;
  1874. X    char *make_char_graphic();
  1875. X
  1876. X    for(itmp = 0; itmp < KDE_COUNT; itmp++)
  1877. X    {
  1878. X        tkde = &funckeymap_table[itmp];
  1879. X        tkde->logical[0] = 0;
  1880. X        tkde->count = 0;
  1881. X        tkde->ikde = 0;
  1882. X    }
  1883. X
  1884. X    funckeymap_name[0] = 0;
  1885. X
  1886. X}    /* end of funckeymap_init */
  1887. X
  1888. X/*+-------------------------------------------------------------------------
  1889. X    funckeymap_define(bufptr) - use funckeymap line to define a mapping
  1890. X
  1891. X  returns 0 good keydef
  1892. X         -1 if syntax error
  1893. X--------------------------------------------------------------------------*/
  1894. Xint
  1895. Xfunckeymap_define(bufptr)
  1896. Xregister char *bufptr;
  1897. X{
  1898. X    register itmp;
  1899. X    register token_number = 0;
  1900. X    KDE *tkde = (KDE *)0;
  1901. X    int ikde = 0;
  1902. X    int octothorpe = 0;
  1903. X    char *token;
  1904. X    char *arg_token();
  1905. X    char *str_token();
  1906. X    char *skip_ld_break();
  1907. X
  1908. X    while(!octothorpe &&
  1909. X       (token = (token_number < 2) ? str_token(bufptr,":")
  1910. X                                   : arg_token(bufptr," \t")))
  1911. X    {
  1912. X        bufptr = (char *)0;    /* further calls to arg_token need NULL */
  1913. X        token = skip_ld_break(token);
  1914. X        strip_trail_break(token);
  1915. X
  1916. X        switch(token_number)
  1917. X        {
  1918. X            case 0:        /* first field is key identifier */
  1919. X                if((ikde = kde_name_to_ikde(token)) < 0)
  1920. X                {
  1921. X                    pprintf("  %s is not a legal key identifier\r\n",token);
  1922. X                    return(-1);
  1923. X                }
  1924. X                tkde = &funckeymap_table[ikde];
  1925. X                tkde->logical[0] = 0;
  1926. X                tkde->count = 0;
  1927. X                tkde->ikde = ikde;
  1928. X                break;
  1929. X
  1930. X            case 1:        /* second field is logical key name */
  1931. X                if(*token == '#')
  1932. X                    goto MISSING_LABEL;
  1933. X                strncpy(tkde->logical,token,sizeof(tkde->logical));
  1934. X                tkde->logical[sizeof(tkde->logical) - 1] = 0;
  1935. X                break;
  1936. X
  1937. X            case 2:        /* third field is first token of sequence */
  1938. X                if(*token == '#')
  1939. X                    goto MISSING_SEQUENCE;
  1940. X
  1941. X            default:    /* third and subsequent to define key */
  1942. X                if(*token == '#')
  1943. X                {
  1944. X                    octothorpe = 1;
  1945. X                    break;
  1946. X                }
  1947. X                if(tkde->count == sizeof(tkde->str))
  1948. X                {
  1949. X                    pprintf("  %s: output count too long",
  1950. X                        keyset_idstr(ikde));
  1951. X                    return(-1);
  1952. X                }
  1953. X                if((itmp = ascii_to_hex(token)) < 0)
  1954. X                {
  1955. X                    pprintf("  %s: '%s' invalid\r\n",
  1956. X                        keyset_idstr(ikde),token);
  1957. X                    return(-1);
  1958. X                }
  1959. X                tkde->str[tkde->count] = itmp;
  1960. X                tkde->count++;
  1961. X                break;
  1962. X        }    /* end of switch(token_number) */
  1963. X
  1964. X        if(octothorpe)
  1965. X            break;
  1966. X
  1967. X        token_number++;
  1968. X
  1969. X    }        /* end while not end of record */
  1970. X
  1971. X    switch(token_number)
  1972. X    {
  1973. X        case 0:
  1974. X            pprintf("funckeymap_define logic error\n");
  1975. X            termecu(TERMECU_LOGIC_ERROR);
  1976. X            break;
  1977. X
  1978. X        case 1:
  1979. XMISSING_LABEL:
  1980. X            pprintf("%s: missing key label\r\n",keyset_idstr(ikde));
  1981. X            break;
  1982. X
  1983. X        case 2:
  1984. XMISSING_SEQUENCE:
  1985. X            pprintf("%s: missing char sequence\r\n",keyset_idstr(ikde));
  1986. X            break;
  1987. X        default:
  1988. X            /* special init string entry */
  1989. X            if(ikde == IKDE_InitStr)
  1990. X                fwrite(tkde->str,1,tkde->count,stderr);
  1991. X            else if(tkde->count)
  1992. X            {
  1993. X                uchar ch = tkde->str[0];
  1994. X                extern uchar kbdeof;        /* current input EOF */
  1995. X                extern uchar kbdeol2;        /* current secondary input EOL */
  1996. X                extern uchar kbdeol;        /* current input EOL */
  1997. X                extern uchar kbderase;        /* current input ERASE */
  1998. X                extern uchar kbdintr;        /* current input INTR */
  1999. X                extern uchar kbdkill;        /* current input KILL */
  2000. X                extern uchar kbdquit;        /* current input QUIT */
  2001. X
  2002. X                if(    (ch == kbdeof) || (ch == kbdeol2) ||
  2003. X                    (ch == kbdeol) || (ch == kbderase) ||
  2004. X                    (ch == kbdintr) || (ch == kbdkill) ||
  2005. X                    (ch == kbdquit) )
  2006. X                {
  2007. X                    pprintf(
  2008. X                        "%s: 1st char cannot be input control character\r\n",
  2009. X                        keyset_idstr(ikde));
  2010. X                    break;
  2011. X                }
  2012. X            }
  2013. X            return(0);
  2014. X    }
  2015. X
  2016. X    return(-1);        /* error */
  2017. X
  2018. X}    /* end of funckeymap_define */
  2019. X
  2020. X/*+-------------------------------------------------------------------------
  2021. X    funckeymap_read(name) - read key-sequence-to-fkey map from funckeymap
  2022. X--------------------------------------------------------------------------*/
  2023. Xvoid
  2024. Xfunckeymap_read(name)
  2025. Xchar *name;
  2026. X{
  2027. X    register itmp;
  2028. X    char buf[128];
  2029. X    FILE *fp_keys;
  2030. X    int errstat = 0;
  2031. X    static char ecukeys_name[128];
  2032. X
  2033. X#if defined(NONANSI_DEBUG)
  2034. X    if(!nadbg)
  2035. X    {
  2036. X        nadbg = fopen("/tmp/nadbg.log","w");
  2037. X        setbuf(nadbg,NULL);
  2038. X    }
  2039. X#endif
  2040. X
  2041. X    funckeymap_init();    /* clear any previous key defns */
  2042. X
  2043. X    if(!ecukeys_name[0])
  2044. X    {
  2045. X        get_home_dir(ecukeys_name);
  2046. X        strcat(ecukeys_name,"/.ecu/funckeymap");
  2047. X    }
  2048. X
  2049. X    if(!(fp_keys = fopen(ecukeys_name,"r")))
  2050. X    {
  2051. X        strcpy(ecukeys_name,eculibdir);
  2052. X        strcat(ecukeys_name,"/funckeymap");
  2053. X        if(!(fp_keys = fopen(ecukeys_name,"r")))
  2054. X        {
  2055. X            ff(stderr,"'funckeymap' not in ~/.ecu or %s; unable to proceed\r\n",
  2056. X                eculibdir);
  2057. X            termecu(TERMECU_CONFIG_ERROR);
  2058. X        }
  2059. X    }
  2060. X
  2061. X/* find funckeymap name */
  2062. X    errstat = 1;
  2063. X    while((itmp = kde_fgets(buf,sizeof(buf),fp_keys)) != KDETYPE_EOF)
  2064. X    {
  2065. X        if((itmp == KDETYPE_COMMENT) || (itmp == KDETYPE_ENTRY))
  2066. X            continue;
  2067. X        if(!strcmp(buf,name))
  2068. X        {
  2069. X            errstat = 0;        /* indicate success */
  2070. X            break;
  2071. X        }
  2072. X    }
  2073. X    if(errstat)
  2074. X    {
  2075. X        ff(stderr,"terminal type '%s'\r\n",name);
  2076. X        ff(stderr,"not found in %s; unable to proceed\r\n",ecukeys_name);
  2077. X        termecu(TERMECU_CONFIG_ERROR);
  2078. X    }
  2079. X
  2080. X/* read past any other funckeymap names matching this set */
  2081. X    errstat = 1;
  2082. X    while((itmp = kde_fgets(buf,sizeof(buf),fp_keys)) != KDETYPE_EOF)
  2083. X    {
  2084. X        if(itmp == KDETYPE_ENTRY)
  2085. X        {
  2086. X            errstat = 0;        /* indicate success */
  2087. X            break;
  2088. X        }
  2089. X    }
  2090. X    if(errstat)
  2091. X    {
  2092. X        ff(stderr,
  2093. X            "terminal type '%s' has null entry in %s; unable to proceed\r\n",
  2094. X            name,ecukeys_name);
  2095. X        termecu(TERMECU_CONFIG_ERROR);
  2096. X    }
  2097. X
  2098. X/* we found the definition ... process it */
  2099. X    errstat = 0;
  2100. X    itmp = KDETYPE_ENTRY;
  2101. X    do {
  2102. X        if(itmp == KDETYPE_NAME)
  2103. X            break;
  2104. X        else if(itmp == KDETYPE_ENTRY)
  2105. X        {
  2106. X            if(funckeymap_define(buf))
  2107. X                errstat = 1;
  2108. X        }
  2109. X    } while((itmp = kde_fgets(buf,sizeof(buf),fp_keys)) != KDETYPE_EOF);
  2110. X
  2111. X/* finish up */
  2112. X    strncpy(funckeymap_name,name,sizeof(funckeymap_name));
  2113. X    funckeymap_name[sizeof(funckeymap_name) - 1] = 0;
  2114. X    fclose(fp_keys);
  2115. X
  2116. X    if(!funckeymap_table[IKDE_HOME].count)
  2117. X    {
  2118. X        ff(stderr,"You MUST have a 'Home' key defined\r\n");
  2119. X        errstat = 2;
  2120. X    }
  2121. X    if(!funckeymap_table[IKDE_END].count)
  2122. X    {
  2123. X        ff(stderr,"You MUST have a 'End' key defined\r\n");
  2124. X        errstat = 2;
  2125. X    }
  2126. X    if((errstat == 2) || (errstat && tty_not_char_special))
  2127. X        termecu(TERMECU_CONFIG_ERROR);
  2128. X
  2129. X    if(errstat)
  2130. X    {
  2131. X        ff(stderr,
  2132. X            "WARNING: key mapping syntax errors\r\nContinue anyway (y,[n])? ");
  2133. X        if((itmp = ttygetc(0)) == 'Y' || (itmp == 'y'))
  2134. X        {
  2135. X            ff(stderr,"YES\r\n");
  2136. X            return;
  2137. X        }
  2138. X        ff(stderr,"NO\r\n");
  2139. X        termecu(TERMECU_CONFIG_ERROR);
  2140. X        /*NOTREACHED*/
  2141. X    }
  2142. X
  2143. X}    /* end of funckeymap_read */
  2144. X
  2145. X/*+-------------------------------------------------------------------------
  2146. X    funckeymap(buf,buflen) - map char sequence to ikde code
  2147. X
  2148. Xreturn XF_ code or XF_not_yet if no match yet, XF_no_way if no match possible
  2149. X--------------------------------------------------------------------------*/
  2150. Xuchar
  2151. Xfunckeymap(buf,buflen)
  2152. Xuchar *buf;
  2153. Xint buflen;
  2154. X{
  2155. X    register ikde;
  2156. X    register KDE *tkde;
  2157. X    int err_rtn = XF_no_way;
  2158. X
  2159. X    if(!buflen)
  2160. X        return(XF_not_yet);
  2161. X
  2162. X#if defined(NONANSI_DEBUG)
  2163. X    if(nadbg)
  2164. X        hex_dump_fp(nadbg,buf,-buflen,"mapna",1);
  2165. X#endif
  2166. X
  2167. X    for(ikde = 0,tkde = funckeymap_table; ikde <= IKDE_lastKey;
  2168. X        ikde++,tkde++)
  2169. X    {
  2170. X#if defined(NONANSI_DEBUG)
  2171. X            if(nadbg)
  2172. X                fprintf(nadbg,"--> %s ",tkde->logical);
  2173. X#endif
  2174. X        if((tkde->count == buflen) && !memcmp(tkde->str,buf,buflen))
  2175. X        {
  2176. X#if defined(NONANSI_DEBUG)
  2177. X            if(nadbg)
  2178. X                fprintf(nadbg,"yes\n");
  2179. X#endif
  2180. X            return(tkde->ikde);
  2181. X        }
  2182. X#if defined(NONANSI_DEBUG)
  2183. X        if(nadbg)
  2184. X            fprintf(nadbg,"no\n");
  2185. X#endif
  2186. X        if((tkde->count > buflen) &&
  2187. X            ((uchar)*(tkde->str + buflen) == *(buf + buflen)))
  2188. X        {
  2189. X            err_rtn = XF_not_yet;
  2190. X        }
  2191. X    }
  2192. X    return(err_rtn);
  2193. X}    /* end of funckeymap */
  2194. X
  2195. X/*+-------------------------------------------------------------------------
  2196. X    funckeymap_display_single(tkde,fp) - display single mapping on FILE fp
  2197. X--------------------------------------------------------------------------*/
  2198. Xvoid
  2199. Xfunckeymap_display_single(ikde,fp)
  2200. Xint ikde;
  2201. XFILE *fp;
  2202. X{
  2203. X    int keys_left;
  2204. X    char *keys;
  2205. X    char s64[64];
  2206. X    KDE *tkde;
  2207. X
  2208. X    if((unsigned)ikde > IKDE_lastKey)
  2209. X        return;
  2210. X
  2211. X    tkde = &funckeymap_table[ikde];
  2212. X    sprintf(s64," %s:%s:                   ",
  2213. X        keyset_idstr(ikde),tkde->logical);
  2214. X    s64[16] = 0;
  2215. X    if(fp == stderr)
  2216. X        pputs(s64);
  2217. X    else
  2218. X        fputs(s64,fp);
  2219. X    keys_left = tkde->count;
  2220. X    keys = tkde->str;
  2221. X    while(keys_left--)
  2222. X    {
  2223. X        if(fp == stderr)
  2224. X        {
  2225. X            pprintf("%s%s",
  2226. X                make_char_graphic(*keys++,0),
  2227. X                (keys_left) ? " " : "");
  2228. X        }
  2229. X        else
  2230. X        {
  2231. X            fprintf(fp,"%s%s",
  2232. X                make_char_graphic(*keys++,0),
  2233. X                (keys_left) ? " " : "");
  2234. X        }
  2235. X    }
  2236. X    if(fp == stderr)
  2237. X        pputs("\n");
  2238. X    else
  2239. X        fputs("\n",fp);
  2240. X
  2241. X}    /* end of funckeymap_display_single */
  2242. X
  2243. X/*+-------------------------------------------------------------------------
  2244. X    funckeymap_display(fp) - display function key table of FILE fp
  2245. X--------------------------------------------------------------------------*/
  2246. Xvoid
  2247. Xfunckeymap_display(fp)
  2248. XFILE *fp;
  2249. X{
  2250. X    int ikde;
  2251. X    char *ftype = 0;
  2252. X
  2253. X    if(dash_f_funckeytype)
  2254. X        ftype =    dash_f_funckeytype;
  2255. X    else
  2256. X        ftype = getenv("ECUFUNCKEY");
  2257. X
  2258. X    if(ttype && ftype)
  2259. X    {
  2260. X        fprintf(fp,"#$TERM=%s -F/$ECUFUNCKEY=%s",ftype,ttype);
  2261. X        if(fp == stderr)
  2262. X            fputs("\r\n",fp);
  2263. X        else
  2264. X            fputs("\n",fp);
  2265. X    }
  2266. X
  2267. X    if(ttype || ftype)
  2268. X    {
  2269. X        fputs((ftype) ? ftype : ttype,fp);
  2270. X        if(fp == stderr)
  2271. X            fputs("\r\n",fp);
  2272. X        else
  2273. X            fputs("\n",fp);
  2274. X    }
  2275. X
  2276. X    for(ikde = 0; ikde <= IKDE_lastKey; ikde++)
  2277. X        funckeymap_display_single(ikde,fp);
  2278. X
  2279. X}    /* end of funckeymap_display */
  2280. X
  2281. X/*+-------------------------------------------------------------------------
  2282. X    fkmap_command(argc,argv) - common interactive and procedure 'fkmap' cmd
  2283. X
  2284. Xreturn procedure error codes
  2285. X--------------------------------------------------------------------------*/
  2286. Xint
  2287. Xfkmap_command(argc,argv)
  2288. Xint argc;
  2289. Xchar **argv;
  2290. X{
  2291. X    register itmp;
  2292. X    int err = 0;
  2293. X    char *ftype = 0;
  2294. X    int iargv = 1;
  2295. X    char *arg;
  2296. X    char fkcmd[512 + 1];
  2297. X    char *fkcptr = fkcmd;
  2298. X    int fkclen = 0;
  2299. X    int ikde;
  2300. X    KDE save;
  2301. X    FILE *fp;
  2302. X    
  2303. X    while((iargv < argc) && (*(arg = argv[iargv]) == '-'))
  2304. X    {
  2305. X        switch(*++arg)
  2306. X        {
  2307. X            case 'r': /* reset */
  2308. X                if(err)
  2309. X                    break;
  2310. X                if(dash_f_funckeytype)
  2311. X                    ftype =    dash_f_funckeytype;
  2312. X                else
  2313. X                    ftype = getenv("ECUFUNCKEY");
  2314. X                if(ttype || ftype)
  2315. X                    funckeymap_read((ftype) ? ftype : ttype);
  2316. X                if(!proc_level || proctrace)
  2317. X                    pputs("funckeymap reset to startup configuration\n");
  2318. X                if(iargv != (argc - 1))
  2319. X                    pputs("extra arguments ignored\n");
  2320. X                return(0);
  2321. X
  2322. X            case 's': /* save in file */
  2323. X                if(err)
  2324. X                    break;
  2325. X                if(iargv != (argc - 2))
  2326. X                {
  2327. X                    pputs("exactly one argument required for -s\n");
  2328. X                    return(eFATAL_ALREADY);
  2329. X                }
  2330. X                iargv++;
  2331. X                if(!(fp = fopen(argv[iargv],"a")))
  2332. X                {
  2333. X                    pperror(argv[iargv]);
  2334. X                    return(eFATAL_ALREADY);
  2335. X                }
  2336. X                funckeymap_display(fp);
  2337. X                fclose(fp);
  2338. X                if(!proc_level || proctrace)
  2339. X                    pprintf("current mapping saved in %s\n",argv[iargv]);
  2340. X                return(0);
  2341. X
  2342. X            default:
  2343. X                pprintf("unknown switch -%c\n",*arg);
  2344. X                err = 1;
  2345. X        }
  2346. X        iargv++;
  2347. X    }
  2348. X
  2349. X    if(err)
  2350. X        return(eFATAL_ALREADY);
  2351. X
  2352. X    if(iargv == argc)
  2353. X    {
  2354. X        funckeymap_display(stderr);
  2355. X        return(0);
  2356. X    }
  2357. X
  2358. X    arg = argv[iargv++];
  2359. X    if((ikde = kde_name_to_ikde(arg)) < 0)
  2360. X    {
  2361. X        pprintf("key name '%s' not recognized\n",arg);
  2362. X        return(eFATAL_ALREADY);
  2363. X    }
  2364. X    sprintf(fkcptr," %s:%s: ",keyset_idstr(ikde),keyset_idstr(ikde));
  2365. X    fkcptr += (itmp = strlen(fkcptr));
  2366. X    fkclen += itmp;
  2367. X
  2368. X    if(iargv == argc)
  2369. X    {
  2370. X        funckeymap_display_single(&funckeymap_table[ikde],stderr);
  2371. X        return(0);
  2372. X    }
  2373. X
  2374. X    while(iargv < argc)
  2375. X    {
  2376. X        arg = argv[iargv++];
  2377. X        itmp = strlen(arg);
  2378. X        if((fkclen + itmp + 2) > sizeof(fkcmd))
  2379. X        {
  2380. X            pprintf("fkmap command may be no longer than %d characters\n",
  2381. X                sizeof(fkcmd) - 1);
  2382. X            return(eFATAL_ALREADY);
  2383. X        }
  2384. X        strcpy(fkcptr,arg);
  2385. X        fkcptr += itmp;
  2386. X        fkclen += itmp;
  2387. X        if(iargv != argc)
  2388. X        {
  2389. X            *fkcptr++ = ' ';
  2390. X            *fkcptr = 0;
  2391. X            fkclen++;
  2392. X        }
  2393. X    }
  2394. X
  2395. X    save = funckeymap_table[ikde];
  2396. X    if(err = funckeymap_define(fkcmd))
  2397. X        funckeymap_table[ikde] = save;
  2398. X
  2399. X    if(!err && (!proc_level || proctrace))
  2400. X        funckeymap_display_single(ikde,stderr);
  2401. X
  2402. X    return((err) ? eFATAL_ALREADY : 0);
  2403. X
  2404. X}    /* end of fkmap_command */
  2405. X
  2406. X/* end of funckeymap.c */
  2407. X/* vi: set tabstop=4 shiftwidth=4: */
  2408. SHAR_EOF
  2409. chmod 0644 funckeymap.c ||
  2410. echo 'restore of funckeymap.c failed'
  2411. Wc_c="`wc -c < 'funckeymap.c'`"
  2412. test 13650 -eq "$Wc_c" ||
  2413.     echo 'funckeymap.c: original size 13650, current size' "$Wc_c"
  2414. rm -f _shar_wnt_.tmp
  2415. fi
  2416. # ============= gint.c ==============
  2417. if test -f 'gint.c' -a X"$1" != X"-c"; then
  2418.     echo 'x - skipping gint.c (File already exists)'
  2419.     rm -f _shar_wnt_.tmp
  2420. else
  2421. > _shar_wnt_.tmp
  2422. echo 'x - extracting gint.c (Text)'
  2423. sed 's/^X//' << 'SHAR_EOF' > 'gint.c' &&
  2424. X/*+-------------------------------------------------------------------------
  2425. X    gint.c - ecu get integer parameter functions
  2426. X    wht@n4hgf.Mt-Park.GA.US
  2427. X
  2428. X  Defined functions:
  2429. X    gcol_range(param,col1,col2)
  2430. X    gint(param,int_returned)
  2431. X    gint_base(param,value)
  2432. X    gint_constant(param,value)
  2433. X    gintop(param,intop)
  2434. X
  2435. X--------------------------------------------------------------------------*/
  2436. X/*+:EDITS:*/
  2437. X/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
  2438. X/*:08-22-1992-15:39-wht@n4hgf-ECU release 3.20 BETA */
  2439. X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
  2440. X/*:01-31-1991-16:50-wht@n4hgf-reinstate octal with 0o prefix */
  2441. X/*:01-09-1991-22:31-wht@n4hgf-ISC port */
  2442. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  2443. X
  2444. X#include "ecu.h"
  2445. X#include "ecuerror.h"
  2446. X#include "esd.h"
  2447. X#include "var.h"
  2448. X
  2449. X#define OP_ADD      1
  2450. X#define OP_SUB      2
  2451. X#define OP_MUL      3
  2452. X#define OP_DIV      4
  2453. X#define OP_XOR      5
  2454. X#define OP_MOD      6
  2455. X#define OP_OR       7
  2456. X#define OP_AND      8
  2457. X
  2458. X#define BASE_DEC    1
  2459. X#define BASE_OCT    2
  2460. X#define BASE_HEX      3
  2461. X
  2462. X
  2463. X/*+-------------------------------------------------------------------------
  2464. X    gint_constant(param,int_returned) - evaluate integer constant
  2465. X--------------------------------------------------------------------------*/
  2466. Xint
  2467. Xgint_constant(param,value)
  2468. XESD *param;
  2469. Xlong *value;
  2470. X{
  2471. Xregister itmp;
  2472. Xint base = BASE_DEC;
  2473. Xint erc;
  2474. Xlong new_value;
  2475. X
  2476. X    if(erc = skip_cmd_break(param))
  2477. X        return(erc);
  2478. X    esd_null_terminate(param);
  2479. X
  2480. X/* get integer from string */
  2481. X    if((!strncmp(param->pb + param->index,"0x",2)) ||
  2482. X        (!strncmp(param->pb + param->index,"0X",2)))
  2483. X    {
  2484. X        base = BASE_HEX;
  2485. X        param->index += 2;
  2486. X    }
  2487. X    else if((!strncmp(param->pb + param->index,"0o",2)) ||
  2488. X        (!strncmp(param->pb + param->index,"0O",2)))
  2489. X    {
  2490. X        base = BASE_OCT;
  2491. X        param->index += 2;
  2492. X    }
  2493. X
  2494. X    param->old_index = param->index;
  2495. X    switch(base)
  2496. X    {
  2497. X        case BASE_HEX:
  2498. X            sscanf(param->pb + param->index,"%lx",&new_value);
  2499. X            itmp = param->index + strspn(param->pb + param->index,
  2500. X                "0123456789ABCDEFabcdef");
  2501. X            erc = eInvalidHexNumber;
  2502. X            break;
  2503. X        case BASE_DEC:
  2504. X            sscanf(param->pb + param->index,"%ld",&new_value);
  2505. X            itmp = param->index + strspn(param->pb + param->index,"0123456789");
  2506. X            erc = eInvalidDecNumber;
  2507. X            break;
  2508. X        case BASE_OCT:
  2509. X            sscanf(param->pb + param->index,"%lo",&new_value);
  2510. X            itmp = param->index + strspn(param->pb + param->index,"01234567");
  2511. X            erc = eInvalidOctNumber;
  2512. X            break;
  2513. X        default:
  2514. X            return(eInternalLogicError);
  2515. X    }
  2516. X
  2517. X    param->index = itmp;
  2518. X    if(isalnum(*(param->pb + itmp)))
  2519. X        param->old_index = itmp;
  2520. X
  2521. X    if(param->old_index != param->index)
  2522. X    {
  2523. X        *value = new_value;
  2524. X        return(0);
  2525. X    }
  2526. X    return(erc);
  2527. X
  2528. X}   /* end of gint_constant */
  2529. X
  2530. X/*+-------------------------------------------------------------------------
  2531. X    gint_base(param,value) - evaluate integer constant, variable or function
  2532. X--------------------------------------------------------------------------*/
  2533. Xint
  2534. Xgint_base(param,value)
  2535. XESD *param;
  2536. Xlong *value;
  2537. X{
  2538. Xregister erc;
  2539. Xlong *varptr;
  2540. X
  2541. X    if(erc = skip_cmd_break(param))
  2542. X        return(erc);
  2543. X
  2544. X    switch(param->pb[param->index])        /* look at first character */
  2545. X    {
  2546. X        case '$':        /* '$i...' variable reference? */
  2547. X            if(param->index >= param->cb-2)
  2548. X                return(eSyntaxError);
  2549. X            param->old_index = ++param->index;
  2550. X            if(to_lower(param->pb[param->index++]) != 'i')
  2551. X                return(eIllegalVarType);
  2552. X            if(erc = get_ivptr(param,&varptr,0))
  2553. X                return(erc);
  2554. X            *value = *varptr;    
  2555. X            return(0);
  2556. X
  2557. X        case '%':        /* '%...' function reference? */
  2558. X            param->index++;
  2559. X            if(erc = feval_int(param,value))
  2560. X                return(erc);
  2561. X            return(0);
  2562. SHAR_EOF
  2563. true || echo 'restore of gint.c failed'
  2564. fi
  2565. echo 'End of ecu320 part 16'
  2566. echo 'File gint.c is continued in part 17'
  2567. echo 17 > _shar_seq_.tmp
  2568. exit 0
  2569.  
  2570. exit 0 # Just in case...
  2571.