home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / source / pac.lzh / pac.4 < prev    next >
Encoding:
Text File  |  1990-08-12  |  44.7 KB  |  1,483 lines
  1. #!/bin/sh
  2. # This is part 04 of a multipart archive
  3. if touch 2>&1 | fgrep '[-amc]' > /dev/null
  4.  then TOUCH=touch
  5.  else TOUCH=true
  6. fi
  7. # ============= help.c ==============
  8. echo "x - extracting help.c (Text)"
  9. sed 's/^X//' << 'SHAR_EOF' > help.c &&
  10. X/* help.c */
  11. X/**********************************************************************
  12. X*    File Name     : help.c
  13. X*    Function      : overlay stack window with help list
  14. X*    Author        : Istvan Mohos, 1987
  15. X***********************************************************************/
  16. X
  17. X#include "defs.h"
  18. X#include "toktab.h"
  19. X
  20. Xchar *hlist[] = {
  21. X"!         factorial of n: 2*3*4*...n",
  22. X"#         comment from here to EOL  ",
  23. X"\'         sum ASCII bytes of nextok ",
  24. X";         separator btw. statements ",
  25. X"?         abbreviation for help     ",
  26. X"X         literal 16                ",
  27. X"\\         most recent result        ",
  28. X"amass     atomic mass unit, grams   ",
  29. X"and       binary bit-wise AND       ",
  30. X"arct      a(x) bc arctangent func.  ",
  31. X"astro     astronomical unit, km     ",
  32. X"at        abbreviation for autotime ",
  33. X"atto      * .000 000 000 000 000 001",
  34. X"au        abbreviation for autoconv ",
  35. X"auto      pac_err: defeat bc keyword",
  36. X"autoconv  on/off continuous convert ",
  37. X"autotime  turn clock on/off at start",
  38. X"avogadro  molecules per gram mole   ",
  39. X"boltzmann constant [k] ergs/Kelvin  ",
  40. X"break     pac_err: defeat bc keyword",
  41. X"bye       exit program; same as TAB ",
  42. X"chroma    440 * chroma: Bflat from A",
  43. X"clr       clear stack cell nextok   ",
  44. X"cm        use comma to format number",
  45. X"comma     use comma to format number",
  46. X"cos       c(x) bc cosine function   ",
  47. X"define    pac_err: defeat bc keyword",
  48. X"dontsave  don't write vars to .pacrc",
  49. X"dp        same as precision         ",
  50. X"ds        abbreviation for dontsave ",
  51. X"dup       duplicate stk cell nextok ",
  52. X"earthmass mass of earth in kg       ",
  53. X"earthrad  radius of earth in meters ",
  54. X"echarge   electron charge [e] esu   ",
  55. X"emass     electron mass at rest, g  ",
  56. X"euler     Euler-Mascheroni constant ",
  57. X"exa       *1,000,000,000,000,000,000",
  58. X"exit      exit program; same as ^E  ",
  59. X"exp       e(x) bc exponential func. ",
  60. X"faraday   constant [F] C/kmole      ",
  61. X"femto     * .000 000 000 000 001    ",
  62. X"fix       show fixed decimal point  ",
  63. X"fo        abbreviation for format   ",
  64. X"for       pac_err: defeat bc keyword",
  65. X"format    commas/spaces in result   ",
  66. X"g         acceleration at sea m/s2  ",
  67. X"gas       constant [Ro] erg/g mole K",
  68. X"giga      * 1,000,000,000           ",
  69. X"gravity   constant [G] N m2/kg2     ",
  70. X"h         value of stack cell h     ",
  71. X"hardform  verbose/terse/xt filedump ",
  72. X"heat      mechanical equiv [J] J/cal",
  73. X"help      briefly explain next token",
  74. X"hf        abbreviation for hardform ",
  75. X"i         value of stack cell i     ",
  76. X"ib        abbreviation for ibase    ",
  77. X"ibase     input radix (2 through 16)",
  78. X"if        pac_err: defeat bc keyword",
  79. X"init      pac to default parameters ",
  80. X"j         value of stack cell j     ",
  81. X"ju        abbreviation for justify  ",
  82. X"justify   left/right/fix display    ",
  83. X"k         value of stack cell k     ",
  84. X"kilo      * 1000                    ",
  85. X"l         value of stack cell l     ",
  86. X"le        abbreviation for left     ",
  87. X"left      ju le; print to left side ",
  88. X"length    pac_err: defeat bc keyword",
  89. X"light     velocity [c] km/s         ",
  90. X"lightyear distance covered/year km  ",
  91. X"log       l(x) bc log function      ",
  92. X"m         value of stack cell m     ",
  93. X"mega      * 1,000,000               ",
  94. X"micro     * .000 001                ",
  95. X"milli     * .001                    ",
  96. X"mod       integer mod, unlike bc %  ",
  97. X"mohos     clear to nextok, pactrace ",
  98. X"moonmass  lunar mass in kg          ",
  99. X"moonrad   radius of moon in meters  ",
  100. X"n         value of stack cell n     ",
  101. X"nano      * .000 000 001            ",
  102. X"natural   Naperian log base [e]     ",
  103. X"nmass     neutron mass at rest, g   ",
  104. X"not       bitwise, field nextok wide",
  105. X"o         value of stack cell o     ",
  106. X"ob        abbreviation of obase     ",
  107. X"obase     output radix (2 thru 16)  ",
  108. X"off       disable capability        ",
  109. X"on        enable capability         ",
  110. X"or        binary, bit-wise OR       ",
  111. X"p         value of stack cell p     ",
  112. X"parallax  solar, in seconds of arc  ",
  113. X"parsec    (parallax + sec2) in km   ",
  114. X"pd        percent diff (pdiff)      ",
  115. X"pdelta    percent diff (pdiff)      ",
  116. X"pdiff     % diff of curtok to nextok",
  117. X"pe        percent equal (pequal)    ",
  118. X"pequal    curtok% = nextok; total?  ",
  119. X"peta      * 1,000,000,000,000,000   ",
  120. X"pi        3.1415... (32 hex digits) ",
  121. X"pico      * .000 000 000 001        ",
  122. X"planck    constant [h] erg sec      ",
  123. X"pll       stk cell nextok to curres ",
  124. X"pm        percent minus (pminus)    ",
  125. X"pmass     proton mass at rest, g    ",
  126. X"pminus    subtract nextok percent   ",
  127. X"po        percent of (pof)          ",
  128. X"pof       what is curtok% of nextok ",
  129. X"pop       discard stack cell nextok ",
  130. X"pp        percent plus (pplus)      ",
  131. X"pplus     add nextok percent        ",
  132. X"pr        abbreviation of precision ",
  133. X"precision digits used past dp (0-32)",
  134. X"psh       curres to stk cell nextok ",
  135. X"pv        percent versus (pversus)  ",
  136. X"pversus   curtok = 100 %, nextok ? %",
  137. X"q         value of stack cell q     ",
  138. X"quit      exit program; same as ^E  ",
  139. X"r         value of stack cell r     ",
  140. X"ri        abbreviation of right     ",
  141. X"right     right justify result      ",
  142. X"rydberg   constant per meter        ",
  143. X"s         value of stack cell s     ",
  144. X"sb        abbreviation of staybase  ",
  145. X"scale     alias of precision        ",
  146. X"sin       s(x) bc sine function     ",
  147. X"sound     air speed @ 15 Celsius m/s",
  148. X"sp        use space to format number",
  149. X"space     use space to format number",
  150. X"sqrt      sqrt(x) bc square root    ",
  151. X"st        abbreviation of 'stack on'",
  152. X"stack     save last 16 results      ",
  153. X"staybase  make next radix permanent ",
  154. X"stefan    Stefan-Boltzmann J/m2 K4 s",
  155. X"sto       store curres in stack cell",
  156. X"sunmass   solar mass kg             ",
  157. X"sunrad    radius of sun in meters   ",
  158. X"swp       swap curres, stack nextok ",
  159. X"t         value of stack cell t     ",
  160. X"te        abbreviation of terse     ",
  161. X"tera      * 1,000,000,000,000       ",
  162. X"terse     hardcopy file format      ",
  163. X"to        convert curres to nextok  ",
  164. X"tomoon    distance from earth, km   ",
  165. X"tosun     distance from earth, km   ",
  166. X"tw        abbreviation of twoscomp  ",
  167. X"twoscomp  bitwise, field nextok wide",
  168. X"u         value of stack cell u     ",
  169. X"v         value of stack cell v     ",
  170. X"ver       abbreviation of verbose   ",
  171. X"verbose   hardcopy file format      ",
  172. X"w         value of stack cell w     ",
  173. X"while     pac_err: defeat bc keyword",
  174. X"wien      displacement constant cm K",
  175. X"x         the number 16             ",
  176. X"xor       curres xor-ed with nextok ",
  177. X"xt        abbreviation of xterse    ",
  178. X"xterse    hardcopy file format      ",
  179. X};
  180. X
  181. X#define HCENTER 6
  182. X#define TOFIT   (STACKDEEP - HCENTER)
  183. X
  184. Xshow_help(cursel)
  185. Xint cursel;
  186. X{
  187. X    register ri;
  188. X    static int tophelp;
  189. X    static char *fid = "show_help";
  190. X
  191. X    _TR
  192. X    if (cursel < HCENTER)
  193. X        tophelp = 0;
  194. X    else if (cursel >= LISTSIZE - TOFIT)
  195. X        tophelp = LISTSIZE - STACKDEEP;
  196. X    else
  197. X        tophelp = cursel - HCENTER + 1;
  198. X
  199. X    for (ri = 0; ri < STACKDEEP; ri++) {
  200. X        mvaddstr(ri + STACKTOP, STACKLEFT, hlist[ri + tophelp]);
  201. X    }
  202. X
  203. X    standout();
  204. X    for (ri = 0; ri < STACKDEEP; ri++) {
  205. X        mvaddch(ri + STACKTOP, LBOUND, ' ');
  206. X    }
  207. X    mvaddstr(STACKTOP + cursel - tophelp, STACKLEFT, hlist[cursel]);
  208. X    standend();
  209. XTR_
  210. X}
  211. X
  212. SHAR_EOF
  213. $TOUCH -am 0221163890 help.c &&
  214. chmod 0644 help.c ||
  215. echo "restore of help.c failed"
  216. set `wc -c help.c`;Wc_c=$1
  217. if test "$Wc_c" != "7333"; then
  218.     echo original size 7333, current size $Wc_c
  219. fi
  220. # ============= ierror.c ==============
  221. echo "x - extracting ierror.c (Text)"
  222. sed 's/^X//' << 'SHAR_EOF' > ierror.c &&
  223. X/* ierror.c */
  224. X/**********************************************************************
  225. X*    Function      : perror, writes into global string buffer "ierbuf"
  226. X*    Author        : Istvan Mohos, 1987
  227. X***********************************************************************/
  228. X
  229. X#include <stdio.h>
  230. Xextern int errno, sys_nerr;
  231. Xextern char *sys_errlist[];
  232. Xextern char ierbuf[];
  233. X
  234. Xierror(ustr, badnum)
  235. Xchar *ustr;
  236. Xint badnum;
  237. X{
  238. X    register char *cp = NULL;
  239. X
  240. X    if (errno > 0 && errno < sys_nerr) {
  241. X        badnum = errno;
  242. X        cp = sys_errlist[errno];
  243. X    }
  244. X
  245. X    if (ustr != (char *)NULL)
  246. X        if (cp != (char *)NULL)
  247. X            sprintf(ierbuf, "%s: %s", cp, ustr);
  248. X        else
  249. X            strcpy(ierbuf, ustr);
  250. X    else
  251. X        if (cp != (char *)NULL)
  252. X            sprintf(ierbuf, "%s:", cp);
  253. X        else
  254. X            *ierbuf = '\0';
  255. X
  256. X    errno = 0;
  257. X    return(badnum);
  258. X}
  259. SHAR_EOF
  260. $TOUCH -am 0221163890 ierror.c &&
  261. chmod 0644 ierror.c ||
  262. echo "restore of ierror.c failed"
  263. set `wc -c ierror.c`;Wc_c=$1
  264. if test "$Wc_c" != "871"; then
  265.     echo original size 871, current size $Wc_c
  266. fi
  267. # ============= interpret.c ==============
  268. echo "x - extracting interpret.c (Text)"
  269. sed 's/^X//' << 'SHAR_EOF' > interpret.c &&
  270. X/* interpret.c */
  271. X/**********************************************************************
  272. X*    File Name     : interpret.c
  273. X*    Function      : pac calculator input tokenizer
  274. X*    Author        : Istvan Mohos, 1987
  275. X***********************************************************************/
  276. X
  277. X#include "defs.h"
  278. X#include "toktab.h"
  279. X#define INTERMAP
  280. X#include "maps.h"
  281. X#undef INTERMAP
  282. X
  283. X#define HIDE_RES Hide = 1; rh = Stack; Stack = DISA; \
  284. X                 prec = Precision; Precision = 32; show_result(1); \
  285. X                 Hide = 0; Stack = rh; Precision = prec
  286. X#define RECOVER  conv_bc(sr->cell, ZERO, 1, 0); addto_ubuf(Convbuf)
  287. X
  288. Xinterpret(source)
  289. Xchar *source;
  290. X{
  291. X    char *eye, *nxeye;
  292. X    char *ip, itemp[LINEMAX];
  293. X    char stacbuf[PIPEMAX];
  294. X    int ri, rh, prec;
  295. X    int cur_cnt = 0;
  296. X    int type, value, nex_type;
  297. X    int first;                /* so conversion can refer to Mainbuf */
  298. X    int conv_flag;            /* to show that TO has taken place */
  299. X    char c_val;
  300. X    static char onechar[2];
  301. X    static struct stk_cell *sr = &Stk[0];
  302. X    static char *fid = "interpret";
  303. X
  304. X    _TR
  305. X
  306. X#ifdef TOX
  307. X    static char Tk[100];
  308. X    char *tk = &Tk[0];
  309. X#endif
  310. X            
  311. X
  312. X    /* transfer raw characters from user window to Spreadbuf,
  313. X       insert spaces between all but contiguous alphanumeric characters
  314. X       to prepare for pactok */
  315. X    fill_spreadbuf(source);
  316. X
  317. X    /* strip spaces and commas, null terminate tokens */
  318. X    place_pointers();
  319. X    *Ubuf = '\0';
  320. X    *Controlbuf = '\0';
  321. X    first = TRUE;
  322. X    conv_flag = FALSE;
  323. X
  324. X    while ((eye = Tokp[++cur_cnt]) != ZERO) {
  325. X        type = lookup(eye);
  326. X
  327. X        if ((nxeye = Tokp[cur_cnt + 1]) != ZERO)
  328. X            nex_type = lookup(nxeye);
  329. X        else
  330. X            nex_type = -1;
  331. X
  332. X#ifdef TOX
  333. X        sprintf(tk, "%d,", type);
  334. X        tk = Tk + strlen(Tk);
  335. X#endif
  336. X
  337. X        switch(type) {
  338. X
  339. X        default:
  340. X        case NOTINLIST:
  341. X            upcase(eye);
  342. X            addto_ubuf(eye);
  343. X            break;
  344. X
  345. X        case IB:
  346. X        case IBASE:
  347. X            show_result(1);
  348. X
  349. X            /* ZERO pointer: no more tokens
  350. X               Convbuf returned: next token not in preferred list
  351. X                   in either case, leave right side alone */
  352. X
  353. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  354. X                == ZERO || eye == Convbuf) {
  355. X                --cur_cnt;
  356. X                Ibase = IB_DFLT;
  357. X            }
  358. X            else {
  359. X                conv_bc(eye, ZERO, Ibase, 10);
  360. X                Ibase = atoi(Convbuf);
  361. X                if (Ibase > 16 || Ibase < 2)
  362. X                    Ibase = IB_DFLT;
  363. X            }
  364. X            sprintf(Mop, "ibase=A;ibase=%d\n",Ibase);
  365. X            addto_controlbuf(Mop);
  366. X            show_result(0);
  367. X            break;
  368. X
  369. X        case OB:
  370. X        case OBASE:
  371. X            show_result(1);
  372. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  373. X                == ZERO || eye == Convbuf) {
  374. X                --cur_cnt;
  375. X                Obase = OB_DFLT;
  376. X            }
  377. X            else {
  378. X                conv_bc(eye, ZERO, Ibase, 10);
  379. X                Obase = atoi(Convbuf);
  380. X                if (Obase > 16 || Obase < 2)
  381. X                    Obase = OB_DFLT;
  382. X            }
  383. X            sprintf(Mop, "ibase=A;obase=%d;ibase=%d\n", Obase, Ibase);
  384. X            addto_controlbuf(Mop);
  385. X            show_result(0);
  386. X            break;
  387. X
  388. X        case TE:
  389. X        case TERSE:
  390. X        case VER:
  391. X        case VERBOSE:
  392. X        case XT:
  393. X        case XTERSE:
  394. X            show_result(1);
  395. X            if (type == TE || type == TERSE)
  396. X                Hf = FTER;
  397. X            else if (type == VER || type == VERBOSE)
  398. X                Hf = FVER;
  399. X            else
  400. X                Hf = FXTER;
  401. X            show_result(0);
  402. X            break;
  403. X
  404. X        case FIX:
  405. X        case RIGHT:
  406. X        case RI:
  407. X        case LE:
  408. X        case LEFT:
  409. X        case CM:
  410. X        case COMMA:
  411. X        case SP:
  412. X        case SPACE:
  413. X            show_result(1);
  414. X            if (type == FIX)
  415. X                Justify = JF;
  416. X            else if (type == RIGHT || type == RI)
  417. X                Justify = JR;
  418. X            else if (type == LE || type == LEFT)
  419. X                Justify = JL;
  420. X            else if (type == CM || type == COMMA)
  421. X                Separator = ',', Format = COMMA_;
  422. X            else if (type == SP || type == SPACE)
  423. X                Separator = ' ', Format = SPACE_;
  424. X            show_result(0);
  425. X            break;
  426. X
  427. X        case QUESTION:
  428. X        case HELP:
  429. X            if (nex_type == -1)
  430. X                show_help(HELP);
  431. X            else {
  432. X                ++cur_cnt;
  433. X                show_help(nex_type);
  434. X            }
  435. X            break;
  436. X
  437. X        case TO:
  438. X            if (!first) {
  439. X                  HIDE_RES;
  440. X            }
  441. X            RECOVER;
  442. X            eye = Tokp[++cur_cnt];
  443. X            if (eye == ZERO)
  444. X                --cur_cnt;
  445. X            else if ((ri = conv_id(eye)) != -1)
  446. X                Convsel = ri;
  447. X            else
  448. X                --cur_cnt;
  449. X            Do_conv = conv_flag = TRUE;
  450. X            HIDE_RES;
  451. X            show_result(0);
  452. X            RECOVER;
  453. X            break;
  454. X
  455. X        case AND:
  456. X        case OR:
  457. X        case XOR:
  458. X            if (!first) {
  459. X                 HIDE_RES;
  460. X            }
  461. X            /* resolve left side; convert it to base 2 */
  462. X            conv_bc(sr->cell, ZERO, 1, 2);
  463. X            strcpy(itemp, Convbuf);
  464. X
  465. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 2))
  466. X            == ZERO || eye == Convbuf)
  467. X                --cur_cnt, eye = itemp;
  468. X            else if (eye == Tokp[cur_cnt]) {
  469. X                /* nextok is a digit string */
  470. X                conv_bc(eye, ZERO, -1, 2);
  471. X                eye = Convbuf;
  472. X            }
  473. X            if ((ip = bitwise(type, itemp, eye, &ri)) == ZERO) {
  474. X                pac_err("conversion range");
  475. X                TR_
  476. X                return;
  477. X            }
  478. X            conv_bc(ip, ZERO, 1, 0);
  479. X            addto_ubuf(Convbuf);
  480. X            HIDE_RES;
  481. X            RECOVER;
  482. X            break;
  483. X
  484. X        case TW:
  485. X        case TWOSCOMP:
  486. X        case NOT:
  487. X            if (type == TWOSCOMP)
  488. X                 type = TW;
  489. X            if (!first) {
  490. X                 HIDE_RES;
  491. X            }
  492. X            /* resolve left side; convert it to base 2 */
  493. X            conv_bc(sr->cell, ZERO, 1, 2);
  494. X            strcpy(itemp, Convbuf);
  495. X
  496. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  497. X            == ZERO || eye == Convbuf) {
  498. X                --cur_cnt;
  499. X                /* reuse previous result */
  500. X                conv_bc(sr->cell, ZERO, 1, 10);
  501. X                eye = Convbuf;
  502. X            }
  503. X            else if (eye == Tokp[cur_cnt]) {
  504. X                /* nextok is a digit string */
  505. X                conv_bc(eye, ZERO, -1, 10);
  506. X                eye = Convbuf;
  507. X            }
  508. X            if ((ip = bitwise(type, itemp, eye, &ri)) == ZERO) {
  509. X                pac_err("conversion range");
  510. X                TR_
  511. X                return;
  512. X            }
  513. X            if (ri)
  514. X                addto_ubuf("-");
  515. X            conv_bc(ip, ZERO, 1, 0);
  516. X            addto_ubuf(Convbuf);
  517. X            if (type == TW)
  518. X                addto_ubuf((ri) ? "-1" : "+1");
  519. X            HIDE_RES;
  520. X            RECOVER;
  521. X            break;
  522. X
  523. X        case MOD:
  524. X            if (!first) {
  525. X                HIDE_RES;
  526. X            }
  527. X            ri = Precision;
  528. X            sprintf(Mop,"ibase=A;scale=0;ibase=%d\n", Ibase);
  529. X            addto_controlbuf(Mop);
  530. X            show_result(0);
  531. X            conv_bc(sr->cell, ZERO, 1, 0);
  532. X            addto_ubuf(Convbuf);
  533. X            addto_ubuf("\%");
  534. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 0))
  535. X                == ZERO || eye == Convbuf) {
  536. X                --cur_cnt;
  537. X                eye = Convbuf;
  538. X            }
  539. X            addto_ubuf(eye);
  540. X            HIDE_RES;
  541. X            sprintf(Mop,"ibase=A;scale=%d;ibase=%d\n",ri, Ibase);
  542. X            addto_controlbuf(Mop);
  543. X            show_result(0);
  544. X            RECOVER;
  545. X            break;
  546. X
  547. X        case BANG:
  548. X            if (!first) {
  549. X                HIDE_RES;
  550. X            }
  551. X            /* resolve left side; convert it to base 10 */
  552. X            conv_bc(sr->cell, ZERO, 1, 10);
  553. X            value = atoi(Convbuf);
  554. X            if (value < 0)
  555. X                 value = 0;
  556. X            else if (value > 35)
  557. X                 value = 35;
  558. X            conv_bc(factab[value], ZERO, 1, 0);
  559. X            addto_ubuf(Convbuf);
  560. X            HIDE_RES;
  561. X            RECOVER;
  562. X            break;
  563. X
  564. X        case JUSTIFY:
  565. X        case JU:
  566. X            eye = Tokp[++cur_cnt];
  567. X            if (eye == ZERO) {
  568. X                show_result(1);
  569. X                Justify = JUS_DFLT;
  570. X                show_result(0);
  571. X            }
  572. X            --cur_cnt;
  573. X            break;
  574. X
  575. X        case HF:
  576. X        case HARDFORM:
  577. X            eye = Tokp[++cur_cnt];
  578. X            if (eye == ZERO) {
  579. X                show_result(1);
  580. X                Hf = HF_DFLT;
  581. X                show_result(0);
  582. X            }
  583. X            --cur_cnt;
  584. X            break;
  585. X
  586. X        case SHARP: /* comment start */
  587. X            (conv_flag || Autoconv == ENA) ? (O_conv = TRUE)
  588. X                                           : (O_conv = FALSE);
  589. X            show_result(2);
  590. X            TR_
  591. X            return;
  592. X
  593. X        case SEMI:
  594. X            show_result(1);
  595. X            first = 2;
  596. X            break;
  597. X
  598. X        case STACK:
  599. X        case ST:
  600. X        case SB:
  601. X        case STAYBASE:
  602. X        case AUTOTIME:
  603. X        case AT:
  604. X            ip = stacbuf;
  605. X            ri = 0;
  606. X            show_result(1);
  607. X            eye = Tokp[++cur_cnt];
  608. X            if (eye == ZERO) {
  609. X                --cur_cnt;
  610. X                if (type == STACK || type == ST)
  611. X                    (Stack == ENA) ? (ri = 1) : (Stack = ENA);
  612. X                else if (type == STAYBASE || type == SB)
  613. X                    Staybase = ENA;
  614. X                else if (type == AUTOTIME || type == AT)
  615. X                    Autotime = ENA;
  616. X                show_result(0);
  617. X            }
  618. X            else {
  619. X                value = lookup(eye);
  620. X                if (value == ON)
  621. X                    value = ENA;
  622. X                else if (value == OFF)
  623. X                    value = DISA;
  624. X                else {
  625. X                    --cur_cnt;
  626. X                    value = ENA;
  627. X                }
  628. X                if (type == STACK || type == ST) {
  629. X                    if (value == ENA && Stack == ENA)
  630. X                        ri = 1;
  631. X                    Stack = value;
  632. X                }
  633. X                else if (type == STAYBASE || type == SB)
  634. X                    Staybase = value;
  635. X                else if (type == AUTOTIME || type == AT)
  636. X                    Autotime = value;
  637. X                show_result(0);
  638. X            }
  639. X            if (Hc != -1 && ri) {
  640. X                save_stack(ip, 1);
  641. X                ri = strlen(stacbuf);
  642. X                if ((write(Hc, stacbuf, ri)) != ri)
  643. X                    fatal("hardcopy stack write");
  644. X            }
  645. X            break;
  646. X
  647. X        case FORMAT:
  648. X        case FO:
  649. X            show_result(1);
  650. X            eye = Tokp[++cur_cnt];
  651. X            if (eye == ZERO) {
  652. X                --cur_cnt;
  653. X                Format = FORM_DFLT;
  654. X                (FORM_DFLT == COMMA_) ? (Separator = '.')
  655. X                                     : (Separator = ' ');
  656. X            }
  657. X            else {
  658. X                value = lookup(eye);
  659. X                switch (value) {
  660. X                    case CM:
  661. X                    case COMMA:
  662. X                        Separator = ',';
  663. X                        Format = COMMA_;
  664. X                        break;
  665. X                    default:
  666. X                        --cur_cnt;
  667. X                        Format = FORM_DFLT;
  668. X                        (FORM_DFLT == COMMA_) ? (Separator = '.')
  669. X                                             : (Separator = ' ');
  670. X                        break;
  671. X                    case SP:
  672. X                    case SPACE:
  673. X                        Separator = ' ';
  674. X                        Format = SPACE_;
  675. X                        break;
  676. X                    case OFF:
  677. X                        Separator = ' ';
  678. X                        Format = DISA;
  679. X                        break;
  680. X                }
  681. X            }
  682. X            show_result(0);
  683. X            break;
  684. X
  685. X        case PR:
  686. X        case PRECISION:
  687. X        case SCALE:
  688. X        case DP:
  689. X            show_result(1);
  690. X            /* get right side literal for input */
  691. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 10))
  692. X                == ZERO || eye == Convbuf) {
  693. X                --cur_cnt;
  694. X                Precision = PREC_DFLT;
  695. X            }
  696. X            else {
  697. X                Precision = atoi(eye);
  698. X                if (Precision < 0  || Precision > 32)
  699. X                    Precision = PREC_DFLT;
  700. X            }
  701. X            sprintf(Mop,"ibase=A;scale=%d;ibase=%d\n",Precision, Ibase);
  702. X            addto_controlbuf(Mop);
  703. X            show_result(0);
  704. X            break;
  705. X
  706. X        case PP: /* PercentPlus */
  707. X        case PPLUS:
  708. X        case PM: /* PercentMinus */
  709. X        case PMINUS:
  710. X        case PD: /* PercentDelta */
  711. X        case PDELTA:
  712. X        case PDIFF:
  713. X        case PV: /* PercentVersus */
  714. X        case PVERSUS:
  715. X        case PO: /* PercentOf */
  716. X        case POF:
  717. X        case PE: /* PercentEqual */
  718. X        case PEQUAL:
  719. X            if (!first) {
  720. X                HIDE_RES;
  721. X            }
  722. X            conv_bc(sr->cell, ZERO, 1, 0); /* left side is input */
  723. X
  724. X            /* get right side literal for input */
  725. X            if ((eye = substivar(-1, Tokp[++cur_cnt], 0))
  726. X                == ZERO || eye == Convbuf) {
  727. X                --cur_cnt;
  728. X                eye = Convbuf;
  729. X            }
  730. X            ip = itemp;
  731. X            switch (type) {
  732. X                case PP:
  733. X                case PPLUS:
  734. X                    sprintf(ip, "%s+(%s*%s/%s)",
  735. X                        Convbuf,Convbuf,eye,hundred[Ibase]);
  736. X                    break;
  737. X                case PM:
  738. X                case PMINUS:
  739. X                    sprintf(ip, "%s-(%s*%s/%s)",
  740. X                        Convbuf,Convbuf,eye,hundred[Ibase]);
  741. X                    break;
  742. X                case PV:
  743. X                case PVERSUS:
  744. X                    sprintf(ip, "%s*%s/%s",
  745. X                        eye,hundred[Ibase],Convbuf);
  746. X                    break;
  747. X                case PD:
  748. X                case PDELTA:
  749. X                case PDIFF:
  750. X                    sprintf(ip, "(%s*(%s-%s))/%s",
  751. X                        hundred[Ibase],eye,Convbuf,Convbuf);
  752. X                    break;
  753. X                case PO:
  754. X                case POF:
  755. X                    sprintf(ip, "(%s*%s/%s)",
  756. X                        eye,Convbuf,hundred[Ibase]);
  757. X                    break;
  758. X                case PE:
  759. X                case PEQUAL:
  760. X                    sprintf(ip, "(%s*%s/%s)",
  761. X                        eye,hundred[Ibase],Convbuf);
  762. X                    break;
  763. X            }
  764. X            addto_ubuf(ip);
  765. X            break;
  766. X
  767. X        case LOG:
  768. X            *onechar = *eye;
  769. X            addto_ubuf(onechar);
  770. X            break;
  771. X
  772. X        case SQRT:
  773. X            addto_ubuf(eye);
  774. X            break;
  775. X
  776. X        case INIT_:
  777. X            show_result(1);
  778. X            pacinit();
  779. X            sprintf(Mop, "ibase=A;obase=%d;ibase=%d\n", Obase, Ibase);
  780. X            addto_controlbuf(Mop);
  781. X            show_result(0);
  782. X            break;
  783. X
  784. X        case DONTSAVE:
  785. X        case DS:
  786. X            Dontsave = 1;
  787. X            break;
  788. X
  789. X        /* copy accum into chosen stack cell, or onto top of stack.
  790. X           Other cells are not disturbed */
  791. X        case STO:
  792. X            show_result(1);
  793. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  794. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w')))
  795. X                c_val = 'h';
  796. X            else {
  797. X                c_val = *nxeye;
  798. X                ++cur_cnt;
  799. X            }
  800. X            stack_reg(c_val - 'g', 0);
  801. X            break;
  802. X
  803. X        case IF:
  804. X        case WHILE:
  805. X        case FOR:
  806. X        case BREAK:
  807. X        case DEFINE:
  808. X        case LENGTH:
  809. X            pac_err("unimplemented key");
  810. X            TR_
  811. X            return;
  812. X
  813. X        case QUIT:
  814. X        case EXIT:
  815. X            go_away(ZERO, 0);
  816. X
  817. X        case BYE:
  818. X            clearstack(0);
  819. X            Amt = Rate = Years = 0.;
  820. X            go_away("I", 0);
  821. X
  822. X        /* value = sum of bytes' ascii values of next token are
  823. X           substituted (in current Ibase) in input to bc */
  824. X        case TICK:
  825. X            value = 0;
  826. X            if ((eye = Tokp[++cur_cnt]) == ZERO)
  827. X                --cur_cnt;
  828. X            else
  829. X                while (*eye)
  830. X                    value += *eye++;
  831. X            sprintf(Mop, "%c %d",Base_str[10], value);
  832. X            conv_bc(Mop, ZERO, 1, 0);
  833. X            addto_ubuf(Convbuf);
  834. X            break;
  835. X
  836. X        case BACKSLASH:
  837. X            RECOVER;
  838. X            break;
  839. X
  840. X        case KILO:
  841. X        case ATTO:
  842. X        case FEMTO:
  843. X        case GIGA:
  844. X        case MEGA:
  845. X        case MICRO:
  846. X        case MILLI:
  847. X        case NANO:
  848. X        case PICO:
  849. X        case TERA:
  850. X        case PETA:
  851. X        case EXA:
  852. X            if (first) {
  853. X                RECOVER;
  854. X            }
  855. X            addto_ubuf("*");
  856. X            addto_ubuf(substivar(type, ZERO, Ibase));
  857. X            break;
  858. X
  859. X        case X_LOWER:
  860. X        case X_UPPER:
  861. X            sprintf(itemp, "%s", sixteen[Ibase]);
  862. X            addto_ubuf(itemp);
  863. X            break;
  864. X
  865. X        /* shift Stack down from named register (or top, if no arg);
  866. X           bottom gets lost. Copy accum into named element.
  867. X           works independently (in addition to) stack effect */
  868. X        case PSH:
  869. X            show_result(1);
  870. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  871. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  872. X                pushstack(1);
  873. X                stack_reg(1, 0);
  874. X            }
  875. X            else {
  876. X                pushstack(*nxeye - 'g');
  877. X                stack_reg(*nxeye - 'g', 0);
  878. X                ++cur_cnt;
  879. X            }
  880. X            break;
  881. X
  882. X        /* Move stack element (or top, if no arg) into accum, move up
  883. X           all elements below it.  Move 0 into bottom location */
  884. X        case PLL:
  885. X            show_result(1);
  886. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  887. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  888. X                onereg(1);
  889. X                popstack(1);
  890. X            }
  891. X            else {
  892. X                onereg(*nxeye - 'g');
  893. X                popstack(*nxeye - 'g');
  894. X                ++cur_cnt;
  895. X            }
  896. X            conv_bc(Onebuf, ZERO, 1, 0);
  897. X            addto_ubuf(Convbuf);
  898. X            HIDE_RES;
  899. X            break;
  900. X
  901. X        /* Swap accum and stacktop (no args), or accum and cell (1 arg),
  902. X           other registers remain intact */
  903. X        case SWP:
  904. X            show_result(1);
  905. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  906. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  907. X                onereg(1);
  908. X                stack_reg(1, 0);
  909. X            }
  910. X            else {
  911. X                onereg(*nxeye - 'g');
  912. X                stack_reg(*nxeye - 'g', 0);
  913. X                ++cur_cnt;
  914. X            }
  915. X            conv_bc(Onebuf, ZERO, 1, 0);
  916. X            addto_ubuf(Convbuf);
  917. X            HIDE_RES;
  918. X            break;
  919. X
  920. X        /* Discard top of stack, (no args) or named stack cell (1 arg);
  921. X           move up lower locations.  Move 0 into bottom location */
  922. X        case POP:
  923. X            show_result(1);
  924. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  925. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w')))
  926. X                popstack(1);
  927. X            else {
  928. X                popstack(*nxeye - 'g');
  929. X                ++cur_cnt;
  930. X            }
  931. X            break;
  932. X
  933. X        case MOHOS:
  934. X#ifdef TRACE
  935. X            if (first) {
  936. X                Trace = !Trace;
  937. X                if (Trace && Tf == NULL) {
  938. X                    Tlev = 18; /* pop 2 off 20 maxdeep tabs */
  939. X                    if ((Tf = fopen("pactrace", "w")) == NULL)
  940. X                        go_away("bad trace file", 1);
  941. X                }
  942. X                if (!Trace && Tf != NULL) {
  943. X                    fclose(Tf);
  944. X                    Tf = NULL;
  945. X                }
  946. X            }
  947. X#endif
  948. X            *Ubuf = '\0';
  949. X            *Controlbuf = '\0';
  950. X            first = TRUE;
  951. X            conv_flag = FALSE;
  952. X            break;
  953. X
  954. X        case PI:
  955. X        case ASTRO:     
  956. X        case AMASS:      
  957. X        case AVOGADRO:  
  958. X        case BOLTZMANN: 
  959. X        case ECHARGE:    
  960. X        case CHROMA:    
  961. X        case EMASS:  
  962. X        case EULER:     
  963. X        case FARADAY:   
  964. X        case G_:        
  965. X        case GAS:       
  966. X        case GRAVITY:   
  967. X        case HEAT:      
  968. X        case LIGHT:     
  969. X        case LIGHTYEAR: 
  970. X        case MOONMASS:     
  971. X        case SUNMASS:      
  972. X        case EARTHMASS:    
  973. X        case NATURAL:   
  974. X        case NMASS:   
  975. X        case PARSEC:    
  976. X        case PARALLAX:    
  977. X        case PLANCK:    
  978. X        case PMASS:    
  979. X        case MOONRAD:     
  980. X        case SUNRAD:      
  981. X        case EARTHRAD:    
  982. X        case RYDBERG:   
  983. X        case SOUND:     
  984. X        case STEFAN:    
  985. X        case TOMOON:    
  986. X        case TOSUN:    
  987. X        case WIEN:      
  988. X            addto_ubuf(substivar(type, ZERO, Ibase));
  989. X            break;
  990. X
  991. X        case H_:
  992. X        case I_:
  993. X        case J_:
  994. X        case K_:
  995. X        case L_:
  996. X        case M_:
  997. X        case N_:
  998. X        case O_:
  999. X        case P_:
  1000. X        case Q_:
  1001. X        case R_:
  1002. X        case S_:
  1003. X        case T_:
  1004. X        case U_:
  1005. X        case V_:
  1006. X        case W_:
  1007. X            conv_bc((char *)find(*eye - 'g'), ZERO, 1, 0);
  1008. X            addto_ubuf(Convbuf);
  1009. X            break;
  1010. X
  1011. X        case SIN:
  1012. X        case COS:
  1013. X        case EXP:
  1014. X        case ARCT:
  1015. X            if (Ibase != 10) {
  1016. X                pac_err("active in 10 base only");
  1017. X                TR_
  1018. X                return;
  1019. X            }
  1020. X            *onechar = *eye;
  1021. X            addto_ubuf(onechar);
  1022. X            break;
  1023. X
  1024. X        /* Put 0 into a  specific stack cell, or into
  1025. X           all cells including accum */
  1026. X        case CLR:
  1027. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  1028. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  1029. X                clearstack(0);
  1030. X                addto_ubuf(";0;");
  1031. X            }
  1032. X            else {
  1033. X                clearstack(*nxeye - 'g');
  1034. X                ++cur_cnt;
  1035. X            }
  1036. X            show_result(1);
  1037. X            break;
  1038. X
  1039. X        /* Values below named cell (or top) move down, bottom gets lost,
  1040. X           named cell is copied into cell below */
  1041. X        case DUP:
  1042. X            show_result(1);
  1043. X            if (nxeye == ZERO || strlen(nxeye) > 1 ||
  1044. X                (strlen(nxeye) == 1 && (*nxeye < 'h' || *nxeye > 'w'))) {
  1045. X                stack_reg('w' - 'g', 0); /* copy it into W first */
  1046. X                pushstack(1);
  1047. X            }
  1048. X            else {
  1049. X                stack_reg('w' - 'g', *nxeye - 'g');
  1050. X                pushstack(*nxeye - 'g');
  1051. X                ++cur_cnt;
  1052. X            }
  1053. X            break;
  1054. X
  1055. X        /* Turn continuous conversion on/off */
  1056. X        case AU:
  1057. X        case AUTO:
  1058. X        case AUTOCONV:
  1059. X            show_result(1);
  1060. X            Do_conv = TRUE;
  1061. X            eye = Tokp[++cur_cnt];
  1062. X            if (eye == ZERO) {
  1063. X                --cur_cnt;
  1064. X                Autoconv = ENA;
  1065. X                show_result(0);
  1066. X                break;
  1067. X            }
  1068. X            value = lookup(eye);
  1069. X            if (value != ON && value != OFF) {
  1070. X                --cur_cnt;
  1071. X                Autoconv = ENA;
  1072. X            }
  1073. X            else if (value == ON)
  1074. X                Autoconv = ENA;
  1075. X            else {
  1076. X                Autoconv = DISA;
  1077. X                Do_conv = FALSE;
  1078. X            }
  1079. X            show_result(0);
  1080. X            break;
  1081. X
  1082. X        }
  1083. X        (first == 2) ? (first = TRUE) : (first = FALSE);
  1084. X        /* FALSE after evaluating the first token */
  1085. X    }
  1086. X    (conv_flag || Autoconv == ENA) ? (O_conv = TRUE) : (O_conv = FALSE);
  1087. X    show_result(2);
  1088. X
  1089. X#ifdef TOX
  1090. X    clear_wline(BOT, ULEFT, RBOUND, 1, 1);
  1091. X    standout();
  1092. X    mvaddstr(BOT, ULEFT, Tk);
  1093. X    standend();
  1094. X    pfresh();
  1095. X    sleep(5);
  1096. X    move(CY, CX);
  1097. X#endif
  1098. X
  1099. X    TR_
  1100. X}
  1101. X
  1102. SHAR_EOF
  1103. $TOUCH -am 0221163890 interpret.c &&
  1104. chmod 0644 interpret.c ||
  1105. echo "restore of interpret.c failed"
  1106. set `wc -c interpret.c`;Wc_c=$1
  1107. if test "$Wc_c" != "23768"; then
  1108.     echo original size 23768, current size $Wc_c
  1109. fi
  1110. # ============= ledit.c ==============
  1111. echo "x - extracting ledit.c (Text)"
  1112. sed 's/^X//' << 'SHAR_EOF' > ledit.c &&
  1113. X/* ledit.c */
  1114. X/**********************************************************************
  1115. X*    File Name     : ledit.c
  1116. X*    Function      : line (window) editor of pac
  1117. X*    Author        : Istvan Mohos, 1987
  1118. X***********************************************************************/
  1119. X
  1120. X#include "defs.h"
  1121. X
  1122. Xledit(retbuf,Map,line_y,lbound,rbound,video,stripspace,intact)
  1123. Xchar *retbuf, *Map;
  1124. Xint line_y, lbound, rbound, video, stripspace, intact;
  1125. X{
  1126. X    char c;
  1127. X    register int ri;
  1128. X    int rj;
  1129. X    int lchar, rchar;
  1130. X    int tbound, bbound;
  1131. X    int control = 1, retval = 0, first = 1;
  1132. X    int insert = 0;
  1133. X    char *rp;
  1134. X    static char *fid = "ledit";
  1135. X
  1136. X    _TR
  1137. X
  1138. X    if (line_y) {
  1139. X        CY = tbound = bbound = line_y;
  1140. X        CX = lbound;
  1141. X    }
  1142. X    else {
  1143. X        /* calculator window */
  1144. X        CY = tbound = UTOP;
  1145. X        bbound = UBOT;
  1146. X        CX = ULEFT;
  1147. X    }
  1148. X        
  1149. X    move(CY, CX);
  1150. X    pfresh();
  1151. X
  1152. X    while(control) {
  1153. X        c = fgetc(stdin) & 127;
  1154. X        if (c == 10 || c == 13)
  1155. X            break;
  1156. X        if (c == 17 || c == 19)
  1157. X            continue;
  1158. X        if (!intact && first && c > 31) {
  1159. X            standout();
  1160. X            mvaddstr(MSG, MSGLEFT, Sp34); /* clear any error messages */
  1161. X            standend();
  1162. X            first = 0;
  1163. X            if (line_y)
  1164. X                clear_wline(tbound, lbound, rbound, video, 1);
  1165. X            else
  1166. X                clear_wline(UTOP, lbound, rbound, video, 3);
  1167. X        }
  1168. X
  1169. X        if (video)
  1170. X            standout();
  1171. X        switch(*(Map+c)) {
  1172. X
  1173. X            default:                /* do nothing */
  1174. X            case 0:
  1175. X                break;
  1176. X
  1177. X            case 1:                 /* exit */
  1178. X                go_away(ZERO, 0);
  1179. X
  1180. X            case 2:                 /* addch */
  1181. X                if (insert) {
  1182. X                    for (rj = bbound; rj >= CY + 1; rj--) {
  1183. X                        for (ri = rbound; ri >= lbound + 1; ri--)
  1184. X                            mvaddch(rj, ri, stdscr->_y[rj][ri - 1]);
  1185. X                        mvaddch(rj, ri, stdscr->_y[rj - 1][rbound]);
  1186. X                    }
  1187. X                    for (ri = rbound; ri >= CX + 1; ri--)
  1188. X                        mvaddch(CY, ri, stdscr->_y[CY][ri - 1]);
  1189. X                }
  1190. X                mvaddch(CY,CX,c);
  1191. X                if(++CX > rbound)
  1192. X                    if (++CY <= bbound)
  1193. X                        CX = lbound;
  1194. X                    else {
  1195. X                        --CY;
  1196. X                        --CX;
  1197. X                    }
  1198. X                move(CY,CX);
  1199. X                break;
  1200. X
  1201. X            case 21:                /* ignore to EOL */
  1202. X                while((c = fgetc(stdin) & 127) != 10 && c != 13);
  1203. X                ungetc(c, stdin);
  1204. X                break;
  1205. X
  1206. X            case 3:                 /* move left */
  1207. X                if (--CX < lbound)
  1208. X                    ++CX;
  1209. X                move(CY, CX);
  1210. X                break;
  1211. X
  1212. X            case 4:                 /* move right */
  1213. X                if (++CX > rbound)
  1214. X                    --CX;
  1215. X                move(CY, CX);
  1216. X                break;
  1217. X
  1218. X            case 13:                /* move up */
  1219. X                if (--CY < tbound)
  1220. X                    ++CY;
  1221. X                move(CY, CX);
  1222. X                break;
  1223. X
  1224. X            case 14:                /* move down */
  1225. X                if (++CY > bbound)
  1226. X                    --CY;
  1227. X                move(CY, CX);
  1228. X                break;
  1229. X
  1230. X            case 15:                /* move down and left */
  1231. X                if (++CY <= bbound)
  1232. X                    CX = lbound;
  1233. X                else
  1234. X                    --CY;
  1235. X                move(CY, CX);
  1236. X                break;
  1237. X
  1238. X            case 7:                 /* clear; exit */
  1239. X                clearstack(0);
  1240. X                Amt = Rate = Years = 0.;
  1241. X                go_away("I", 0);
  1242. X
  1243. X            case 8:                 /* wants parent to pop */
  1244. X                retval = 1;
  1245. X                control = 0;
  1246. X                break;
  1247. X
  1248. X            case 9:                 /* wants parent to push */
  1249. X                retval = 2;
  1250. X                control = 0;
  1251. X                break;
  1252. X
  1253. X            /* give back last c, read buffer */
  1254. X            case 12:
  1255. X                retval = c;
  1256. X                control = 0;
  1257. X                break;
  1258. X
  1259. X            /* give back last c, skip buffer */
  1260. X            case 17:
  1261. X                pfresh();
  1262. X                TR_
  1263. X                return(c);
  1264. X
  1265. X            case 10:                /* fill to eol with spaces */
  1266. X                for (ri = CX; ri <= rbound; ri++)
  1267. X                    addch(' ');
  1268. X                for (rj = tbound + 1; rj <= bbound; rj++) {
  1269. X                    move(rj, lbound);
  1270. X                    for (ri = CX; ri <= rbound; ri++)
  1271. X                        addch(' ');
  1272. X                }
  1273. X                move(CY,CX);
  1274. X                break;
  1275. X
  1276. X            /* curr line: delete char and move 1 pos to left */
  1277. X            case 11:
  1278. X                for (ri = CX + 1; ri <= rbound; ri++)
  1279. X                    addch(stdscr->_y[CY][ri]);
  1280. X                addch(' ');
  1281. X                if (--CX < lbound)
  1282. X                     ++CX;
  1283. X                move(CY,CX);
  1284. X                break;
  1285. X
  1286. X            /* across lines: delete char and move 1 pos to left */
  1287. X            case 16:
  1288. X                for (ri = CX + 1; ri <= rbound; ri++)
  1289. X                    addch(stdscr->_y[CY][ri]);
  1290. X                for (rj = CY + 1; rj <= bbound; rj++) {
  1291. X                    addch(stdscr->_y[rj][lbound]);
  1292. X                    move(rj, lbound);
  1293. X                    for (ri = lbound + 1; ri <= rbound; ri++)
  1294. X                        addch(stdscr->_y[rj][ri]);
  1295. X                }
  1296. X                addch(' ');
  1297. X                if (--CX < lbound)
  1298. X                     ++CX;
  1299. X                move(CY,CX);
  1300. X                break;
  1301. X
  1302. X            case 18 :
  1303. X                clearok(curscr, TRUE);
  1304. X                break;                /* ^R redraw */
  1305. X
  1306. X            case 19 :
  1307. X                insert = 1;
  1308. X                break;
  1309. X
  1310. X            case 20 :
  1311. X                insert = 0;
  1312. X                break;
  1313. X        }
  1314. X        standend();
  1315. X        pfresh();
  1316. X    }
  1317. X
  1318. X    rp = retbuf; 
  1319. X    if (stripspace) { /* single line implementation only */
  1320. X        /* find first non-space from the left */
  1321. X        for (ri = lbound; ri <= rbound; ri++)
  1322. X            if ((stdscr->_y[CY][ri] & 127) > 32)
  1323. X                break;
  1324. X        if ((lchar = ri) > rbound) {
  1325. X            *rp = '\0';
  1326. X            pfresh();
  1327. X            TR_
  1328. X            return(retval);
  1329. X        }
  1330. X    
  1331. X        /* find first non-space from the right */
  1332. X        for (ri = rbound; ri >= lbound; ri--)
  1333. X            if ((stdscr->_y[CY][ri] & 127) > 32)
  1334. X                break;
  1335. X        rchar = ri;
  1336. X    
  1337. X        /* give back everything in between */
  1338. X        for (ri = lchar; ri <= rchar; ri++)
  1339. X                *rp++ = stdscr->_y[CY][ri] & 127;
  1340. X    }
  1341. X    else
  1342. X        for (rj = tbound; rj <= bbound; rj++)
  1343. X            for (ri = lbound; ri <= rbound; ri++)
  1344. X                *rp++ = stdscr->_y[rj][ri] & 127;
  1345. X    *rp = '\0';
  1346. X    pfresh();
  1347. X
  1348. X    if (Trace && Tf != NULL)
  1349. X        fprintf(Tf, "[%s]\n", retbuf);
  1350. X    TR_
  1351. X    return(retval);
  1352. X}
  1353. X
  1354. SHAR_EOF
  1355. $TOUCH -am 0221163890 ledit.c &&
  1356. chmod 0644 ledit.c ||
  1357. echo "restore of ledit.c failed"
  1358. set `wc -c ledit.c`;Wc_c=$1
  1359. if test "$Wc_c" != "6967"; then
  1360.     echo original size 6967, current size $Wc_c
  1361. fi
  1362. # ============= onlay.c ==============
  1363. echo "x - extracting onlay.c (Text)"
  1364. sed 's/^X//' << 'SHAR_EOF' > onlay.c &&
  1365. X/* onlay.c */
  1366. X/**********************************************************************
  1367. X*    File Name     : onlay.c
  1368. X*    Function      : draw initial pac screen
  1369. X*    Author        : Istvan Mohos, 1987
  1370. X***********************************************************************/
  1371. X
  1372. X#define SO standout()
  1373. X#define SE standend()
  1374. X#define uw 48
  1375. X#define re 78
  1376. X#define se 58
  1377. X#define sp " "
  1378. X
  1379. X#include "defs.h"
  1380. X
  1381. Xonlay()
  1382. X{
  1383. X    register int i = TOP + 1, j = LBOUND;
  1384. X    static char *fid = "onlay";
  1385. X
  1386. X    _TR
  1387. X mvaddstr(UTOP,     ATOIX, "^A  asc");
  1388. X mvaddstr(UTOP + 1, ATOIX, "^D  dec");
  1389. X mvaddstr(UTOP + 2, ATOIX, "^O  oct");
  1390. X mvaddstr(UTOP + 3, ATOIX, "^X  hex");
  1391. X
  1392. X SO;
  1393. X mvaddstr(TOP, j, "  ");
  1394. X mvaddstr(TOP, ULEFT, Titlq[0]);
  1395. X SE;SO;
  1396. X mvaddstr(i,j,sp);mvaddstr(i,uw,sp);mvaddstr(i,se,sp);mvaddstr(i++,re,sp);SE;SO;
  1397. X mvaddstr(i,j,sp);mvaddstr(i,uw,sp);mvaddstr(i,se,sp);mvaddstr(i++,re,sp);SE;SO;
  1398. X mvaddstr(i,j,sp);mvaddstr(i,uw,sp);mvaddstr(i,se,sp);mvaddstr(i++,re,sp);SE;SO;
  1399. X mvaddstr(i,j,sp);mvaddstr(i,uw,sp);mvaddstr(i,se,sp);mvaddstr(i++,re,sp);SE;SO;
  1400. X mvaddstr(i,j, "                                               LOAN      ");
  1401. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);SE;SO;
  1402. X
  1403. X    SO; mvaddstr(STATY - 1, STATMSG - 1, "    GLOBALS     "); SE;
  1404. X
  1405. X    i = STACKTOP;
  1406. X    SO;
  1407. X    mvaddstr(i,j,"h");SE;addstr("   0");SO;mvaddstr(i,40,"amt");
  1408. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1409. X    mvaddstr(i,j,"i");SE;addstr("   0");SO;mvaddstr(i,40," % ");
  1410. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1411. X    mvaddstr(i,j,"j");SE;addstr("   0");SO;mvaddstr(i,40,"yrs");
  1412. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1413. X    mvaddstr(i,j,"k");SE;addstr("   0");SO;mvaddstr(i,40,"pay");
  1414. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1415. X    mvaddstr(i,j,"l");SE;addstr("   0");SO;mvaddstr(i,40,"^B ");
  1416. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1417. X    mvaddstr(i,j,"m");SE;addstr("   0");SO;mvaddstr(i,40,"   ");
  1418. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1419. X    mvaddstr(i,j,"n");SE;addstr("   0");SO;mvaddstr(i,40,"[le");
  1420. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1421. X    mvaddstr(i,j,"o");SE;addstr("   0");SO;mvaddstr(i,40,"]ri");
  1422. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1423. X    mvaddstr(i,j,"p");SE;addstr("   0");SO;mvaddstr(i,40,"{up");
  1424. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1425. X    mvaddstr(i,j,"q");SE;addstr("   0");SO;mvaddstr(i,40,"}dn");
  1426. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1427. X    mvaddstr(i,j,"r");SE;addstr("   0");SO;mvaddstr(i,40,"|cr");
  1428. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1429. X    mvaddstr(i,j,"s");SE;addstr("   0");SO;mvaddstr(i,40,"^Cl");
  1430. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1431. X    mvaddstr(i,j,"t");SE;addstr("   0");SO;mvaddstr(i,40," BS");
  1432. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1433. X    mvaddstr(i,j,"u");SE;addstr("   0");SO;mvaddstr(i,40,"DEL");
  1434. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1435. X    mvaddstr(i,j,"v");SE;addstr("   0");SO;mvaddstr(i,40,">im");
  1436. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1437. X    mvaddstr(i,j,"w");SE;addstr("   0");SO;mvaddstr(i,40,"<ei");
  1438. X        mvaddstr(i,se,sp);mvaddstr(i++,re,sp);
  1439. X    mvaddstr(i, j, "  ");
  1440. X    mvaddstr(i, ULEFT, Basq[0]); SE;
  1441. XTR_
  1442. X}
  1443. X
  1444. Xupdate()
  1445. X{
  1446. X    register int ri;
  1447. X    int pyp, pxp;
  1448. X    static char *fid = "update";
  1449. X
  1450. X    _TR
  1451. X    CYX;
  1452. X    for (ri = TREQ; --ri >= 0;) {
  1453. X        if (Titlq[ri] != ZERO)  {
  1454. X            standout();
  1455. X            mvaddstr(TOP, ULEFT, Titlq[ri]);
  1456. X            break;
  1457. X        }
  1458. X    }
  1459. X
  1460. X    for (ri = BREQ; --ri >= 0;) {
  1461. X        if (Basq[ri] != ZERO)  {
  1462. X            mvaddstr(BOT, ULEFT, Basq[ri]);
  1463. X            standend();
  1464. X            break;
  1465. X        }
  1466. X    }
  1467. X
  1468. X    PYX;
  1469. XTR_
  1470. X}
  1471. SHAR_EOF
  1472. $TOUCH -am 0221163890 onlay.c &&
  1473. chmod 0644 onlay.c ||
  1474. echo "restore of onlay.c failed"
  1475. set `wc -c onlay.c`;Wc_c=$1
  1476. if test "$Wc_c" != "3586"; then
  1477.     echo original size 3586, current size $Wc_c
  1478. fi
  1479. echo "End of part 4, continue with part 5"
  1480. exit 0
  1481.  
  1482.  
  1483.