home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume16 / ecu3 / part11 < prev    next >
Encoding:
Internet Message Format  |  1991-01-06  |  49.9 KB

  1. From: wht@n4hgf.uucp (Warren Tucker)
  2. Newsgroups: comp.sources.misc
  3. Subject: v16i035:  ECU async comm package rev 3.0, Part11/35
  4. Message-ID: <1991Jan6.052101.27799@sparky.IMD.Sterling.COM>
  5. Date: 6 Jan 91 05:21:01 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: 2f781117 04a9eb0a 0897d00e 3e02762f
  8.  
  9. Submitted-by: wht@n4hgf.uucp (Warren Tucker)
  10. Posting-number: Volume 16, Issue 35
  11. Archive-name: ecu3/part11
  12.  
  13. ---- Cut Here and feed the following to sh ----
  14. #!/bin/sh
  15. # This is part 11 of ecu3
  16. if touch 2>&1 | fgrep 'amc' > /dev/null
  17.  then TOUCH=touch
  18.  else TOUCH=true
  19. fi
  20. # ============= expresp.c ==============
  21. echo 'x - extracting expresp.c (Text)'
  22. sed 's/^X//' << 'SHAR_EOF' > 'expresp.c' &&
  23. X/*+-------------------------------------------------------------------------
  24. X    expresp.c - HDB expect/respond per SCO Devices file
  25. X    wht@n4hgf.Mt-Park.GA.US
  26. X
  27. X Meaning of some of the escape characters:
  28. X \p - pause (approximately 1/4-1/2 second delay)
  29. X \d - delay (2 seconds)
  30. X \D - phone number/token
  31. X \T - phone number with Dialcodes and character translation
  32. X \N - null byte
  33. X \K - insert a BREAK
  34. X \E - turn on echo checking (for slow devices)
  35. X \e - turn off echo checking
  36. X \r - carriage return
  37. X \c - no new-line
  38. X \n - send new-line
  39. X \nnn - send octal number
  40. X \m### - sleep ### (decimal) milliseconds (non-standard)
  41. X Speed - Hayes-specific speed-adaptive connect handler
  42. X
  43. X  Defined functions:
  44. X    pcmd_expresp(param)
  45. X    execute_expresp(expresp_script)
  46. X    expect(str)
  47. X    respond(str)
  48. X
  49. X--------------------------------------------------------------------------*/
  50. X/*+:EDITS:*/
  51. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  52. X
  53. X#include "ecu.h"
  54. X#include "ecuerror.h"
  55. X#include "esd.h"
  56. X#include "var.h"
  57. X#include "proc.h"
  58. X
  59. X
  60. X#define MAX_FIELDS    50    /* max fields in a chat script */
  61. X#define MAX_EXPRESP    511    /* max length of a chat script */
  62. X#define MAX_EXPECT    63    /* max length of expect string */
  63. X#define DEFAULT_TIMEOUT_MSECS (10*1000L)
  64. X
  65. X#define ERDEBUG(verb,str,arg) if(expresp_verbosity >= verb) \
  66. X    pprintf(str,arg);
  67. X
  68. Xlong atol();
  69. X
  70. Xextern int proctrace;
  71. Xextern int interrupt;
  72. X
  73. Xint expresp_verbosity = 0;
  74. Xulong expect_timeout_msecs = DEFAULT_TIMEOUT_MSECS;
  75. Xint expresp_echo_check = 0;
  76. X
  77. Xchar last_Speed_result[32];
  78. X
  79. X/*+-------------------------------------------------------------------------
  80. X    expect(str) - expect (read) string from remote
  81. Xreturn code on failure, 0 on success
  82. X--------------------------------------------------------------------------*/
  83. Xint
  84. Xexpect(str)
  85. Xchar *str;
  86. X{
  87. X    register char *cptr;
  88. X    char parsebuf[MAX_EXPECT + 1];
  89. X    int remaining = MAX_EXPECT;
  90. X    int erc;
  91. X    int old_ttymode = get_ttymode();
  92. X    register char *parsed = parsebuf;
  93. X    char s4[4];
  94. X    int itmp;
  95. X    long atol();
  96. X
  97. X    if(old_ttymode != 2)
  98. X        ttymode(2);
  99. X
  100. X    if (!strncmp(str, "~t[", 3) || !strncmp(str, "~m[", 3))
  101. X    {
  102. X        expect_timeout_msecs = atol(str + 3);
  103. X        if(*(str + 1) == 't')
  104. X            expect_timeout_msecs *= 1000L;
  105. X        str += 3;
  106. X        ERDEBUG(2,"expect timeout = %lu msec\n",expect_timeout_msecs);
  107. X        if (cptr = strchr(str, ']'))
  108. X        {
  109. X            str = cptr + 1;
  110. X            ERDEBUG(3, "expect: %s\n", str);
  111. X        }
  112. X        else
  113. X        {
  114. X            erc = eExpectRespondFail;
  115. X            goto RESTORE_TTYMODE_AND_RETURN_ERC;
  116. X        }
  117. X    }
  118. X    ERDEBUG(2,"expect: <<%s>>\n",str);
  119. X    if(!strlen(str) || !strcmp(str,"\"\""))
  120. X        goto GOT_EXPECTED;
  121. X
  122. X    if(!strcmp(str,"Speed"))
  123. X    {
  124. X        LRWT lr;
  125. X        long ms_start;
  126. X        long ms_now;
  127. X        struct timeb now_timeb;
  128. X        ftime(&now_timeb);
  129. X        ms_start = (now_timeb.time * 1000) + now_timeb.millitm;
  130. X        do {
  131. X            last_Speed_result[0] = 0;
  132. X            lr.to1 = 90 * 100L;
  133. X            lr.to2 = 120L;
  134. X            /* allow interrupts + cooked read */
  135. X            lr.raw_flag = 0x80;
  136. X            lr.buffer = last_Speed_result;
  137. X            lr.bufsize = sizeof(last_Speed_result);
  138. X            lr.delim = "\n";
  139. X            lr.echo = 0;
  140. X            lgets_timeout(&lr);
  141. X            ftime(&now_timeb);
  142. X            ms_now = (now_timeb.time * 1000) + now_timeb.millitm;
  143. X        } while (!interrupt && !lr.count && ((ms_now - ms_start) < 90*1000L));
  144. X
  145. X        if(interrupt || strncmp(lr.buffer,"CONNECT",7))
  146. X            goto DID_NOT_GET_EXPECTED;
  147. X        else
  148. X            goto GOT_EXPECTED;
  149. X    }
  150. X
  151. X    cptr = str;
  152. X    while(remaining)
  153. X    {
  154. X        if(*cptr == '\\')
  155. X        {
  156. X            if(!*(++cptr))    /* if no character after escape, ... */
  157. X            {
  158. X                ERDEBUG(2," error: str ended with '\\'\n",0);
  159. X                goto DID_NOT_GET_EXPECTED;
  160. X            }
  161. X
  162. X            if(isdigit(*cptr))    /* handle \ooo */
  163. X            {
  164. X                strncpy(s4,cptr,3);
  165. X                s4[3] = 0;
  166. X                sscanf(s4,"%o",&itmp);
  167. X                cptr += strspn(s4,"01234567");
  168. X                *parsed++ = (char)itmp;
  169. X                remaining--;
  170. X                continue;
  171. X            }
  172. X
  173. X            switch(*cptr)
  174. X            {
  175. X            case 'n':
  176. X                *parsed++ = 0x0A;
  177. X                remaining--;
  178. X                break;
  179. X            case 'r':
  180. X                *parsed++ = 0x0D;
  181. X                remaining--;
  182. X                break;
  183. X            default:
  184. X                ERDEBUG(2," meaningless here: \\%c\n",*cptr);
  185. X                break;
  186. X            }
  187. X            cptr++;
  188. X        }
  189. X        else
  190. X        {
  191. X            *parsed++ = *cptr++;
  192. X            remaining--;
  193. X        }
  194. X    }
  195. X    *parsed = 0;
  196. X
  197. X    if(remaining)
  198. X        ERDEBUG(1," expect string too long\n",0);
  199. X
  200. X    if(expresp_verbosity >= 3)
  201. X        hex_dump(parsebuf,strlen(parsebuf),"expecting",1);
  202. X
  203. X    if(llookfor(parsebuf,expect_timeout_msecs,
  204. X        (expresp_verbosity < 3) ? expresp_verbosity : 0))
  205. X    {
  206. XGOT_EXPECTED:
  207. X        ERDEBUG(2,"[EXPECT SUCCEEDED]\n",0);
  208. X        erc = 0;
  209. X        goto RESTORE_TTYMODE_AND_RETURN_ERC;
  210. X        
  211. X    }
  212. X
  213. XDID_NOT_GET_EXPECTED:
  214. X    ERDEBUG(2,"[EXPECT FAILED%s]\n",(interrupt) ? " (interrupted)" : "");
  215. X    if(interrupt)
  216. X    {
  217. X        interrupt = 0;
  218. X        erc = eCONINT;
  219. X    }
  220. X    else
  221. X        erc = eExpectRespondFail;
  222. X    goto RESTORE_TTYMODE_AND_RETURN_ERC;
  223. X
  224. XRESTORE_TTYMODE_AND_RETURN_ERC:
  225. X    if(old_ttymode != 2)
  226. X        ttymode(old_ttymode);
  227. X    return(erc);
  228. X
  229. X}    /* end of expect */
  230. X
  231. X/*+-------------------------------------------------------------------------
  232. X    respond(str) - send to remote
  233. X--------------------------------------------------------------------------*/
  234. Xvoid
  235. Xrespond(str)
  236. Xregister char *str;
  237. X{
  238. Xint itmp;
  239. Xlong ltmp;
  240. Xchar s4[4];
  241. Xint send_no_cr = 0;
  242. X
  243. X    ERDEBUG(2,"respond: <<%s>>\n",str);
  244. X    while(*str)
  245. X    {
  246. X        if(*str == '\\')
  247. X        {
  248. X            /* handle \nnn - send octal number */
  249. X            if(isdigit(*++str))    /* handle \ooo */
  250. X            {
  251. X                strncpy(s4,str,3);
  252. X                s4[3] = 0;
  253. X                sscanf(s4,"%o",&itmp);
  254. X                str += strspn(s4,"01234567") - 1;    /* -1 cause str++ later */
  255. X                lputc((char)itmp);
  256. X            }
  257. X            else switch(*str)
  258. X            {
  259. X                case 'p':  /* pause (approximately 1/4-1/2 second delay) */
  260. X                    ldraino(0);    /* wait for output to drain */
  261. X                    nap(400L);
  262. X                    break;
  263. X                case 'm':  /* nap a while (non-standard) */
  264. X                    ltmp = atol(str + 1);
  265. X                    str += strspn(str + 1,"0123456789");
  266. X                    ldraino(0);    /* wait for output to drain */
  267. X                    nap(ltmp);
  268. X                    break;
  269. X                case 'd':  /* delay (2 seconds) */
  270. X                    ldraino(0);    /* wait for output to drain */
  271. X                    nap(2000L);
  272. X                    break;
  273. X                case 'D':  /* phone number/token */
  274. X                    if(expresp_echo_check)
  275. X                        lputs_paced(40,shm->Ltelno);    /* fake it */
  276. X                    else
  277. X                        lputs(shm->Ltelno);
  278. X                    break;
  279. X                case 'T':  /* phnum with Dialcodes and char translation */
  280. X                    if(expresp_echo_check)
  281. X                        lputs_paced(40,shm->Ltelno);    /* fake it */
  282. X                    else
  283. X                        lputs(shm->Ltelno);
  284. X                    break;
  285. X                case 'N':  /* null byte */
  286. X                    lputc(0);
  287. X                    break;
  288. X                case 'K':  /* insert a BREAK */
  289. X                    lbreak();
  290. X                    break;
  291. X                case 'E':  /* turn on echo checking (for slow devices) */
  292. X                    expresp_echo_check = 1;
  293. X                    break;
  294. X                case 'e':  /* turn off echo checking */
  295. X                    expresp_echo_check = 0;
  296. X                    break;
  297. X                case 'r':  /* carriage return */
  298. X                    lputc(0x0D);
  299. X                    break;
  300. X                case 'c':  /* no new-line */
  301. X                    send_no_cr = 1;
  302. X                    break;
  303. X                case 'n':  /* send new-line */
  304. X                    lputc(0x0D);
  305. X                    break;
  306. X            }
  307. X
  308. X        }
  309. X        else
  310. X            lputc(*str);
  311. X
  312. X
  313. X        if(expresp_echo_check)
  314. X        {
  315. X            ldraino(1);        /* wait for output to drain, then flush input */
  316. X            nap(40L);        /* fake it */
  317. X        }
  318. X        str++;
  319. X    }
  320. X
  321. X    if(!send_no_cr)
  322. X        lputc(0x0D);
  323. X}    /* end of respond */
  324. X
  325. X/*+-------------------------------------------------------------------------
  326. X    execute_expresp(expresp_script)
  327. X
  328. Xreturn 0 on success, else error code
  329. X--------------------------------------------------------------------------*/
  330. Xint
  331. Xexecute_expresp(expresp_script)
  332. Xchar *expresp_script;
  333. X{
  334. Xchar *fields[MAX_FIELDS + 1];
  335. Xint ifields;
  336. Xint nfields;
  337. Xint erc;
  338. Xchar expresp_copy[MAX_EXPRESP + 1];
  339. Xchar *expect_this;
  340. Xchar *send_on_fail;
  341. X
  342. X#define EXPECT_STATE (!(ifields & 1))    /* even numbered fields are expect */
  343. X    expresp_echo_check = 0;
  344. X    last_Speed_result[0] = 0;
  345. X
  346. X    strncpy(expresp_copy,expresp_script,sizeof(expresp_copy));
  347. X    build_arg_array(expresp_copy,fields,MAX_FIELDS,&nfields);
  348. X    if(!nfields)    /* if no script, assume success */
  349. X    {
  350. X        ERDEBUG(2,"[EMPTY SCRIPT - EXPECT/RESPOND SUCCEEDED]\n",0);
  351. X        return(0);
  352. X    }
  353. X
  354. X    for(ifields = 0; ifields < nfields; ifields++)
  355. X    {
  356. X        if(interrupt)
  357. X            break;
  358. X        if(EXPECT_STATE)
  359. X        {
  360. X            expect_this = fields[ifields];
  361. X            while(1)    /* until break or return(-1) */
  362. X            {
  363. X                if(send_on_fail = strchr(expect_this,'-'))
  364. X                    *send_on_fail++ = 0;
  365. X                if(!(erc = expect(expect_this)))
  366. X                    break;
  367. X                if((erc != eExpectRespondFail) || !send_on_fail)
  368. X                {
  369. X                    ERDEBUG(2,"[EXPECT/RESPOND FAILED]\n",0);
  370. X                    return(eExpectRespondFail);
  371. X                }
  372. X                if(expect_this = strchr(send_on_fail,'-'))
  373. X                    *expect_this++ = 0;
  374. X                if(interrupt)
  375. X                    break;
  376. X                respond(send_on_fail);
  377. X            }
  378. X        }
  379. X        else
  380. X            respond(fields[ifields]);
  381. X    }
  382. X    if(interrupt)
  383. X    {
  384. X        interrupt = 0;
  385. X        ERDEBUG(2,"[CONSOLE INTERRUPT]\n",0);
  386. X        return(eCONINT);
  387. X    }
  388. X    ERDEBUG(2,"[EXPECT/RESPOND SUCCEEDED]\n",0);
  389. X    return(0);
  390. X
  391. X}    /* end of execute_expresp */
  392. X
  393. X/*+-------------------------------------------------------------------------
  394. X    pcmd_expresp(param)
  395. Xexpresp [-v[v...]] <exp-resp-str> [<timeout_msecs>]
  396. X--------------------------------------------------------------------------*/
  397. Xint
  398. Xpcmd_expresp(param)
  399. XESD *param;
  400. X{
  401. Xint erc;
  402. Xint itmp;
  403. Xchar *cptr;
  404. XESD *tesd;
  405. Xchar switches[8];
  406. X
  407. X    if((tesd = make_esd(MAX_EXPRESP + 1)) == (ESD *)0)
  408. X        return(eNoMemory);
  409. X
  410. X    get_switches(param,switches,sizeof(switches));
  411. X
  412. X    if(erc = gstr(param,tesd,0))
  413. X    {
  414. X        free_esd(tesd);
  415. X        return(erc);
  416. X    }
  417. X
  418. X    expect_timeout_msecs = DEFAULT_TIMEOUT_MSECS;
  419. X    expresp_verbosity = (!!strchr(switches,'v')) || proctrace;
  420. X    if(expresp_verbosity)
  421. X    {
  422. X        cptr = switches, itmp = 0;
  423. X        while(*cptr)
  424. X            itmp += (*cptr++ == 'v');
  425. X        if(itmp > 1)
  426. X            expresp_verbosity = itmp;
  427. X    }
  428. X        
  429. X    if(erc = gint(param,&expect_timeout_msecs))
  430. X    {
  431. X        /* if something there non-integer */
  432. X        if(!end_of_cmd(param))
  433. X        {
  434. X            erc = eSyntaxError;
  435. X            goto RETURN;
  436. X        }
  437. X    }
  438. X
  439. X    erc = execute_expresp(tesd->pb);
  440. X
  441. XRETURN:
  442. X    free_esd(tesd);
  443. X    iv[0] = !!erc;
  444. X    if(erc == eExpectRespondFail)
  445. X        erc = 0;
  446. X    return(erc);
  447. X
  448. X}    /* end of pcmd_expresp */
  449. X
  450. X/* vi: set tabstop=4 shiftwidth=4: */
  451. X/* end of expresp.c */
  452. SHAR_EOF
  453. $TOUCH -am 1224223790 'expresp.c' &&
  454. chmod 0644 expresp.c ||
  455. echo 'restore of expresp.c failed'
  456. Wc_c="`wc -c < 'expresp.c'`"
  457. test 9617 -eq "$Wc_c" ||
  458.     echo 'expresp.c: original size 9617, current size' "$Wc_c"
  459. # ============= feval.c ==============
  460. echo 'x - extracting feval.c (Text)'
  461. sed 's/^X//' << 'SHAR_EOF' > 'feval.c' &&
  462. X/*+-------------------------------------------------------------------------
  463. X    feval.c - integer and string function evaluation
  464. X    wht@n4hgf.Mt-Park.GA.US
  465. X
  466. X    feval_int(param,&int_returned) where 'int' here means long ECU $i int
  467. X    feval_str(param,&esd_to_be_plugged)
  468. X
  469. X  These routines are called with param.index as follows:
  470. X
  471. X         !nnnnn       nnn is name of function
  472. X          ^
  473. X          |
  474. X
  475. X  Defined functions:
  476. X    feval_int(param,value)
  477. X    feval_str(param,result_esd)
  478. X    strfunc_left(param,scratch_esd,result_esd)
  479. X    strfunc_right(param,scratch_esd,result_esd)
  480. X
  481. X--------------------------------------------------------------------------*/
  482. X/*+:EDITS:*/
  483. X/*:12-24-1990-04:31-wht@n4hgf-experimental esio driver functions */
  484. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  485. X
  486. X#include "ecu.h"
  487. X#include "ecuerror.h"
  488. X#include "esd.h"
  489. X#include "proc.h"
  490. X#include "var.h"
  491. X
  492. X#if defined(ESIO_IN_USE)
  493. Xchar *msr_text();
  494. X#endif
  495. X
  496. X#define FIargc           1
  497. X#define FIbaud           2
  498. X#define FIcolors         3
  499. X#define FIconn           4
  500. X#define FIcsec           5
  501. X#define FIctoi           6
  502. X#define FIcurx           7
  503. X#define FIcury           8
  504. X#define FIfatime         9
  505. X#define FIfmode         10
  506. X#define FIfmtime        11
  507. X#define FIfsize         12
  508. X#define FIftell         13
  509. X#define FIinstr         14
  510. X#define FIisalnum       15
  511. X#define FIisalpha       16
  512. X#define FIisascii       17
  513. X#define FIischr         18
  514. X#define FIiscntrl       19
  515. X#define FIisdigit       20
  516. X#define FIisdir         21
  517. X#define FIisgraph       22
  518. X#define FIislower       23
  519. X#define FIisprint       24
  520. X#define FIispunct       25
  521. X#define FIisreg         26
  522. X#define FIisspace       27
  523. X#define FIisupper       28
  524. X#define FIisxdigit      29
  525. X#define FIlen           30
  526. X#define FIlgetc         31
  527. X#define FImatch         32
  528. X#define FImhack         33
  529. X#define FIpid           34
  530. X#define FIrchr          35
  531. X#define FIrchrc         36
  532. X#define FIshmid         37
  533. X#define FIstoi          38
  534. X#define FIxchr          39
  535. X#define FIxchrc         40
  536. X#define FIesecs         41
  537. X#define FIlines         42
  538. X#define FIcols          43
  539. X#define FIrinstr        44
  540. X#define FIesio          45
  541. X#if defined(ESIO_IN_USE)
  542. X#define FImsr           46
  543. X#define FIlnerr         47
  544. X#define FIridet         49
  545. X#define FIbrdet         50
  546. X#endif
  547. X
  548. XKEYTAB feval_int_tbl[] =
  549. X{
  550. X    {"argc",FIargc},
  551. X    {"baud",FIbaud},
  552. X#if defined(ESIO_IN_USE)
  553. X    {"brdet",FIbrdet},
  554. X#endif
  555. X    {"colors",FIcolors},
  556. X    {"cols",FIcols},
  557. X    {"conn",FIconn},
  558. X    {"csec",FIcsec},
  559. X    {"ctoi",FIctoi},
  560. X    {"curx",FIcurx},
  561. X    {"cury",FIcury},
  562. X    {"esecs",FIesecs},
  563. X    {"esio",FIesio},
  564. X    {"fatime",FIfatime},
  565. X    {"fmode",FIfmode},
  566. X    {"fmtime",FIfmtime},
  567. X    {"fsize",FIfsize},
  568. X    {"ftell",FIftell},
  569. X    {"instr",FIinstr},
  570. X    {"isalnum",FIisalnum},
  571. X    {"isalpha",FIisalpha},
  572. X    {"isalpha",FIisalpha},
  573. X    {"isascii",FIisascii},
  574. X    {"ischr",FIischr},
  575. X    {"iscntrl",FIiscntrl},
  576. X    {"isdigit",FIisdigit},
  577. X    {"isdir",FIisdir},
  578. X    {"isgraph",FIisgraph},
  579. X    {"islower",FIislower},
  580. X    {"isprint",FIisprint},
  581. X    {"ispunct",FIispunct},
  582. X    {"isreg",FIisreg},
  583. X    {"isspace",FIisspace},
  584. X    {"isupper",FIisupper},
  585. X    {"isxdigit",FIisxdigit},
  586. X    {"len",FIlen},
  587. X#if defined(ESIO_IN_USE)
  588. X    {"lnerr",FIlnerr},
  589. X#endif
  590. X    {"lgetc",FIlgetc},
  591. X    {"lines",FIlines},
  592. X    {"match",FImatch},
  593. X    {"mhack",FImhack},
  594. X#if defined(ESIO_IN_USE)
  595. X    {"msr",FImsr},
  596. X#endif
  597. X    {"pid",FIpid},
  598. X    {"rchr",FIrchr},
  599. X    {"rchrc",FIrchrc},
  600. X#if defined(ESIO_IN_USE)
  601. X    {"ridet",FIridet},
  602. X#endif
  603. X    {"rinstr",FIrinstr},
  604. X    {"shmid",FIshmid},
  605. X    {"stoi",FIstoi},
  606. X    {"xchr",FIxchr},
  607. X    {"xchrc",FIxchrc},
  608. X    {(char *)0,0}
  609. X};
  610. X
  611. X#define FSargv           1
  612. X#define FScgetc          2
  613. X#define FScgets          3
  614. X#define FSchr            4
  615. X#define FSdate           5
  616. X#define FSdatez          6
  617. X#define FSday            7
  618. X#define FSdayz           8
  619. X#define FSdir            9
  620. X#define FSedate         10
  621. X#define FSenvvar        11
  622. X#define FSerrstr        12
  623. X#define FSetime         13
  624. X#define FSfmodestr      14
  625. X#define FSitos          15
  626. X#define FSleft          16
  627. X#define FSline          17
  628. X#define FSlogname       18
  629. X#define FSmid           19
  630. X#define FSmonth         20
  631. X#define FSmonthz        21
  632. X#define FSrdesc         22
  633. X#define FSright         23
  634. X#define FSrname         24
  635. X#define FSrtel          25
  636. X#define FSscreen        26
  637. X#define FStime          27
  638. X#define FStimes         28
  639. X#define FStimez         29
  640. X#define FStimezs        30
  641. X#define FStty           31
  642. X#define FSbasename      32
  643. X#define FSdirpart       33
  644. X#define FSfilepart      34
  645. X#if defined(ESIO_IN_USE)
  646. X#define FSmsrtext       35
  647. X#endif
  648. X
  649. XKEYTAB feval_str_tbl[] =
  650. X{
  651. X    {"argv",FSargv},
  652. X    {"basename",FSbasename},
  653. X    {"cgetc",FScgetc},
  654. X    {"cgets",FScgets},
  655. X    {"chr",FSchr},
  656. X    {"date",FSdate},
  657. X    {"datez",FSdatez},
  658. X    {"day",FSday},
  659. X    {"dir",FSdir},
  660. X    {"dirpart",FSdirpart},
  661. X    {"edate",FSedate},
  662. X    {"envvar",FSenvvar},
  663. X    {"errstr",FSerrstr},
  664. X    {"etime",FSetime},
  665. X    {"filepart",FSfilepart},
  666. X    {"fmodestr",FSfmodestr},
  667. X    {"itos",FSitos},
  668. X    {"left",FSleft},
  669. X    {"line",FSline},
  670. X    {"logname",FSlogname},
  671. X    {"mid",FSmid},
  672. X    {"month",FSmonth},
  673. X#if defined(ESIO_IN_USE)
  674. X    {"msrtext",FSmsrtext},
  675. X#endif
  676. X    {"rdesc",FSrdesc},
  677. X    {"right",FSright},
  678. X    {"rname",FSrname},
  679. X    {"rtelno",FSrtel},
  680. X    {"screen",FSscreen},
  681. X    {"time",FStime},
  682. X    {"times",FStimes},
  683. X    {"timez",FStimez},
  684. X    {"timezs",FStimezs},
  685. X    {"tty",FStty},
  686. X    {(char *)0,0}
  687. X};
  688. X
  689. Xextern char curr_dir[];
  690. Xextern int proctrace;
  691. Xextern PCB *pcb_stack[];
  692. Xextern int proc_level;
  693. Xextern char *sys_errlist[];
  694. Xextern int sys_nerr;
  695. Xextern struct timeb starting_timeb;
  696. Xextern uint tcap_LINES;
  697. Xextern uint tcap_COLS;
  698. X
  699. Xextern int shm_shmid;
  700. X
  701. Xchar *day_of_week_list = "SunMonTueWedThuFriSat";
  702. Xchar *month_name_list = "JanFebMarAprMayJunJulAugSepOctNovDec";
  703. X
  704. X/*+-------------------------------------------------------------------------
  705. X    erc = feval_int(param,&int_returned);
  706. XFunctions (parameter types are expressed by the usage of variables)
  707. X--------------------------------------------------------------------------*/
  708. Xfeval_int(param,value)
  709. XESD *param;
  710. Xlong *value;
  711. X{
  712. Xregister erc;
  713. Xregister keyword_token;
  714. Xint index_save;
  715. XESD *tesd1 = (ESD *)0;
  716. XESD *tesd2 = (ESD *)0;
  717. Xulong int1;
  718. Xchar s32[32];
  719. Xstruct timeb now_timeb;
  720. X
  721. X    index_save = param->index;
  722. X
  723. X    if(erc = get_alphanum_zstr(param,s32,sizeof(s32)))
  724. X    {
  725. X        erc = eInvalidFunction;
  726. X        goto RETURN;
  727. X    }
  728. X
  729. X    keyword_token = keyword_lookup(feval_int_tbl,s32);
  730. X    switch(keyword_token)
  731. X    {
  732. X/* LEN($S0)         length of $S0 */
  733. X    case FIlen:
  734. X        if(!(tesd1 = make_esd(256)))
  735. X        {
  736. X            erc = eNoMemory;
  737. X            goto RETURN;
  738. X        }
  739. X        if(erc = skip_paren(param,1))
  740. X            goto RETURN;
  741. X        if(erc = gstr(param,tesd1,1))
  742. X            goto RETURN;
  743. X        if(erc = skip_paren(param,0))
  744. X            goto RETURN;
  745. X        *value = (long)tesd1->cb;
  746. X        break;
  747. X
  748. X/* INSTR($I0,$I1)   index of first occurrence of $I1 in $I0, -1 if none */
  749. X    case FIinstr:
  750. X        if(!(tesd1 = make_esd(256)))
  751. X        {
  752. X            erc = eNoMemory;
  753. X            goto RETURN;
  754. X        }
  755. X        if(!(tesd2 = make_esd(256)))
  756. X        {
  757. X            erc = eNoMemory;
  758. X            goto RETURN;
  759. X        }
  760. X        if(erc = skip_paren(param,1))
  761. X            goto RETURN;
  762. X        if(erc = gstr(param,tesd1,1))
  763. X            goto RETURN;
  764. X        if(erc = skip_comma(param))
  765. X            goto RETURN;
  766. X        if(erc = gstr(param,tesd2,1))
  767. X            goto RETURN;
  768. X        if(erc = skip_paren(param,0))
  769. X            goto RETURN;
  770. X
  771. X        *value = (long)ulindex(tesd1->pb,tesd2->pb);
  772. X        break;
  773. X
  774. X/* RINSTR($I0,$I1)   index of last occurrence of $I1 in $I0, -1 if none */
  775. X    case FIrinstr:
  776. X        if(!(tesd1 = make_esd(256)))
  777. X        {
  778. X            erc = eNoMemory;
  779. X            goto RETURN;
  780. X        }
  781. X        if(!(tesd2 = make_esd(256)))
  782. X        {
  783. X            erc = eNoMemory;
  784. X            goto RETURN;
  785. X        }
  786. X        if(erc = skip_paren(param,1))
  787. X            goto RETURN;
  788. X        if(erc = gstr(param,tesd1,1))
  789. X            goto RETURN;
  790. X        if(erc = skip_comma(param))
  791. X            goto RETURN;
  792. X        if(erc = gstr(param,tesd2,1))
  793. X            goto RETURN;
  794. X        if(erc = skip_paren(param,0))
  795. X            goto RETURN;
  796. X
  797. X        *value = (long)ulrindex(tesd1->pb,tesd2->pb);
  798. X        break;
  799. X
  800. X    case FImatch:
  801. X        if(!(tesd1 = make_esd(256)))
  802. X        {
  803. X            erc = eNoMemory;
  804. X            goto RETURN;
  805. X        }
  806. X        if(!(tesd2 = make_esd(256)))
  807. X        {
  808. X            erc = eNoMemory;
  809. X            goto RETURN;
  810. X        }
  811. X        if(erc = skip_paren(param,1))
  812. X            goto RETURN;
  813. X        if(erc = gstr(param,tesd1,1))
  814. X            goto RETURN;
  815. X        if(erc = skip_comma(param))
  816. X            goto RETURN;
  817. X        if(erc = gstr(param,tesd2,1))
  818. X            goto RETURN;
  819. X        if(erc = skip_paren(param,0))
  820. X            goto RETURN;
  821. X
  822. X        erc = regexp_operation(tesd1->pb,tesd2->pb,value);
  823. X        break;
  824. X
  825. X    case FImhack:
  826. X        ftime(&now_timeb);
  827. X        *value = ((now_timeb.time - starting_timeb.time) * 1000) +
  828. X                (now_timeb.millitm - starting_timeb.millitm);
  829. X        erc = 0;
  830. X        break;
  831. X
  832. X    case FIesecs:
  833. X        ftime(&now_timeb);
  834. X        *value = now_timeb.time;
  835. X        erc = 0;
  836. X        break;
  837. X
  838. X    case FIargc:
  839. X        if(!proc_level)
  840. X        {
  841. X            pputs("not executing procedure\n");
  842. X            erc = eFATAL_ALREADY;
  843. X            break;
  844. X        }
  845. X        *value = (long)pcb_stack[proc_level - 1]->argc;
  846. X        break;
  847. X
  848. X    case FIcolors:
  849. X        if(erc = ifunc_colors(value))
  850. X            goto RETURN;
  851. X        break;
  852. X
  853. X    case FIftell:
  854. X        if(erc = ifunc_ftell(param,value))
  855. X            goto RETURN;
  856. X        break;
  857. X
  858. X    case FIfmode:
  859. X        if(erc = ifunc_fmode(param,value))
  860. X            goto RETURN;
  861. X        break;
  862. X
  863. X    case FIfsize:
  864. X        if(erc = ifunc_fsize(param,value))
  865. X            goto RETURN;
  866. X        break;
  867. X
  868. X    case FIfmtime:
  869. X        if(erc = ifunc_fmtime(param,value))
  870. X            goto RETURN;
  871. X        break;
  872. X
  873. X    case FIfatime:
  874. X        if(erc = ifunc_fatime(param,value))
  875. X            goto RETURN;
  876. X        break;
  877. X
  878. X    case FIischr:
  879. X        if(erc = ifunc_ischr(param,value))
  880. X            goto RETURN;
  881. X        break;
  882. X
  883. X    case FIisdir:
  884. X        if(erc = ifunc_isdir(param,value))
  885. X            goto RETURN;
  886. X        break;
  887. X
  888. X    case FIisreg:
  889. X        if(erc = ifunc_isreg(param,value))
  890. X            goto RETURN;
  891. X        break;
  892. X
  893. X    case FIbaud:
  894. X        *value = (long)shm->Lbaud;
  895. X        erc = 0;
  896. X        break;
  897. X
  898. X    case FIpid:
  899. X        *value = (long)getpid();
  900. X        erc = 0;
  901. X        break;
  902. X
  903. X    case FIcsec:
  904. X        *value = (shm->Lmodem_off_hook) ? shm->Loff_hook_time : -1;
  905. X        erc = 0;
  906. X        break;
  907. X
  908. X    case FIconn:
  909. X        *value = (long)(shm->Lmodem_off_hook) ? (long)shm->Liofd : 0;
  910. X        erc = 0;
  911. X        break;
  912. X
  913. X    case FIxchr:
  914. X        *value = shm->xmit_chars;
  915. X        erc = 0;
  916. X        break;
  917. X
  918. X    case FIxchrc:
  919. X        *value = shm->xmit_chars_this_connect;
  920. X        erc = 0;
  921. X        break;
  922. X
  923. X    case FIrchr:
  924. X        shmx_rc_report(value,&int1);
  925. X        break;
  926. X
  927. X    case FIrchrc:
  928. X        shmx_rc_report(&int1,value);
  929. X        erc = 0;
  930. X        break;
  931. X
  932. X/* LGETC($I0) get char from line, waiting for $I0 msec
  933. Xreturns  character read or -1 if none read in time */
  934. X    case FIlgetc:
  935. X        if(erc = skip_paren(param,1))
  936. X            goto RETURN;
  937. X        if(erc = gint(param,&int1))
  938. X            goto RETURN;
  939. X        if(erc = skip_paren(param,0))
  940. X            goto RETURN;
  941. X        *value = (long)lgetc_timeout(int1);
  942. X        break;
  943. X
  944. X    case FIctoi:
  945. X        if(!(tesd1 = make_esd(256)))
  946. X        {
  947. X            erc = eNoMemory;
  948. X            goto RETURN;
  949. X        }
  950. X        if(erc = skip_paren(param,1))
  951. X            goto RETURN;
  952. X        if(erc = gstr(param,tesd1,1))
  953. X            goto RETURN;
  954. X        if(erc = skip_paren(param,0))
  955. X            goto RETURN;
  956. X        if(tesd1->cb == 0)
  957. X            *value = -1;
  958. X        else
  959. X            *value = (long)((unsigned)0xFF & (unsigned)tesd1->pb[0]);
  960. X        break;
  961. X
  962. X    case FIstoi:
  963. X        if(!(tesd1 = make_esd(256)))
  964. X        {
  965. X            erc = eNoMemory;
  966. X            goto RETURN;
  967. X        }
  968. X        if(erc = skip_paren(param,1))
  969. X            goto RETURN;
  970. X        if(erc = gstr(param,tesd1,1))
  971. X            goto RETURN;
  972. X        if(erc = skip_paren(param,0))
  973. X            goto RETURN;
  974. X
  975. X        tesd1->index = 0;
  976. X        skip_cmd_break(tesd1);
  977. X        *value = 0;
  978. X        gint_constant(tesd1,value);
  979. X        break;
  980. X
  981. X    case FIcurx:
  982. X        *value = (long)shm->cursor_x;
  983. X        break;
  984. X
  985. X    case FIcury:
  986. X        *value = (long)shm->cursor_y;
  987. X        break;
  988. X
  989. X    case FIshmid:
  990. X        *value = (long)shm_shmid;
  991. X        break;
  992. X
  993. X    case FIisalpha:
  994. X    case FIisupper:
  995. X    case FIislower:
  996. X    case FIisdigit:
  997. X    case FIisxdigit:
  998. X    case FIisspace:
  999. X    case FIispunct:
  1000. X    case FIisalnum:
  1001. X    case FIisprint:
  1002. X    case FIisgraph:
  1003. X    case FIiscntrl:
  1004. X    case FIisascii:
  1005. X        if(!(tesd1 = make_esd(256)))
  1006. X        {
  1007. X            erc = eNoMemory;
  1008. X            goto RETURN;
  1009. X        }
  1010. X        if(erc = skip_paren(param,1))
  1011. X            goto RETURN;
  1012. X        if(erc = gstr(param,tesd1,1))
  1013. X            goto RETURN;
  1014. X        if(erc = skip_paren(param,0))
  1015. X            goto RETURN;
  1016. X        if(!tesd1->cb)
  1017. X        {
  1018. X            *value = 0;
  1019. X            goto RETURN;
  1020. X        }
  1021. X        switch(keyword_token)
  1022. X        {
  1023. X            case FIisalpha:
  1024. X                *value = !!isalpha(*tesd1->pb);
  1025. X                break;
  1026. X            case FIisupper:
  1027. X                *value = !!isupper(*tesd1->pb);
  1028. X                break;
  1029. X            case FIislower:
  1030. X                *value = !!islower(*tesd1->pb);
  1031. X                break;
  1032. X            case FIisdigit:
  1033. X                *value = !!isdigit(*tesd1->pb);
  1034. X                break;
  1035. X            case FIisxdigit:
  1036. X                *value = !!isxdigit(*tesd1->pb);
  1037. X                break;
  1038. X            case FIisspace:
  1039. X                *value = !!isspace(*tesd1->pb);
  1040. X                break;
  1041. X            case FIispunct:
  1042. X                *value = !!ispunct(*tesd1->pb);
  1043. X                break;
  1044. X            case FIisalnum:
  1045. X                *value = !!isalnum(*tesd1->pb);
  1046. X                break;
  1047. X            case FIisprint:
  1048. X                *value = !!isprint(*tesd1->pb);
  1049. X                break;
  1050. X            case FIisgraph:
  1051. X                *value = !!isgraph(*tesd1->pb);
  1052. X                break;
  1053. X            case FIiscntrl:
  1054. X                *value = !!iscntrl(*tesd1->pb);
  1055. X                break;
  1056. X            case FIisascii:
  1057. X                *value = !!isascii(*tesd1->pb);
  1058. X                break;
  1059. X        }
  1060. X        break;
  1061. X
  1062. X    case FIlines:
  1063. X        *value = (long)tcap_LINES;
  1064. X        break;
  1065. X
  1066. X    case FIcols:
  1067. X        *value = (long)tcap_COLS;
  1068. X        break;
  1069. X
  1070. X#if defined(ESIO_IN_USE)
  1071. X    case FIesio:
  1072. X        *value = 1;
  1073. X        break;
  1074. X    case FImsr:
  1075. X        *value = (long)esio_msr();
  1076. X        break;
  1077. X    case FIlnerr:
  1078. X        *value = (long)esio_line_errors();
  1079. X        break;
  1080. X    case FIridet:
  1081. X        *value = (long)esio_rings_detected();
  1082. X        break;
  1083. X    case FIbrdet:
  1084. X        *value = (long)esio_breaks_detected();
  1085. X        break;
  1086. X#else
  1087. X    case FIesio:
  1088. X        *value = 0;
  1089. X        break;
  1090. X#endif
  1091. X
  1092. X    default:
  1093. X        erc = eInvalidFunction;
  1094. X    }   /* end of keyword lookup erc switch statement */
  1095. X
  1096. XRETURN:
  1097. X    if(tesd1)
  1098. X        free_esd(tesd1);
  1099. X    if(tesd2)
  1100. X        free_esd(tesd2);
  1101. X    return(erc);
  1102. X
  1103. X}   /* end of feval_int() */
  1104. X
  1105. X/*+------------------------------------------------------------------
  1106. X    strfunc_left(param,&scratch_esd,&result_esd)
  1107. X-------------------------------------------------------------------*/
  1108. Xint
  1109. Xstrfunc_left(param,scratch_esd,result_esd)
  1110. XESD *param;
  1111. XESD *scratch_esd;
  1112. XESD *result_esd;
  1113. X{
  1114. Xregister erc;
  1115. Xint itmp;
  1116. Xlong ltmp;
  1117. X
  1118. X    if(erc = skip_paren(param,1))
  1119. X        return(erc);
  1120. X    if(erc = gstr(param,scratch_esd,1))
  1121. X        return(erc);
  1122. X    if(erc = skip_comma(param))
  1123. X        return(erc);
  1124. X    if(erc = gint(param,<mp))
  1125. X        return(erc);
  1126. X    itmp = (int)ltmp;
  1127. X    if(itmp < 0)
  1128. X        return(eBadParameter);
  1129. X    if(erc = skip_paren(param,0))
  1130. X        return(erc);
  1131. X    /* take min of param and .cb */
  1132. X    itmp = (itmp < scratch_esd->cb) ? itmp : scratch_esd->cb;
  1133. X    if(itmp > (result_esd->maxcb - result_esd->cb) )
  1134. X        return(eBufferTooSmall);
  1135. X    memcpy(&result_esd->pb[result_esd->cb],
  1136. X        scratch_esd->pb,itmp);
  1137. X    result_esd->cb += itmp;
  1138. X    return(erc);
  1139. X}   /* end of strfunc_left() */
  1140. X
  1141. X/*+-------------------------------------------------------------------------
  1142. X    erc = strfunc_right(param,&scratch_esd,&result_esd)
  1143. X--------------------------------------------------------------------------*/
  1144. Xint
  1145. Xstrfunc_right(param,scratch_esd,result_esd)
  1146. XESD *param;
  1147. XESD *scratch_esd;
  1148. XESD *result_esd;
  1149. X{
  1150. Xregister erc;
  1151. Xint itmp;
  1152. Xlong ltmp;
  1153. X
  1154. X    if(erc = skip_paren(param,1))
  1155. X        return(erc);
  1156. X    if(erc = gstr(param,scratch_esd,1))
  1157. X        return(erc);
  1158. X    if(erc = skip_comma(param))
  1159. X        return(erc);
  1160. X    if(erc = gint(param,<mp))
  1161. X        return(erc);
  1162. X    itmp = (int)ltmp;
  1163. X    if(itmp < 0)
  1164. X        return(eBadParameter);
  1165. X    if(erc = skip_paren(param,0))
  1166. X        return(erc);
  1167. X
  1168. X/* take min of param and .cb */
  1169. X    itmp = (itmp < scratch_esd->cb) ? itmp : scratch_esd->cb;
  1170. X    if(itmp > (result_esd->maxcb - result_esd->cb) )
  1171. X        return(eBufferTooSmall);
  1172. X    memcpy(&result_esd->pb[result_esd->cb],
  1173. X        &scratch_esd->pb[scratch_esd->cb - itmp],itmp);
  1174. X    result_esd->cb += itmp;
  1175. X    return(0);
  1176. X
  1177. X}   /* end of strfunc_right() */
  1178. X
  1179. X/*+-------------------------------------------------------------------------
  1180. X    erc = feval_str(param,&esd_to_be_plugged);
  1181. X    results are APPENDED to 'result_esd'
  1182. X--------------------------------------------------------------------------*/
  1183. Xfeval_str(param,result_esd)
  1184. XESD *param;
  1185. XESD *result_esd;
  1186. X{
  1187. Xregister erc;
  1188. Xregister itmp;
  1189. Xint int1,int2;
  1190. Xchar s32[32];
  1191. Xchar *cptr;
  1192. Xlong ltmp;
  1193. Xlong ltmp2;
  1194. Xlong ltmp3;
  1195. XESD *tesd1;
  1196. XESD *tesd2 = (ESD *)0;
  1197. Xchar *get_ttyname();
  1198. Xchar *getenv();
  1199. Xchar *getlogin();
  1200. Xchar *get_elapsed_time();
  1201. Xchar *mode_map();
  1202. X
  1203. X    if(!(tesd1 = make_esd(128)))
  1204. X        return(eNoMemory);
  1205. X
  1206. X    if(erc = get_alphanum_zstr(param,s32,sizeof(s32)-1))
  1207. X    {
  1208. X        free_esd(tesd1);
  1209. X        return(eInvalidFunction);
  1210. X    }
  1211. X
  1212. X    erc = 0;
  1213. X    itmp=keyword_lookup(feval_str_tbl,s32);
  1214. X    switch(itmp)
  1215. X    {
  1216. X/* LEFT($S0,$I0)   return leftmost $I0 characters of $S0 */
  1217. X    case FSleft:
  1218. X        erc = strfunc_left(param,tesd1,result_esd);
  1219. X        break;
  1220. X
  1221. X/* RIGHT($S0,$I0)   return rightmost $I0 characters of $S0 */
  1222. X    case FSright:
  1223. X        erc = strfunc_right(param,tesd1,result_esd);
  1224. X        break;
  1225. X
  1226. X/* MID($S0,$I0,$I1)   return middle $I1 chars of $S0 starting at $I0 */
  1227. X    case FSmid:
  1228. X        if(erc = skip_paren(param,1))
  1229. X            break;
  1230. X        if(erc = gstr(param,tesd1,1))
  1231. X            break;
  1232. X        if(erc = skip_comma(param))
  1233. X            break;
  1234. X        if(erc = gint(param,<mp))
  1235. X            break;
  1236. X        int1 = (int)ltmp;
  1237. X        if(int1 < 0)
  1238. X        {
  1239. X            erc = eBadParameter;
  1240. X            break;
  1241. X        }
  1242. X        if(erc = skip_cmd_break(param))
  1243. X            break;
  1244. X        if(param->pb[param->index] == ')') /* if we find a ')' instead of ... */
  1245. X        {                                  /* 2nd int param, default to max */
  1246. X            ++param->index;
  1247. X            int2 = 256;
  1248. X        }
  1249. X        else
  1250. X        {
  1251. X            if(erc = skip_comma(param))
  1252. X                break;
  1253. X            if(erc = gint(param,<mp))
  1254. X                break;
  1255. X            int2 = (int)ltmp;
  1256. X            if(int2 < 0)
  1257. X            {
  1258. X                erc = eBadParameter;
  1259. X                break;
  1260. X            }
  1261. X            if(erc = skip_paren(param,0))
  1262. X                break;
  1263. X        }
  1264. X
  1265. X        if(int1 >= tesd1->cb) /* if initial index past end of string */
  1266. X            break;
  1267. X        itmp = tesd1->cb - int1;
  1268. X        itmp = (int2 < itmp) ? int2 : itmp;
  1269. X        cptr = tesd1->pb + int1;
  1270. X        goto CPTR_ITMP_COMMON;
  1271. X
  1272. X/* ARGV($I0) */
  1273. X    case FSargv:
  1274. X        if(!proc_level)
  1275. X        {
  1276. X            pputs("not executing procedure\n");
  1277. X            erc = eFATAL_ALREADY;
  1278. X            break;
  1279. X        }
  1280. X        if(erc = skip_paren(param,1))
  1281. X            break;
  1282. X        if(erc = gint(param,<mp))
  1283. X            break;
  1284. X        if(erc = skip_paren(param,0))
  1285. X            break;
  1286. X        itmp = (long)pcb_stack[proc_level - 1]->argc; /* arg count */
  1287. X        if((int)ltmp > itmp - 1)
  1288. X        {
  1289. X            if(proctrace)
  1290. X            {
  1291. X                pprintf("WARNING: %%argc=%d, %%argv(%ld) null\n",
  1292. X                    itmp,ltmp);
  1293. X            }
  1294. X            break;
  1295. X        }
  1296. X        cptr = (pcb_stack[proc_level - 1])->argv[(int)ltmp];
  1297. X        itmp = strlen(cptr);
  1298. X        goto CPTR_ITMP_COMMON;
  1299. X
  1300. X    case FSdir:
  1301. X        cptr = curr_dir;
  1302. X        itmp = strlen(curr_dir);
  1303. X        goto CPTR_ITMP_COMMON;
  1304. X
  1305. X    case FSetime:
  1306. X        if(erc = skip_paren(param,1))
  1307. X            break;
  1308. X        if(erc = gint(param,<mp))
  1309. X            break;
  1310. X        if(erc = skip_paren(param,0))
  1311. X            break;
  1312. X        cptr = get_elapsed_time(ltmp);
  1313. X        itmp = strlen(cptr);
  1314. X        goto CPTR_ITMP_COMMON;
  1315. X
  1316. X    case FSerrstr:
  1317. X        if(erc = skip_paren(param,1))
  1318. X            break;
  1319. X        if(erc = gint(param,<mp))
  1320. X            break;
  1321. X        if(erc = skip_paren(param,0))
  1322. X            break;
  1323. X        if((int)ltmp >= sys_nerr)
  1324. X        {
  1325. X            sprintf(s32,"error %d",(int)ltmp);
  1326. X            cptr = s32;
  1327. X        }
  1328. X        else
  1329. X            cptr = sys_errlist[(int)ltmp];
  1330. X        itmp = strlen(cptr);
  1331. X        goto CPTR_ITMP_COMMON;
  1332. X
  1333. X    case FSenvvar:
  1334. X        if(erc = skip_paren(param,1))
  1335. X            break;
  1336. X        if(erc = gstr(param,tesd1,1))
  1337. X            break;
  1338. X        if(erc = skip_paren(param,0))
  1339. X            break;
  1340. X        if(!(cptr = getenv(tesd1->pb)))
  1341. X            break;
  1342. X        itmp = strlen(cptr);
  1343. X        goto CPTR_ITMP_COMMON;
  1344. X
  1345. X    case FSlogname:
  1346. X        if(!(cptr = getlogin()))
  1347. X            break;
  1348. X        itmp = strlen(cptr);
  1349. X        goto CPTR_ITMP_COMMON;
  1350. X
  1351. X    case FSfmodestr:
  1352. X        if(erc = skip_paren(param,1))
  1353. X            break;
  1354. X        if(erc = gint(param,<mp))
  1355. X            break;
  1356. X        if(erc = skip_paren(param,0))
  1357. X            break;
  1358. X        cptr = mode_map((int)ltmp,(char *)0);
  1359. X        itmp = strlen(cptr);
  1360. X        goto CPTR_ITMP_COMMON;
  1361. X
  1362. X    case FStty:
  1363. X        cptr = get_ttyname();
  1364. X        itmp = strlen(cptr);
  1365. X        goto CPTR_ITMP_COMMON;
  1366. X
  1367. X    case FSrname:
  1368. X        if(!shm->Lmodem_off_hook)
  1369. X            break;
  1370. X        cptr = shm->Lrname;
  1371. X        itmp = strlen(shm->Lrname);
  1372. X        goto CPTR_ITMP_COMMON;
  1373. X
  1374. X    case FSrdesc:
  1375. X        if(!shm->Lmodem_off_hook)
  1376. X            break;
  1377. X        cptr = shm->Ldescr;
  1378. X        itmp = strlen(shm->Ldescr);
  1379. X        goto CPTR_ITMP_COMMON;
  1380. X
  1381. X    case FSrtel:
  1382. X        if(!shm->Lmodem_off_hook)
  1383. X            break;
  1384. X        cptr = shm->Ltelno;
  1385. X        itmp = strlen(shm->Ltelno);
  1386. X        goto CPTR_ITMP_COMMON;
  1387. X
  1388. X    case FSline:
  1389. X        if(shm->Liofd < 0)
  1390. X            break;
  1391. X        cptr = shm->Lline;
  1392. X        itmp = strlen(shm->Lline);
  1393. X        goto CPTR_ITMP_COMMON;
  1394. X
  1395. X    case FSmonth:
  1396. X    case FSmonthz:
  1397. X        cptr = &month_name_list[(get_month(itmp == FSmonthz) - 1) * 3];
  1398. X        itmp = 3;
  1399. X        goto CPTR_ITMP_COMMON;
  1400. X
  1401. X    case FSday:
  1402. X    case FSdayz:
  1403. X        cptr = &day_of_week_list[get_day(itmp == FSdayz) * 3];
  1404. X        itmp = 3;
  1405. X        goto CPTR_ITMP_COMMON;
  1406. X
  1407. X    case FSscreen:
  1408. X        if(erc = skip_paren(param,1))
  1409. X            break;
  1410. X        if(erc = gint(param,<mp))        /* y */
  1411. X            break;
  1412. X        if(ltmp > 42)
  1413. X        {
  1414. X            erc = eBadParameter;
  1415. X            break;
  1416. X        }
  1417. X        if(erc = skip_comma(param))
  1418. X            break;
  1419. X        if(erc = gint(param,<mp2))    /* x */
  1420. X            break;
  1421. X        if(ltmp2 > 79)
  1422. X        {
  1423. X            erc = eBadParameter;
  1424. X            break;
  1425. X        }
  1426. X        if(erc = skip_comma(param))
  1427. X            break;
  1428. X        if(erc = gint(param,<mp3))    /* len */
  1429. X            break;
  1430. X        if(erc = skip_paren(param,0))
  1431. X            break;
  1432. X
  1433. X        int1 = ((int)ltmp * 80) + (int)ltmp2;    /* screen position */
  1434. X        itmp = (int)ltmp3;                        /* length */
  1435. X        int2 = sizeof(shm->screen) - int1;        /* size from y,x to end */
  1436. X        if(itmp > int2)
  1437. X            itmp = int2;
  1438. X        cptr = ((char *)shm->screen) + int1;
  1439. X        goto CPTR_ITMP_COMMON;
  1440. X
  1441. X    case FSbasename:
  1442. X        if(!(tesd2 = make_esd(32)))
  1443. X            return(eNoMemory);
  1444. X        if(erc = skip_paren(param,1))
  1445. X            break;
  1446. X        if(erc = gstr(param,tesd1,1))
  1447. X            break;
  1448. X        if(erc = skip_comma(param))
  1449. X            break;
  1450. X        if(erc = gstr(param,tesd2,1))
  1451. X            break;
  1452. X        if(erc = skip_paren(param,0))
  1453. X            break;
  1454. X        cptr = tesd1->pb;
  1455. X        itmp = tesd1->cb;
  1456. X        if((tesd1->cb >= tesd2->cb) &&
  1457. X            !strcmp(cptr + tesd1->cb - tesd2->cb,tesd2->pb))
  1458. X        {
  1459. X            itmp -= tesd2->cb;
  1460. X        }
  1461. X        goto CPTR_ITMP_COMMON;
  1462. X
  1463. X    case FSdirpart:
  1464. X        if(erc = skip_paren(param,1))
  1465. X            break;
  1466. X        if(erc = gstr(param,tesd1,1))
  1467. X            break;
  1468. X        if(erc = skip_paren(param,0))
  1469. X            break;
  1470. X        if(cptr = strrchr(tesd1->pb,'/'))
  1471. X            itmp = cptr - tesd1->pb;
  1472. X        else
  1473. X            itmp = tesd1->cb;
  1474. X        cptr = tesd1->pb;
  1475. X        goto CPTR_ITMP_COMMON;
  1476. X
  1477. X    case FSfilepart:
  1478. X        if(erc = skip_paren(param,1))
  1479. X            break;
  1480. X        if(erc = gstr(param,tesd1,1))
  1481. X            break;
  1482. X        if(erc = skip_paren(param,0))
  1483. X            break;
  1484. X        if(cptr = strrchr(tesd1->pb,'/'))
  1485. X            itmp = strlen(++cptr);
  1486. X        else
  1487. X        {
  1488. X            cptr = tesd1->pb;
  1489. X            itmp = tesd1->cb;
  1490. X        }
  1491. X        goto CPTR_ITMP_COMMON;
  1492. X
  1493. X#if defined(ESIO_IN_USE)
  1494. X    case FSmsrtext:
  1495. X        cptr = msr_text(esio_msr());
  1496. X        itmp = strlen(cptr);
  1497. X        goto CPTR_ITMP_COMMON;
  1498. X#endif
  1499. X
  1500. XCPTR_ITMP_COMMON:
  1501. X        if( itmp > (result_esd->maxcb - result_esd->cb))
  1502. X        {
  1503. X            erc = eBufferTooSmall;
  1504. X            break;
  1505. X        }
  1506. X        memcpy(&result_esd->pb[result_esd->cb],cptr,itmp);
  1507. X        result_esd->cb += itmp;
  1508. X        break;
  1509. X
  1510. X    case FSedate:
  1511. X        if(erc = skip_paren(param,1))
  1512. X            break;
  1513. X        if(erc = gint(param,<mp))
  1514. X            break;
  1515. X        if(erc = skip_paren(param,0))
  1516. X            break;
  1517. X        if(19 > (result_esd->maxcb - result_esd->cb))
  1518. X        {
  1519. X            erc = eBufferTooSmall;
  1520. X            break;
  1521. X        }
  1522. X        epoch_secs_to_str(ltmp,3,&result_esd->pb[result_esd->cb]);
  1523. X        result_esd->cb += 19;
  1524. X        break;
  1525. X
  1526. X    case FStime:
  1527. X        if(5 > (result_esd->maxcb - result_esd->cb))
  1528. X        {
  1529. X            erc = eBufferTooSmall;
  1530. X            break;
  1531. X        }
  1532. X        get_tod(0,&result_esd->pb[result_esd->cb]);
  1533. X        result_esd->cb += 5;
  1534. X        break;
  1535. X
  1536. X    case FStimes:
  1537. X        if(8 > (result_esd->maxcb - result_esd->cb))
  1538. X        {
  1539. X            erc = eBufferTooSmall;
  1540. X            break;
  1541. X        }
  1542. X        get_tod(1,&result_esd->pb[result_esd->cb]);
  1543. X        result_esd->cb += 8;
  1544. X        break;
  1545. X
  1546. X    case FStimez:
  1547. X        if(5 > (result_esd->maxcb - result_esd->cb))
  1548. X        {
  1549. X            erc = eBufferTooSmall;
  1550. X            break;
  1551. X        }
  1552. X        get_tod(6,&result_esd->pb[result_esd->cb]);
  1553. X        result_esd->cb += 5;
  1554. X        break;
  1555. X
  1556. X    case FStimezs:
  1557. X        if(8 > (result_esd->maxcb - result_esd->cb))
  1558. X        {
  1559. X            erc = eBufferTooSmall;
  1560. X            break;
  1561. X        }
  1562. X        get_tod(7,&result_esd->pb[result_esd->cb]);
  1563. X        result_esd->cb += 8;
  1564. X        break;
  1565. X
  1566. X    case FSdate:
  1567. X        if(10 > (result_esd->maxcb - result_esd->cb))
  1568. X        {
  1569. X            erc = eBufferTooSmall;
  1570. X            break;
  1571. X        }
  1572. X        get_tod(5,&result_esd->pb[result_esd->cb]);
  1573. X        result_esd->cb += 10;
  1574. X        break;
  1575. X
  1576. X    case FSdatez:
  1577. X        if(10 > (result_esd->maxcb - result_esd->cb))
  1578. X        {
  1579. X            erc = eBufferTooSmall;
  1580. X            break;
  1581. X        }
  1582. X        get_tod(8,&result_esd->pb[result_esd->cb]);
  1583. X        result_esd->cb += 10;
  1584. X        break;
  1585. X
  1586. X    case FScgets:
  1587. X        erc = ttygets_esd(result_esd,1,1);
  1588. X        break;
  1589. X
  1590. X    case FScgetc:
  1591. X        if(result_esd->cb == result_esd->maxcb)
  1592. X        {
  1593. X            erc = eBufferTooSmall;
  1594. X            break;
  1595. X        }
  1596. X        result_esd->pb[result_esd->cb] = ttygetc(0);
  1597. X        result_esd->cb++;
  1598. X        break;
  1599. X
  1600. X    case FSchr:
  1601. X        if(erc = skip_paren(param,1))
  1602. X            break;
  1603. X        if(erc = gint(param,<mp))
  1604. X            break;
  1605. X        if(!ltmp)
  1606. X        {
  1607. X            pputs("cannot use %chr(0)\n");
  1608. X            return(eFATAL_ALREADY);
  1609. X        }
  1610. X        if(erc = skip_paren(param,0))
  1611. X            break;
  1612. X        if(result_esd->cb == result_esd->maxcb )
  1613. X        {
  1614. X            erc = eBufferTooSmall;
  1615. X            break;
  1616. X        }
  1617. X        result_esd->pb[result_esd->cb] = (char)ltmp;
  1618. X        result_esd->cb++;
  1619. X        break;
  1620. X
  1621. X    case FSitos:
  1622. X        if(erc = skip_paren(param,1))
  1623. X            break;
  1624. X        if(erc = gint(param,<mp))
  1625. X            break;
  1626. X        s32[0] = 0;
  1627. X        if(!skip_comma(param))
  1628. X        {
  1629. X            if(erc = get_numeric_zstr(param,s32 + 1,sizeof(s32) - 4))
  1630. X                strcpy(s32 + 1,"1");
  1631. X            if(((itmp = atoi(s32 + 1)) < 0) ||
  1632. X                (itmp > (result_esd->maxcb - result_esd->cb)))
  1633. X            {
  1634. X                erc = eBufferTooSmall;
  1635. X                break;
  1636. X            }
  1637. X            s32[0] = '%';
  1638. X            if(ulindex(param->pb + param->index,"x") == 0)
  1639. X            {
  1640. X                param->index++;
  1641. X                strcat(s32,"lx");
  1642. X            }
  1643. X            else if(ulindex(param->pb + param->index,"o") == 0)
  1644. X            {
  1645. X                param->index++;
  1646. X                strcat(s32,"lo");
  1647. X            }
  1648. X            else if(ulindex(param->pb + param->index,"d") == 0)
  1649. X            {
  1650. X                param->index++;
  1651. X                strcat(s32,"ld");
  1652. X            }
  1653. X            else if(erc)
  1654. X                break;
  1655. X            else
  1656. X                strcat(s32,"ld");
  1657. X        }
  1658. X        if(erc = skip_paren(param,0))
  1659. X            break;
  1660. X        sprintf(tesd1->pb,s32[0] ? s32 : "%ld",ltmp);
  1661. X        tesd1->cb = strlen(tesd1->pb);
  1662. X        if(result_esd->maxcb - result_esd->cb < tesd1->cb)
  1663. X        {
  1664. X            erc = eBufferTooSmall;
  1665. X            break;
  1666. X        }
  1667. X        strcpy(&result_esd->pb[result_esd->cb],tesd1->pb);
  1668. X        result_esd->cb += tesd1->cb;
  1669. X        break;
  1670. X
  1671. X
  1672. X    default:
  1673. X        erc = eInvalidFunction;
  1674. X        break;
  1675. X    }   /* end of keyword lookup erc switch statement */
  1676. X
  1677. X    null_terminate_esd(result_esd);
  1678. X    free_esd(tesd1);
  1679. X    if(tesd2)
  1680. X        free_esd(tesd1);
  1681. X    return(erc);
  1682. X
  1683. X}   /* end of feval_str() */
  1684. X
  1685. X/* vi: set tabstop=4 shiftwidth=4: */
  1686. X/* end of feval.c */
  1687. SHAR_EOF
  1688. $TOUCH -am 1226023290 'feval.c' &&
  1689. chmod 0644 feval.c ||
  1690. echo 'restore of feval.c failed'
  1691. Wc_c="`wc -c < 'feval.c'`"
  1692. test 24950 -eq "$Wc_c" ||
  1693.     echo 'feval.c: original size 24950, current size' "$Wc_c"
  1694. # ============= gint.c ==============
  1695. echo 'x - extracting gint.c (Text)'
  1696. sed 's/^X//' << 'SHAR_EOF' > 'gint.c' &&
  1697. X/*+-------------------------------------------------------------------------
  1698. X    gint.c - ecu get integer parameter functions
  1699. X    wht@n4hgf.Mt-Park.GA.US
  1700. X
  1701. X  Defined functions:
  1702. X    gcol_range(param,col1,col2)
  1703. X    gint(param,int_returned)
  1704. X    gint_base(param,value)
  1705. X    gint_constant(param,value)
  1706. X    gintop(param,intop)
  1707. X
  1708. X--------------------------------------------------------------------------*/
  1709. X/*+:EDITS:*/
  1710. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  1711. X
  1712. X#include "ecu.h"
  1713. X#include "ecuerror.h"
  1714. X#include "esd.h"
  1715. X#include "var.h"
  1716. X
  1717. X#define OP_ADD      1
  1718. X#define OP_SUB      2
  1719. X#define OP_MUL      3
  1720. X#define OP_DIV      4
  1721. X#define OP_XOR      5
  1722. X#define OP_MOD      6
  1723. X#define OP_OR       7
  1724. X#define OP_AND      8
  1725. X
  1726. X#define BASE_DEC    1
  1727. X#define BASE_OCT    2
  1728. X#define BASE_HEX      3
  1729. X
  1730. X
  1731. X/*+-------------------------------------------------------------------------
  1732. X    gint_constant(param,int_returned) - evaluate integer constant
  1733. X--------------------------------------------------------------------------*/
  1734. Xint
  1735. Xgint_constant(param,value)
  1736. XESD *param;
  1737. Xlong *value;
  1738. X{
  1739. Xregister itmp;
  1740. Xint base = BASE_DEC;
  1741. Xint erc;
  1742. Xlong new_value;
  1743. X
  1744. X    if(erc = skip_cmd_break(param))
  1745. X        return(erc);
  1746. X    null_terminate_esd(param);
  1747. X
  1748. X/* get integer from string */
  1749. X    if((!strncmp(param->pb + param->index,"0x",2)) ||
  1750. X        (!strncmp(param->pb + param->index,"0X",2)))
  1751. X    {
  1752. X        base = BASE_HEX;
  1753. X        param->index += 2;
  1754. X    }
  1755. X#ifdef WANT_OCT
  1756. X    else if(*(param->pb + param->index) == '0')
  1757. X        base = BASE_OCT;
  1758. X#endif
  1759. X
  1760. X    param->old_index = param->index;
  1761. X    switch(base)
  1762. X    {
  1763. X    case BASE_HEX:
  1764. X        sscanf(param->pb + param->index,"%lx",&new_value);
  1765. X        itmp = param->index + strspn(param->pb + param->index,
  1766. X            "0123456789ABCDEFabcdef");
  1767. X        erc = eInvalidHexNumber;
  1768. X        break;
  1769. X    case BASE_DEC:
  1770. X        sscanf(param->pb + param->index,"%ld",&new_value);
  1771. X        itmp = param->index + strspn(param->pb + param->index,"0123456789");
  1772. X        erc = eInvalidDecNumber;
  1773. X        break;
  1774. X#ifdef WANT_OCT
  1775. X    case BASE_OCT:
  1776. X        sscanf(param->pb + param->index,"%lo",&new_value);
  1777. X        itmp = param->index + strspn(param->pb + param->index,"01234567");
  1778. X        erc = eInvalidOctNumber;
  1779. X        break;
  1780. X#endif
  1781. X    }
  1782. X
  1783. X    param->index = itmp;
  1784. X    if(isalnum(*(param->pb + itmp)))
  1785. X        param->old_index = itmp;
  1786. X
  1787. X    if(param->old_index != param->index)
  1788. X    {
  1789. X        *value = new_value;
  1790. X        return(0);
  1791. X    }
  1792. X    return(erc);
  1793. X
  1794. X}   /* end of gint_constant */
  1795. X
  1796. X/*+-------------------------------------------------------------------------
  1797. X    gint_base(param,value) - evaluate integer constant, variable or function
  1798. X--------------------------------------------------------------------------*/
  1799. Xint
  1800. Xgint_base(param,value)
  1801. XESD *param;
  1802. Xlong *value;
  1803. X{
  1804. Xregister erc;
  1805. Xlong *varptr;
  1806. X
  1807. X    if(erc = skip_cmd_break(param))
  1808. X        return(erc);
  1809. X
  1810. X    switch(param->pb[param->index])        /* look at first character */
  1811. X    {
  1812. X    case '$':        /* '$i...' variable reference? */
  1813. X        if(param->index >= param->cb-2)
  1814. X            return(eSyntaxError);
  1815. X        param->old_index = ++param->index;
  1816. X        if(to_lower(param->pb[param->index++]) != 'i')
  1817. X            return(eIllegalVarType);
  1818. X        if(erc = get_ivptr(param,&varptr,0))
  1819. X            return(erc);
  1820. X        *value = *varptr;    
  1821. X        return(0);
  1822. X
  1823. X    case '%':        /* '%...' function reference? */
  1824. X        param->index++;
  1825. X        if(erc = feval_int(param,value))
  1826. X            return(erc);
  1827. X        return(0);
  1828. X
  1829. X    default:
  1830. X        break;
  1831. X    }   /* end of switch statement */
  1832. X
  1833. X/* we did not catch any special cases with the switch statement must
  1834. Xbe numeric integer */
  1835. X
  1836. X    return(gint_constant(param,value));
  1837. X
  1838. X}   /* end of gint_base() */
  1839. X
  1840. X/*+-------------------------------------------------------------------------
  1841. X    gintop(param,intop) - evaluate integer operator
  1842. X--------------------------------------------------------------------------*/
  1843. Xint
  1844. Xgintop(param,intop)
  1845. XESD *param;
  1846. Xint *intop;
  1847. X{
  1848. X    register erc;
  1849. X
  1850. X    if(erc = skip_cmd_break(param))
  1851. X        return(erc);
  1852. X    switch(param->pb[param->index])
  1853. X    {
  1854. X    case '+':
  1855. X        param->index++;
  1856. X        *intop = OP_ADD;
  1857. X        break;
  1858. X
  1859. X    case '-':
  1860. X        param->index++;
  1861. X        *intop = OP_SUB;
  1862. X        break;
  1863. X
  1864. X    case '*':
  1865. X        param->index++;
  1866. X        *intop = OP_MUL;
  1867. X        break;
  1868. X
  1869. X    case '/':
  1870. X        param->index++;
  1871. X        *intop = OP_DIV;
  1872. X        break;
  1873. X
  1874. X    case '|':
  1875. X        if(*(param->pb + param->index + 1) == '|')
  1876. X            return(eInvalidIntOp);
  1877. X        param->index++;
  1878. X        *intop = OP_OR;
  1879. X        break;
  1880. X
  1881. X    case '@':
  1882. X        param->index++;
  1883. X        *intop = OP_MOD;
  1884. X        break;
  1885. X
  1886. X    case '^':
  1887. X        param->index++;
  1888. X        *intop = OP_XOR;
  1889. X        break;
  1890. X
  1891. X    case '&':
  1892. X        if(*(param->pb + param->index + 1) == '&')
  1893. X            return(eInvalidIntOp);
  1894. X        param->index++;
  1895. X        *intop = OP_AND;
  1896. X        break;
  1897. X
  1898. X    default:
  1899. X        return(eInvalidIntOp);
  1900. X        break;
  1901. X    }   /* end of switch statement */
  1902. X
  1903. X    return(0);
  1904. X
  1905. X}   /* end of gintop() */
  1906. X
  1907. X/*+-------------------------------------------------------------------------
  1908. X    gint(param,int_returned) - evaluate integer expression
  1909. X--------------------------------------------------------------------------*/
  1910. Xint
  1911. Xgint(param,int_returned)
  1912. XESD *param;
  1913. Xlong *int_returned;
  1914. X{
  1915. Xregister erc;
  1916. Xlong int1;
  1917. Xlong int_accum = 0;
  1918. Xint intop;
  1919. Xint unary_minus = 0;
  1920. X
  1921. X    if(erc = skip_cmd_break(param))
  1922. X        return(erc);
  1923. X    if(param->pb[param->index] == '-')
  1924. X        unary_minus++,param->index++;
  1925. X
  1926. X    if(erc = gint_base(param,&int1))
  1927. X        return(erc);
  1928. X    int_accum = (unary_minus) ? -int1 : int1;
  1929. X
  1930. X    while((erc = gintop(param,&intop)) == 0)
  1931. X    {
  1932. X        if(erc = gint_base(param,&int1))
  1933. X            return(erc);
  1934. X        switch(intop)
  1935. X        {
  1936. X        case OP_ADD:
  1937. X            int_accum += int1;
  1938. X            break;
  1939. X        case OP_SUB:
  1940. X            int_accum -= int1;
  1941. X            break;
  1942. X        case OP_MUL:
  1943. X            int_accum *= int1;
  1944. X            break;
  1945. X        case OP_DIV:
  1946. X            int_accum /= int1;
  1947. X            break;
  1948. X        case OP_MOD:
  1949. X            int_accum %= int1;
  1950. X            break;
  1951. X        case OP_XOR:
  1952. X            (unsigned)int_accum ^= (unsigned)int1;
  1953. X            break;
  1954. X        case OP_AND:
  1955. X            (unsigned)int_accum &= (unsigned)int1;
  1956. X            break;
  1957. X        case OP_OR:
  1958. X            (unsigned)int_accum |= (unsigned)int1;
  1959. X            break;
  1960. X        default:
  1961. X            return(eInvalidIntOp);
  1962. X        }
  1963. X    }
  1964. X    param->index = param->old_index;
  1965. X
  1966. X    *int_returned = int_accum;
  1967. X    return(0);
  1968. X}   /* end of gint() */
  1969. X
  1970. X/*+-------------------------------------------------------------------------
  1971. X    col_range(param,col1,col2) - get a column range
  1972. X:$i0[-$i1]
  1973. Xargument may be integer constant, function or variable, but not expression
  1974. X--------------------------------------------------------------------------*/
  1975. Xint
  1976. Xgcol_range(param,col1,col2)
  1977. XESD *param;
  1978. Xulong *col1;
  1979. Xulong *col2;
  1980. X{
  1981. X    register erc;
  1982. X
  1983. X    if(skip_cmd_char(param,':') == 0)
  1984. X    {
  1985. X        if(erc = gint_base(param,col1))
  1986. X            return(erc);
  1987. X
  1988. X        if(skip_cmd_char(param,'-') == 0)     /* if hyphen found, range */
  1989. X        {
  1990. X            if(erc = gint_base(param,col2))
  1991. X                return(erc);
  1992. X        }
  1993. X        else
  1994. X            *col2 = *col1;        /* otherwise, first and last columns same */
  1995. X
  1996. X        if(*col1 > *col2)
  1997. X        {
  1998. X            pputs("Invalid column range: column 1 greater than column 2\n");
  1999. X            return(eFATAL_ALREADY);
  2000. X        }
  2001. X    }
  2002. X    else
  2003. X        erc = eBadParameter;
  2004. X
  2005. X    return(erc);
  2006. X}   /* end of gcol_range() */
  2007. X
  2008. X/* vi: set tabstop=4 shiftwidth=4: */
  2009. X/* end of gint.c */
  2010. SHAR_EOF
  2011. $TOUCH -am 1224223890 'gint.c' &&
  2012. chmod 0644 gint.c ||
  2013. echo 'restore of gint.c failed'
  2014. Wc_c="`wc -c < 'gint.c'`"
  2015. test 6629 -eq "$Wc_c" ||
  2016.     echo 'gint.c: original size 6629, current size' "$Wc_c"
  2017. # ============= gstr.c ==============
  2018. echo 'x - extracting gstr.c (Text)'
  2019. sed 's/^X//' << 'SHAR_EOF' > 'gstr.c' &&
  2020. X/*+-------------------------------------------------------------------------
  2021. X    gstr.c - ecu get string parameter functions
  2022. X    wht@n4hgf.Mt-Park.GA.US
  2023. X
  2024. X  Defined functions:
  2025. X    gstr(param,result,realloc_ok)
  2026. X
  2027. X--------------------------------------------------------------------------*/
  2028. X/*+:EDITS:*/
  2029. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  2030. X
  2031. X#include "ecu.h"
  2032. X#include "ecuerror.h"
  2033. X#include "esd.h"
  2034. X#include "var.h"
  2035. X
  2036. Xextern int proctrace;
  2037. X
  2038. X/*+-------------------------------------------------------------------------
  2039. X    gstr(param,result,realloc_ok) - get a string 
  2040. X
  2041. XExamples:
  2042. X
  2043. X set $s0='test ... '+%date+' '+%time+%chr(0x0D)+%chr(0x0A)
  2044. X hexdump $s0
  2045. X0000  74 65 73 74 20 2E 2E 2E 20 30 36 2D 30 39 2D 31 | test ... 06-09-1 |
  2046. X0010  39 38 39 20 31 37 3A 31 35 0D 0A                | 989 17:15..      |
  2047. X
  2048. X set $s0='12345678':1-6+'abc'
  2049. X set s0
  2050. X$S00 = '234567abc'
  2051. X
  2052. Xif realloc_ok and string too small, realloc result string as necessary
  2053. X
  2054. X--------------------------------------------------------------------------*/
  2055. Xint
  2056. Xgstr(param,result,realloc_ok)
  2057. XESD *param;
  2058. XESD *result;
  2059. Xint realloc_ok;
  2060. X{
  2061. Xregister char param_char;
  2062. Xregister char *pb;
  2063. XESD *tesd;
  2064. XESD *svptr;
  2065. Xint cb = 0;
  2066. Xint segment_index;
  2067. Xint next_is_literal = 0;    /* last char was not a backslash */
  2068. Xulong itmp1;
  2069. Xulong itmp2;
  2070. Xulong itmp3;
  2071. Xulong itmp4;
  2072. Xint erc;
  2073. Xint param_index_save;
  2074. Xint result_remaining;
  2075. Xint in_quoted_string = 0;   /* not currently in quoted string */
  2076. Xint end_of_parameter = 0;
  2077. X
  2078. X    if(erc = skip_cmd_break(param))
  2079. X        return(erc);
  2080. X
  2081. X    segment_index = 0;            
  2082. X    result_remaining = result->maxcb;    /* number we can put into result */
  2083. X    param_index_save = param->index;
  2084. X
  2085. X    if((tesd = make_esd(5120)) == (ESD *)0)
  2086. X        return(eNoMemory);
  2087. X    pb = tesd->pb;
  2088. X
  2089. XCONCATENATE:
  2090. X    while((param->index < param->cb) && !end_of_parameter)
  2091. X    {
  2092. X        param_char = param->pb[param->index];
  2093. X        if(in_quoted_string)
  2094. X        {
  2095. X            ++param->index;
  2096. X            if(next_is_literal)
  2097. X            {
  2098. X                next_is_literal = 0;
  2099. X                switch(param_char)
  2100. X                {
  2101. X                    case 'b' : param_char = 0x08; break;
  2102. X                    case 'n' : param_char = 0x0A; break;
  2103. X                    case 'r' : param_char = 0x0D; break;
  2104. X                    case 't' : param_char = 0x09; break;
  2105. X                    case '\'': param_char = '\''; break;
  2106. X                }
  2107. X                if((result_remaining-- == 0) && (!realloc_ok && (cb == 5120)))
  2108. X                {
  2109. X                    erc = eBufferTooSmall;
  2110. X                    goto RETURN;
  2111. X                }
  2112. X                *(pb + cb++) = param_char;
  2113. X            }
  2114. X            else if(param_char == '\\')
  2115. X                next_is_literal = 1;
  2116. X            else if(param_char == '\'')
  2117. X                in_quoted_string = 0;
  2118. X            else
  2119. X            {
  2120. X                if((result_remaining-- == 0) && (!realloc_ok && (cb == 5120)))
  2121. X                {
  2122. X                    erc = eBufferTooSmall;
  2123. X                    goto RETURN;
  2124. X                }
  2125. X                *(pb + cb++) = param_char;
  2126. X            }
  2127. X        }
  2128. X        else /* not in quoted string */
  2129. X        {
  2130. X            param->old_index = param->index;
  2131. X            switch(param_char)
  2132. X            {
  2133. X            case '\'':      /* apostrophe denotes literal text */
  2134. X                ++param->index;
  2135. X                in_quoted_string = 1;
  2136. X                break;
  2137. X
  2138. X            case '%':
  2139. X                ++param->index;
  2140. X                tesd->cb = cb;
  2141. X                if(erc = feval_str(param,tesd))
  2142. X                    goto RETURN;
  2143. X                cb = tesd->cb;
  2144. X                result_remaining = (result->maxcb - cb);
  2145. X                break;
  2146. X
  2147. X            case '$':           /* '$Snn' variable reference? */
  2148. X                /* must be at least two more character */
  2149. X                if(param->index >= param->cb-2)
  2150. X                {
  2151. X                    erc = eSyntaxError;
  2152. X                    goto RETURN;
  2153. X                }
  2154. X                param->old_index = ++param->index;
  2155. X                if(to_lower(param->pb[param->index++]) != 's' )
  2156. X                {
  2157. X                    erc = eIllegalVarType;
  2158. X                    goto RETURN;
  2159. X                }
  2160. X                if(erc = get_svptr(param,&svptr,0))
  2161. X                    goto RETURN;
  2162. X                if((!realloc_ok && (svptr->cb > (result->maxcb - cb))) ||
  2163. X                    (svptr->cb > (5120 - cb)))
  2164. X                {
  2165. X                    erc = eBufferTooSmall;
  2166. X                    goto RETURN;
  2167. X                }
  2168. X                else if(svptr->cb)
  2169. X                {
  2170. X                    memcpy(&pb[cb],svptr->pb,svptr->cb);
  2171. X                    cb += svptr->cb;
  2172. X                    result_remaining -= svptr->cb;
  2173. X                }
  2174. X                break;
  2175. X
  2176. X            case ':':
  2177. X/*
  2178. Xitmp1 holds col 1 (0-n) of substring operation
  2179. Xitmp2 holds col 2 (0-n) of operation adjusted to reflect end of string segment
  2180. Xitmp3 holds length of string segment
  2181. Xitmp4 holds length of substring segment output by substring operation
  2182. X*/
  2183. X                if(erc = gcol_range(param,&itmp1,&itmp2))
  2184. X                    goto RETURN;
  2185. X                if((itmp3 = cb - segment_index)
  2186. X                    &&
  2187. X                    (itmp4 = ((itmp2<itmp3)?itmp2:itmp3) - itmp1 + 1))
  2188. X                {
  2189. X                    if(itmp1)
  2190. X                        memcpy(&pb[segment_index],
  2191. X                            &pb[segment_index+(int)itmp1],(int)itmp4);
  2192. X                    cb -= ((int)itmp3 - (int)itmp4);
  2193. X                }
  2194. X                break;
  2195. X
  2196. X            case '+':
  2197. X                segment_index = cb;
  2198. X                ++param->index;
  2199. X                goto CONCATENATE;
  2200. X
  2201. X            case ';':
  2202. X            case '#':
  2203. X                end_of_parameter = 1;
  2204. X                break;
  2205. X
  2206. X            default:
  2207. X                null_terminate_esd(result);
  2208. X                erc = 0;
  2209. X                if((param->index < param->cb) &&
  2210. X                    isalnum(*(param->pb + param->index)))
  2211. X                    erc = eSyntaxError;
  2212. X                else if(param_index_save == param->index)
  2213. X                    erc = eBadParameter;
  2214. X                end_of_parameter = 1;
  2215. X                break;
  2216. X            }   /* end of switch (param_char) */
  2217. X        }       /* end of else not in quoted string */
  2218. X    }           /* end of while(index<cb) */
  2219. X
  2220. X
  2221. XRETURN:
  2222. X    if(result_remaining < 0)
  2223. X    {
  2224. X        if(realloc_ok)
  2225. X            erc = realloc_esd(result,((cb * 64) * 31) / 64);
  2226. X        else
  2227. X            erc = eBufferTooSmall;
  2228. X        if(erc)
  2229. X            return(erc);
  2230. X    }
  2231. X    if(cb)
  2232. X        memcpy(result->pb,pb,cb);
  2233. X    result->cb = cb;
  2234. X    null_terminate_esd(result);
  2235. X    free_esd(tesd);
  2236. X    return(erc);
  2237. X}   /* end of gqstr */
  2238. X
  2239. X/* vi: set tabstop=4 shiftwidth=4: */
  2240. X/* end of qstr.c */
  2241. SHAR_EOF
  2242. $TOUCH -am 1224223890 'gstr.c' &&
  2243. chmod 0644 gstr.c ||
  2244. echo 'restore of gstr.c failed'
  2245. Wc_c="`wc -c < 'gstr.c'`"
  2246. test 5212 -eq "$Wc_c" ||
  2247.     echo 'gstr.c: original size 5212, current size' "$Wc_c"
  2248. true || echo 'restore of hdbintf.c failed'
  2249. echo End of part 11, continue with part 12
  2250. exit 0
  2251. --------------------------------------------------------------------
  2252. Warren Tucker, TuckerWare emory!n4hgf!wht or wht@n4hgf.Mt-Park.GA.US
  2253. Hacker Extraordinaire  d' async PADs,  pods,  proteins and protocols
  2254.  
  2255. exit 0 # Just in case...
  2256. -- 
  2257. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2258. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2259. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2260. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2261.