home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume12 / ecu2.80 / part14 < prev    next >
Encoding:
Text File  |  1990-05-11  |  53.9 KB  |  2,475 lines
  1. Newsgroups: comp.sources.misc
  2. subject: v12i067: ECU 2.80 part 14/29
  3. from: wht%n4hgf@gatech.edu (Warren Tucker)
  4. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  5.  
  6. Posting-number: Volume 12, Issue 67
  7. Submitted-by: wht%n4hgf@gatech.edu (Warren Tucker)
  8. Archive-name: ecu2.80/part14
  9.  
  10. ---- Cut Here and unpack ----
  11. #!/bin/sh
  12. # This is part 14 of ecu280
  13. if touch 2>&1 | fgrep '[-amc]' > /dev/null
  14.  then TOUCH=touch
  15.  else TOUCH=true
  16. fi
  17. # ============= proc.c ==============
  18. echo "x - extracting proc.c (Text)"
  19. sed 's/^X//' << 'SHAR_EOF' > proc.c &&
  20. X/* CHK=0x1EED */
  21. X/*+-------------------------------------------------------------------------
  22. X    proc.c
  23. X    wht%n4hgf@gatech.edu
  24. X
  25. X  Defined functions:
  26. X    _get_goto_label(param)
  27. X    cmd_do(param)
  28. X    cmd_goto(param)
  29. X    cmd_gotob(param)
  30. X    cmd_return(param)
  31. X    do_proc(argc,argv)
  32. X    dump_proc(pcb)
  33. X    execute_esd(tesd)
  34. X    execute_goto(pcb,goto_type)
  35. X    execute_labelled_esd(tesd)
  36. X    execute_proc(pcb)
  37. X    find_labelled_lcb(label,first,last)
  38. X    find_proc_cmd(cmd_list,cmd)
  39. X    find_procedure(name)
  40. X    free_lcb_chain(lcb)
  41. X    show_error_position(pcb)
  42. X    trace_proc_cmd(pcb)
  43. X
  44. X--------------------------------------------------------------------------*/
  45. X/*+:EDITS:*/
  46. X/*:05-07-1990-21:24-wht@n4hgf---- 2.80 --- */
  47. X/*:04-19-1990-03:08-wht@n4hgf-GCC run found unused vars -- rm them */
  48. X/*:03-25-1990-14:11-wht@n4hgf------ x2.70 ------- */
  49. X/*:03-25-1990-12:42-wht@n4hgf-add interrupt test to execute_esd */
  50. X/*:10-14-1989-21:10-wht-allow user to change ecu color choices */
  51. X/*:07-03-1989-22:57-wht------ x2.00 ----- */
  52. X/*:06-24-1989-16:53-wht-flush edits --- ecu 1.95 */
  53. X
  54. X#include <ctype.h>
  55. X#include "ecu.h"
  56. X#include "ecuerror.h"
  57. X#include "esd.h"
  58. X#include "var.h"
  59. X#include "proc.h"
  60. X
  61. X#define NEED_P_CMD
  62. X#include "ecucmd.h"
  63. X
  64. Xextern int rcvr_pid;
  65. Xextern int interrupt;
  66. Xextern int proc_interrupt;
  67. X
  68. XPCB *pcb_stack[PROC_STACK_MAX];
  69. X
  70. Xint proc_level = 0;
  71. Xint proctrace = 0;
  72. X
  73. Xchar goto_label[64];
  74. X
  75. X/*+-------------------------------------------------------------------------
  76. X    _get_goto_label(param)
  77. X--------------------------------------------------------------------------*/
  78. Xint
  79. X_get_goto_label(param)
  80. XESD *param;
  81. X{
  82. Xregister erc;
  83. Xregister ESD *label_esd;
  84. X
  85. X    goto_label[0] = 0;
  86. X    if(erc = get_alphanum_zstr(param,goto_label,sizeof(goto_label)))
  87. X    {
  88. X        if((label_esd = make_esd(64)) == (ESD *)0)
  89. X            return(eNoMemory);
  90. X        if(!(erc = gstr(param,label_esd)))
  91. X            strcpy(goto_label,label_esd->pb);
  92. X        free_esd(label_esd);
  93. X    }
  94. X
  95. X    return(erc);
  96. X
  97. X}    /* end of __get_goto_label */
  98. X
  99. X/*+-------------------------------------------------------------------------
  100. X    cmd_goto(param)
  101. X--------------------------------------------------------------------------*/
  102. Xint
  103. Xcmd_goto(param)
  104. XESD *param;
  105. X{
  106. X
  107. X    if(_get_goto_label(param))
  108. X        return(eInvalidLabel);
  109. X    return(eProcAttn_GOTO);
  110. X
  111. X}    /* end of cmd_goto */
  112. X
  113. X/*+-------------------------------------------------------------------------
  114. X    cmd_gotob(param)
  115. X--------------------------------------------------------------------------*/
  116. Xint
  117. Xcmd_gotob(param)
  118. XESD *param;
  119. X{
  120. X
  121. X    if(_get_goto_label(param))
  122. X        return(eInvalidLabel);
  123. X    return(eProcAttn_GOTOB);
  124. X
  125. X}    /* end of cmd_gotob */
  126. X
  127. X/*+-------------------------------------------------------------------------
  128. X    cmd_return(param)
  129. X--------------------------------------------------------------------------*/
  130. Xint
  131. Xcmd_return(param)
  132. XESD *param;
  133. X{
  134. Xlong value = 0;
  135. X    if(!gint(param,&value))
  136. X    {
  137. X        value &= (e_USER - 1);
  138. X        if(proctrace)
  139. X            pprintf("return value %ld\n",value);
  140. X        return((int)value);
  141. X    }
  142. X    return(eProcAttn_RETURN);
  143. X}    /* end of cmd_return */
  144. X
  145. X/*+-------------------------------------------------------------------------
  146. X    find_labelled_lcb(label,first,last)
  147. Xsearch for match between label
  148. X--------------------------------------------------------------------------*/
  149. XLCB *
  150. Xfind_labelled_lcb(label,first,last)
  151. Xchar *label;
  152. Xregister LCB *first;
  153. XLCB *last;
  154. X{
  155. Xregister llen = strlen(label);
  156. XESD *text;
  157. X
  158. X    while(first)
  159. X    {
  160. X        text = first->text;
  161. X        if((text->cb >= llen) && (!strncmp(text->pb,label,llen))
  162. X            && (!text->pb[llen] || isspace(text->pb[llen])))
  163. X            return(first);
  164. X
  165. X        if(first == last)
  166. X            return((LCB *)0);
  167. X        first = first->next;
  168. X    }
  169. X    pputs("find_labelled_lab logic error\n");
  170. X    return((LCB *)0);
  171. X
  172. X}    /* end of find_labelled_lcb */
  173. X
  174. X/*+-------------------------------------------------------------------------
  175. X    execute_goto(pcb,goto_type)
  176. X--------------------------------------------------------------------------*/
  177. Xexecute_goto(pcb,goto_type)
  178. XPCB *pcb;
  179. Xint goto_type;
  180. X{
  181. XLCB *next;    /* next lcb to execute */
  182. X
  183. X    switch(goto_type)
  184. X    {
  185. X        case eProcAttn_GOTO:
  186. X            if(!(next = find_labelled_lcb(goto_label,pcb->current,pcb->last)))
  187. X                next = find_labelled_lcb(goto_label,pcb->first,pcb->current);
  188. X            break;
  189. X        case eProcAttn_GOTOB:
  190. X            if(!(next = find_labelled_lcb(goto_label,pcb->first,pcb->current)))
  191. X                next = find_labelled_lcb(goto_label,pcb->current,pcb->last);
  192. X            break;
  193. X    }
  194. X    if(next)
  195. X    {
  196. X        pcb->current = next;
  197. X        return(0);
  198. X    }
  199. X    pprintf("goto label not found: %s\n",goto_label);
  200. X    return(eFATAL_ALREADY);
  201. X
  202. X}    /* end of execute_goto */
  203. X
  204. X/*+-------------------------------------------------------------------------
  205. X    show_error_position(pcb)
  206. Xcursor MUST be at left margin when this is called
  207. X--------------------------------------------------------------------------*/
  208. Xvoid
  209. Xshow_error_position(pcb)
  210. XPCB *pcb;
  211. X{
  212. XESD *tesd = pcb->current->text;
  213. Xregister itmp = tesd->old_index;
  214. Xchar tag[64];
  215. X
  216. X    sprintf(tag,"%s %u> ",pcb->argv[0],pcb->current->lineno);
  217. X    pputs(tag);
  218. X    pputs(tesd->pb);
  219. X    pputs("\n");
  220. X    itmp = strlen(tag) + tesd->old_index;
  221. X    while(itmp--)
  222. X        pputc(' ');
  223. X    pputs("^\n");
  224. X
  225. X}    /* end of show_error_position */
  226. X
  227. X/*+-------------------------------------------------------------------------
  228. X    find_proc_cmd(cmd_list,cmd)
  229. X--------------------------------------------------------------------------*/
  230. XP_CMD *
  231. Xfind_proc_cmd(cmd_list,cmd)
  232. Xregister P_CMD *cmd_list;
  233. Xregister char *cmd;
  234. X{
  235. X    while(cmd_list->token != -1)
  236. X    {
  237. X        if(!strcmp(cmd_list->cmd,cmd))
  238. X            break;
  239. X        cmd_list++;
  240. X    }
  241. X    return((cmd_list->token == -1) ? (P_CMD *)0 : cmd_list);
  242. X
  243. X}    /* end of find_proc_cmd */
  244. X
  245. X/*+-------------------------------------------------------------------------
  246. X    execute_esd(tesd)
  247. X--------------------------------------------------------------------------*/
  248. Xexecute_esd(tesd)
  249. XESD *tesd;
  250. X{
  251. Xint erc;
  252. XP_CMD *pcmd;
  253. Xstatic P_CMD *set_pcmd = (P_CMD *)0;    /* quick access to 'set' */
  254. Xchar cmd[32];
  255. X
  256. X    /* if interrupt, exit */
  257. X    if(interrupt)
  258. X    {
  259. X        proc_interrupt = 1;
  260. X        return(eCONINT);
  261. X    }
  262. X
  263. X    /* if blank, skip it */
  264. X    if(skip_cmd_break(tesd))
  265. X        return(0);
  266. X
  267. X    /* if comment, skip it */
  268. X    if(!skip_cmd_char(tesd,'#'))
  269. X        return(0);
  270. X
  271. X    if(*(tesd->pb + tesd->index) == '{')
  272. X    {
  273. X        pputs("invalid '{'\n");
  274. X        return(eFATAL_ALREADY);
  275. X    }
  276. X
  277. X    while(1)
  278. X    {
  279. X        /* get command -- allow leading '$' to assume 'set' command */
  280. X        if(*(tesd->pb + tesd->index) == '$')
  281. X        {
  282. X            /* find 'set' in the list -- save for rapid access later */
  283. X            if(set_pcmd)
  284. X                pcmd = set_pcmd;
  285. X            else if((pcmd = find_proc_cmd(icmd_cmds,"set")) == (P_CMD *)0)
  286. X                return(eInternalLogicError);
  287. X            else
  288. X                set_pcmd = pcmd;
  289. X        }
  290. X        else
  291. X        {
  292. X            if(get_alphanum_zstr(tesd,cmd,sizeof(cmd)))
  293. X                return(eIllegalCommand);
  294. X            /* find it in the list */
  295. X            if((pcmd = find_proc_cmd(icmd_cmds,cmd)) == (P_CMD *)0)
  296. X                return(eIllegalCommand);
  297. X        }
  298. X
  299. X        /* check to see if this command available for procedure */
  300. X        if(!pcmd->proc)
  301. X            return(eInteractiveCmd);
  302. X
  303. X        /* execute the command */
  304. X        if(erc = (*pcmd->proc)(tesd))
  305. X            return(erc);
  306. X
  307. X        /* look for comment */
  308. X        if(!skip_cmd_char(tesd,'#'))
  309. X            break;
  310. X
  311. X        /* look for multiple commands on line */
  312. X        if(skip_cmd_char(tesd,';'))
  313. X            break;
  314. X
  315. X        /* if blank after ';', skip it */
  316. X        if(skip_cmd_break(tesd))
  317. X            break;
  318. X    }
  319. X    return(0);
  320. X        
  321. X}    /* end of execute_esd */
  322. X
  323. X/*+-------------------------------------------------------------------------
  324. X    execute_labelled_esd(tesd)
  325. X--------------------------------------------------------------------------*/
  326. Xexecute_labelled_esd(tesd)
  327. XESD *tesd;
  328. X{
  329. Xregister index = 0;
  330. Xregister cb = tesd->cb;
  331. Xregister char *pb = tesd->pb;
  332. X
  333. X/* reset indices */
  334. X    tesd->index = index;
  335. X    tesd->old_index = index;
  336. X
  337. X/* if comment, skip it */
  338. X    if(!skip_cmd_char(tesd,'#'))
  339. X        return(0);
  340. X
  341. X/* skip over any label */
  342. X    while(!isspace(*(pb + index)) && (index < cb))
  343. X        index++;
  344. X    tesd->index = index;
  345. X    tesd->old_index = index;
  346. X
  347. X    return(execute_esd(tesd));
  348. X}    /* end of execute_labelled_esd */
  349. X
  350. X/*+-------------------------------------------------------------------------
  351. X    dump_proc(pcb)
  352. X--------------------------------------------------------------------------*/
  353. Xvoid
  354. Xdump_proc(pcb)
  355. XPCB *pcb;
  356. X{
  357. Xint itmp;
  358. XLCB *lcb;
  359. X
  360. X    pprintf("------ pcb @ 0x%08lx -----------------\n",pcb);
  361. X    pprintf("argc=%d first=0x%08lx last=0x%08lx\n",pcb->argc,
  362. X        pcb->first,pcb->last);
  363. X    for(itmp = 0; itmp < pcb->argc; itmp++)
  364. X    {
  365. X        pprintf("argv(%d) @ 0x%lx: '%s'\n",itmp,pcb->argv[itmp],
  366. X            pcb->argv[itmp]);
  367. X    }
  368. X    pputs("\n");
  369. X    lcb = pcb->first;
  370. X    while(lcb)
  371. X    {
  372. X        pprintf("lcb @ 0x%08lx   lineno=%u\n",lcb,lcb->lineno);
  373. X        pputs("\n");
  374. X        lcb = lcb->next;
  375. X    }
  376. X    pflush();
  377. X}    /* end of dump_proc */
  378. X
  379. X/*+-------------------------------------------------------------------------
  380. X    trace_proc_cmd(pcb) - if asked, show command
  381. X--------------------------------------------------------------------------*/
  382. Xvoid
  383. Xtrace_proc_cmd(pcb)
  384. XPCB *pcb;
  385. X{
  386. X    if(proctrace)
  387. X    {
  388. X        pprintf("%s %u> ",pcb->argv[0],pcb->current->lineno);
  389. X        pputs(pcb->current->text->pb);
  390. X        pputc('\n');
  391. X    }
  392. X
  393. X}    /* end of trace_proc_cmd */
  394. X
  395. X/*+-------------------------------------------------------------------------
  396. X    execute_proc(pcb) - execute a memory-resident procedure
  397. X--------------------------------------------------------------------------*/
  398. Xexecute_proc(pcb)
  399. XPCB *pcb;
  400. X{
  401. Xint erc = 0;
  402. X
  403. X    if(proc_level == PROC_STACK_MAX)
  404. X        return(eProcStackTooDeep);
  405. X
  406. X    pcb_stack[proc_level++] = pcb;
  407. X    pcb->current = pcb->first;
  408. X    mkv_proc_starting(pcb);
  409. X
  410. X    while(pcb->current)
  411. X    {
  412. X        /* execute the command */
  413. X        trace_proc_cmd(pcb);
  414. X        if(erc = execute_labelled_esd(pcb->current->text))
  415. X        {
  416. X            /* handle other classes of errors */
  417. X            switch(erc & 0xF000)
  418. X            {
  419. X                case e_WARNING:        /* warning */
  420. X                    erc = 0;
  421. X                    break;
  422. X
  423. X                case e_FATAL:        /* fatal */
  424. X                    goto PROC_RETURN;
  425. X
  426. X                case e_ProcAttn:    /* proc attention */
  427. X                    switch(erc)
  428. X                    {
  429. X                        case eProcAttn_GOTO:
  430. X                        case eProcAttn_GOTOB:
  431. X                            if(erc = execute_goto(pcb,erc))
  432. X                                break;    /* didn't find it */
  433. X                            continue;    /* pcb->current is now goto target */
  434. X
  435. X                        case eProcAttn_RETURN:
  436. X                            erc = 0;
  437. X                            break;
  438. X
  439. X                        case eProcAttn_Interrupt:
  440. X                        case eProcAttn_ESCAPE:
  441. X                            pprintf(
  442. X                                "procedure %s interrupted.\n",pcb->argv[0]);
  443. X                            erc = eFATAL_ALREADY;
  444. X                            break;
  445. X
  446. X                        default:
  447. X                            pprintf("procedure error 0x%x\n",erc);
  448. X                            erc = eFATAL_ALREADY;
  449. X                            break;
  450. X                    }
  451. X                    goto PROC_RETURN;
  452. X
  453. X                default:    /* must be proc return error code */
  454. X                    goto PROC_RETURN;
  455. X                    break;
  456. X            }
  457. X        }
  458. X
  459. X        if(proc_interrupt)
  460. X        {
  461. X            proc_interrupt = 0;
  462. X            interrupt = 0;
  463. X            pprintf("procedure %s interrupted\n",pcb->argv[0]);
  464. X            erc = eFATAL_ALREADY;
  465. X        }
  466. X
  467. X        if(erc)
  468. X            break;
  469. X        pcb->current = pcb->current->next;
  470. X    }
  471. X
  472. XPROC_RETURN:
  473. X    mkv_proc_terminating(pcb);
  474. X    if(erc)
  475. X    {
  476. X        if((erc > 0) && (erc < e_USER))
  477. X        {
  478. X            pprintf(">>procedure %s returned %d\n",pcb->argv[0],erc);
  479. X            erc |= e_USER;
  480. X        }
  481. X        else if((erc > e_USER) && (erc <= 0x1FFF))
  482. X        {
  483. X            ;    /* already said it */
  484. X        }
  485. X        else
  486. X        {
  487. X            if(erc != eFATAL_ALREADY)
  488. X            {
  489. X                proc_error(erc);
  490. X                erc = eFATAL_ALREADY;
  491. X            }
  492. X            show_error_position(pcb);
  493. X        }
  494. X    }
  495. X    pcb_stack[--proc_level] = (PCB *)0;
  496. X    if(erc && !proc_level)
  497. X        plog_control((char *)0);
  498. X    return(erc);
  499. X}    /* end of execute_proc */
  500. X
  501. X/*+-------------------------------------------------------------------------
  502. X    free_lcb_chain(lcb)
  503. X--------------------------------------------------------------------------*/
  504. Xvoid
  505. Xfree_lcb_chain(lcb)
  506. Xregister LCB *lcb;
  507. X{
  508. XLCB *plcb;
  509. X
  510. X    while(lcb)
  511. X    {
  512. X        if(lcb->text)
  513. X            free_esd(lcb->text);
  514. X        plcb  = lcb;
  515. X        lcb = lcb->next;
  516. X        free((char *)plcb);
  517. X    }
  518. X
  519. X}    /* end of free_lcb_chain */
  520. X
  521. X/*+-------------------------------------------------------------------------
  522. X    find_procedure(name)
  523. X--------------------------------------------------------------------------*/
  524. Xchar *
  525. Xfind_procedure(name)
  526. Xchar *name;
  527. X{
  528. Xstatic char procpath[256];
  529. X
  530. X/* try to find proc file in current directory */
  531. X    strcpy(procpath,name);
  532. X    strcat(procpath,".ep");
  533. X    if(access(procpath,4))
  534. X    {
  535. X        /* try to find proc file in home .ecu subdirectory */
  536. X        get_home_dir(procpath);
  537. X        strcat(procpath,"/.ecu/");
  538. X        strcat(procpath,name);
  539. X        strcat(procpath,".ep");
  540. X        if(access(procpath,4))
  541. X            return((char *)0);
  542. X    }
  543. X    return(procpath);
  544. X
  545. X}    /* end of find_procedure */
  546. X
  547. X/*+-------------------------------------------------------------------------
  548. X    do_proc(argc,argv) - read in a disk-based procedure and execute it
  549. X--------------------------------------------------------------------------*/
  550. Xdo_proc(argc,argv)
  551. Xint argc;
  552. Xchar **argv;
  553. X{
  554. Xregister itmp;
  555. Xint itmp2;
  556. Xint erc;
  557. Xint iargv;
  558. Xchar *pargv[MAX_PARGV];
  559. Xint ipargv = 0;
  560. Xchar s256[256];
  561. Xchar *procpath;
  562. XFILE *fp;
  563. XPCB *pcb = (PCB *)0;
  564. XLCB *lcb;
  565. XLCB *plcb;
  566. Xushort line_count = 0;
  567. Xextern ulong colors_current;
  568. Xulong colors_at_entry = colors_current;
  569. X
  570. X    proc_interrupt = 0;
  571. X    interrupt = 0;
  572. X    for(iargv = 0; iargv < argc; iargv++)
  573. X    {
  574. X        if(ipargv == MAX_PARGV)
  575. X        {
  576. X            pprintf("\nToo many arguments to %s invocation\n",pargv[0]);
  577. X            erc = eFATAL_ALREADY;
  578. X            goto RETURN;
  579. X        }
  580. X        pargv[ipargv++] = argv[iargv];
  581. X    }
  582. X
  583. X    if(!ipargv)
  584. X    {
  585. X        pputs("\nno procedure name given\n");
  586. X        erc = eFATAL_ALREADY;
  587. X        goto RETURN;
  588. X    }
  589. X
  590. X    if(!(procpath = find_procedure(pargv[0])))
  591. X    {
  592. X        pprintf("\nprocedure %s not found\n",pargv[0]);
  593. X        erc = eFATAL_ALREADY;
  594. X        goto RETURN;
  595. X    }
  596. X    fp = fopen(procpath,"r");
  597. X
  598. X    if(!(pcb = (PCB *)malloc(sizeof(PCB))))
  599. X    {
  600. X        erc = eNoMemory;
  601. X        goto RETURN;
  602. X    }
  603. X
  604. X    pcb->argv = pargv;
  605. X    pcb->argc = ipargv;
  606. X    pcb->first = (LCB *)0;
  607. X
  608. X    plcb = (LCB *)0;
  609. X    line_count = 0;
  610. X    while(1)
  611. X    {
  612. X        if(fgets(s256,sizeof(s256),fp) == NULL)
  613. X            break;
  614. X        line_count++;
  615. X
  616. X        itmp = strlen(s256) - 1;    /* skip blank lines */
  617. X        if(!itmp)
  618. X            continue;
  619. X        s256[itmp] = 0;                /* kill trailing NL */
  620. X        for(itmp2 = 0; itmp2 < itmp; itmp2++)
  621. X        {
  622. X            if(s256[itmp2] == 0x09)
  623. X                s256[itmp2] = 0x20;
  624. X        }
  625. X        if(s256[0] == '#')             /* skip comments */
  626. X            continue;
  627. X
  628. X        if(!(lcb = (LCB *)malloc(sizeof(LCB))))
  629. X        {
  630. X            fclose(fp);
  631. X            erc = eNoMemory;
  632. X            goto RETURN;
  633. X        }
  634. X
  635. X        lcb->prev = plcb;
  636. X        lcb->next = (LCB *)0;
  637. X        lcb->lineno = line_count;
  638. X
  639. X        if(plcb)
  640. X            plcb->next = lcb;
  641. X        else
  642. X            pcb->first = lcb;
  643. X
  644. X        if((lcb->text = make_esd(itmp)) == (ESD *)0)
  645. X        {
  646. X            fclose(fp);
  647. X            erc = eNoMemory;
  648. X            goto RETURN;
  649. X        }
  650. X        strcpy(lcb->text->pb,s256);
  651. X        lcb->text->cb = itmp;
  652. X        null_terminate_esd(lcb->text);
  653. X        plcb = lcb;
  654. X    }
  655. X    fclose(fp);
  656. X    pcb->last = lcb;
  657. X    if(line_count)
  658. X        erc = execute_proc(pcb);
  659. X    else
  660. X        erc = eProcEmpty;
  661. X
  662. XRETURN:
  663. X    if(pcb)
  664. X    {
  665. X        if(pcb->first)
  666. X            free_lcb_chain(pcb->first);
  667. X        free((char *)pcb);
  668. X    }
  669. X    if((erc > e_USER) && (erc <= 0x1FFF))
  670. X        erc -= e_USER;
  671. X    if(erc > e_USER)
  672. X        setcolor(colors_at_entry);
  673. X    return(erc);
  674. X
  675. X}    /* end of do_proc */
  676. X
  677. X/*+-------------------------------------------------------------------------
  678. X    cmd_do(param)
  679. X--------------------------------------------------------------------------*/
  680. Xcmd_do(param)
  681. XESD *param;
  682. X{
  683. Xint erc;
  684. Xregister ipargv;
  685. Xchar *cmd_copy;
  686. Xchar *pargv[MAX_PARGV];
  687. XESD *pargv_esd[MAX_PARGV];
  688. Xint pargc = 0;
  689. X
  690. X    if(!(cmd_copy = (char *)malloc(param->cb)))
  691. X        return(eNoMemory);
  692. X    strcpy(cmd_copy,param->pb + param->old_index);
  693. X    while(pargc != MAX_PARGV)
  694. X    {
  695. X        if(end_of_cmd(param))
  696. X            break;
  697. X        if((pargv_esd[pargc] = make_esd(256)) == (ESD *)0)
  698. X        {
  699. X            erc = eNoMemory;
  700. X            goto RETURN;
  701. X        }
  702. X        if(erc = gstr(param,pargv_esd[pargc]))
  703. X            goto RETURN;
  704. X        pargv[pargc] = pargv_esd[pargc]->pb;
  705. X        pargc++;
  706. X    }
  707. X
  708. X    if(pargc < MAX_PARGV)
  709. X        erc = do_proc(pargc,pargv);
  710. X    else
  711. X    {
  712. X        pprintf("too many arguments to procedure\n");
  713. X        erc = eFATAL_ALREADY;
  714. X    }
  715. X
  716. XRETURN:
  717. X    free(cmd_copy);
  718. X    for(ipargv = 0; ipargv < pargc; ipargv++)
  719. X        free_esd(pargv_esd[ipargv]);
  720. X    return(erc);
  721. X
  722. X}    /* end of cmd_do */
  723. X
  724. X/* vi: set tabstop=4 shiftwidth=4: */
  725. X/* end of proc.c */
  726. SHAR_EOF
  727. $TOUCH -am 0507233390 proc.c &&
  728. chmod 0644 proc.c ||
  729. echo "restore of proc.c failed"
  730. set `wc -c proc.c`;Wc_c=$1
  731. if test "$Wc_c" != "15370"; then
  732.     echo original size 15370, current size $Wc_c
  733. fi
  734. # ============= proc_error.c ==============
  735. echo "x - extracting proc_error.c (Text)"
  736. sed 's/^X//' << 'SHAR_EOF' > proc_error.c &&
  737. X/* CHK=0x034A */
  738. X/*+-------------------------------------------------------------------------
  739. X    proc_error.c - print ecu procedure error
  740. X--------------------------------------------------------------------------*/
  741. X/*+:EDITS:*/
  742. X/*:05-08-1990-02:31-build_err-creation from ecuerror.h */
  743. X
  744. X#include "ecu.h"
  745. X#include "ecuerror.h"
  746. X
  747. X/*+-------------------------------------------------------------------------
  748. X    proc_error(erc) - print error message
  749. X--------------------------------------------------------------------------*/
  750. Xvoid
  751. Xproc_error(erc)
  752. Xint erc;
  753. X{
  754. X    switch(erc)
  755. X    {
  756. X        case eProcEmpty:
  757. X            pputs("empty procedure\n");
  758. X            break;
  759. X        case eConnectFailed:
  760. X            pputs("failed to connect\n");
  761. X            break;
  762. X        case eNoSwitches:
  763. X            pputs("no switch(es) to command\n");
  764. X            break;
  765. X        case eIllegalCommand:
  766. X            pputs("invalid command\n");
  767. X            break;
  768. X        case eNoMemory:
  769. X            pputs("no more memory available\n");
  770. X            break;
  771. X        case eSyntaxError:
  772. X            pputs("syntax error\n");
  773. X            break;
  774. X        case eIllegalVarNumber:
  775. X            pputs("variable number is invalid or out of range\n");
  776. X            break;
  777. X        case eIllegalVarType:
  778. X            pputs("unrecognized variable type\n");
  779. X            break;
  780. X        case eNotInteger:
  781. X            pputs("integer expected and not found\n");
  782. X            break;
  783. X        case eCONINT:
  784. X            pputs("abort due to interrupt\n");
  785. X            break;
  786. X        case eInvalidFunction:
  787. X            pputs("invalid function name\n");
  788. X            break;
  789. X        case eMissingLeftParen:
  790. X            pputs("did not find expected left paren\n");
  791. X            break;
  792. X        case eMissingRightParen:
  793. X            pputs("did not find expected right paren\n");
  794. X            break;
  795. X        case eCommaExpected:
  796. X            pputs("expected comma not found\n");
  797. X            break;
  798. X        case eProcStackTooDeep:
  799. X            pputs("procedure stack depth exceeded\n");
  800. X            break;
  801. X        case eInvalidRelOp:
  802. X            pputs("invalid relational operator\n");
  803. X            break;
  804. X        case eInvalidIntOp:
  805. X            pputs("invalid integer operator\n");
  806. X            break;
  807. X        case eInvalidStrOp:
  808. X            pputs("invalid string operator\n");
  809. X            break;
  810. X        case eNotExecutingProc:
  811. X            pputs("not executing DO at this time\n");
  812. X            break;
  813. X        case eInvalidLabel:
  814. X            pputs("invalid label\n");
  815. X            break;
  816. X        case eInternalLogicError:
  817. X            pputs("internal logic error ... whoops\n");
  818. X            break;
  819. X        case eEOF:
  820. X            pputs("end of file or read error\n");
  821. X            break;
  822. X        case eBufferTooSmall:
  823. X            pputs("string too long\n");
  824. X            break;
  825. X        case eNoParameter:
  826. X            pputs("expected parameter not found\n");
  827. X            break;
  828. X        case eBadParameter:
  829. X            pputs("bad parameter\n");
  830. X            break;
  831. X        case eInvalidHexNumber:
  832. X            pputs("invalid hexadecimal digit\n");
  833. X            break;
  834. X        case eInvalidDecNumber:
  835. X            pputs("invalid decimal digit\n");
  836. X            break;
  837. X        case eInvalidOctNumber:
  838. X            pputs("invalid octal digit\n");
  839. X            break;
  840. X        case eInteractiveCmd:
  841. X            pputs("interactive command\n");
  842. X            break;
  843. X        case eNoLineAttached:
  844. X            pputs("no line (modem) attached\n");
  845. X            break;
  846. X        case eBadFileNumber:
  847. X            pputs("file number out of range\n");
  848. X            break;
  849. X        case eNotImplemented:
  850. X            pputs("not implemented\n");
  851. X            break;
  852. X        case eDuplicateMatch:
  853. X            pputs("more than one condition matches\n");
  854. X            break;
  855. X        case eColonExpected:
  856. X            pputs("expected colon not found\n");
  857. X            break;
  858. X        case eLabelInvalidHere:
  859. X            pputs("label not allowed on this statement\n");
  860. X            break;
  861. X        case eNoCloseFrame:
  862. X            pputs("missing '}' for '{'\n");
  863. X            break;
  864. X        case eNoFrame:
  865. X            pputs("missing command or command group after 'while' or 'if'\n");
  866. X            break;
  867. X        case eMissingCommand:
  868. X            pputs("expected command not found\n");
  869. X            break;
  870. X        case eBreakCommand:
  871. X            pputs("'break' outside 'while'\n");
  872. X            break;
  873. X        case eContinueCommand:
  874. X            pputs("'continue' outside 'while'\n");
  875. X            break;
  876. X        case eElseCommand:
  877. X            pputs("'else' without matching 'if'\n");
  878. X            break;
  879. X        case eInvalidVarName:
  880. X            pputs("invalid variable name\n");
  881. X            break;
  882. X        case eNoSuchVariable:
  883. X            pputs("variable by this name not defined\n");
  884. X            break;
  885. X        case eInvalidLogicOp:
  886. X            pputs("invalid logical operator\n");
  887. X            break;
  888. X        case eExpectRespondFail:
  889. X            pputs("expect-respond failed\n");
  890. X            break;
  891. X        case eProcAttn_GOTO:
  892. X            pputs("GOTO detected\n");
  893. X            break;
  894. X        case eProcAttn_GOTOB:
  895. X            pputs("GOTOB detected\n");
  896. X            break;
  897. X        case eProcAttn_RETURN:
  898. X            pputs("RETURN detected\n");
  899. X            break;
  900. X        case eProcAttn_ESCAPE:
  901. X            pputs("ESCAPE detected\n");
  902. X            break;
  903. X        case eProcAttn_Interrupt:
  904. X            pputs("procedure interrupted\n");
  905. X            break;
  906. X        case eFATAL_ALREADY:
  907. X        case eWARNING_ALREADY:
  908. X            break;
  909. X        default:
  910. X            pprintf("unknown error %x\n",erc);
  911. X            break;
  912. X    }
  913. X} /* end of proc_error */
  914. X
  915. X/* vi: set tabstop=4 shiftwidth=4: */
  916. X/* end of proc_error.c */
  917. SHAR_EOF
  918. $TOUCH -am 0508023190 proc_error.c &&
  919. chmod 0644 proc_error.c ||
  920. echo "restore of proc_error.c failed"
  921. set `wc -c proc_error.c`;Wc_c=$1
  922. if test "$Wc_c" != "4423"; then
  923.     echo original size 4423, current size $Wc_c
  924. fi
  925. # ============= procframe.c ==============
  926. echo "x - extracting procframe.c (Text)"
  927. sed 's/^X//' << 'SHAR_EOF' > procframe.c &&
  928. X/* CHK=0x83D2 */
  929. X/*+-------------------------------------------------------------------------
  930. X    procframe.c - execute frame of statements
  931. X    wht%n4hgf@gatech.edu
  932. X
  933. X  Defined functions:
  934. X    cmd_break(param);
  935. X    cmd_continue(param);
  936. X    execute_frame(truth)
  937. X
  938. X--------------------------------------------------------------------------*/
  939. X/*+:EDITS:*/
  940. X/*:05-07-1990-21:24-wht@n4hgf---- 2.80 --- */
  941. X/*:03-25-1990-14:12-wht@n4hgf------ x2.70 ------- */
  942. X/*:07-03-1989-22:57-wht------ x2.00 ----- */
  943. X/*:06-24-1989-16:53-wht-flush edits --- ecu 1.95 */
  944. X
  945. X#include <ctype.h>
  946. X#include "ecu.h"
  947. X#include "ecukey.h"
  948. X#include "ecuerror.h"
  949. X#include "esd.h"
  950. X#include "var.h"
  951. X#include "proc.h"
  952. X
  953. Xextern PCB *pcb_stack[PROC_STACK_MAX];
  954. Xextern int proc_level;
  955. Xextern int proc_interrupt;
  956. Xextern int proctrace;
  957. X
  958. X/*+-------------------------------------------------------------------------
  959. X    cmd_break(param)
  960. X--------------------------------------------------------------------------*/
  961. Xint
  962. Xcmd_break(param)
  963. XESD *param;
  964. X{
  965. X    return(eBreakCommand);
  966. X}    /* end of cmd_break */
  967. X
  968. X/*+-------------------------------------------------------------------------
  969. X    cmd_continue(param)
  970. X--------------------------------------------------------------------------*/
  971. Xint
  972. Xcmd_continue(param)
  973. XESD *param;
  974. X{
  975. X    return(eContinueCommand);
  976. X}    /* end of cmd_continue */
  977. X
  978. X/*+-------------------------------------------------------------------------
  979. X    execute_frame(truth)
  980. X
  981. X  pcb_stack[proc_level - 1]->current points to lcb behind frame: one
  982. X  statement or { statements }
  983. X
  984. X  if truth true, execute frame, else skip it
  985. X--------------------------------------------------------------------------*/
  986. Xint
  987. Xexecute_frame(truth)
  988. Xint truth;
  989. X{
  990. Xregister itmp;
  991. Xint erc = 0;
  992. XPCB *pcb = pcb_stack[proc_level - 1];
  993. XLCB *original_lcb = pcb->current;
  994. XLCB *begin_lcb;
  995. XESD *text;
  996. Xint nest_level = 0;
  997. Xint remember_break = 0;
  998. X
  999. X    if(!(pcb->current = pcb->current->next))
  1000. X    {
  1001. X        pcb->current = original_lcb;
  1002. X        return(eNoFrame);
  1003. X    }
  1004. X
  1005. X    text = pcb->current->text;
  1006. X    text->old_index = text->index = 0;
  1007. X
  1008. X    if(*text->pb != SPACE)
  1009. X        return(eLabelInvalidHere);
  1010. X    skip_cmd_break(text);
  1011. X
  1012. X/* handle single statement frame */
  1013. X    if(*(text->pb + text->index) != '{')
  1014. X    {
  1015. X        itmp = text->cb - text->index;
  1016. X        if( ((itmp > 2) && !strncmp(text->pb + text->index,"if",2)))
  1017. X        {
  1018. X            pputs("command must appear inside {} or on same line as else\n");
  1019. X            erc = eFATAL_ALREADY;
  1020. X        }
  1021. X        else if( ((itmp > 5) && !strncmp(text->pb + text->index,"while",5)))
  1022. X        {
  1023. X            pputs("command must appear inside {} within this context\n");
  1024. X            erc = eFATAL_ALREADY;
  1025. X        }
  1026. X        else if(truth)
  1027. X        {
  1028. X            trace_proc_cmd(pcb);
  1029. X            erc = execute_esd(text);
  1030. X        }
  1031. X        return(erc);
  1032. X    }
  1033. X
  1034. X/* we've got a {} frame */
  1035. X    begin_lcb = pcb->current;
  1036. X    pcb->current = pcb->current->next;
  1037. X    while(pcb->current)
  1038. X    {
  1039. X        if(proc_interrupt)
  1040. X            return(eCONINT);
  1041. X        text = pcb->current->text;
  1042. X        text->old_index = text->index = 0;
  1043. X        if(*text->pb != SPACE)
  1044. X            return(eLabelInvalidHere);
  1045. X        skip_cmd_break(text);
  1046. X        if(*(text->pb + text->index) == '}')
  1047. X        {
  1048. X            if(!nest_level)
  1049. X            {
  1050. X                text->index = text->cb;
  1051. X                if(remember_break)
  1052. X                    return(eBreakCommand);
  1053. X                return(0);
  1054. X            }
  1055. X            nest_level--;
  1056. X        }
  1057. X        else if(truth)
  1058. X        {
  1059. X            trace_proc_cmd(pcb);
  1060. X            if(erc = execute_esd(text))
  1061. X            {
  1062. X                if(erc != eBreakCommand)
  1063. X                    return(erc);
  1064. X                remember_break = 1;
  1065. X                truth = 0;
  1066. X            }
  1067. X        }
  1068. X        else if(*(text->pb + text->index) == '{')
  1069. X            nest_level++;
  1070. X        pcb->current = pcb->current->next;
  1071. X    }
  1072. X    pcb->current = begin_lcb;
  1073. X    return(eNoCloseFrame);
  1074. X    
  1075. X}    /* end of execute_frame */
  1076. X
  1077. X/* vi: set tabstop=4 shiftwidth=4: */
  1078. X/* end of procframe.c */
  1079. SHAR_EOF
  1080. $TOUCH -am 0507233390 procframe.c &&
  1081. chmod 0644 procframe.c ||
  1082. echo "restore of procframe.c failed"
  1083. set `wc -c procframe.c`;Wc_c=$1
  1084. if test "$Wc_c" != "3525"; then
  1085.     echo original size 3525, current size $Wc_c
  1086. fi
  1087. # ============= regexp.c ==============
  1088. echo "x - extracting regexp.c (Text)"
  1089. sed 's/^X//' << 'SHAR_EOF' > regexp.c &&
  1090. X/* CHK=0x1078 */
  1091. X/*+-------------------------------------------------------------------------
  1092. X    regexp.c -- regular expression functions made sane
  1093. X--------------------------------------------------------------------------*/
  1094. X/*+:EDITS:*/
  1095. X/*:05-07-1990-21:24-wht@n4hgf---- 2.80 --- */
  1096. X/*:04-19-1990-03:08-wht@n4hgf-GCC run found unused vars -- rm them */
  1097. X/*:03-25-1990-14:12-wht@n4hgf------ x2.70 ------- */
  1098. X/*:07-03-1989-22:57-wht------ x2.00 ----- */
  1099. X/*:06-24-1989-20:40-wht-adapt for ecu */
  1100. X
  1101. X#include <stdio.h>
  1102. X#include "stdio_lint.h"
  1103. X#include "lint_args.h"
  1104. X#include "ecuerror.h"
  1105. X#include "esd.h"
  1106. X#include "var.h"
  1107. X#include <setjmp.h>
  1108. X
  1109. X#define    CBRA    2
  1110. X#define    CCHR    4
  1111. X#define    CDOT    8
  1112. X#define    CCL    12
  1113. X#define    CDOL    20
  1114. X#define    CCEOF    22
  1115. X#define    CKET    24
  1116. X#define    CBACK    36
  1117. X
  1118. X#define    STAR    01
  1119. X#define    RNGE    03
  1120. X
  1121. X#define    NBRA    9
  1122. X
  1123. X#define    PLACE(c)    ep[c >> 3] |= bittab[c & 07]
  1124. X#define    ISTHERE(c)    (ep[c >> 3] & bittab[c & 07])
  1125. X
  1126. Xextern int proctrace;
  1127. Xextern int proc_level;
  1128. X
  1129. Xchar *braslist[NBRA];
  1130. Xchar *braelist[NBRA];
  1131. Xint nbra,ebra;
  1132. Xchar *match_start,*match_end,*locs;
  1133. Xint sed;
  1134. Xint nodelim;
  1135. Xint circf;
  1136. Xint low;
  1137. Xint size;
  1138. X
  1139. Xchar bittab[] = { 1,2,4,8,16,32,64,128 };
  1140. X
  1141. Xjmp_buf    compile_error_jmpbuf;
  1142. X
  1143. Xvoid
  1144. Xcompile(pattern,ep,endbuf,seof)
  1145. Xregister char *ep;
  1146. Xchar *pattern,*endbuf;
  1147. X{
  1148. X    register char *sp = pattern;
  1149. X    register c;
  1150. X    register eof = seof;
  1151. X    char *lastep = pattern;
  1152. X    int cclcnt;
  1153. X    char bracket[NBRA],*bracketp;
  1154. X    int closed;
  1155. X    char neg;
  1156. X    int lc;
  1157. X    int i,cflg;
  1158. X
  1159. X    lastep = 0;
  1160. X    if((c = *sp++) == eof || c == '\n')
  1161. X    {
  1162. X        if(c == '\n')
  1163. X        {
  1164. X            --sp;
  1165. X            nodelim = 1;
  1166. X        }
  1167. X        if(*ep == 0 && !sed)
  1168. X            longjmp(compile_error_jmpbuf,41);
  1169. X        return;
  1170. X    }
  1171. X    bracketp = bracket;
  1172. X    circf = closed = nbra = ebra = 0;
  1173. X    if(c == '^')
  1174. X        circf++;
  1175. X    else
  1176. X        --sp;
  1177. X    while(1)
  1178. X    {
  1179. X        if(ep >= endbuf)
  1180. X            longjmp(compile_error_jmpbuf,50);
  1181. X        c = *sp++;
  1182. X        if(c != '*' && ((c != '\\') || (*sp != '{')))
  1183. X            lastep = ep;
  1184. X        if(c == eof)
  1185. X        {
  1186. X            *ep++ = CCEOF;
  1187. X            return;
  1188. X        }
  1189. X        switch(c)
  1190. X        {
  1191. X
  1192. X        case '.':
  1193. X            *ep++ = CDOT;
  1194. X            continue;
  1195. X
  1196. X        case '\n':
  1197. X            if(!sed)
  1198. X            {
  1199. X                --sp;
  1200. X                *ep++ = CCEOF;
  1201. X                nodelim = 1;
  1202. X                return;
  1203. X            }
  1204. X            else longjmp(compile_error_jmpbuf,36);
  1205. X        case '*':
  1206. X            if(lastep==0 || *lastep==CBRA || *lastep==CKET)
  1207. X                goto defchar;
  1208. X            *lastep |= STAR;
  1209. X            continue;
  1210. X
  1211. X        case '$':
  1212. X            if(*sp != eof && *sp != '\n')
  1213. X                goto defchar;
  1214. X            *ep++ = CDOL;
  1215. X            continue;
  1216. X
  1217. X        case '[':
  1218. X            if(&ep[17] >= endbuf)
  1219. X                longjmp(compile_error_jmpbuf,50);
  1220. X
  1221. X            *ep++ = CCL;
  1222. X            lc = 0;
  1223. X            for(i = 0; i < 16; i++)
  1224. X                ep[i] = 0;
  1225. X
  1226. X            neg = 0;
  1227. X            if((c = *sp++) == '^')
  1228. X            {
  1229. X                neg = 1;
  1230. X                c = *sp++;
  1231. X            }
  1232. X
  1233. X            do 
  1234. X            {
  1235. X                if(c == '\0' || c == '\n')
  1236. X                    longjmp(compile_error_jmpbuf,49);
  1237. X                if(c == '-' && lc != 0)
  1238. X                {
  1239. X                    if((c = *sp++) == ']')
  1240. X                    {
  1241. X                        PLACE('-');
  1242. X                        break;
  1243. X                    }
  1244. X                    while(lc < c)
  1245. X                    {
  1246. X                        PLACE(lc);
  1247. X                        lc++;
  1248. X                    }
  1249. X                }
  1250. X                if(c == '\\')
  1251. X                {
  1252. X                    switch(c = *sp++)
  1253. X                    {
  1254. X                    case 'n':
  1255. X                        c = '\n';
  1256. X                        break;
  1257. X                    }
  1258. X                }
  1259. X                lc = c;
  1260. X                PLACE(c);
  1261. X            } while((c = *sp++) != ']');
  1262. X            if(neg)
  1263. X            {
  1264. X                for(cclcnt = 0; cclcnt < 16; cclcnt++)
  1265. X                    ep[cclcnt] ^= -1;
  1266. X                ep[0] &= 0376;
  1267. X            }
  1268. X
  1269. X            ep += 16;
  1270. X
  1271. X            continue;
  1272. X
  1273. X        case '\\':
  1274. X            switch(c = *sp++)
  1275. X            {
  1276. X
  1277. X            case '(':
  1278. X                if(nbra >= NBRA)
  1279. X                    longjmp(compile_error_jmpbuf,43);
  1280. X                *bracketp++ = nbra;
  1281. X                *ep++ = CBRA;
  1282. X                *ep++ = nbra++;
  1283. X                continue;
  1284. X
  1285. X            case ')':
  1286. X                if(bracketp <= bracket || ++ebra != nbra)
  1287. X                    longjmp(compile_error_jmpbuf,42);
  1288. X                *ep++ = CKET;
  1289. X                *ep++ = *--bracketp;
  1290. X                closed++;
  1291. X                continue;
  1292. X
  1293. X            case '{':
  1294. X                if(lastep == (char *) (0))
  1295. X                    goto defchar;
  1296. X                *lastep |= RNGE;
  1297. X                cflg = 0;
  1298. Xnlim:
  1299. X                c = *sp++;
  1300. X                i = 0;
  1301. X                do 
  1302. X                {
  1303. X                    if('0' <= c && c <= '9')
  1304. X                        i = 10 * i + c - '0';
  1305. X                    else
  1306. X                        longjmp(compile_error_jmpbuf,16);
  1307. X                } while(((c = *sp++) != '\\') && (c != ','));
  1308. X                if(i >= 255)
  1309. X                    longjmp(compile_error_jmpbuf,11);
  1310. X                *ep++ = i;
  1311. X                if(c == ',')
  1312. X                {
  1313. X                    if(cflg++)
  1314. X                        longjmp(compile_error_jmpbuf,44);
  1315. X                    if((c = *sp++) == '\\')
  1316. X                        *ep++ = 255;
  1317. X                    else 
  1318. X                    {
  1319. X                        --sp;
  1320. X                        goto nlim;
  1321. X                        /* get 2'nd number */
  1322. X                    }
  1323. X                }
  1324. X                if(*sp++ != '}')
  1325. X                    longjmp(compile_error_jmpbuf,45);
  1326. X                if(!cflg)    /* one number */
  1327. X                    *ep++ = i;
  1328. X                else if((ep[-1] & 0377) < (ep[-2] & 0377))
  1329. X                    longjmp(compile_error_jmpbuf,46);
  1330. X                continue;
  1331. X
  1332. X            case '\n':
  1333. X                longjmp(compile_error_jmpbuf,36);
  1334. X
  1335. X            case 'n':
  1336. X                c = '\n';
  1337. X                goto defchar;
  1338. X
  1339. X            default:
  1340. X                if(c >= '1' && c <= '9')
  1341. X                {
  1342. X                    if((c -= '1') >= closed)
  1343. X                        longjmp(compile_error_jmpbuf,25);
  1344. X                    *ep++ = CBACK;
  1345. X                    *ep++ = c;
  1346. X                    continue;
  1347. X                }
  1348. X            }
  1349. X            /* Drop through to default to use \ to turn off special chars */
  1350. X
  1351. Xdefchar:
  1352. X        default:
  1353. X            lastep = ep;
  1354. X            *ep++ = CCHR;
  1355. X            *ep++ = c;
  1356. X        }
  1357. X    }
  1358. X}
  1359. X
  1360. Xstep(p1,p2)
  1361. Xregister char *p1,*p2;
  1362. X{
  1363. X    register c;
  1364. X
  1365. X    if(circf)
  1366. X    {
  1367. X        match_start = p1;
  1368. X        return(advance(p1,p2));
  1369. X    }
  1370. X    /* fast check for first character */
  1371. X    if(*p2==CCHR)
  1372. X    {
  1373. X        c = p2[1];
  1374. X        do 
  1375. X        {
  1376. X            if(*p1 != c)
  1377. X                continue;
  1378. X            if(advance(p1,p2))
  1379. X            {
  1380. X                match_start = p1;
  1381. X                return(1);
  1382. X            }
  1383. X        } while(*p1++);
  1384. X        return(0);
  1385. X    }
  1386. X    /* regular algorithm */
  1387. X    do 
  1388. X    {
  1389. X        if(advance(p1,p2))
  1390. X        {
  1391. X            match_start = p1;
  1392. X            return(1);
  1393. X        }
  1394. X    } while(*p1++);
  1395. X    return(0);
  1396. X}
  1397. X
  1398. Xadvance(lp,ep)
  1399. Xregister char *lp,*ep;
  1400. X{
  1401. X    register char *curlp;
  1402. X    char c;
  1403. X    char *bbeg;
  1404. X    int ct;
  1405. X
  1406. X    while(1)
  1407. X        switch(*ep++)
  1408. X        {
  1409. X
  1410. X        case CCHR:
  1411. X            if(*ep++ == *lp++)
  1412. X                continue;
  1413. X            return(0);
  1414. X
  1415. X        case CDOT:
  1416. X            if(*lp++)
  1417. X                continue;
  1418. X            return(0);
  1419. X
  1420. X        case CDOL:
  1421. X            if(*lp==0)
  1422. X                continue;
  1423. X            return(0);
  1424. X
  1425. X        case CCEOF:
  1426. X            match_end = lp;
  1427. X            return(1);
  1428. X
  1429. X        case CCL:
  1430. X            c = *lp++ & 0177;
  1431. X            if(ISTHERE(c))
  1432. X            {
  1433. X                ep += 16;
  1434. X                continue;
  1435. X            }
  1436. X            return(0);
  1437. X        case CBRA:
  1438. X            braslist[*ep++] = lp;
  1439. X            continue;
  1440. X
  1441. X        case CKET:
  1442. X            braelist[*ep++] = lp;
  1443. X            continue;
  1444. X
  1445. X        case CCHR|RNGE:
  1446. X            c = *ep++;
  1447. X            getrnge(ep);
  1448. X            while(low--)
  1449. X                if(*lp++ != c)
  1450. X                    return(0);
  1451. X            curlp = lp;
  1452. X            while(size--)
  1453. X                if(*lp++ != c)
  1454. X                    break;
  1455. X            if(size < 0)
  1456. X                lp++;
  1457. X            ep += 2;
  1458. X            goto star;
  1459. X
  1460. X        case CDOT|RNGE:
  1461. X            getrnge(ep);
  1462. X            while(low--)
  1463. X                if(*lp++ == '\0')
  1464. X                    return(0);
  1465. X            curlp = lp;
  1466. X            while(size--)
  1467. X                if(*lp++ == '\0')
  1468. X                    break;
  1469. X            if(size < 0)
  1470. X                lp++;
  1471. X            ep += 2;
  1472. X            goto star;
  1473. X
  1474. X        case CCL|RNGE:
  1475. X            getrnge(ep + 16);
  1476. X            while(low--)
  1477. X            {
  1478. X                c = *lp++ & 0177;
  1479. X                if(!ISTHERE(c))
  1480. X                    return(0);
  1481. X            }
  1482. X            curlp = lp;
  1483. X            while(size--)
  1484. X            {
  1485. X                c = *lp++ & 0177;
  1486. X                if(!ISTHERE(c))
  1487. X                    break;
  1488. X            }
  1489. X            if(size < 0)
  1490. X                lp++;
  1491. X            ep += 18;        /* 16 + 2 */
  1492. X            goto star;
  1493. X
  1494. X        case CBACK:
  1495. X            bbeg = braslist[*ep];
  1496. X            ct = braelist[*ep++] - bbeg;
  1497. X
  1498. X            if(ecmp(bbeg,lp,ct))
  1499. X            {
  1500. X                lp += ct;
  1501. X                continue;
  1502. X            }
  1503. X            return(0);
  1504. X
  1505. X        case CBACK|STAR:
  1506. X            bbeg = braslist[*ep];
  1507. X            ct = braelist[*ep++] - bbeg;
  1508. X            curlp = lp;
  1509. X            while(ecmp(bbeg,lp,ct))
  1510. X                lp += ct;
  1511. X
  1512. X            while(lp >= curlp)
  1513. X            {
  1514. X                if(advance(lp,ep))    return(1);
  1515. X                lp -= ct;
  1516. X            }
  1517. X            return(0);
  1518. X
  1519. X
  1520. X        case CDOT|STAR:
  1521. X            curlp = lp;
  1522. X            while(*lp++);
  1523. X            goto star;
  1524. X
  1525. X        case CCHR|STAR:
  1526. X            curlp = lp;
  1527. X            while(*lp++ == *ep);
  1528. X            ep++;
  1529. X            goto star;
  1530. X
  1531. X        case CCL|STAR:
  1532. X            curlp = lp;
  1533. X            do 
  1534. X            {
  1535. X                c = *lp++ & 0177;
  1536. X            } while(ISTHERE(c));
  1537. X            ep += 16;
  1538. X            goto star;
  1539. X
  1540. Xstar:
  1541. X            do 
  1542. X            {
  1543. X                if(--lp == locs)
  1544. X                    break;
  1545. X                if(advance(lp,ep))
  1546. X                    return(1);
  1547. X            } while(lp > curlp);
  1548. X            return(0);
  1549. X
  1550. X        }
  1551. X}
  1552. X
  1553. Xvoid
  1554. Xgetrnge(regexp)
  1555. Xregister char *regexp;
  1556. X{
  1557. X    low = *regexp++ & 0377;
  1558. X    size = ((*regexp & 0377) == 255) ? 20000 : (*regexp & 0377) - low;
  1559. X}
  1560. X
  1561. Xecmp(a,b,count)
  1562. Xregister char *a,*b;
  1563. Xregister count;
  1564. X{
  1565. X    while(count--)
  1566. X        if(*a++ != *b++)
  1567. X            return(0);
  1568. X    return(1);
  1569. X}
  1570. X
  1571. X/*+-------------------------------------------------------------------------
  1572. X    itmp = regexp_compile(regexp,cmpbuf,cmpbuf_size,emsg)
  1573. X
  1574. Xreturns 0 if no compile error,
  1575. Xelse error occurred (*emsg points to error message text)
  1576. X--------------------------------------------------------------------------*/
  1577. Xint
  1578. Xregexp_compile(regexp,cmpbuf,cmpbuf_size,emsg)
  1579. Xchar *regexp;
  1580. Xchar *cmpbuf;
  1581. Xint cmpbuf_size;
  1582. Xchar **emsg;
  1583. X{
  1584. X    register int itmp;
  1585. X    static char errm[40];
  1586. X
  1587. X    if(itmp = setjmp(compile_error_jmpbuf))
  1588. X    {
  1589. X        switch(itmp)
  1590. X        {
  1591. X        case 11:
  1592. X            *emsg = "Range endpoint too large";
  1593. X            break;
  1594. X        case 16:
  1595. X            *emsg = "Bad number";
  1596. X            break;
  1597. X        case 25:
  1598. X            *emsg = "\"\\digit\" out of range";
  1599. X            break;
  1600. X        case 36:
  1601. X            *emsg = "Illegal or missing delimiter";
  1602. X            break;
  1603. X        case 41:
  1604. X            *emsg = "No previous regular expression";
  1605. X            break;
  1606. X        case 42:
  1607. X            *emsg = "More \\)'s than \\('s in regular expression";
  1608. X            break;
  1609. X        case 43:
  1610. X            *emsg = "More \\('s than \\)'s in regular expression";
  1611. X            break;
  1612. X        case 44:
  1613. X            *emsg = "More than 2 numbers in \\{ \\}";
  1614. X            break;
  1615. X        case 45:
  1616. X            *emsg = "} expected after \\";
  1617. X            break;
  1618. X        case 46:
  1619. X            *emsg = "First number exceeds second in \\{ \\}";
  1620. X            break;
  1621. X        case 49:
  1622. X            *emsg = "[] imbalance";
  1623. X            break;
  1624. X        case 50:
  1625. X            *emsg = "Regular expression too complex";
  1626. X            break;
  1627. X        default:
  1628. X            sprintf(errm,"Unknown regexp compile error %d",itmp);
  1629. X            *emsg = errm;
  1630. X            break;
  1631. X        }
  1632. X        return(itmp);
  1633. X    }
  1634. X
  1635. X    compile(regexp,cmpbuf,cmpbuf + cmpbuf_size,0);
  1636. X    return(0);
  1637. X}    /* end of regexp_compile */
  1638. X
  1639. X/*+-------------------------------------------------------------------------
  1640. X    regexp_scan(cmpbuf,str_to_search,&match,&matchlen)
  1641. Xreturn 1 if string match found, else 0
  1642. Xif string matches, match receives pointer to first byte, matchlen = length
  1643. Xof matching string
  1644. X--------------------------------------------------------------------------*/
  1645. Xregexp_scan(cmpbuf,str_to_search,match,matchlen)
  1646. Xchar *cmpbuf;
  1647. Xchar *str_to_search;
  1648. Xchar **match;
  1649. Xint *matchlen;
  1650. X{
  1651. X    register int itmp = step(str_to_search,cmpbuf);
  1652. X    if(itmp)
  1653. X    {
  1654. X        *match = match_start;
  1655. X        *matchlen = (int)(match_end - match_start);
  1656. X    }
  1657. X    return(itmp);
  1658. X}    /* end of regexp_scan */
  1659. X
  1660. X#define CMPBUF_SIZE    256
  1661. Xchar cmpbuf[CMPBUF_SIZE];
  1662. X
  1663. X/*+-------------------------------------------------------------------------
  1664. X    regexp_operation(match_str,regexp_str,rtn_value)
  1665. X--------------------------------------------------------------------------*/
  1666. Xint
  1667. Xregexp_operation(match_str,regexp_str,rtn_value)
  1668. Xchar *match_str;
  1669. Xchar *regexp_str;
  1670. Xlong *rtn_value;
  1671. X{
  1672. Xchar *emsg;
  1673. Xchar *match;
  1674. Xint matchlen;
  1675. X
  1676. X    if(regexp_compile(regexp_str,cmpbuf,sizeof(cmpbuf),&emsg))
  1677. X    {
  1678. X        pprintf("compile 1 error: %s\n",emsg);
  1679. X        return(eFATAL_ALREADY);
  1680. X    }
  1681. X
  1682. X    if(regexp_scan(cmpbuf,match_str,&match,&matchlen))
  1683. X    {
  1684. X        *rtn_value = (long)(match - match_str);
  1685. X        iv[0] = (long)matchlen;
  1686. X        if(proc_level && proctrace)
  1687. X            pprintf("%match set $i00 = %ld\n",iv[0]);
  1688. X    }
  1689. X    else
  1690. X        *rtn_value = -1;
  1691. X
  1692. X    return(0);
  1693. X}    /* end of regexp_operation */
  1694. X
  1695. X/* vi: set tabstop=4 shiftwidth=4: */
  1696. X/* end of regexp.c */
  1697. SHAR_EOF
  1698. $TOUCH -am 0507232990 regexp.c &&
  1699. chmod 0644 regexp.c ||
  1700. echo "restore of regexp.c failed"
  1701. set `wc -c regexp.c`;Wc_c=$1
  1702. if test "$Wc_c" != "10420"; then
  1703.     echo original size 10420, current size $Wc_c
  1704. fi
  1705. # ============= sysdep.c ==============
  1706. echo "x - extracting sysdep.c (Text)"
  1707. sed 's/^X//' << 'SHAR_EOF' > sysdep.c &&
  1708. X/* CHK=0xCD25 */
  1709. X/*+-------------------------------------------------------------------------
  1710. X    sysdep.c -- system dependency aid
  1711. X--------------------------------------------------------------------------*/
  1712. X/*+:EDITS:*/
  1713. X/*:05-07-1990-21:24-wht@n4hgf---- 2.80 --- */
  1714. X/*:03-25-1990-14:12-wht@n4hgf------ x2.70 ------- */
  1715. X/*:11-25-1989-16:13-wht-add M_UNIX */
  1716. X/*:07-06-1989-15:06-wht-added i386 */
  1717. X/*:02-27-1989-21:59-wht-add M_I286 and M_I386 */
  1718. X/*:11-17-1988-15:17-wht-creation */
  1719. X
  1720. X#include <stdio.h>
  1721. X
  1722. Xchar    *defines[] =
  1723. X{
  1724. X#if defined(M_UNIX)
  1725. X    "M_UNIX",
  1726. X#undef M_XENIX        /* <---------------------- */
  1727. X#endif
  1728. X#if defined(M_XENIX)
  1729. X    "M_XENIX",
  1730. X#endif
  1731. X#if defined(M_SYS5)
  1732. X    "M_SYS5",
  1733. X#endif
  1734. X#if defined(M_I386)
  1735. X    "M_I386",
  1736. X#endif
  1737. X#if defined(M_I286)
  1738. X    "M_I286",
  1739. X#endif
  1740. X#if defined(M_I186)
  1741. X    "M_I186",
  1742. X#endif
  1743. X#if defined(M_I8086)
  1744. X    "M_I8086",
  1745. X#endif
  1746. X#if defined(M_I86)
  1747. X    "M_I86",
  1748. X#endif
  1749. X#if defined(pyr)
  1750. X    "pyr",
  1751. X#endif
  1752. X#if defined(i386)
  1753. X    "i386",
  1754. X#endif
  1755. X#if defined(sun)
  1756. X    "sun",
  1757. X#endif
  1758. X#if defined(sun2)
  1759. X    "sun2,
  1760. X#endif
  1761. X#if defined(sun3)
  1762. X    "sun3",
  1763. X#endif
  1764. X#if defined(sun4)
  1765. X    "sun4",
  1766. X#endif
  1767. X#if defined(vax)
  1768. X    "vax",
  1769. X#endif
  1770. X#if defined(pdp11)
  1771. X    "pdp11",
  1772. X#endif
  1773. X#if defined(M_INTERNAT)
  1774. X    "M_INTERNAT",
  1775. X#endif
  1776. X    (char *)0
  1777. X};
  1778. X
  1779. X/*+-------------------------------------------------------------------------
  1780. X    pos_in_ztermed_list(test,list)
  1781. X--------------------------------------------------------------------------*/
  1782. Xint
  1783. Xpos_in_ztermed_list(test,list)
  1784. Xchar    *test;
  1785. Xchar    **list;
  1786. X{
  1787. X    register int itmp = 0;
  1788. X
  1789. X    while(*list)
  1790. X    {
  1791. X        if(!strcmp(*list++,test))
  1792. X            return(itmp);
  1793. X        itmp++;
  1794. X    }
  1795. X    return(-1);
  1796. X}    /* end of pos_in_ztermed_list */
  1797. X
  1798. X/*+-------------------------------------------------------------------------
  1799. X    main(argc,argv,envp)
  1800. X--------------------------------------------------------------------------*/
  1801. Xmain(argc,argv,envp)
  1802. Xint argc;
  1803. Xchar    **argv;
  1804. Xchar    **envp;
  1805. X{
  1806. Xregister int iargv;
  1807. Xchar **cpptr;
  1808. X
  1809. X    for(iargv = 1; iargv < argc; iargv++)
  1810. X    {
  1811. X        if(*argv[iargv] == '=')
  1812. X        {
  1813. X            if(pos_in_ztermed_list(argv[iargv] + 1,defines) >= 0)
  1814. X                break;
  1815. X        }
  1816. X    }
  1817. X    if(iargv == argc)
  1818. X    {
  1819. X        fprintf(stderr,"\n\nsysdep: no system match\n\n");
  1820. X        fprintf(stderr,"On this system, I recognize:\n");
  1821. X        cpptr = defines;
  1822. X        while(*cpptr)
  1823. X            fprintf(stderr,"    %s\n",*cpptr++);
  1824. X        fputs("\n",stderr);
  1825. X        exit(1);
  1826. X    }
  1827. X
  1828. X    while(++iargv <argc)
  1829. X    {
  1830. X        if(*argv[iargv] == '=')
  1831. X            break;
  1832. X        fputs(argv[iargv],stdout);
  1833. X        fputc(' ',stdout);
  1834. X    }
  1835. X    fputs("\n",stdout);
  1836. X    exit(0);
  1837. X}    /* end of main */
  1838. X
  1839. SHAR_EOF
  1840. $TOUCH -am 0507232990 sysdep.c &&
  1841. chmod 0644 sysdep.c ||
  1842. echo "restore of sysdep.c failed"
  1843. set `wc -c sysdep.c`;Wc_c=$1
  1844. if test "$Wc_c" != "2419"; then
  1845.     echo original size 2419, current size $Wc_c
  1846. fi
  1847. # ============= utmpstat.c ==============
  1848. echo "x - extracting utmpstat.c (Text)"
  1849. sed 's/^X//' << 'SHAR_EOF' > utmpstat.c &&
  1850. X/* CHK=0xEAB0 */
  1851. X
  1852. X#if defined(WHT)
  1853. X#define LOG_UTMP
  1854. X#endif
  1855. X/*+-------------------------------------------------------------------------
  1856. X    utmpstat.c - utmp status for XENIX/UNIX line
  1857. X    wht%n4hgf@gatech.edu
  1858. X
  1859. X  Defined functions:
  1860. X    strcmpi(s1,s2)
  1861. X    utmp_status(line)
  1862. X
  1863. X--------------------------------------------------------------------------*/
  1864. X/*+:EDITS:*/
  1865. X/*:05-07-1990-21:24-wht@n4hgf---- 2.80 --- */
  1866. X/*:03-25-1990-14:12-wht@n4hgf------ x2.70 ------- */
  1867. X/*:03-23-1990-14:44-wht@n4hgf-add strcmpi */
  1868. X/*:11-24-1989-21:04-wht-creation */
  1869. X
  1870. X#include "ecu.h"
  1871. X#include "ecuhangup.h"
  1872. X#include "utmpstatus.h"
  1873. X#include "ecuungetty.h"
  1874. X#include "dialer.h"
  1875. X#include <errno.h>
  1876. X#include <utmp.h>
  1877. X
  1878. Xextern int errno;
  1879. X
  1880. Xchar *utmp_file = "/etc/utmp";
  1881. Xstruct utmp last_utmp;
  1882. X
  1883. X/*+-------------------------------------------------------------------------
  1884. X    strcmpi(s1,s2) - case-insensitive strcmp
  1885. X--------------------------------------------------------------------------*/
  1886. Xint
  1887. Xstrcmpi(s1,s2)
  1888. Xregister char *s1;
  1889. Xregister char *s2;
  1890. X{
  1891. Xregister char c1,c2;
  1892. X
  1893. X    for ( ; *s1 ; s1++, s2++)
  1894. X    {
  1895. X        if(isupper(*s1))
  1896. X            c1 = tolower(*s1);
  1897. X        else
  1898. X            c1 = *s1;
  1899. X        if(isupper(*s2))
  1900. X            c2 = tolower(*s2);
  1901. X        else
  1902. X            c2 = *s2;
  1903. X        if(c1 != c2)
  1904. X            break;
  1905. X    }
  1906. X    return (*s1 - *s2);
  1907. X}    /* end of strcmpi */
  1908. X
  1909. X/*+-------------------------------------------------------------------------
  1910. X    utmp_status(line) - check line status in utmp
  1911. X'line' is "/dev/ttyxx"-style
  1912. Xreturns US_ value and global utmp struct last_utmp;
  1913. X--------------------------------------------------------------------------*/
  1914. Xint
  1915. Xutmp_status(line)
  1916. Xchar *line;
  1917. X{
  1918. Xregister ufd;
  1919. Xregister itmp;
  1920. Xregister status = US_NOTFOUND;
  1921. X#if defined(LOG_UTMP)
  1922. Xchar logstr[128];
  1923. X#endif
  1924. X
  1925. X    if((ufd = open(utmp_file,O_RDONLY,755)) < 0)
  1926. X    {
  1927. X        perror(utmp_file);
  1928. X        hangup(HANGUP_LINE_OPEN_ERROR);
  1929. X    }
  1930. X
  1931. X    while(read(ufd,(char *)&last_utmp,sizeof(last_utmp)) > 0)
  1932. X    {
  1933. X#if defined(M_UNIX)
  1934. X        if((!strcmp(last_utmp.ut_name,"uugetty") ||
  1935. X         !strcmp(last_utmp.ut_name,"getty")) &&
  1936. X         (ulindex(last_utmp.ut_id,line + 8) == (strlen(last_utmp.ut_id) - 2)))
  1937. X        {
  1938. X            if(itmp = line_locked(line))
  1939. X                status = US_DIALOUT;
  1940. X            else
  1941. X                status = US_LOGIN;
  1942. X            break;
  1943. X        }
  1944. X        if((!strcmpi(last_utmp.ut_line,line + 5)) &&
  1945. X            (!kill(last_utmp.ut_pid,0) || (errno != ESRCH)))
  1946. X        {
  1947. X            status = US_LOGGEDIN;
  1948. X            break;
  1949. X        }
  1950. X#else
  1951. X        if((!strcmpi(last_utmp.ut_line,line + 5)) &&
  1952. X            (!kill(last_utmp.ut_pid,0) || (errno != ESRCH)))
  1953. X        {
  1954. X            if(!strcmp(last_utmp.ut_user,"LOGIN"))
  1955. X                status = US_LOGIN;
  1956. X            else if(!strcmp(last_utmp.ut_user,"DIALOUT"))
  1957. X                status = US_DIALOUT;
  1958. X            else
  1959. X                status = US_LOGGEDIN;
  1960. X            break;
  1961. X        }
  1962. X#endif
  1963. X    }
  1964. X
  1965. X#if defined(LOG_UTMP)
  1966. X    if(status == US_NOTFOUND)
  1967. X        sprintf(logstr,"UTMP %s: no entry in utmp, status=%d",line,status);
  1968. X    else
  1969. X    {
  1970. X    char *ctime();
  1971. X        sprintf(logstr,"UTMP %s:%s:%s:%d:status=%d:%s", 
  1972. X            last_utmp.ut_user, last_utmp.ut_id, last_utmp.ut_line,
  1973. X            last_utmp.ut_pid,status, ctime(&last_utmp.ut_time));
  1974. X        logstr[strlen(logstr) - 1] = 0;    /* kill NL from ctime() */
  1975. X    }
  1976. X    ecu_log_event(logstr);
  1977. X#endif
  1978. X    close(ufd);
  1979. X    return(status);
  1980. X
  1981. X}    /* end of utmp_status */
  1982. X
  1983. X/* vi: set tabstop=4 shiftwidth=4: */
  1984. X/* end of utmpstat.c */
  1985. SHAR_EOF
  1986. $TOUCH -am 0507233390 utmpstat.c &&
  1987. chmod 0644 utmpstat.c ||
  1988. echo "restore of utmpstat.c failed"
  1989. set `wc -c utmpstat.c`;Wc_c=$1
  1990. if test "$Wc_c" != "3130"; then
  1991.     echo original size 3130, current size $Wc_c
  1992. fi
  1993. # ============= var.c ==============
  1994. echo "x - extracting var.c (Text)"
  1995. sed 's/^X//' << 'SHAR_EOF' > var.c &&
  1996. X/* CHK=0xF525 */
  1997. X/*+-------------------------------------------------------------------------
  1998. X    var.c - ecu variable routines
  1999. X    wht%n4hgf@gatech.edu
  2000. X
  2001. X  Defined functions:
  2002. X    alloc_MKV(name)
  2003. X    build_mkvi(param)
  2004. X    build_mkvi_primitive(name)
  2005. X    build_mkvs(param)
  2006. X    build_mkvs_primitive(name,length)
  2007. X    cmd_mkvar(param)
  2008. X    find_mkvs(name,ppesd,auto_create)
  2009. X    find_mkvi(name,pplong,auto_create)
  2010. X    free_mkvi(mkv)
  2011. X    free_mkvs(mkv)
  2012. X    get_ivptr(param,ppiv,auto_create)
  2013. X    get_subscript(param,psubscript)
  2014. X    get_svptr(param,ppsv,auto_create)
  2015. X    mkv_proc_starting(pcb)
  2016. X    mkv_proc_terminating(pcb)
  2017. X    var_init()
  2018. X
  2019. X--------------------------------------------------------------------------*/
  2020. X/*+:EDITS:*/
  2021. X/*:05-07-1990-21:24-wht@n4hgf---- 2.80 --- */
  2022. X/*:04-19-1990-03:08-wht@n4hgf-GCC run found unused vars -- rm them */
  2023. X/*:04-19-1990-03:04-wht@n4hgf-miraculous: alloc_MKV was working w/no return */
  2024. X/*:04-08-1990-19:07-wht@n4hgf-add auto_create to get_{i,s}vptr */
  2025. X/*:03-25-1990-14:12-wht@n4hgf------ x2.70 ------- */
  2026. X/*:03-24-1990-18:54-wht@n4hgf-add switch to funcs to control auto creation */
  2027. X/*:03-24-1990-18:54-wht@n4hgf-fix bug in auto string var creation */
  2028. X/*:11-20-1989-17:01-wht-auto-make named variables, warn if proctrace on */
  2029. X/*:11-20-1989-16:50-wht-add build_mkv?_primitive functions */
  2030. X/*:07-03-1989-22:57-wht------ x2.00 ----- */
  2031. X/*:06-27-1989-21:37-wht-start on mkv */
  2032. X/*:06-24-1989-16:53-wht-flush edits --- ecu 1.95 */
  2033. X
  2034. X#include "ecu.h"
  2035. X#include "esd.h"
  2036. X#define VDECL
  2037. X#include "var.h"
  2038. X#include "proc.h"
  2039. X#include "ecukey.h"
  2040. X#include "ecuerror.h"
  2041. X
  2042. Xextern int proc_level;
  2043. Xextern int proctrace;
  2044. X
  2045. Xtypedef union mkvu_type
  2046. X{
  2047. X    ESD    *sv;
  2048. X    long iv;
  2049. X} MKVU;
  2050. X
  2051. Xtypedef struct mkv_type
  2052. X{
  2053. X    MKVU item;                /* pointer to esd if sv or long if iv */
  2054. X    struct mkv_type *next;    /* next MKV in chain; if==NULL, no more in chain */
  2055. X    struct mkv_type *prev;    /* previous MKV in chain; if==NULL, top of chain */
  2056. X    char *name;                /* name of variable */
  2057. X} MKV;
  2058. X
  2059. XMKV *mkvi_last = (MKV *)0;
  2060. XMKV *mkvs_last = (MKV *)0;
  2061. X
  2062. X/*+-------------------------------------------------------------------------
  2063. X    var_init()
  2064. X--------------------------------------------------------------------------*/
  2065. Xvoid
  2066. Xvar_init()
  2067. X{
  2068. Xregister itmp;
  2069. X
  2070. X    for(itmp = 0; itmp < SVQUAN; itmp++)
  2071. X    {
  2072. X        if((sv[itmp] = make_esd(SVLEN)) == (ESD *)0)
  2073. X        {
  2074. X            pputs("out of memory\n");
  2075. X            exit(1);
  2076. X        }
  2077. X    }
  2078. X
  2079. X    for(itmp = 0; itmp < IVQUAN; itmp++)
  2080. X        iv[itmp] = 0;
  2081. X
  2082. X}    /* end of var_init */
  2083. X
  2084. X/*+-------------------------------------------------------------------------
  2085. X    alloc_MKV(name)
  2086. X--------------------------------------------------------------------------*/
  2087. XMKV *
  2088. Xalloc_MKV(name)
  2089. Xchar *name;
  2090. X{
  2091. XMKV *mkv;
  2092. X    if(!(mkv = (MKV *)malloc(sizeof(MKV))))
  2093. X        return((MKV *)0);
  2094. X    if(!(mkv->name = malloc(strlen(name) + 1)))
  2095. X    {
  2096. X        free((char *)mkv);
  2097. X        return((MKV *)0);
  2098. X    }
  2099. X    strcpy(mkv->name,name);
  2100. X    mkv->item.iv = 0;
  2101. X    return(mkv);
  2102. X}    /* end of alloc_MKV */
  2103. X
  2104. X/*+-------------------------------------------------------------------------
  2105. X    build_mkvi_primitive(name)
  2106. X--------------------------------------------------------------------------*/
  2107. Xbuild_mkvi_primitive(name)
  2108. Xchar *name;
  2109. X{
  2110. XMKV *mkv;
  2111. X
  2112. X    if((mkv = alloc_MKV(name)) == (MKV *)0)
  2113. X        return(eNoMemory);
  2114. X    if(mkvi_last)
  2115. X        mkvi_last->next = mkv;
  2116. X    mkv->prev = mkvi_last;
  2117. X    mkv->next = (MKV *)0;
  2118. X    mkvi_last = mkv;
  2119. X    return(0);
  2120. X}    /* end of build_mkvi_primitive */
  2121. X
  2122. X/*+-------------------------------------------------------------------------
  2123. X    build_mkvi(param)
  2124. X--------------------------------------------------------------------------*/
  2125. Xbuild_mkvi(param)
  2126. XESD *param;
  2127. X{
  2128. Xregister erc;
  2129. Xchar name[16];
  2130. X
  2131. X    if(erc = get_alphanum_zstr(param,name,sizeof(name)))
  2132. X        return(erc);
  2133. X    return(build_mkvi_primitive(name));
  2134. X
  2135. X}    /* end of build_mkvi */
  2136. X
  2137. X/*+-------------------------------------------------------------------------
  2138. X    build_mkvs_primitive(name,length)
  2139. Xtrusts caller not to exceed 5120 max size
  2140. X--------------------------------------------------------------------------*/
  2141. Xbuild_mkvs_primitive(name,length)
  2142. Xchar *name;
  2143. Xint length;
  2144. X{
  2145. XMKV *mkv;
  2146. XESD *text;
  2147. X
  2148. X    if((text = make_esd((int)length)) == (ESD *)0)
  2149. X        return(eNoMemory);
  2150. X
  2151. X    if((mkv = alloc_MKV(name)) == (MKV *)0)
  2152. X    {
  2153. X        free_esd(text);
  2154. X        return(eNoMemory);
  2155. X    }
  2156. X
  2157. X    mkv->item.sv = text;
  2158. X
  2159. X    if(mkvs_last)
  2160. X        mkvs_last->next = mkv;
  2161. X    mkv->prev = mkvs_last;
  2162. X    mkv->next = (MKV *)0;
  2163. X    mkvs_last = mkv;
  2164. X    return(0);
  2165. X
  2166. X}    /* end of build_mkvs_primitive */
  2167. X
  2168. X/*+-------------------------------------------------------------------------
  2169. X    build_mkvs(param)
  2170. X--------------------------------------------------------------------------*/
  2171. Xbuild_mkvs(param)
  2172. XESD *param;
  2173. X{
  2174. Xregister erc;
  2175. Xchar name[16];
  2176. Xulong length;
  2177. X
  2178. X    if(erc = get_alphanum_zstr(param,name,sizeof(name)))
  2179. X        return(erc);
  2180. X
  2181. X    if(erc = skip_paren(param,1))
  2182. X        return(erc);
  2183. X    if(erc = gint(param,&length))
  2184. X        return(erc);
  2185. X    if(length > 5120)
  2186. X    {
  2187. X        pprintf("max string size is 5120 ... cannot make %lu byte string\n",
  2188. X            length);
  2189. X        return(eFATAL_ALREADY);
  2190. X    }
  2191. X    if(erc = skip_paren(param,0))
  2192. X        return(erc);
  2193. X
  2194. X    return(build_mkvs_primitive(name,(int)length));
  2195. X
  2196. X}    /* end of build_mkvs */
  2197. X
  2198. X/*+-------------------------------------------------------------------------
  2199. X    cmd_mkvar(param)
  2200. X
  2201. Xmkvar i<name>
  2202. Xmkvar s<name>(<size-int>)
  2203. X--------------------------------------------------------------------------*/
  2204. Xint
  2205. Xcmd_mkvar(param)
  2206. XESD *param;
  2207. X{
  2208. Xregister erc;
  2209. Xchar vartype;
  2210. X
  2211. X    if(!proc_level)
  2212. X        return(eNotExecutingProc);
  2213. X
  2214. X    do {
  2215. X        if(erc = get_cmd_char(param,&vartype))
  2216. X            return(erc);
  2217. X        if(vartype == '$')
  2218. X        {
  2219. X            if(erc = get_cmd_char(param,&vartype))
  2220. X                return(erc);
  2221. X        }
  2222. X        vartype = to_lower(vartype);
  2223. X        switch(vartype)
  2224. X        {
  2225. X            case 'i':
  2226. X                erc = build_mkvi(param);
  2227. X                break;
  2228. X            case 's':
  2229. X                erc = build_mkvs(param);
  2230. X                break;
  2231. X            default:
  2232. X                return(eIllegalVarType);
  2233. X        }
  2234. X        if(erc)
  2235. X            return(erc);
  2236. X    } while(!skip_comma(param));
  2237. X
  2238. X    if(!end_of_cmd(param))
  2239. X        return(eSyntaxError);
  2240. X
  2241. X    return(0);
  2242. X
  2243. X}    /* end of cmd_mkvar */
  2244. X
  2245. X/*+-------------------------------------------------------------------------
  2246. X    free_mkvi(mkv)
  2247. X--------------------------------------------------------------------------*/
  2248. Xvoid
  2249. Xfree_mkvi(mkv)
  2250. XMKV *mkv;
  2251. X{
  2252. X    free(mkv->name);
  2253. X    free((char *)mkv);
  2254. X}    /* end of free_mkvi */
  2255. X
  2256. X/*+-------------------------------------------------------------------------
  2257. X    free_mkvs(mkv)
  2258. X--------------------------------------------------------------------------*/
  2259. Xvoid
  2260. Xfree_mkvs(mkv)
  2261. XMKV *mkv;
  2262. X{
  2263. X    free_esd(mkv->item.sv);
  2264. X    free(mkv->name);
  2265. X    free((char *)mkv);
  2266. X}    /* end of free_mkvs */
  2267. X
  2268. X/*+-------------------------------------------------------------------------
  2269. X    mkv_proc_starting(pcb)
  2270. X--------------------------------------------------------------------------*/
  2271. Xvoid
  2272. Xmkv_proc_starting(pcb)
  2273. XPCB *pcb;
  2274. X{
  2275. X    pcb->mkvs_last = (char *)mkvs_last;
  2276. X    pcb->mkvi_last = (char *)mkvi_last;
  2277. X}    /* end of mkv_proc_starting */
  2278. X
  2279. X/*+-------------------------------------------------------------------------
  2280. X    mkv_proc_terminating(pcb)
  2281. X--------------------------------------------------------------------------*/
  2282. Xvoid
  2283. Xmkv_proc_terminating(pcb)
  2284. XPCB *pcb;
  2285. X{
  2286. XMKV *pmkv;
  2287. X
  2288. X    while(mkvi_last != (MKV *)pcb->mkvi_last)
  2289. X    {
  2290. X        pmkv = mkvi_last->prev;
  2291. X        free_mkvi(mkvi_last);
  2292. X        mkvi_last = pmkv;
  2293. X    }
  2294. X    while(mkvs_last != (MKV *)pcb->mkvs_last)
  2295. X    {
  2296. X        pmkv = mkvs_last->prev;
  2297. X        free_mkvs(mkvs_last);
  2298. X        mkvs_last = pmkv;
  2299. X    }
  2300. X
  2301. X}    /* end of mkv_proc_terminating */
  2302. X
  2303. X/*+-------------------------------------------------------------------------
  2304. X    find_mkvs(name,ppesd,auto_create)
  2305. X--------------------------------------------------------------------------*/
  2306. Xint
  2307. Xfind_mkvs(name,ppesd,auto_create)
  2308. Xchar *name;
  2309. XESD **ppesd;
  2310. Xint auto_create;
  2311. X{
  2312. Xint erc;
  2313. XMKV *mkv = mkvs_last;
  2314. X
  2315. X    while(mkv)
  2316. X    {
  2317. X        if(!strcmp(name,mkv->name))
  2318. X        {
  2319. X            *ppesd = mkv->item.sv;
  2320. X            return(0);
  2321. X        }
  2322. X        mkv = mkv->prev;
  2323. X    }
  2324. X
  2325. X    if(auto_create)
  2326. X    {
  2327. X        if(proctrace)
  2328. X            pprintf("creating $s%s(256)\n",name);
  2329. X        if(erc = build_mkvs_primitive(name,256))
  2330. X            return(erc);
  2331. X        *ppesd = mkvs_last->item.sv;
  2332. X        return(0);
  2333. X    }
  2334. X
  2335. X    return(eNoSuchVariable);
  2336. X
  2337. X}    /* end of find_mkvs */
  2338. X
  2339. X/*+-------------------------------------------------------------------------
  2340. X    find_mkvi(name,pplong,auto_create)
  2341. X--------------------------------------------------------------------------*/
  2342. Xint
  2343. Xfind_mkvi(name,pplong,auto_create)
  2344. Xchar *name;
  2345. Xlong **pplong;
  2346. Xint auto_create;
  2347. X{
  2348. Xint erc;
  2349. XMKV *mkv = mkvi_last;
  2350. X
  2351. X    while(mkv)
  2352. X    {
  2353. X        if(!strcmp(name,mkv->name))
  2354. X        {
  2355. X            *pplong = &mkv->item.iv;
  2356. X            return(0);
  2357. X        }
  2358. X        mkv = mkv->prev;
  2359. X    }
  2360. X
  2361. X    if(auto_create)
  2362. X    {
  2363. X        if(proctrace)
  2364. X            pprintf("creating $i%s\n",name);
  2365. X        if(erc = build_mkvi_primitive(name))
  2366. X            return(erc);
  2367. X        *pplong = &mkvi_last->item.iv;
  2368. X        return(0);
  2369. X    }
  2370. X
  2371. X    return(eNoSuchVariable);
  2372. X
  2373. X}    /* end of find_mkvi */
  2374. X
  2375. X/*+-------------------------------------------------------------------------
  2376. X    get_subscript(param,psubscript)
  2377. Xonly called when '[' at pb + index
  2378. X--------------------------------------------------------------------------*/
  2379. Xget_subscript(param,psubscript)
  2380. XESD *param;
  2381. Xulong *psubscript;
  2382. X{
  2383. Xregister erc;
  2384. X
  2385. X    param->index++;
  2386. X    if(erc = gint(param,psubscript))
  2387. X        return(erc);
  2388. X    if(skip_cmd_char(param,']'))
  2389. X        return(eSyntaxError);
  2390. X    return(0);
  2391. X}    /* end of get_subscript */
  2392. X
  2393. X/*+-------------------------------------------------------------------------
  2394. X    get_ivptr(param,ppiv,auto_create)
  2395. Xcalled with index set to $i.....
  2396. X                           ^
  2397. X--------------------------------------------------------------------------*/
  2398. Xget_ivptr(param,ppiv,auto_create)
  2399. XESD *param;
  2400. Xlong **ppiv;
  2401. Xint auto_create;
  2402. X{
  2403. Xregister erc;
  2404. Xulong varnum;
  2405. Xchar name[16];
  2406. X
  2407. X    if(end_of_cmd(param))
  2408. X        return(eSyntaxError);
  2409. X    else if(!get_numeric_value(param,&varnum))
  2410. X        goto TEST_VARNUM;
  2411. X    else if(*(param->pb + param->index) == '[')
  2412. X    {
  2413. X        if(erc = get_subscript(param,&varnum))
  2414. X            return(erc);
  2415. XTEST_VARNUM:
  2416. X        if(varnum >= IVQUAN)
  2417. X            return(eIllegalVarNumber);
  2418. X        *ppiv = &iv[(int)varnum];
  2419. X        return(0);
  2420. X    }
  2421. X    else if(get_alphanum_zstr(param,name,sizeof(name)))
  2422. X        return(eInvalidVarName);
  2423. X
  2424. X    return(find_mkvi(name,ppiv,auto_create));
  2425. X
  2426. X}    /* end of get_ivptr */
  2427. X
  2428. X/*+-------------------------------------------------------------------------
  2429. X    get_svptr(param,ppsv,auto_create)
  2430. Xcalled with index set to $s.....
  2431. X                           ^
  2432. X--------------------------------------------------------------------------*/
  2433. Xget_svptr(param,ppsv,auto_create)
  2434. XESD *param;
  2435. XESD **ppsv;
  2436. Xint auto_create;
  2437. X{
  2438. Xregister erc;
  2439. Xulong varnum;
  2440. Xchar name[16];
  2441. X
  2442. X    if(end_of_cmd(param))
  2443. X        return(eSyntaxError);
  2444. X    else if(!get_numeric_value(param,&varnum))
  2445. X        goto TEST_VARNUM;
  2446. X    else if(*(param->pb + param->index) == '[')
  2447. X    {
  2448. X        if(erc = get_subscript(param,&varnum))
  2449. X            return(erc);
  2450. XTEST_VARNUM:
  2451. X        if(varnum >= SVQUAN)
  2452. X            return(eIllegalVarNumber);
  2453. X        *ppsv = sv[(int)varnum];
  2454. X        return(0);
  2455. X    }
  2456. X    if(get_alphanum_zstr(param,name,sizeof(name)))
  2457. X        return(eInvalidVarName);
  2458. X    return(find_mkvs(name,ppsv,0));
  2459. X
  2460. X}    /* end of get_svptr */
  2461. X
  2462. X/* vi: set tabstop=4 shiftwidth=4: */
  2463. X/* end of var.c */
  2464. SHAR_EOF
  2465. $TOUCH -am 0507233390 var.c &&
  2466. chmod 0644 var.c ||
  2467. echo "restore of var.c failed"
  2468. set `wc -c var.c`;Wc_c=$1
  2469. if test "$Wc_c" != "10708"; then
  2470.     echo original size 10708, current size $Wc_c
  2471. fi
  2472. echo "End of part 14, continue with part 15"
  2473. exit 0
  2474.  
  2475.