home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume32 / ecu / part19 < prev    next >
Encoding:
Text File  |  1992-09-13  |  57.0 KB  |  2,615 lines
  1. Newsgroups: comp.sources.misc
  2. From: wht@n4hgf.Mt-Park.GA.US (Warren Tucker)
  3. Subject:  v32i054:  ecu - ECU Asynchronous Communications v3.20, Part19/40
  4. Message-ID: <1992Sep13.153820.5799@sparky.imd.sterling.com>
  5. X-Md4-Signature: 34b83be9cbc3ddc1c5153db8340cb9d5
  6. Date: Sun, 13 Sep 1992 15:38:20 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: wht@n4hgf.Mt-Park.GA.US (Warren Tucker)
  10. Posting-number: Volume 32, Issue 54
  11. Archive-name: ecu/part19
  12. Environment: SCO,XENIX,ISC,SUNOS,SYSVR4,HDB,Curses
  13. Supersedes: ecu: Volume 21, Issue 53-89
  14.  
  15. ---- Cut Here and feed the following to sh ----
  16. #!/bin/sh
  17. # this is ecu320.19 (part 19 of ecu320)
  18. # do not concatenate these parts, unpack them in order with /bin/sh
  19. # file pcmd.c continued
  20. #
  21. if test ! -r _shar_seq_.tmp; then
  22.     echo 'Please unpack part 1 first!'
  23.     exit 1
  24. fi
  25. (read Scheck
  26.  if test "$Scheck" != 19; then
  27.     echo Please unpack part "$Scheck" next!
  28.     exit 1
  29.  else
  30.     exit 0
  31.  fi
  32. ) < _shar_seq_.tmp || exit 1
  33. if test ! -f _shar_wnt_.tmp; then
  34.     echo 'x - still skipping pcmd.c'
  35. else
  36. echo 'x - continuing file pcmd.c'
  37. sed 's/^X//' << 'SHAR_EOF' >> 'pcmd.c' &&
  38. X            interval = hzmsec;        /* SCO nap bug */
  39. X        if(proctrace && (interval > 100))    /* short naps hurt by pprintf */
  40. X            pprintf("nap %ld msec\n",interval);
  41. X        if(Nap(interval) == -1)        /* EINTR is the only error returned ... */
  42. X        {                            /* but check anyway */
  43. X            if(errno == EINTR)
  44. X                erc = eCONINT;
  45. X        }
  46. X    }
  47. X    return(erc);
  48. X}    /* end of pcmd_nap */
  49. X
  50. X/*+-------------------------------------------------------------------------
  51. X    pcmd_nice(param)
  52. X--------------------------------------------------------------------------*/
  53. Xint
  54. Xpcmd_nice(param)
  55. XESD *param;
  56. X{
  57. Xlong new_nice;
  58. Xint erc;
  59. Xint old_nice;
  60. Xint nice();
  61. X
  62. X    if(shm->Liofd < 0)
  63. X        return(eNoLineAttached);
  64. X
  65. X    if(erc = gint(param,&new_nice))
  66. X        return(erc);
  67. X    if((new_nice < 0) || (new_nice > 39))
  68. X    {
  69. X        pprintf("warning: invalid nice %ld ignored (valid range 0-39)\n",
  70. X            new_nice);
  71. X        return(0);
  72. X    }
  73. X
  74. X    old_nice = nice(0) + 20;
  75. X    nice(-old_nice + (int)new_nice);
  76. X
  77. X    if(proctrace)
  78. X        pprintf("nice desired %u, set to %u\n",(uint)new_nice,nice(0) + 20);
  79. X    return(0);
  80. X
  81. X}    /* end of pcmd_nice */
  82. X
  83. X/*+-------------------------------------------------------------------------
  84. X    pcmd_parity(param)
  85. Xparity [e | o | n]
  86. Xparity ['e' | 'o' | 'n']
  87. X--------------------------------------------------------------------------*/
  88. Xint
  89. Xpcmd_parity(param)
  90. XESD *param;
  91. X{
  92. Xint erc;
  93. Xint new_parity = 0;
  94. XESD *tesd;
  95. Xchar s64[64];
  96. X
  97. X    if(erc = skip_cmd_break(param))
  98. X        return(erc);
  99. X    if(!(tesd = esdalloc(64)))
  100. X        return(eNoMemory);
  101. X    if(!gstr(param,tesd,0))
  102. X        new_parity = to_lower(*tesd->pb);
  103. X    else if(!get_alpha_zstr(param,s64,sizeof(s64)))
  104. X        new_parity = to_lower(s64[0]);
  105. X    else
  106. X    {
  107. X        erc = eSyntaxError;
  108. X        goto RETURN;
  109. X    }
  110. X    esdfree(tesd);
  111. X
  112. X    switch(new_parity)
  113. X    {
  114. X        case 'n':
  115. X            new_parity = 0;
  116. X        case 'e':
  117. X        case 'o':
  118. X            shm->Lparity = new_parity;
  119. X            if(shm->Liofd < 0)
  120. X                lset_parity(1);
  121. X            break;
  122. X        default:
  123. X            erc = eBadParameter;
  124. X    }
  125. X    if(proctrace && !erc)
  126. X    {
  127. X        pprintf("parity set to %s\n",
  128. X            (shm->Lparity) ? ((shm->Lparity == 'e') ? "even" : "odd")
  129. X                           : "none");
  130. X    }
  131. X
  132. XRETURN:
  133. X    esdfree(tesd);
  134. X    return(erc);
  135. X
  136. X}    /* end of pcmd_parity */
  137. X
  138. X/*+-------------------------------------------------------------------------
  139. X    pcmd_prompt(param)
  140. X--------------------------------------------------------------------------*/
  141. Xint
  142. Xpcmd_prompt(param)
  143. XESD *param;
  144. X{
  145. Xextern ESD *icmd_prompt;
  146. X
  147. X    return(gstr(param,icmd_prompt,0));
  148. X}    /* end of pcmd_prompt */
  149. X
  150. X/*+-------------------------------------------------------------------------
  151. X    pcmd_ptrace(param)
  152. X--------------------------------------------------------------------------*/
  153. Xint
  154. Xpcmd_ptrace(param)
  155. XESD *param;
  156. X{
  157. Xchar s8[8];
  158. X
  159. X    if(get_alpha_zstr(param,s8,sizeof(s8)))
  160. X        return(eSyntaxError);
  161. X    if(isdigit(s8[0]))
  162. X        proctrace = atoi(s8);
  163. X    if(!strcmp(s8,"on"))
  164. X        proctrace = 1;
  165. X    else if(!strcmp(s8,"off"))
  166. X        proctrace = 0;
  167. X    else
  168. X        return(eSyntaxError);
  169. X    return(0);
  170. X}    /* end of pcmd_ptrace */
  171. X
  172. X/*+-------------------------------------------------------------------------
  173. X    pcmd_rname(param) - set remote name
  174. X--------------------------------------------------------------------------*/
  175. Xint
  176. Xpcmd_rname(param)
  177. XESD *param;
  178. X{
  179. Xint erc;
  180. XESD *rname;
  181. X
  182. X    if(shm->Liofd < 0)
  183. X        return(eNoLineAttached);
  184. X    if(!shm->Lconnected)
  185. X    {
  186. X        pputs("Not connected\n");
  187. X        return(eFATAL_ALREADY);
  188. X    }
  189. X
  190. X    if((rname = esdalloc(sizeof(shm->Lrname) - 1)) == (ESD *)0)
  191. X        return(eNoMemory);
  192. X
  193. X    if(!(erc = gstr(param,rname,0)))
  194. X    {
  195. X        strcpy(shm->Lrname,rname->pb);
  196. X        if(proctrace)
  197. X            pprintf("rname set to '%s'\n",rname->pb);
  198. X    }
  199. X    esdfree(rname);
  200. X    return(erc);
  201. X
  202. X}    /* end of pcmd_rname */
  203. X
  204. X/*+-------------------------------------------------------------------------
  205. X    pcmd_send(param)
  206. Xsend [-n] <str>
  207. X-n do not send trailing CR
  208. X-v turn on proctrace for just this statement
  209. X-p## pace characters ## msec apart
  210. X--------------------------------------------------------------------------*/
  211. Xint
  212. Xpcmd_send(param)
  213. XESD *param;
  214. X{
  215. Xint erc;
  216. Xchar *cptr;
  217. XESD *buf;
  218. Xchar switches[32];
  219. Xint send_cr;
  220. Xint tell_it;
  221. Xlong pace_msec = 0L;
  222. X
  223. X    if(shm->Liofd < 0)
  224. X        return(eNoLineAttached);
  225. X
  226. X    if((buf = esdalloc(256)) == (ESD *)0)
  227. X        return(eNoMemory);
  228. X
  229. X    get_switches(param,switches,sizeof(switches));
  230. X    send_cr = !strchr(switches,'n');
  231. X    tell_it = !!strchr(switches,'v');
  232. X    if(cptr = strchr(switches,'p'))
  233. X        sscanf(cptr + 1,"%ld",&pace_msec);
  234. X
  235. X    if(erc = gstr(param,buf,1))
  236. X    {
  237. X        esdfree(buf);
  238. X        return(erc);
  239. X    }
  240. X
  241. X    if(proctrace || tell_it)
  242. X    {
  243. X        hex_dump(buf->pb,buf->cb,
  244. X            (send_cr) ? "send with CR" : "send w/o CR",1);
  245. X    }
  246. X
  247. X    if(pace_msec)
  248. X        lputs_paced(pace_msec,buf->pb);
  249. X    else
  250. X        lputs(buf->pb);
  251. X
  252. X    if(send_cr)
  253. X        lputc(CRET);
  254. X    if(pace_msec)
  255. X        Nap(pace_msec);
  256. X
  257. X    esdfree(buf);
  258. X    return(erc);
  259. X}    /* end of pcmd_send */
  260. X
  261. X/*+-------------------------------------------------------------------------
  262. X    pcmd_set(param)
  263. X--------------------------------------------------------------------------*/
  264. Xint
  265. Xpcmd_set(param)
  266. XESD *param;
  267. X{
  268. Xint erc;
  269. Xint itmp;
  270. Xulong varnum;
  271. Xuint varmax;
  272. Xchar vartype;
  273. Xchar varstr[16];
  274. Xint show_status;
  275. Xlong *ivptr;
  276. XESD *svptr;
  277. Xchar *cptr;
  278. Xchar *make_char_graphic();
  279. X
  280. X    if(erc = skip_cmd_break(param))
  281. X        return(erc);
  282. X
  283. X    do {
  284. X
  285. X        /* $ is optional */
  286. X        if((erc = skip_cmd_char(param,'$')) && (erc != eSyntaxError))
  287. X            return(erc);
  288. X
  289. X        /* get variable type */
  290. X        if(get_cmd_char(param,&vartype))
  291. X            return(eSyntaxError);
  292. X
  293. X        /* validate variable type */
  294. X        vartype = to_lower(vartype);
  295. X        switch(vartype)
  296. X        {
  297. X            case 'i':
  298. X                varmax = IVQUAN;
  299. X                break;
  300. X            case 's':
  301. X                varmax = SVQUAN;
  302. X                break;
  303. X            default:
  304. X                return(eIllegalVarType);
  305. X        }
  306. X
  307. X        if(!get_numeric_value(param,&varnum))
  308. X            goto TEST_VARNUM;
  309. X        else if(*(param->pb + param->index) == '[')
  310. X        {
  311. X            if(erc = get_subscript(param,&varnum))
  312. X                return(erc);
  313. XTEST_VARNUM:
  314. X            if((int)varnum >= varmax)
  315. X                return(eIllegalVarNumber);
  316. X            switch(vartype)
  317. X            {
  318. X                case 'i':
  319. X                    ivptr = &iv[(int)varnum];
  320. X                    break;
  321. X                default:
  322. X                    svptr = sv[(int)varnum];
  323. X            }
  324. X        }
  325. X        else if(get_alphanum_zstr(param,varstr,sizeof(varstr)))
  326. X            return(eInvalidVarName);
  327. X        else
  328. X        {
  329. X            varnum = NAMED_VARIABLE_FLAG;
  330. X            switch(vartype)
  331. X            {
  332. X                case 'i':
  333. X                    erc = find_mkvi(varstr,&ivptr,1);
  334. X                    break;
  335. X                default:
  336. X                    erc = find_mkvs(varstr,&svptr,1);
  337. X            }
  338. X            if(erc)
  339. X                return(erc);
  340. X        }
  341. X            
  342. X        show_status = 1;
  343. X        if(!skip_cmd_char(param,'='))    /* assignment */
  344. X        {
  345. X            switch(vartype)
  346. X            {
  347. X                case 'i':
  348. X                    if(erc = gint(param,ivptr))
  349. X                        return(erc);
  350. X                    break;
  351. X                default:
  352. X                    if(erc = gstr(param,svptr,1))
  353. X                        return(erc);
  354. X                    break;
  355. X            }
  356. X            if(!proctrace)
  357. X                show_status = 0;
  358. X        }
  359. X        if(show_status)
  360. X        {
  361. X            switch(vartype)
  362. X            {
  363. X                case 'i':
  364. X                    if(varnum != NAMED_VARIABLE_FLAG)
  365. X                        pprintf("$i%02ld = %7ld (0x%08lx,0%03lo",varnum,
  366. X                            *ivptr,*ivptr,*ivptr);
  367. X                    else
  368. X                        pprintf("$i%s = %ld (0x%08lx,0%03lo",varstr,
  369. X                            *ivptr,*ivptr,*ivptr);
  370. X                    if((*ivptr >= 0) && (*ivptr <= 255))
  371. X                        pprintf(",'%s'",make_char_graphic((char)*ivptr,1));
  372. X                    pputs(")\n");
  373. X                    break;
  374. X                default:
  375. X                    if(varnum != NAMED_VARIABLE_FLAG)
  376. X                        pprintf("$s%02ld = '",varnum);
  377. X                    else
  378. X                        pprintf("$s%s = '",varstr);
  379. X                    itmp = svptr->cb;
  380. X                    cptr = svptr->pb;
  381. X                    while(itmp--)
  382. X                        pputs(make_char_graphic(*cptr++,0));
  383. X                    pputs("'\n");
  384. X                    break;
  385. X            }
  386. X        }
  387. X    } while(!skip_comma(param));
  388. X
  389. X    if(!end_of_cmd(param))
  390. X        return(eSyntaxError);
  391. X
  392. X    return(0);
  393. X}    /* end of pcmd_set */
  394. X
  395. X/*+-------------------------------------------------------------------------
  396. X    pcmd_system(param)
  397. X
  398. Xsystem [-l] 'cmd'
  399. X-l makes comm line stdin/stdout
  400. X-s keeps all fds the same
  401. X
  402. Xreturns $i0 set to exit status of program or 0x100 if interrupted
  403. X--------------------------------------------------------------------------*/
  404. Xint
  405. Xpcmd_system(param)
  406. XESD *param;
  407. X{
  408. Xint erc;
  409. XESD *cmd;
  410. Xextern int last_child_wait_status;
  411. Xchar switches[8];
  412. X
  413. X    if((cmd = esdalloc(256)) == (ESD *)0)
  414. X        return(eNoMemory);
  415. X
  416. X    get_switches(param,switches,sizeof(switches));
  417. X
  418. X/* a hack */
  419. X    *cmd->pb++ = (strchr(switches,'s')) ? '>' : 
  420. X        ((strchr(switches,'l')) ? '$' : '!');
  421. X
  422. X    cmd->maxcb--;
  423. X
  424. X    if(erc = gstr(param,cmd,1))
  425. X    {
  426. X        cmd->pb--;        /* be nice */
  427. X        cmd->maxcb++;    /* or surely this will haunt us one day */
  428. X        esdfree(cmd);
  429. X        return(erc);
  430. X    }
  431. X
  432. X/* rehack */
  433. X    cmd->pb--;
  434. X    cmd->cb++;
  435. X    cmd->maxcb++;
  436. X
  437. X    if(proctrace)
  438. X    {
  439. X        pputs(cmd->pb + 1);
  440. X        pputs("\n");
  441. X    }
  442. X
  443. X    last_child_wait_status = 0xFF00;
  444. X    shell(cmd->pb);
  445. X    iv[0] = (last_child_wait_status & 0xFF)
  446. X            ? 0x100L : (long)last_child_wait_status >> 8;
  447. X    if(proctrace)
  448. X        pprintf("$i0 = %ld, (%s)\n",iv[0],
  449. X            (iv[0] == 0x100L) ? "interrupted" : "program exit status");
  450. X
  451. X    esdfree(cmd);
  452. X    return(0);
  453. X}    /* end of pcmd_system */
  454. X
  455. X/*+-------------------------------------------------------------------------
  456. X    get_big_endian_16(ptr)
  457. X--------------------------------------------------------------------------*/
  458. Xushort
  459. Xget_big_endian_16(ptr)
  460. Xregister uchar *ptr;
  461. X{
  462. Xregister ushort uint16 = ((ushort)ptr[0] << 8) | ptr[1];
  463. X 
  464. X    return(uint16);
  465. X 
  466. X}    /* end of get_big_endian_16 */
  467. X 
  468. X/*+-------------------------------------------------------------------------
  469. X    get_big_endian_32(ptr)
  470. X--------------------------------------------------------------------------*/
  471. Xulong
  472. Xget_big_endian_32(ptr)
  473. Xregister uchar *ptr;
  474. X{
  475. Xregister ulong uint32 = ((ulong)*ptr++) << 24;
  476. X    uint32 |= ((ulong)*ptr++) << 16;
  477. X    uint32 |= ((ulong)*ptr++) <<  8;
  478. X    uint32 |=  (ulong)*ptr++;
  479. X    return(uint32);
  480. X 
  481. X}    /* end of get_big_endian_32 */
  482. X
  483. X/*+-------------------------------------------------------------------------
  484. X    pcmd_getf(param) - get friend memory
  485. X
  486. Xgetf -x <int-var-spec> <offset>
  487. Xwhere: -x ==
  488. X   -b byte
  489. X   -w word (little-endian)
  490. X   -W word (big-endian)
  491. X   -l 32-bits (little-endian)
  492. X   -L 32-bits (big-endian)
  493. X--------------------------------------------------------------------------*/
  494. Xint
  495. Xpcmd_getf(param)
  496. XESD *param;
  497. X{
  498. Xint erc;
  499. Xchar switches[8];
  500. Xlong *piv;
  501. Xlong offset;
  502. Xint size;
  503. Xint big_endian;
  504. X
  505. X    if(erc = get_switches(param,switches,sizeof(switches)))
  506. X        return(erc);
  507. X    if((strlen(switches) != 2) || !strchr("bwWlL",switches[1]))
  508. X    {
  509. X        pputs("invalid switch\n");
  510. X        return(eFATAL_ALREADY);
  511. X    }
  512. X    size = to_lower(switches[1]);
  513. X    big_endian = isupper(switches[1]);
  514. X
  515. X/*
  516. X    if(!get_svptr(param,&psv))
  517. X        return(eNotImplemented);
  518. X    else
  519. X*/
  520. X    if(!strncmp(param->pb + param->index,"$i",2))
  521. X        param->index += 2;
  522. X    if(erc = get_ivptr(param,&piv,1))
  523. X        return(erc);
  524. X
  525. X    if(erc = gint(param,&offset))
  526. X        return(erc);
  527. X
  528. X    if(proctrace)
  529. X        pprintf("getf %s offset=0x%lx",switches,offset);
  530. X
  531. X    switch(size)
  532. X    {
  533. X        case 'b':
  534. X            if(offset > ((long)sizeof(shm->friend_space) - 1))
  535. X                goto OFFSET_TOO_LARGE;
  536. X            *piv = *(((uchar *)shm->friend_space) + (int)offset) & 0xFF;
  537. X            break;
  538. X        case 'w':
  539. X            if(offset > ((long)sizeof(shm->friend_space) - 2))
  540. X                goto OFFSET_TOO_LARGE;
  541. X            if(big_endian)
  542. X                *piv = get_big_endian_16((uchar *)shm->friend_space +
  543. X                        (int)offset);
  544. X            else
  545. X                *piv = *(((ushort *)shm->friend_space) + (int)offset) & 0xFFFF;
  546. X            break;
  547. X        case 'l':
  548. X            if(offset > ((long)sizeof(shm->friend_space) - 4))
  549. X                goto OFFSET_TOO_LARGE;
  550. X            if(big_endian)
  551. X            {
  552. X                *piv = get_big_endian_32((uchar *)shm->friend_space +
  553. X                        (int)offset);
  554. X            }
  555. X            else
  556. X                *piv = *((long *)((char *)shm->friend_space + (int)offset));
  557. X            break;
  558. X    }
  559. X
  560. X    if(proctrace)
  561. X        pprintf(" value=%ld (%08lx)\n",*piv,*piv);
  562. X    return(0);
  563. X
  564. XOFFSET_TOO_LARGE:
  565. X    if(proctrace)
  566. X        pputs("\n");
  567. X    pprintf("offset 0x%02lx too large for -%c (0x%02x bytes available)\n",
  568. X        offset,switches[1],sizeof(shm->friend_space));
  569. X    return(eFATAL_ALREADY);
  570. X
  571. X}    /* end of pcmd_getf */
  572. X
  573. X/*+-------------------------------------------------------------------------
  574. X    pcmd_putf(param)
  575. X--------------------------------------------------------------------------*/
  576. X/*ARGSUSED*/
  577. Xint
  578. Xpcmd_putf(param)
  579. XESD *param;
  580. X{
  581. X    return(eNotImplemented);
  582. X}    /* end of pcmd_putf */
  583. X
  584. X/*+-------------------------------------------------------------------------
  585. X    pcmd_xon(param)
  586. X--------------------------------------------------------------------------*/
  587. Xint
  588. Xpcmd_xon(param)
  589. XESD *param;
  590. X{
  591. Xint erc;
  592. Xchar new_xonxoff[8];
  593. Xchar *xon_status();
  594. X
  595. X    if(shm->Liofd < 0)
  596. X        return(eNoLineAttached);
  597. X
  598. X    if(erc = get_alpha_zstr(param,new_xonxoff,sizeof(new_xonxoff)))
  599. X        return(erc);
  600. X
  601. X    if(set_xon_xoff_by_arg(new_xonxoff))
  602. X        return(eBadParameter);
  603. X
  604. X    if(proctrace)
  605. X        pprintf("xon/xoff flow control set to %s\n",xon_status());
  606. X
  607. X    return(erc);
  608. X
  609. X}    /* end of pcmd_xon */
  610. X
  611. X/*+-------------------------------------------------------------------------
  612. X    pcmd_rtscts(param)
  613. X--------------------------------------------------------------------------*/
  614. Xint
  615. Xpcmd_rtscts(param)
  616. XESD *param;
  617. X{
  618. Xint erc;
  619. Xchar new_rtscts[8];
  620. X
  621. X    if(shm->Liofd < 0)
  622. X        return(eNoLineAttached);
  623. X
  624. X    if(erc = get_alphanum_zstr(param,new_rtscts,sizeof(new_rtscts)))
  625. X        return(erc);
  626. X
  627. X#if defined(HW_FLOW_CONTROL) /* see ecu.h */
  628. X    lRTSCTS_control(yes_or_no(new_rtscts));
  629. X
  630. X    if(proctrace)
  631. X        display_hw_flow_config();
  632. X#else
  633. X    if(proctrace)
  634. X        pprintf("hardware flow control not available .... rtscts ignored\n");
  635. X#endif /* RTSFLOW */
  636. X
  637. X    return(erc);
  638. X}    /* end of pcmd_rtscts */
  639. X
  640. X/*+-------------------------------------------------------------------------
  641. X    pcmd_setline(param) - _rc.ep setline command
  642. X
  643. XThis command can be used to set the initial line in _rc.ep
  644. X--------------------------------------------------------------------------*/
  645. Xint
  646. Xpcmd_setline(param)
  647. XESD *param;
  648. X{
  649. Xint erc;
  650. XESD *tesd;
  651. X
  652. X    if(rc_ep_has_run)
  653. X    {
  654. X        pprintf("command legal only in _rc.ep\n");
  655. X        return(eFATAL_ALREADY);
  656. X    }
  657. X
  658. X    if(!(tesd = esdalloc(sizeof(shm->Lline))))
  659. X        return(eNoMemory);
  660. X    if(erc = gstr(param,tesd,0))
  661. X        goto RETURN;
  662. X    shm->Lline[0] = 0;
  663. X    if(strncmp(tesd->pb,"/dev/",5))
  664. X        strcat(shm->Lline,"/dev/");
  665. X    strncat(shm->Lline,tesd->pb,sizeof(shm->Lline) - strlen(shm->Lline));
  666. X    shm->Lline[sizeof(shm->Lline) - 1] = 0;
  667. X    if(proctrace)
  668. X        pprintf("line set to %s\n",shm->Lline);
  669. X
  670. XRETURN:
  671. X    esdfree(tesd);
  672. X    return(erc);
  673. X}    /* end of pcmd_setline */
  674. X
  675. X/* vi: set tabstop=4 shiftwidth=4: */
  676. X/* end of pcmd.c */
  677. SHAR_EOF
  678. echo 'File pcmd.c is complete' &&
  679. chmod 0644 pcmd.c ||
  680. echo 'restore of pcmd.c failed'
  681. Wc_c="`wc -c < 'pcmd.c'`"
  682. test 31521 -eq "$Wc_c" ||
  683.     echo 'pcmd.c: original size 31521, current size' "$Wc_c"
  684. rm -f _shar_wnt_.tmp
  685. fi
  686. # ============= pcmdfile.c ==============
  687. if test -f 'pcmdfile.c' -a X"$1" != X"-c"; then
  688.     echo 'x - skipping pcmdfile.c (File already exists)'
  689.     rm -f _shar_wnt_.tmp
  690. else
  691. > _shar_wnt_.tmp
  692. echo 'x - extracting pcmdfile.c (Text)'
  693. sed 's/^X//' << 'SHAR_EOF' > 'pcmdfile.c' &&
  694. X/*+-------------------------------------------------------------------------
  695. X    pcmdfile.c - ecu file-related procedure commands
  696. X    wht@n4hgf.Mt-Park.GA.US
  697. X
  698. X  Defined functions:
  699. X    _file_not_open(filenum)
  700. X    _gfilenum(param,filenum)
  701. X    _param_to_stat(param,pstat_rtnd)
  702. X    ifunc_fatime(param,pvalue)
  703. X    ifunc_fmode(param,pvalue)
  704. X    ifunc_fmtime(param,pvalue)
  705. X    ifunc_fsize(param,pvalue)
  706. X    ifunc_ftell(param,pvalue)
  707. X    ifunc_ischr(param,pvalue)
  708. X    ifunc_isdir(param,pvalue)
  709. X    ifunc_isreg(param,pvalue)
  710. X    pcmd_fchmod(param)
  711. X    pcmd_fclose(param)
  712. X    pcmd_fdel(param)
  713. X    pcmd_fgetc(param)
  714. X    pcmd_fgets(param)
  715. X    pcmd_fopen(param)
  716. X    pcmd_fputc(param)
  717. X    pcmd_fputs(param)
  718. X    pcmd_fread(param)
  719. X    pcmd_fseek(param)
  720. X    pcmd_fwrite(param)
  721. X    pcmd_mkdir(param)
  722. X    pcmd_pclose(param)
  723. X    pcmd_popen(param)
  724. X    proc_file_reset()
  725. X    str_to_filemode(modestr,filemode)
  726. X
  727. X--------------------------------------------------------------------------*/
  728. X/*+:EDITS:*/
  729. X/*:09-10-1992-14:00-wht@n4hgf-ECU release 3.20 */
  730. X/*:08-22-1992-15:39-wht@n4hgf-ECU release 3.20 BETA */
  731. X/*:07-03-1992-12:48-wht@n4hgf-why not let fchmod set any bits? */
  732. X/*:07-25-1991-12:59-wht@n4hgf-ECU release 3.10 */
  733. X/*:06-27-1991-13:45-wht@n4hgf-$i0 wasn't always plugged on failures */
  734. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  735. X
  736. X#include "ecu.h"
  737. X#include "ecukey.h"
  738. X#include "ecuerror.h"
  739. X#include "esd.h"
  740. X#include "var.h"
  741. X#include "proc.h"
  742. X
  743. X#if !defined(S_IRUSR)
  744. X#define    S_IRUSR    00400        /* read permission: owner */
  745. X#define    S_IWUSR    00200        /* write permission: owner */
  746. X#define    S_IXUSR    00100        /* execute permission: owner */
  747. X#define    S_IRWXG    00070        /* read, write, execute: group */
  748. X#define    S_IRGRP    00040        /* read permission: group */
  749. X#define    S_IWGRP    00020        /* write permission: group */
  750. X#define    S_IXGRP    00010        /* execute permission: group */
  751. X#define    S_IRWXO    00007        /* read, write, execute: other */
  752. X#define    S_IROTH    00004        /* read permission: other */
  753. X#define    S_IWOTH    00002        /* write permission: other */
  754. X#define    S_IXOTH    00001        /* execute permission: other */
  755. X#endif
  756. X
  757. Xextern PCB *pcb_stack[];
  758. X
  759. X#define FILE_MAX    5
  760. X
  761. Xtypedef struct pfile_struct
  762. X{
  763. X    FILE *f;    /* file pointer */
  764. X    ESD *n;        /* file name */
  765. X} PFILE;
  766. X
  767. XPFILE pfile[FILE_MAX];
  768. X
  769. Xchar fwrite_error_fmt[] = "file %d write error (not open for write?)\n";
  770. X
  771. X/*+-------------------------------------------------------------------------
  772. X    proc_file_reset()
  773. X--------------------------------------------------------------------------*/
  774. Xvoid
  775. Xproc_file_reset()
  776. X{
  777. Xregister itmp;
  778. X
  779. X    for(itmp = 0; itmp < FILE_MAX; itmp++)
  780. X    {
  781. X        if(pfile[itmp].f)
  782. X        {
  783. X            fclose(pfile[itmp].f);
  784. X            pfile[itmp].f = (FILE *)0;
  785. X            esdfree(pfile[itmp].n);
  786. X        }
  787. X    }
  788. X}    /* end of proc_file_reset */
  789. X
  790. X/*+-------------------------------------------------------------------------
  791. X    _file_not_open(filenum)
  792. X--------------------------------------------------------------------------*/
  793. Xint
  794. X_file_not_open(filenum)
  795. Xint filenum;
  796. X{
  797. X    pprintf("file %d not open\n",filenum);
  798. X    return(eFATAL_ALREADY);
  799. X}    /* end of _file_not_open */
  800. X
  801. X/*+-------------------------------------------------------------------------
  802. X    _gfilenum(param,filenum)
  803. X--------------------------------------------------------------------------*/
  804. Xint
  805. X_gfilenum(param,filenum)
  806. XESD *param;
  807. Xint *filenum;
  808. X{
  809. Xint erc;
  810. Xulong lvarnum;
  811. Xint old_index;
  812. X
  813. X    skip_cmd_break(param);
  814. X    old_index = param->old_index;
  815. X    if(erc = gint(param,&lvarnum))
  816. X        return(erc);
  817. X    if(lvarnum > FILE_MAX)
  818. X        return(eBadFileNumber);
  819. X    *filenum = (int)lvarnum;
  820. X    param->old_index = old_index;
  821. X    return(0);
  822. X}    /* end of _gfilenum */
  823. X
  824. X/*+-------------------------------------------------------------------------
  825. X    str_to_filemode(modestr,filemode) - "rwxrwxrwx" to mode integer
  826. X--------------------------------------------------------------------------*/
  827. Xstr_to_filemode(modestr,filemode)
  828. Xchar *modestr;
  829. Xlong *filemode;
  830. X{
  831. Xregister i;
  832. Xregister mode = 0;
  833. Xint erc = 0;
  834. X
  835. X    if(strlen(modestr) != 9)
  836. X    {
  837. X        pprintf("bad length: '%s'\n",modestr);
  838. X        return(eFATAL_ALREADY);
  839. X    }
  840. X
  841. X    for(i=0; i < 9; i++)
  842. X    {
  843. X        switch(modestr[i])
  844. X        {
  845. X
  846. X        case 'r':
  847. X            if(i == 0)
  848. X                mode |= S_IRUSR;
  849. X            else if(i == 3)
  850. X                mode |= S_IRGRP;
  851. X            else if(i == 6)
  852. X                mode |= S_IROTH;
  853. X            else
  854. X                erc = eSyntaxError;
  855. X            break;
  856. X
  857. X
  858. X        case 'w':
  859. X            if(i == 1)
  860. X                mode |= S_IWUSR;
  861. X            else if(i == 4)
  862. X                mode |= S_IWGRP;
  863. X            else if(i == 7)
  864. X                mode |= S_IWOTH;
  865. X            else
  866. X                erc = eSyntaxError;
  867. X            break;
  868. X
  869. X
  870. X        case 'x':
  871. X            if(i == 2)
  872. X                mode |= S_IXUSR;
  873. X            else if(i == 5)
  874. X                mode |= S_IXGRP;
  875. X            else if(i == 8)
  876. X                mode |= S_IXOTH;
  877. X            else
  878. X                erc = eSyntaxError;
  879. X            break;
  880. X
  881. X
  882. X        case 's':
  883. X            if(i == 2)
  884. X            {
  885. X                mode |= S_ISUID;
  886. X                mode |= S_IXUSR;
  887. X            }
  888. X            else if(i == 5)
  889. X            {
  890. X                mode |= S_ISGID;
  891. X                mode |= S_IXGRP;
  892. X            }
  893. X            else if(i == 7)
  894. X            {
  895. X                mode |= S_ISGID;
  896. X                mode |= S_IXGRP;
  897. X            }
  898. X            else
  899. X                erc = eSyntaxError;
  900. X            break;
  901. X
  902. X
  903. X        case 't':
  904. X#if defined(FULL_FEATURE_CHMODE)
  905. X            if(i == 8)
  906. X            {
  907. X                mode |= S_ISVTX;
  908. X                mode |= S_IXOTH;
  909. X            }
  910. X            else
  911. X                erc = eSyntaxError;
  912. X#else
  913. X            pputs("set sticky bit not allowed\n");
  914. X            erc = eFATAL_ALREADY;
  915. X#endif /* defined(FULL_FEATURE_CHMODE) */
  916. X            break;
  917. X        case 'l':
  918. X            if(i == 5)
  919. X            {
  920. X                mode |= S_ISGID;
  921. X                mode &= ~S_IXGRP;
  922. X            }
  923. X            else
  924. X                erc = eSyntaxError;
  925. X            break;
  926. X        case '-':
  927. X            break;
  928. X        default:
  929. X            erc = eSyntaxError;
  930. X        }    /* end switch */
  931. X
  932. X        if(erc)
  933. X            break;
  934. X
  935. X    }        /* end for */
  936. X
  937. X    if(erc)
  938. X    {
  939. X        if(erc != eFATAL_ALREADY)
  940. X            pputs("invalid mode specifier\n");
  941. X        pputs(modestr);
  942. X        while(i--)
  943. X            pputc(' ');
  944. X        pputs("^\n");
  945. X        
  946. X    }
  947. X    else
  948. X        *filemode = (long)mode;
  949. X
  950. X    return(erc);
  951. X
  952. X}    /* end of str_to_filemode */
  953. X
  954. X/*+-------------------------------------------------------------------------
  955. X    pcmd_fgetc(param)
  956. X
  957. Xfgetc <filenum-int> [$][i<varspec> | $s<varspec>]
  958. Xint variable receives 0 if EOF
  959. Xstr var receives null str on eof
  960. X--------------------------------------------------------------------------*/
  961. Xint
  962. Xpcmd_fgetc(param)
  963. XESD *param;
  964. X{
  965. Xint erc;
  966. Xint filenum;
  967. Xint vartype;
  968. Xint inchar;
  969. XESD *svptr;
  970. Xlong *ivptr;
  971. X
  972. X    if(!proc_level)
  973. X        return(eNotExecutingProc);
  974. X
  975. X    if(erc = _gfilenum(param,&filenum))
  976. X        return(erc);
  977. X
  978. X    if(!pfile[filenum].f)
  979. X        return(_file_not_open(filenum));
  980. X
  981. X    skip_cmd_char(param,'$');
  982. X    if((param->index >= param->cb) ||
  983. X        ( ((vartype = to_lower(*(param->pb + param->index))) != 'i') &&
  984. X            (vartype != 's')))
  985. X        return(eIllegalVarType);
  986. X    param->index++;
  987. X    switch(vartype)
  988. X    {
  989. X        case 'i':
  990. X            erc = get_ivptr(param,&ivptr,1);
  991. X            break;
  992. X        default:
  993. X            erc = get_svptr(param,&svptr,1);
  994. X            break;
  995. X    }
  996. X    if(erc)
  997. X        return(erc);
  998. X
  999. X    if((inchar = fgetc(pfile[filenum].f)) == EOF)
  1000. X    {
  1001. X        if(proctrace)
  1002. X            pputs("fgetc EOF\n");
  1003. X        if(vartype == 'i')
  1004. X            *ivptr = -1;
  1005. X        else
  1006. X            esdzero(svptr);
  1007. X    }
  1008. X    else if(vartype == 'i')
  1009. X        *ivptr = inchar;
  1010. X    else
  1011. X    {
  1012. X        *svptr->pb = inchar;
  1013. X        svptr->cb = 1;
  1014. X    }
  1015. X
  1016. X    if(proctrace)
  1017. X    {
  1018. X        pputs("fgetc set ");
  1019. X        pputs((vartype == 'i') ? "int" : "str");
  1020. X        pprintf(" var = %lu (0x%02x)\n",inchar,inchar);
  1021. X    }
  1022. X    return(0);
  1023. X
  1024. X}    /* end of pcmd_fgetc */
  1025. X
  1026. X/*+-------------------------------------------------------------------------
  1027. X    pcmd_fread(param)
  1028. X--------------------------------------------------------------------------*/
  1029. X/*ARGSUSED*/
  1030. Xint
  1031. Xpcmd_fread(param)
  1032. XESD *param;
  1033. X{
  1034. X    return(eNotImplemented);
  1035. X}    /* end of pcmd_fread */
  1036. X
  1037. X/*+-------------------------------------------------------------------------
  1038. X    pcmd_fgets(param)
  1039. Xfgetc <filenum-int> [$][s]<varspec>
  1040. X--------------------------------------------------------------------------*/
  1041. Xint
  1042. Xpcmd_fgets(param)
  1043. XESD *param;
  1044. X{
  1045. Xint erc;
  1046. Xint filenum;
  1047. Xchar ctmp;
  1048. XESD *svptr;
  1049. X
  1050. X    if(!proc_level)
  1051. X        return(eNotExecutingProc);
  1052. X
  1053. X    if(erc = _gfilenum(param,&filenum))
  1054. X        return(erc);
  1055. X
  1056. X    if(!pfile[filenum].f)
  1057. X        return(_file_not_open(filenum));
  1058. X
  1059. X    skip_cmd_char(param,'$');
  1060. X    if(erc = get_cmd_char(param,&ctmp))
  1061. X        return(erc);
  1062. X    if(to_lower(ctmp) != 's')
  1063. X        return(eIllegalVarType);
  1064. X    if(erc = get_svptr(param,&svptr,1))
  1065. X        return(erc);
  1066. X    *svptr->pb = 0;
  1067. X    svptr->cb = 0;
  1068. X    if(!(iv[0] = !fgets(svptr->pb,svptr->maxcb + 1,pfile[filenum].f)))
  1069. X    {
  1070. X        svptr->cb = strlen(svptr->pb);
  1071. X        if(*(svptr->pb + svptr->cb - 1) == NL)
  1072. X        {
  1073. X            svptr->cb--;
  1074. X            esd_null_terminate(svptr);
  1075. X        }
  1076. X    }
  1077. X    if(proctrace)
  1078. X        pprintf("fgets set str var = '%s'\n",svptr->pb);
  1079. X    return(0);
  1080. X
  1081. X}    /* end of pcmd_fgets */
  1082. X
  1083. X/*+-------------------------------------------------------------------------
  1084. X    pcmd_fclose(param)
  1085. Xfclose <filenum-int>
  1086. X--------------------------------------------------------------------------*/
  1087. Xint
  1088. Xpcmd_fclose(param)
  1089. XESD *param;
  1090. X{
  1091. Xint erc;
  1092. Xint filenum;
  1093. X
  1094. X    if(!proc_level)
  1095. X        return(eNotExecutingProc);
  1096. X
  1097. X    if(erc = _gfilenum(param,&filenum))
  1098. X        return(erc);
  1099. X
  1100. X    if(pfile[filenum].f)
  1101. X    {
  1102. X        fclose(pfile[filenum].f);
  1103. X        pfile[filenum].f = (FILE *)0;
  1104. X        esdfree(pfile[filenum].n);
  1105. X    }
  1106. X
  1107. X    return(0);
  1108. X
  1109. X}    /* end of pcmd_fclose */
  1110. X
  1111. X/*+-------------------------------------------------------------------------
  1112. X    pcmd_fputc(param)
  1113. Xfputc <file-num> <int>
  1114. Xfputc <file-num> <str>
  1115. X--------------------------------------------------------------------------*/
  1116. Xint
  1117. Xpcmd_fputc(param)
  1118. XESD *param;
  1119. X{
  1120. Xint erc;
  1121. Xint filenum;
  1122. XESD *buf = (ESD *)0;
  1123. Xchar outchar = 0;
  1124. Xlong outlong;
  1125. X
  1126. X    if(!proc_level)
  1127. X        return(eNotExecutingProc);
  1128. X
  1129. X    if(erc = _gfilenum(param,&filenum))
  1130. X        return(erc);
  1131. X
  1132. X    if(!pfile[filenum].f)
  1133. X        return(_file_not_open(filenum));
  1134. X
  1135. X    if(!gint(param,&outlong))
  1136. X        outchar = (char)outlong;
  1137. X    else
  1138. X    {
  1139. X        if((buf = esdalloc(64)) == (ESD *)0)
  1140. X            return(eNoMemory);
  1141. X        if(erc = gstr(param,buf,1))
  1142. X            goto RETURN;
  1143. X        if(!buf->cb)
  1144. X        {
  1145. X            pputs("cannot fputc: zero length string\n");
  1146. X            erc = eFATAL_ALREADY;
  1147. X            goto RETURN;
  1148. X        }
  1149. X        outchar = *buf->pb;
  1150. X    }
  1151. X
  1152. X    if(fputc(outchar,pfile[filenum].f) < 0)
  1153. X    {
  1154. X        pprintf(fwrite_error_fmt,filenum);
  1155. X        erc = eFATAL_ALREADY;
  1156. X    }
  1157. X
  1158. XRETURN:
  1159. X    if(buf)
  1160. X        esdfree(buf);
  1161. X    return(erc);
  1162. X}    /* end of pcmd_fputc */
  1163. X
  1164. X/*+-------------------------------------------------------------------------
  1165. X    pcmd_fopen(param)
  1166. X
  1167. Xfopen [-<fopen_switches>] <filenum-int> <filename-str>
  1168. Xsets $i0 with result
  1169. X--------------------------------------------------------------------------*/
  1170. Xint
  1171. Xpcmd_fopen(param)
  1172. XESD *param;
  1173. X{
  1174. Xint erc;
  1175. Xint filenum;
  1176. XESD *fname = (ESD *)0;
  1177. Xchar switches[8];
  1178. X
  1179. X    if(!proc_level)
  1180. X        return(eNotExecutingProc);
  1181. X
  1182. X    if(get_switches(param,switches,sizeof(switches)))
  1183. X    {
  1184. X        strcpy(switches,"-r");
  1185. X        if(proctrace)
  1186. X        {
  1187. X            pputs("Warning: fopen defaulting to read\n");
  1188. X            show_error_position(pcb_stack[proc_level - 1]);
  1189. X        }
  1190. X    }
  1191. X
  1192. X    if(erc = _gfilenum(param,&filenum))
  1193. X        return(erc);
  1194. X
  1195. X    if(pfile[filenum].f)
  1196. X    {
  1197. X        pprintf("file %d already open\n",filenum);
  1198. X        return(eFATAL_ALREADY);
  1199. X    }
  1200. X
  1201. X    if((fname = esdalloc(256)) == (ESD *)0)
  1202. X        return(eNoMemory);
  1203. X
  1204. X    if(erc = gstr(param,fname,1))
  1205. X        goto RETURN;
  1206. X
  1207. X    iv[0] = 0;
  1208. X    if(pfile[filenum].f = fopen(fname->pb,switches + 1))
  1209. X    {
  1210. X        iv[0] = (long)errno;
  1211. X        if(proctrace)
  1212. X        {
  1213. X            pprintf("'%s'",fname->pb);
  1214. X            pperror(" ");
  1215. X        }
  1216. X    }
  1217. X    else if(proctrace)
  1218. X        pprintf("opened '%s' as file %d\n",fname->pb,filenum);
  1219. X
  1220. X    if(!erc)
  1221. X        pfile[filenum].n = fname;
  1222. X
  1223. XRETURN:
  1224. X    if(erc)
  1225. X        esdfree(fname);
  1226. X    return(erc);
  1227. X}    /* end of pcmd_fopen */
  1228. X
  1229. X/*+-------------------------------------------------------------------------
  1230. X    pcmd_fputs(param)
  1231. Xfputs [-n] <filenum-int> <str>
  1232. X-n do not output newline after <str>
  1233. X<filenum-int> file number for operation
  1234. X<str> string to write to file
  1235. X--------------------------------------------------------------------------*/
  1236. Xint
  1237. Xpcmd_fputs(param)
  1238. XESD *param;
  1239. X{
  1240. Xint erc;
  1241. Xint filenum;
  1242. XESD *buf = (ESD *)0;
  1243. Xchar switches[8];
  1244. X
  1245. X    if(!proc_level)
  1246. X        return(eNotExecutingProc);
  1247. X
  1248. X    get_switches(param,switches,sizeof(switches));
  1249. X
  1250. X    if(erc = _gfilenum(param,&filenum))
  1251. X        return(erc);
  1252. X
  1253. X    if(!pfile[filenum].f)
  1254. X        return(_file_not_open(filenum));
  1255. X
  1256. X    if((buf = esdalloc(256)) == (ESD *)0)
  1257. X        return(eNoMemory);
  1258. X
  1259. X    if(erc = gstr(param,buf,1))
  1260. X        goto RETURN;
  1261. X
  1262. X    if(!fputs(buf->pb,pfile[filenum].f) && strlen(buf->pb))
  1263. X    {
  1264. X        pprintf(fwrite_error_fmt,filenum);
  1265. X        erc = eFATAL_ALREADY;
  1266. X        goto RETURN;
  1267. X    }
  1268. X
  1269. X    if(!strchr(switches,'n'))
  1270. X        fputc(NL,pfile[filenum].f);
  1271. X
  1272. XRETURN:
  1273. X    esdfree(buf);
  1274. X    return(erc);
  1275. X}    /* end of pcmd_fputs */
  1276. X
  1277. X/*+-------------------------------------------------------------------------
  1278. X    pcmd_fwrite(param)
  1279. Xfwrite <filenum-int> <str>
  1280. X--------------------------------------------------------------------------*/
  1281. X/*ARGSUSED*/
  1282. Xint
  1283. Xpcmd_fwrite(param)
  1284. XESD *param;
  1285. X{
  1286. X    return(eNotImplemented);
  1287. X#ifdef USE_FWRITE
  1288. Xint erc;
  1289. Xint filenum;
  1290. XESD *buf = (ESD *)0;
  1291. X
  1292. X    if(!proc_level)
  1293. X        return(eNotExecutingProc);
  1294. X
  1295. X    if(erc = _gfilenum(param,&filenum))
  1296. X        return(erc);
  1297. X
  1298. X    if(!pfile[filenum].f)
  1299. X        return(_file_not_open(filenum));
  1300. X
  1301. X    if((buf = esdalloc(256)) == (ESD *)0)
  1302. X        return(eNoMemory);
  1303. X
  1304. X    if(erc = gstr(param,buf,1))
  1305. X        goto RETURN;
  1306. X
  1307. X    if(!fputs(buf->pb,pfile[filenum].f) && strlen(buf->pb))
  1308. X    {
  1309. X        pprintf(fwrite_error_fmt,filenum);
  1310. X        erc = eFATAL_ALREADY;
  1311. X    }
  1312. X
  1313. XRETURN:
  1314. X    esdfree(buf);
  1315. X    return(erc);
  1316. X#endif
  1317. X}    /* end of pcmd_fwrite */
  1318. X
  1319. X/*+-------------------------------------------------------------------------
  1320. X    pcmd_fchmod(param)
  1321. X
  1322. Xfchmod <mode-str> | <mode-int> <filenum-int> | <filename-str>
  1323. X$i0 = 0 if successful, else errno
  1324. X--------------------------------------------------------------------------*/
  1325. Xint
  1326. Xpcmd_fchmod(param)
  1327. XESD *param;
  1328. X{
  1329. X    int erc;
  1330. X    int filenum;
  1331. X    ESD *fname = (ESD *)0;
  1332. X    ESD *mode = (ESD *)0;
  1333. X    long new_mode;
  1334. X    char *path = "??";;
  1335. X
  1336. X    if((fname = esdalloc(256)) == (ESD *)0)
  1337. X        return(eNoMemory);
  1338. X
  1339. X    if((mode = esdalloc(64)) == (ESD *)0)
  1340. X    {
  1341. X        esdfree(fname);
  1342. X        return(eNoMemory);
  1343. X    }
  1344. X
  1345. X    if(erc = skip_cmd_break(param))
  1346. X        goto RETURN;
  1347. X    else if(!gstr(param,mode,0))
  1348. X    {
  1349. X        if(erc = str_to_filemode(mode->pb,&new_mode))
  1350. X            goto RETURN;
  1351. X    }
  1352. X    else if(erc = gint(param,&new_mode))
  1353. X    {
  1354. X        erc = eBadParameter;
  1355. X        goto RETURN;
  1356. X    }
  1357. X
  1358. X    if(erc = skip_cmd_break(param))
  1359. X        goto RETURN;
  1360. X    else if(!gstr(param,fname,1))
  1361. X    {
  1362. X        path = fname->pb;
  1363. X        if(iv[0] = (long)(chmod(path,(unsigned short)new_mode)))
  1364. X        {
  1365. X            iv[0] = (long)errno;
  1366. X            if(proctrace)
  1367. X                pperror(path);
  1368. X        }
  1369. X    }
  1370. X    else if(!_gfilenum(param,&filenum))
  1371. X    {
  1372. X        if(!pfile[filenum].f)
  1373. X        {
  1374. X            erc = (_file_not_open(filenum));
  1375. X            iv[0] = EBADF;
  1376. X        }
  1377. X        else if(iv[0] = (long)chmod(pfile[filenum].n->pb,
  1378. X            (unsigned short)new_mode))
  1379. X        {
  1380. X            iv[0] = (long)errno;
  1381. X            if(proctrace)
  1382. X            {
  1383. X                sprintf(fname->pb,"file %d",filenum);
  1384. X                pperror(fname->pb);
  1385. X            }
  1386. X        }
  1387. X        if(!iv[0])
  1388. X            path = pfile[filenum].n->pb;
  1389. X    }
  1390. X    else
  1391. X        erc = eBadParameter;
  1392. X
  1393. X    if(proctrace && !erc && !iv[0])
  1394. X        pprintf("'%s' mode set to %o\n",path,(int)new_mode);
  1395. X
  1396. XRETURN:
  1397. X    esdfree(mode);
  1398. X    esdfree(fname);
  1399. X
  1400. X    return(erc);
  1401. X
  1402. X}    /* end of pcmd_fchmod */
  1403. X
  1404. X/*+-------------------------------------------------------------------------
  1405. X    pcmd_fdel(param)
  1406. X
  1407. Xfdel <filename-str>
  1408. X$i0 = 0 if successful, else errno
  1409. X--------------------------------------------------------------------------*/
  1410. Xint
  1411. Xpcmd_fdel(param)
  1412. XESD *param;
  1413. X{
  1414. Xint erc;
  1415. XESD *fname = (ESD *)0;
  1416. X
  1417. X    if((fname = esdalloc(256)) == (ESD *)0)
  1418. X        return(eNoMemory);
  1419. X
  1420. X    if(erc = gstr(param,fname,1))
  1421. X        goto RETURN;
  1422. X
  1423. X    if(iv[0] = (long)unlink(fname->pb))
  1424. X        iv[0] = (long)errno;
  1425. X
  1426. X    if(proctrace)
  1427. X    {
  1428. X        if(iv[0])
  1429. X            pperror(fname->pb);
  1430. X        else
  1431. X            pprintf("'%s' deleted\n",fname->pb);
  1432. X    }
  1433. X
  1434. XRETURN:
  1435. X    esdfree(fname);
  1436. X    return(erc);
  1437. X}    /* end of pcmd_fdel */
  1438. X
  1439. X/*+-------------------------------------------------------------------------
  1440. X    pcmd_fseek(param)
  1441. Xfseek <filenum-int> <filepos-int>
  1442. Xsets $i0 with result
  1443. X--------------------------------------------------------------------------*/
  1444. Xint
  1445. Xpcmd_fseek(param)
  1446. XESD *param;
  1447. X{
  1448. Xint erc;
  1449. Xint filenum;
  1450. Xlong seekpos;
  1451. X
  1452. X    if(!proc_level)
  1453. X        return(eNotExecutingProc);
  1454. X    if(erc = _gfilenum(param,&filenum))
  1455. X        return(erc);
  1456. X    if(!pfile[filenum].f)
  1457. X        return(_file_not_open(filenum));
  1458. X    if(erc = gint(param,&seekpos))
  1459. X        return(erc);
  1460. X
  1461. X    iv[0] = 0;
  1462. X    if(fseek(pfile[filenum].f,seekpos,0) < 0)
  1463. X    {
  1464. X        iv[0] = (long)errno;
  1465. X        if(proctrace)
  1466. X        {
  1467. X            pprintf("file %d ",filenum);
  1468. X            pperror("seekerror");
  1469. X        }
  1470. X    }
  1471. X    else if(proctrace)
  1472. X        pprintf("file %d set to position %ld\n",filenum,seekpos);
  1473. X
  1474. X    return(erc);
  1475. X
  1476. X}    /* end of pcmd_fseek */
  1477. X
  1478. X/*+-------------------------------------------------------------------------
  1479. X    pcmd_mkdir(param)
  1480. X
  1481. Xmkdir <filename-str>
  1482. X$i0 = 0 if successful, else errno
  1483. X--------------------------------------------------------------------------*/
  1484. Xint
  1485. Xpcmd_mkdir(param)
  1486. XESD *param;
  1487. X{
  1488. Xint erc;
  1489. XESD *fname = (ESD *)0;
  1490. X
  1491. X    if((fname = esdalloc(256)) == (ESD *)0)
  1492. X        return(eNoMemory);
  1493. X
  1494. X    if(erc = gstr(param,fname,1))
  1495. X        goto RETURN;
  1496. X
  1497. X    if(iv[0] = (long)mkdir(fname->pb,0755))
  1498. X        iv[0] = (long)errno;
  1499. X
  1500. X    if(proctrace)
  1501. X    {
  1502. X        if(iv[0])
  1503. X            pperror(fname->pb);
  1504. X        else
  1505. X            pprintf("'%s' deleted\n",fname->pb);
  1506. X    }
  1507. X
  1508. XRETURN:
  1509. X    esdfree(fname);
  1510. X    return(erc);
  1511. X}    /* end of pcmd_mkdir */
  1512. X
  1513. X/*+-------------------------------------------------------------------------
  1514. X    pcmd_pclose(param)
  1515. Xpclose <filenum-int>
  1516. X--------------------------------------------------------------------------*/
  1517. Xint
  1518. Xpcmd_pclose(param)
  1519. XESD *param;
  1520. X{
  1521. Xint erc;
  1522. Xint filenum;
  1523. X
  1524. X    if(!proc_level)
  1525. X        return(eNotExecutingProc);
  1526. X
  1527. X    if(erc = _gfilenum(param,&filenum))
  1528. X        return(erc);
  1529. X
  1530. X    if(pfile[filenum].f)
  1531. X    {
  1532. X        pclose(pfile[filenum].f);
  1533. X        pfile[filenum].f = (FILE *)0;
  1534. X        esdfree(pfile[filenum].n);
  1535. X    }
  1536. X
  1537. X    return(0);
  1538. X
  1539. X}    /* end of pcmd_pclose */
  1540. X
  1541. X/*+-------------------------------------------------------------------------
  1542. X    pcmd_popen(param)
  1543. X
  1544. Xpopen [-<popen_switches>] <filenum-int> <filename-str>
  1545. Xsets $i0 with result
  1546. X--------------------------------------------------------------------------*/
  1547. Xint
  1548. Xpcmd_popen(param)
  1549. XESD *param;
  1550. X{
  1551. Xint erc;
  1552. Xint filenum;
  1553. XESD *fname = (ESD *)0;
  1554. Xchar switches[8];
  1555. X#if !defined(M_UNIX)
  1556. XFILE *popen();
  1557. X#endif
  1558. X
  1559. X    if(!proc_level)
  1560. X        return(eNotExecutingProc);
  1561. X
  1562. X    if(get_switches(param,switches,sizeof(switches)))
  1563. X    {
  1564. X        strcpy(switches,"-r");
  1565. X        if(proctrace)
  1566. X        {
  1567. X            pputs("Warning: popen defaulting to read\n");
  1568. X            show_error_position(pcb_stack[proc_level - 1]);
  1569. X        }
  1570. X    }
  1571. X
  1572. X    if(erc = _gfilenum(param,&filenum))
  1573. X        return(erc);
  1574. X
  1575. X    if(pfile[filenum].f)
  1576. X    {
  1577. X        pprintf("file %d already open\n",filenum);
  1578. X        return(eFATAL_ALREADY);
  1579. X    }
  1580. X
  1581. X    if((fname = esdalloc(256)) == (ESD *)0)
  1582. X        return(eNoMemory);
  1583. X
  1584. X    if(erc = gstr(param,fname,1))
  1585. X        goto RETURN;
  1586. X
  1587. X    iv[0] = 0;
  1588. X    if(pfile[filenum].f = popen(fname->pb,switches + 1))
  1589. X    {
  1590. X        iv[0] = (long)errno;
  1591. X        if(proctrace)
  1592. X        {
  1593. X            pprintf("'%s'",fname->pb);
  1594. X            pperror(" ");
  1595. X        }
  1596. X    }
  1597. X    else if(proctrace)
  1598. X        pprintf("opened '%s' as file %d\n",fname->pb,filenum);
  1599. X
  1600. X    if(!erc)
  1601. X        pfile[filenum].n = fname;
  1602. X
  1603. XRETURN:
  1604. X    if(erc)
  1605. X        esdfree(fname);
  1606. X    return(erc);
  1607. X}    /* end of pcmd_popen */
  1608. X
  1609. X/*+-------------------------------------------------------------------------
  1610. X    ifunc_ftell(param,pvalue)
  1611. X%ftell(<filenum-int>)
  1612. X--------------------------------------------------------------------------*/
  1613. Xint
  1614. Xifunc_ftell(param,pvalue)
  1615. XESD *param;
  1616. Xlong *pvalue;
  1617. X{
  1618. Xint erc;
  1619. Xint filenum;
  1620. Xlong ftell();
  1621. X
  1622. X    if(!proc_level)
  1623. X        return(eNotExecutingProc);
  1624. X    if(erc = skip_paren(param,1))
  1625. X        return(erc);
  1626. X    if(erc = _gfilenum(param,&filenum))
  1627. X        return(erc);
  1628. X    if(!pfile[filenum].f)
  1629. X        return(_file_not_open(filenum));
  1630. X    if(erc = skip_paren(param,0))
  1631. X        return(erc);
  1632. X
  1633. X    *pvalue = ftell(pfile[filenum].f);
  1634. X    return(0);
  1635. X}    /* end of ifunc_ftell */
  1636. X
  1637. X/*+-------------------------------------------------------------------------
  1638. X    _param_to_stat(param,pstat_rtnd)
  1639. X--------------------------------------------------------------------------*/
  1640. Xint
  1641. X_param_to_stat(param,pstat_rtnd)
  1642. XESD *param;
  1643. Xstruct stat **pstat_rtnd;
  1644. X{
  1645. Xint erc;
  1646. Xint filenum;
  1647. Xstatic struct stat fst;
  1648. Xstruct stat *pstat = &fst;
  1649. XESD *fname;
  1650. X
  1651. X    errno = 0;
  1652. X
  1653. X    if(erc = skip_paren(param,1))
  1654. X        return(erc);
  1655. X
  1656. X    if((fname = esdalloc(256)) == (ESD *)0)
  1657. X        return(eNoMemory);
  1658. X
  1659. X    if(!gstr(param,fname,1))
  1660. X    {
  1661. X        if(stat(fname->pb,pstat))
  1662. X            pstat = (struct stat *)0;
  1663. X    }
  1664. X    else if(param->index = param->old_index,!_gfilenum(param,&filenum))
  1665. X    {
  1666. X        if(!pfile[filenum].f)
  1667. X        {
  1668. X            esdfree(fname);
  1669. X            return(_file_not_open(filenum));
  1670. X        }
  1671. X        if(stat(pfile[filenum].n->pb,pstat))
  1672. X            pstat = (struct stat *)0;
  1673. X    }
  1674. X    else
  1675. X        erc = eBadParameter;
  1676. X
  1677. X    esdfree(fname);
  1678. X
  1679. X    if(erc)
  1680. X        return(erc);
  1681. X
  1682. X    if(erc = skip_paren(param,0))
  1683. X        return(erc);
  1684. X
  1685. X    *pstat_rtnd = pstat;
  1686. X    if(proctrace && !pstat)
  1687. X        pperror("stat");
  1688. X    return(0);
  1689. X
  1690. X}    /* end of _param_to_stat */
  1691. X
  1692. X/*+-------------------------------------------------------------------------
  1693. X    ifunc_fsize(param,pvalue)
  1694. X%fsize(<filenum-int>)
  1695. X%fsize('filename')
  1696. X--------------------------------------------------------------------------*/
  1697. Xint
  1698. Xifunc_fsize(param,pvalue)
  1699. XESD *param;
  1700. Xlong *pvalue;
  1701. X{
  1702. Xregister erc;
  1703. Xstruct stat *pstat;
  1704. X
  1705. X    if(erc = _param_to_stat(param,&pstat))
  1706. X        return(erc);
  1707. X    if(!pstat)
  1708. X        *pvalue = -1;
  1709. X    else
  1710. X        *pvalue = pstat->st_size;
  1711. X    return(0);
  1712. X}    /* end of ifunc_fsize */
  1713. X
  1714. X/*+-------------------------------------------------------------------------
  1715. X    ifunc_fatime(param,pvalue)
  1716. X%fatime(<filenum-int>)
  1717. X%fatime('filename')
  1718. X--------------------------------------------------------------------------*/
  1719. Xint
  1720. Xifunc_fatime(param,pvalue)
  1721. XESD *param;
  1722. Xlong *pvalue;
  1723. X{
  1724. Xregister erc;
  1725. Xstruct stat *pstat;
  1726. X
  1727. X    if(erc = _param_to_stat(param,&pstat))
  1728. X        return(erc);
  1729. X    if(!pstat)
  1730. X        *pvalue = -1;
  1731. X    else
  1732. X        *pvalue = pstat->st_atime;
  1733. X    return(0);
  1734. X}    /* end of ifunc_fatime */
  1735. X
  1736. X/*+-------------------------------------------------------------------------
  1737. X    ifunc_fmtime(param,pvalue)
  1738. X%fmtime(<filenum-int>)
  1739. X%fmtime('filename')
  1740. X--------------------------------------------------------------------------*/
  1741. Xint
  1742. Xifunc_fmtime(param,pvalue)
  1743. XESD *param;
  1744. Xlong *pvalue;
  1745. X{
  1746. Xregister erc;
  1747. Xstruct stat *pstat;
  1748. X
  1749. X    if(erc = _param_to_stat(param,&pstat))
  1750. X        return(erc);
  1751. X    if(!pstat)
  1752. X        *pvalue = -1;
  1753. X    else
  1754. X        *pvalue = pstat->st_mtime;
  1755. X    return(0);
  1756. X}    /* end of ifunc_fmtime */
  1757. X
  1758. X/*+-------------------------------------------------------------------------
  1759. X    ifunc_fmode(param,pvalue)
  1760. X%fmode(<filenum-int>)
  1761. X%fmode('filename')
  1762. X--------------------------------------------------------------------------*/
  1763. Xint
  1764. Xifunc_fmode(param,pvalue)
  1765. XESD *param;
  1766. Xlong *pvalue;
  1767. X{
  1768. Xregister erc;
  1769. Xstruct stat *pstat;
  1770. X
  1771. X    if(erc = _param_to_stat(param,&pstat))
  1772. X        return(erc);
  1773. X    if(!pstat)
  1774. X        *pvalue = -1;
  1775. X    else
  1776. X        *pvalue = (long)pstat->st_mode;
  1777. X    return(0);
  1778. X}    /* end of ifunc_fmode */
  1779. X
  1780. X/*+-------------------------------------------------------------------------
  1781. X    ifunc_isreg(param,pvalue)
  1782. X%isreg(<filenum-int>)
  1783. X%isreg('filename')
  1784. X--------------------------------------------------------------------------*/
  1785. Xint
  1786. Xifunc_isreg(param,pvalue)
  1787. XESD *param;
  1788. Xlong *pvalue;
  1789. X{
  1790. Xregister erc;
  1791. X
  1792. X    if(erc = ifunc_fmode(param,pvalue))
  1793. X        return(erc);
  1794. X    if(*pvalue != -1)
  1795. X        *pvalue = ((*pvalue & S_IFMT) == S_IFREG);
  1796. X    return(0);
  1797. X}    /* end of ifunc_isreg */
  1798. X
  1799. X/*+-------------------------------------------------------------------------
  1800. X    ifunc_isdir(param,pvalue)
  1801. X%isdir(<filenum-int>)
  1802. X%isdir('filename')
  1803. X--------------------------------------------------------------------------*/
  1804. Xint
  1805. Xifunc_isdir(param,pvalue)
  1806. XESD *param;
  1807. Xlong *pvalue;
  1808. X{
  1809. Xregister erc;
  1810. X
  1811. X    if(erc = ifunc_fmode(param,pvalue))
  1812. X        return(erc);
  1813. X    if(*pvalue != -1)
  1814. X        *pvalue = ((*pvalue & S_IFMT) == S_IFDIR);
  1815. X    return(0);
  1816. X}    /* end of ifunc_isdir */
  1817. X
  1818. X/*+-------------------------------------------------------------------------
  1819. X    ifunc_ischr(param,pvalue)
  1820. X%ischr(<filenum-int>)
  1821. X%ischr('filename')
  1822. X--------------------------------------------------------------------------*/
  1823. Xint
  1824. Xifunc_ischr(param,pvalue)
  1825. XESD *param;
  1826. Xlong *pvalue;
  1827. X{
  1828. Xregister erc;
  1829. X
  1830. X    if(erc = ifunc_fmode(param,pvalue))
  1831. X        return(erc);
  1832. X    if(*pvalue != -1)
  1833. X        *pvalue = ((*pvalue & S_IFMT) == S_IFCHR);
  1834. X    return(0);
  1835. X}    /* end of ifunc_ischr */
  1836. X
  1837. X/* vi: set tabstop=4 shiftwidth=4: */
  1838. X/* end of pcmdfile.c */
  1839. SHAR_EOF
  1840. chmod 0644 pcmdfile.c ||
  1841. echo 'restore of pcmdfile.c failed'
  1842. Wc_c="`wc -c < 'pcmdfile.c'`"
  1843. test 22996 -eq "$Wc_c" ||
  1844.     echo 'pcmdfile.c: original size 22996, current size' "$Wc_c"
  1845. rm -f _shar_wnt_.tmp
  1846. fi
  1847. # ============= pcmdif.c ==============
  1848. if test -f 'pcmdif.c' -a X"$1" != X"-c"; then
  1849.     echo 'x - skipping pcmdif.c (File already exists)'
  1850.     rm -f _shar_wnt_.tmp
  1851. else
  1852. > _shar_wnt_.tmp
  1853. echo 'x - extracting pcmdif.c (Text)'
  1854. sed 's/^X//' << 'SHAR_EOF' > 'pcmdif.c' &&
  1855. X/*+-------------------------------------------------------------------------
  1856. X    pcmdif.c - ecu if procedure commands
  1857. X    wht@n4hgf.Mt-Park.GA.US
  1858. X
  1859. X    IFI $i0 rel-op $i1 cmd
  1860. X    IFS $s0 rel-op $s1 cmd
  1861. X    IFLT, IFLE, IFZ, IFNZ, IFGE, IFGT $i0
  1862. X
  1863. X    where rel-op is "=", "==", "!=", "<>", ">", "<", ">=", "=<"
  1864. X
  1865. X  Defined functions:
  1866. X    _cmd_ifrel_common(param,relop)
  1867. X    _if_common(param,truth)
  1868. X    get_logicop(param,op_returned)
  1869. X    get_relop(param,op_returned)
  1870. X    get_truth_int(param,truth)
  1871. X    get_truth_str(param,truth)
  1872. X    pcmd_else(param)
  1873. X    pcmd_ifge(param)
  1874. X    pcmd_ifgt(param)
  1875. X    pcmd_ifi(param)
  1876. X    pcmd_ifle(param)
  1877. X    pcmd_iflt(param)
  1878. X    pcmd_ifnz(param)
  1879. X    pcmd_ifs(param)
  1880. X    pcmd_ifz(param)
  1881. X    test_truth_int(int1,relop,int2)
  1882. X
  1883. X--------------------------------------------------------------------------*/
  1884. X/*+:EDITS:*/
  1885. X/*:09-10-1992-14:00-wht@n4hgf-ECU release 3.20 */
  1886. X/*:08-22-1992-15:39-wht@n4hgf-ECU release 3.20 BETA */
  1887. X/*:07-25-1991-12:59-wht@n4hgf-ECU release 3.10 */
  1888. X/*:08-26-1990-22:23-wht@n4hgf-fix zero-relative if commands */
  1889. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  1890. X
  1891. X#include <ctype.h>
  1892. X#include "ecu.h"
  1893. X#include "ecuerror.h"
  1894. X#include "esd.h"
  1895. X#include "var.h"
  1896. X#include "proc.h"
  1897. X#include "relop.h"
  1898. X
  1899. Xextern PCB *pcb_stack[];
  1900. Xextern int proctrace;
  1901. X
  1902. X#define MAX_IF 40    /* damn enough */
  1903. Xuchar if_level = 0;
  1904. Xuchar truth_already[MAX_IF];
  1905. X
  1906. X/*+-------------------------------------------------------------------------
  1907. X    get_relop(param,&op_returned)
  1908. X--------------------------------------------------------------------------*/
  1909. Xint
  1910. Xget_relop(param,op_returned)
  1911. XESD *param;
  1912. Xint *op_returned;
  1913. X{
  1914. X    if(end_of_cmd(param))
  1915. X        return(eInvalidRelOp);
  1916. X
  1917. X    switch(param->pb[param->index++]) /* index decremented in default */
  1918. X    {
  1919. X    case '=':
  1920. X        if((param->cb != param->index) && (param->pb[param->index] == '='))
  1921. X            param->index++;
  1922. X        *op_returned = OP_EQ;
  1923. X        return(0);
  1924. X
  1925. X    case '!':
  1926. X        if(param->cb == param->index)
  1927. X            return(eInvalidRelOp);
  1928. X        switch(param->pb[param->index])
  1929. X        {
  1930. X        case '=':
  1931. X            param->index++;
  1932. X            *op_returned = OP_NE;
  1933. X            return(0);
  1934. X        default:
  1935. X            return(eInvalidRelOp);
  1936. X        }
  1937. X
  1938. X    case '<':
  1939. X        if(param->cb == param->index)
  1940. X        {
  1941. X            *op_returned = OP_LT;
  1942. X            return(0);
  1943. X        }
  1944. X        switch(param->pb[param->index])
  1945. X        {
  1946. X        case '>':
  1947. X            param->index++;
  1948. X            *op_returned = OP_NE;
  1949. X            return(0);
  1950. X        case '=':
  1951. X            param->index++;
  1952. X            *op_returned = OP_LE;
  1953. X            return(0);
  1954. X        default:
  1955. X            *op_returned = OP_LT;
  1956. X            return(0);
  1957. X        }
  1958. X
  1959. X    case '>':
  1960. X        if(param->cb == param->index)
  1961. X        {
  1962. X            *op_returned = OP_LT;
  1963. X            return(0);
  1964. X        }
  1965. X        switch(param->pb[param->index])
  1966. X        {
  1967. X        case '=':
  1968. X            param->index++;
  1969. X            *op_returned = OP_GE;
  1970. X            return(0);
  1971. X        default:
  1972. X            *op_returned = OP_GT;
  1973. X            return(0);
  1974. X        }
  1975. X    default:
  1976. X        param->index--;
  1977. X    }
  1978. X    return(eInvalidRelOp);
  1979. X}   /* end of get_relop */
  1980. X
  1981. X/*+-------------------------------------------------------------------------
  1982. X    get_logicop(param,op_returned)
  1983. X--------------------------------------------------------------------------*/
  1984. Xint
  1985. Xget_logicop(param,op_returned)
  1986. XESD *param;
  1987. Xint *op_returned;
  1988. X{
  1989. Xregister erc;
  1990. Xregister char *cptr;
  1991. X
  1992. X    if(erc = skip_cmd_break(param))
  1993. X        return(eInvalidLogicOp);
  1994. X
  1995. X    if((param->cb - param->index) < 2)
  1996. X        return(eInvalidLogicOp);
  1997. X
  1998. X    cptr = param->pb + param->index;
  1999. X    erc = eInvalidLogicOp;
  2000. X    if(!strncmp(cptr,"&&",2))
  2001. X    {
  2002. X        *op_returned = OP_AND;
  2003. X        erc = 0;
  2004. X    }
  2005. X    else if(!strncmp(cptr,"||",2))
  2006. X    {
  2007. X        *op_returned = OP_OR;
  2008. X        erc = 0;
  2009. X    }
  2010. X    if(!erc)
  2011. X        param->index += 2;
  2012. X    return(erc);
  2013. X
  2014. X}    /* end of get_logicop */
  2015. X
  2016. X/*+-------------------------------------------------------------------------
  2017. X    test_truth_int(int1,relop,int2)
  2018. X--------------------------------------------------------------------------*/
  2019. Xint
  2020. Xtest_truth_int(int1,relop,int2)
  2021. Xlong int1;
  2022. Xint relop;
  2023. Xlong int2;
  2024. X{
  2025. Xregister truth = 0;
  2026. X
  2027. X    switch(relop)
  2028. X    {
  2029. X    case OP_EQ:
  2030. X        truth = (int1 == int2);
  2031. X        break;
  2032. X    case OP_NE:
  2033. X        truth = (int1 != int2);
  2034. X        break;
  2035. X    case OP_GT:
  2036. X        truth = (int1 > int2);
  2037. X        break;
  2038. X    case OP_LT:
  2039. X        truth = (int1 < int2);
  2040. X        break;
  2041. X    case OP_GE:
  2042. X        truth = (int1 >= int2);
  2043. X        break;
  2044. X    case OP_LE:
  2045. X        truth = (int1 <= int2);
  2046. X        break;
  2047. X    }
  2048. X    return(truth);
  2049. X
  2050. X}    /* end of test_truth_int */
  2051. X
  2052. X/*+-------------------------------------------------------------------------
  2053. X    get_truth_int(param,truth)
  2054. X--------------------------------------------------------------------------*/
  2055. Xint
  2056. Xget_truth_int(param,truth)
  2057. XESD *param;
  2058. Xint *truth;
  2059. X{
  2060. Xregister erc;
  2061. Xlong int1;
  2062. Xlong int2;
  2063. Xint operator;
  2064. Xint truth2;
  2065. X
  2066. X    if(erc = gint(param,&int1))
  2067. X        return(erc);
  2068. X    if(erc = get_relop(param,&operator))
  2069. X        return(erc);
  2070. X    if(erc = gint(param,&int2))
  2071. X        return(erc);
  2072. X    *truth = test_truth_int(int1,operator,int2);
  2073. X
  2074. X    while(!get_logicop(param,&operator))
  2075. X    {
  2076. X        if(erc = get_truth_int(param,&truth2))
  2077. X            return(erc);
  2078. X        switch(operator)
  2079. X        {
  2080. X            case OP_AND:
  2081. X                *truth &= truth2;
  2082. X                break;
  2083. X
  2084. X            case OP_OR:
  2085. X                *truth |= truth2;
  2086. X                break;
  2087. X        }
  2088. X    }
  2089. X    return(0);
  2090. X
  2091. X}    /* end of get_truth_int */
  2092. X
  2093. X/*+-------------------------------------------------------------------------
  2094. X    get_truth_str(param,truth)
  2095. X--------------------------------------------------------------------------*/
  2096. Xint
  2097. Xget_truth_str(param,truth)
  2098. XESD *param;
  2099. Xint *truth;
  2100. X{
  2101. Xregister erc;
  2102. XESD *tesd1 = (ESD *)0;
  2103. XESD *tesd2 = (ESD *)0;
  2104. Xint operator;
  2105. Xint strcmp_result;
  2106. Xint truth2;
  2107. X
  2108. X    if(!(tesd1 = esdalloc(256)) || !(tesd2 = esdalloc(256)))
  2109. X    {
  2110. X        erc = eNoMemory;
  2111. X        goto RETURN;
  2112. X    }    
  2113. X
  2114. X    if(erc = gstr(param,tesd1,1))
  2115. X        goto RETURN;
  2116. X    if(erc = get_relop(param,&operator))
  2117. X        goto RETURN;
  2118. X    if(erc = gstr(param,tesd2,1))
  2119. X        goto RETURN;
  2120. X
  2121. X    strcmp_result = strcmp(tesd1->pb,tesd2->pb);
  2122. X
  2123. X    switch(operator)
  2124. X    {
  2125. X        case OP_EQ:
  2126. X            *truth = (strcmp_result == 0);
  2127. X            break;
  2128. X        case OP_NE:
  2129. X            *truth = (strcmp_result != 0);
  2130. X            break;
  2131. X        case OP_GT:
  2132. X            *truth = (strcmp_result > 0);
  2133. X            break;
  2134. X        case OP_LT:
  2135. X            *truth = (strcmp_result < 0);
  2136. X            break;
  2137. X        case OP_GE:
  2138. X            *truth = (strcmp_result >= 0);
  2139. X            break;
  2140. X        case OP_LE:
  2141. X            *truth = (strcmp_result <= 0);
  2142. X            break;
  2143. X        default:
  2144. X            return(eInvalidStrOp);
  2145. X    }
  2146. X
  2147. X    while(!get_logicop(param,&operator))
  2148. X    {
  2149. X        if(erc = get_truth_str(param,&truth2))
  2150. X            return(erc);
  2151. X        switch(operator)
  2152. X        {
  2153. X            case OP_AND:
  2154. X                *truth &= truth2;
  2155. X                break;
  2156. X
  2157. X            case OP_OR:
  2158. X                *truth |= truth2;
  2159. X                break;
  2160. X        }
  2161. X    }
  2162. X
  2163. X    erc = 0;
  2164. X
  2165. XRETURN:
  2166. X    if(tesd1)
  2167. X        esdfree(tesd1);
  2168. X    if(tesd2)
  2169. X        esdfree(tesd2);
  2170. X    return(erc);
  2171. X
  2172. X}   /* end of get_truth_str */
  2173. X
  2174. X/*+-------------------------------------------------------------------------
  2175. X    _if_common(param,truth)
  2176. X--------------------------------------------------------------------------*/
  2177. Xint
  2178. X_if_common(param,truth)
  2179. XESD *param;
  2180. Xint truth;
  2181. X{
  2182. Xregister erc = 0;
  2183. Xchar s80[80];
  2184. XPCB *pcb;
  2185. XESD *else_line;
  2186. Xint label_on_else_line;
  2187. Xint truth2;
  2188. Xint save_index;
  2189. Xlong int1;
  2190. X
  2191. X    if(proctrace > 1)
  2192. X    {
  2193. X        pprintf("if condition %s",(truth) ? "TRUE: " : "FALSE\n");
  2194. X        if(truth)
  2195. X        {
  2196. X            skip_cmd_break(param);
  2197. X            pputs(param->pb + param->index);
  2198. X            pputc('\n');
  2199. X        }
  2200. X    }
  2201. X
  2202. X    truth_already[if_level] = truth;
  2203. X
  2204. X/* if end of command, execute frame else conditionally execute rest of esd */
  2205. X    s80[0] = 0;
  2206. X    if(end_of_cmd(param))
  2207. X        erc = execute_frame(truth);
  2208. X    else if(truth)
  2209. X        erc = execute_esd(param);
  2210. X    else
  2211. X        param->index = param->cb;
  2212. X
  2213. X    if(erc)
  2214. X        return(erc);
  2215. X
  2216. X/* check for else statement */
  2217. X    pcb = pcb_stack[proc_level - 1];
  2218. X    if(!pcb->current->next)        /* if no next line, no "else" */
  2219. X        return(0);
  2220. X
  2221. X    else_line = pcb->current->next->text;
  2222. X    else_line->index = else_line->old_index = 0;
  2223. X    if(label_on_else_line = (*else_line->pb != 0x20))
  2224. X    {    /* strip label */
  2225. X        if(get_alphanum_zstr(else_line,s80,sizeof(s80)))
  2226. X            return(eInvalidLabel);
  2227. X    }
  2228. X    if(get_alphanum_zstr(else_line,s80,sizeof(s80)))
  2229. X        return(0);        /* not "else" */
  2230. X    if(strcmp(s80,"else"))
  2231. X        return(0);        /* not "else" */
  2232. X    if(label_on_else_line)
  2233. X    {
  2234. X        else_line->old_index = 0;
  2235. X        pputs("label not allowed on else statement\n");
  2236. X        return(eFATAL_ALREADY);
  2237. X    }
  2238. X
  2239. X/* we have an "else" condition */
  2240. X    truth = !truth;
  2241. X    pcb->current = pcb->current->next;
  2242. X
  2243. X    trace_proc_cmd(pcb);
  2244. X
  2245. X    if(end_of_cmd(else_line))
  2246. X        erc = execute_frame(truth);
  2247. X    else
  2248. X    {
  2249. X        save_index = else_line->old_index = else_line->index;
  2250. X        s80[0] = 0;
  2251. X        if((*(else_line->pb + else_line->index) != '$') &&
  2252. X            get_alpha_zstr(else_line,s80,sizeof(s80)))
  2253. X        {
  2254. X            pputs("illegal command after 'else'\n");
  2255. X            return(eFATAL_ALREADY);
  2256. X        }
  2257. X        if(!strcmp(s80,"ifi"))
  2258. X        {
  2259. X            if(erc = get_truth_int(else_line,&truth2))
  2260. X                return(erc);
  2261. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2262. X            truth_already[if_level] |= truth2;
  2263. X        }
  2264. X        else if(!strcmp(s80,"ifs"))
  2265. X        {
  2266. X            if(erc = get_truth_str(else_line,&truth2))
  2267. X                return(erc);
  2268. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2269. X            truth_already[if_level] |= truth2;
  2270. X        }
  2271. X        else if(!strcmp(s80,"ifz"))
  2272. X        {
  2273. X            if(erc = gint(else_line,&int1))
  2274. X                return(erc);
  2275. X            truth2 = test_truth_int(int1,OP_EQ,0L);
  2276. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2277. X            truth_already[if_level] |= truth2;
  2278. X        }
  2279. X        else if(!strcmp(s80,"ifnz"))
  2280. X        {
  2281. X            if(erc = gint(else_line,&int1))
  2282. X                return(erc);
  2283. X            truth2 = test_truth_int(int1,OP_NE,0L);
  2284. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2285. X            truth_already[if_level] |= truth2;
  2286. X        }
  2287. X        else if(!strcmp(s80,"iflt"))
  2288. X        {
  2289. X            if(erc = gint(else_line,&int1))
  2290. X                return(erc);
  2291. X            truth2 = test_truth_int(int1,OP_LT,0L);
  2292. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2293. X            truth_already[if_level] |= truth2;
  2294. X        }
  2295. X        else if(!strcmp(s80,"ifle"))
  2296. X        {
  2297. X            if(erc = gint(else_line,&int1))
  2298. X                return(erc);
  2299. X            truth2 = test_truth_int(int1,OP_LE,0L);
  2300. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2301. X            truth_already[if_level] |= truth2;
  2302. X        }
  2303. X        else if(!strcmp(s80,"ifgt"))
  2304. X        {
  2305. X            if(erc = gint(else_line,&int1))
  2306. X                return(erc);
  2307. X            truth2 = test_truth_int(int1,OP_GT,0L);
  2308. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2309. X            truth_already[if_level] |= truth2;
  2310. X        }
  2311. X        else if(!strcmp(s80,"ifge"))
  2312. X        {
  2313. X            if(erc = gint(else_line,&int1))
  2314. X                return(erc);
  2315. X            truth2 = test_truth_int(int1,OP_GE,0L);
  2316. X            erc = _if_common(else_line,!truth_already[if_level] & truth2);
  2317. X            truth_already[if_level] |= truth2;
  2318. X        }
  2319. X        else if(!strncmp(s80,"while",5))
  2320. X        {
  2321. X            pputs("'while' command not allowed as 'else' conditional\n");
  2322. X            return(eFATAL_ALREADY);
  2323. X        }
  2324. X        else
  2325. X        {
  2326. X            else_line->index = save_index;
  2327. X            if(truth)
  2328. X                erc = execute_esd(else_line);
  2329. X        }
  2330. X    }
  2331. X
  2332. X    return(erc);
  2333. X}    /* end of _if_common */
  2334. X
  2335. X/*+-------------------------------------------------------------------------
  2336. X    pcmd_ifi(param)
  2337. X--------------------------------------------------------------------------*/
  2338. Xint
  2339. Xpcmd_ifi(param)
  2340. XESD *param;
  2341. X{
  2342. Xregister erc;
  2343. Xint truth;
  2344. X
  2345. X    if(!proc_level)
  2346. X        return(eNotExecutingProc);
  2347. X
  2348. X    if(if_level == MAX_IF)
  2349. X    {
  2350. X        pputs("if statements nested too deeply\n");
  2351. X        return(eFATAL_ALREADY);
  2352. X    }
  2353. X    if_level++;
  2354. X    truth_already[if_level] = 0;
  2355. X
  2356. X    if(!(erc = get_truth_int(param,&truth)))
  2357. X        erc = _if_common(param,truth);
  2358. X    if_level--;
  2359. X    return(erc);
  2360. X
  2361. X}   /* end of pcmd_ifi */
  2362. X
  2363. X/*+-------------------------------------------------------------------------
  2364. X    _cmd_ifrel_common(param,relop)
  2365. X--------------------------------------------------------------------------*/
  2366. Xint
  2367. X_cmd_ifrel_common(param,relop)
  2368. XESD *param;
  2369. Xint relop;
  2370. X{
  2371. Xregister erc;
  2372. Xint truth;
  2373. Xlong int1;
  2374. X
  2375. X    if(!proc_level)
  2376. X        return(eNotExecutingProc);
  2377. X
  2378. X    if(if_level == MAX_IF)
  2379. X    {
  2380. X        pputs("if statements nested too deeply\n");
  2381. X        return(eFATAL_ALREADY);
  2382. X    }
  2383. X    if_level++;
  2384. X    truth_already[if_level] = 0;
  2385. X
  2386. X    if(erc = gint(param,&int1))
  2387. X        return(erc);
  2388. X    truth = test_truth_int(int1,relop,0L);
  2389. X    erc = _if_common(param,truth);
  2390. X    if_level--;
  2391. X    return(erc);
  2392. X
  2393. X}    /* end of _cmd_ifrel_common */
  2394. X
  2395. X/*+-------------------------------------------------------------------------
  2396. X    pcmd_ifz(param)
  2397. X--------------------------------------------------------------------------*/
  2398. Xint
  2399. Xpcmd_ifz(param)
  2400. XESD *param;
  2401. X{
  2402. X    return(_cmd_ifrel_common(param,OP_EQ));
  2403. X}    /* end of pcmd_ifz */
  2404. X
  2405. X/*+-------------------------------------------------------------------------
  2406. X    pcmd_ifnz(param)
  2407. X--------------------------------------------------------------------------*/
  2408. Xint
  2409. Xpcmd_ifnz(param)
  2410. XESD *param;
  2411. X{
  2412. X    return(_cmd_ifrel_common(param,OP_NE));
  2413. X}    /* end of pcmd_ifnz */
  2414. X
  2415. X/*+-------------------------------------------------------------------------
  2416. X    pcmd_ifle(param)
  2417. X--------------------------------------------------------------------------*/
  2418. Xint
  2419. Xpcmd_ifle(param)
  2420. XESD *param;
  2421. X{
  2422. X    return(_cmd_ifrel_common(param,OP_LE));
  2423. X}    /* end of pcmd_ifle */
  2424. X
  2425. X/*+-------------------------------------------------------------------------
  2426. X    pcmd_ifge(param)
  2427. X--------------------------------------------------------------------------*/
  2428. Xint
  2429. Xpcmd_ifge(param)
  2430. XESD *param;
  2431. X{
  2432. X    return(_cmd_ifrel_common(param,OP_GE));
  2433. X}    /* end of pcmd_ifge */
  2434. X
  2435. X/*+-------------------------------------------------------------------------
  2436. X    pcmd_iflt(param)
  2437. X--------------------------------------------------------------------------*/
  2438. Xint
  2439. Xpcmd_iflt(param)
  2440. XESD *param;
  2441. X{
  2442. X    return(_cmd_ifrel_common(param,OP_LT));
  2443. X}    /* end of pcmd_iflt */
  2444. X
  2445. X/*+-------------------------------------------------------------------------
  2446. X    pcmd_ifgt(param)
  2447. X--------------------------------------------------------------------------*/
  2448. Xint
  2449. Xpcmd_ifgt(param)
  2450. XESD *param;
  2451. X{
  2452. X    return(_cmd_ifrel_common(param,OP_GT));
  2453. X}    /* end of pcmd_ifgt */
  2454. X
  2455. X/*+-------------------------------------------------------------------------
  2456. X    pcmd_ifs(param)
  2457. X--------------------------------------------------------------------------*/
  2458. Xint
  2459. Xpcmd_ifs(param)
  2460. XESD *param;
  2461. X{
  2462. Xregister erc;
  2463. Xint truth;
  2464. X
  2465. X    if(!proc_level)
  2466. X        return(eNotExecutingProc);
  2467. X
  2468. X    if(if_level == MAX_IF)
  2469. X    {
  2470. X        pputs("if statements nested too deeply\n");
  2471. X        return(eFATAL_ALREADY);
  2472. X    }
  2473. X    if_level++;
  2474. X    truth_already[if_level] = 0;
  2475. X
  2476. X    if(!(erc = get_truth_str(param,&truth)))
  2477. X        erc = _if_common(param,truth);
  2478. X    if_level--;
  2479. X    return(erc);
  2480. X
  2481. X}   /* end of pcmd_ifs */
  2482. X
  2483. X/*+-------------------------------------------------------------------------
  2484. X    pcmd_else(param)
  2485. X--------------------------------------------------------------------------*/
  2486. X/*ARGSUSED*/
  2487. Xint
  2488. Xpcmd_else(param)
  2489. XESD *param;
  2490. X{
  2491. X    return(eElseCommand);
  2492. X}    /* end of pcmd_else */
  2493. X
  2494. X/* vi: set tabstop=4 shiftwidth=4: */
  2495. X/* end of pcmdif.c */
  2496. SHAR_EOF
  2497. chmod 0644 pcmdif.c ||
  2498. echo 'restore of pcmdif.c failed'
  2499. Wc_c="`wc -c < 'pcmdif.c'`"
  2500. test 13936 -eq "$Wc_c" ||
  2501.     echo 'pcmdif.c: original size 13936, current size' "$Wc_c"
  2502. rm -f _shar_wnt_.tmp
  2503. fi
  2504. # ============= pcmdtty.c ==============
  2505. if test -f 'pcmdtty.c' -a X"$1" != X"-c"; then
  2506.     echo 'x - skipping pcmdtty.c (File already exists)'
  2507.     rm -f _shar_wnt_.tmp
  2508. else
  2509. > _shar_wnt_.tmp
  2510. echo 'x - extracting pcmdtty.c (Text)'
  2511. sed 's/^X//' << 'SHAR_EOF' > 'pcmdtty.c' &&
  2512. X/*+-------------------------------------------------------------------------
  2513. X    pcmdtty.c - tty (console) related procedure commands
  2514. X    wht@n4hgf.Mt-Park.GA.US
  2515. X
  2516. X  Defined functions:
  2517. X    ifunc_colors(pvalue)
  2518. X    pcmd_cls(param)
  2519. X    pcmd_color(param)
  2520. X    pcmd_cursor(param)
  2521. X    pcmd_delline(param)
  2522. X    pcmd_eeol(param)
  2523. X    pcmd_fkey(param)
  2524. X    pcmd_fkmap(param)
  2525. X    pcmd_home(param)
  2526. X    pcmd_icolor(param)
  2527. X    pcmd_insline(param)
  2528. X    pcmd_scrdump(param)
  2529. X    pcmd_vidcolor(param)
  2530. X    pcmd_vidnorm(param)
  2531. X    pcmd_vidrev(param)
  2532. X
  2533. X--------------------------------------------------------------------------*/
  2534. X/*+:EDITS:*/
  2535. X/*:09-10-1992-14:00-wht@n4hgf-ECU release 3.20 */
  2536. X/*:08-30-1992-23:15-wht@n4hgf-add fkmap */
  2537. X/*:08-22-1992-15:39-wht@n4hgf-ECU release 3.20 BETA */
  2538. X/*:07-25-1991-12:59-wht@n4hgf-ECU release 3.10 */
  2539. X/*:05-21-1991-00:45-wht@n4hgf-added -3 error code to keyset_read */
  2540. X/*:01-23-1991-01:58-wht@n4hgf-illegal color name make hi_white on hi_white */
  2541. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  2542. X
  2543. X#include "ecu.h"
  2544. X#include "ecuerror.h"
  2545. X#include "esd.h"
  2546. X#include "ecutty.h"
  2547. X#include "esd.h"
  2548. X#include "proc.h"
  2549. X
  2550. Xextern int proctrace;
  2551. Xextern ulong colors_current;
  2552. X
  2553. X/*+-------------------------------------------------------------------------
  2554. X    pcmd_color(param)
  2555. X
  2556. XUsage:   color [-r] [argument] [argument]
  2557. XOptions:
  2558. X   color color      Set foreground and background normal video colors
  2559. X   -r color color   Set foreground & background reverse video colors
  2560. X
  2561. XColor names
  2562. X   blue      magenta      brown      black
  2563. X   lt_blue   lt_magenta   yellow     gray
  2564. X   cyan      white        green      red
  2565. X   lt_cyan   hi_white     lt_green   lt_red
  2566. X
  2567. X--------------------------------------------------------------------------*/
  2568. Xpcmd_color(param)
  2569. XESD *param;
  2570. X{
  2571. X    register erc;
  2572. X    char switches[8];
  2573. X    int normal;
  2574. X    char s32[32];
  2575. X    ulong foreground;
  2576. X    ulong background;
  2577. X
  2578. X    get_switches(param,switches,sizeof(switches));
  2579. X    if(!strlen(switches))
  2580. X        normal = 1;
  2581. X    else if(switches[1] == 'r')
  2582. X        normal = 0;        /* reverse */
  2583. X    else
  2584. X    {
  2585. X        pputs("unrecognized switch\n");
  2586. X        return(eFATAL_ALREADY);
  2587. X    }
  2588. X
  2589. X    if((erc = get_alpha_zstr(param,s32,sizeof(s32))) ||
  2590. X            ((int)(foreground = color_name_to_num(s32)) < 0))
  2591. X        goto ERROR;
  2592. X
  2593. X    if(erc = get_alpha_zstr(param,s32,sizeof(s32)))
  2594. X    {
  2595. X        if(!end_of_cmd(param))
  2596. X            goto ERROR;
  2597. X        background = 0;
  2598. X    }
  2599. X    else if((int)(background = color_name_to_num(s32)) < 0)
  2600. X        goto ERROR;
  2601. X
  2602. X    if(normal)
  2603. X    {
  2604. X        colors_current &= 0xFFFF0000;
  2605. X        colors_current |= (foreground << 8) | background;
  2606. SHAR_EOF
  2607. true || echo 'restore of pcmdtty.c failed'
  2608. fi
  2609. echo 'End of ecu320 part 19'
  2610. echo 'File pcmdtty.c is continued in part 20'
  2611. echo 20 > _shar_seq_.tmp
  2612. exit 0
  2613.  
  2614. exit 0 # Just in case...
  2615.