home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume9 / popi / part03 < prev    next >
Internet Message Format  |  1991-03-08  |  47KB
  1. From: richb@sunaus.sun.oz.AU (Rich Burridge)
  2. Newsgroups: comp.sources.misc
  3. Subject: v09i049: popi, The Digital Darkroom, Part03/09
  4. Message-ID: <2783@basser.oz>
  5. Date: 12 Dec 89 23:46:03 GMT
  6. Approved: john@cs.su.oz.AU (John Mackin - comp.sources.misc)
  7.  
  8. Posting-number: Volume 9, Issue 49
  9. Submitted-by: Rich Burridge <richb@sunaus.sun.oz.AU>
  10. Archive-name: popi/part03
  11.  
  12. ---- Cut Here and unpack ----
  13. #!/bin/sh
  14. # this is part 3 of a multipart archive
  15. # do not concatenate these parts, unpack them in order with /bin/sh
  16. # file mgr.c continued
  17. #
  18. CurArch=3
  19. if test ! -r s2_seq_.tmp
  20. then echo "Please unpack part 1 first!"
  21.      exit 1; fi
  22. ( read Scheck
  23.   if test "$Scheck" != $CurArch
  24.   then echo "Please unpack part $Scheck next!"
  25.        exit 1;
  26.   else exit 0; fi
  27. ) < s2_seq_.tmp || exit 1
  28. echo "x - Continuing file mgr.c"
  29. sed 's/^X//' << 'Funky_Stuff' >> mgr.c
  30. X  m_bitwrite(x, y, width, height) ;
  31. X}
  32. X
  33. X
  34. Xdrawline(x1, y1, x2, y2)
  35. Xint x1, y1, x2, y2 ;
  36. X{
  37. X  m_func(B_COPY) ;
  38. X  m_line(x1, y1, x2, y2) ;
  39. X}
  40. X
  41. X
  42. Xdrawtext(x, y, fontno, str)
  43. Xenum font_type fontno ;
  44. Xint x, y ;
  45. Xchar *str ;
  46. X{
  47. X       if (fontno == NFONT) m_font(N_FONT) ;
  48. X  else if (fontno == BFONT) m_font(B_FONT) ;
  49. X  m_func(B_XOR) ;
  50. X  if (str[strlen(str)-1] == '\n') str[strlen(str)-1] = '\0' ;
  51. X  m_stringto(0, x, y+4, str) ;
  52. X  m_movecursor(2500, 2500) ;
  53. X}
  54. X
  55. X
  56. Xget_next_char(c)      /* Process events, and return when character typed. */
  57. Xchar *c ;
  58. X{
  59. X  int chr ;
  60. X  static struct timeval tval = { 0, 0 } ;
  61. X
  62. X  m_flush() ;
  63. X  for (;;)
  64. X    {
  65. X      readmask = fullmask ;
  66. X#ifdef NO_43SELECT
  67. X      SELECT(32, &readmask, 0, 0, &tval) ;
  68. X      if (readmask && (1 << mgr_infd))
  69. X#else
  70. X      SELECT(FD_SETSIZE, &readmask, (fd_set *) 0, (fd_set *) 0, &tval) ;
  71. X      if (FD_ISSET(mgr_infd, &readmask))
  72. X#endif /* NO_4.3SELECT */
  73. X        {
  74. X          if ((chr = m_getchar()) == EOF)
  75. X            {
  76. X              clearerr(m_termin) ;
  77. X              continue ;
  78. X            }
  79. X          switch (chr)
  80. X            {
  81. X              case '\032' :
  82. X              case '\033' : close_frame() ;    /* Turn window iconic. */
  83. X                            break ;
  84. X              case '\034' : clean(1) ;         /* Window destroyed. */
  85. X              case '\035' : if (iconic) iconic = 0 ;
  86. X              case '\036' : reshape(OPEN) ;
  87. X              case '\037' : paint_canvas() ;   /* Repaint popi canvas. */
  88. X                            break ;
  89. X              default     : *c = chr ;
  90. X                            return ;
  91. X            }
  92. X        }
  93. X    }
  94. X}
  95. X
  96. X
  97. Xinit_fonts()
  98. X{
  99. X  char path[MAXLINE] ;     /* Directory path for font files. */
  100. X
  101. X#ifdef MGRHOME
  102. X  STRCPY(path, MGRHOME) ;
  103. X#else
  104. X  STRCPY(path, "/usr/mgr") ;
  105. X#endif
  106. X
  107. X  SPRINTF(fontname, "%s/font/%s", path, NORMAL_FONT) ;
  108. X  m_loadfont(NFONT, fontname) ;
  109. X  nfont_width = 7 ;
  110. X
  111. X  SPRINTF(fontname, "%s/font/%s", path, BOLD_FONT) ;
  112. X  m_loadfont(BFONT, fontname) ;
  113. X}
  114. X
  115. X
  116. Xinit_ws_type()
  117. X{
  118. X  m_setup(M_FLUSH) ;     /* Setup I/O; turn on flushing. */
  119. X  m_push(P_BITMAP | P_MENU | P_EVENT | P_FONT | P_FLAGS | P_POSITION) ;
  120. X  mgr_infd = fileno(m_termin) ;
  121. X  mgr_outfd = fileno(m_termout) ;
  122. X
  123. X  SIGNAL(SIGHUP, clean) ;
  124. X  SIGNAL(SIGINT, clean) ;
  125. X  SIGNAL(SIGTERM, clean) ;
  126. X  m_ttyset() ;
  127. X  m_setraw() ;
  128. X  m_setmode(M_NOWRAP) ;
  129. X  m_setmode(M_ABS) ;
  130. X  m_setmode(ACTIVATE) ;
  131. X  m_clearmode(M_NOINPUT) ;
  132. X  m_func(B_COPY) ;
  133. X
  134. X  mptr = (unsigned char *) malloc((unsigned) Xsize) ;
  135. X  ops[(int) GCLR] = B_CLEAR ;
  136. X  ops[(int) GSET] = B_SET ;
  137. X  return 0 ;
  138. X}
  139. X
  140. X
  141. Xload_colors()                /* Hardwired to a monochrome version. */
  142. X{
  143. X  iscolor = 0 ;
  144. X}
  145. X
  146. X
  147. Xload_icon(pixrect, ibuf)
  148. Xint pixrect ;
  149. Xshort ibuf[256] ;
  150. X{
  151. X  int size ;
  152. X
  153. X  IOCTL(mgr_outfd, TIOCLGET, &local_mode) ;
  154. X  local_mode |= LLITOUT ;
  155. X  IOCTL(mgr_outfd, TIOCLSET, &local_mode) ;
  156. X
  157. X  size = ICONHEIGHT * (((64 + 15) &~ 15) >> 3) ;
  158. X  m_bitldto(ICONWIDTH, ICONHEIGHT, 0, 0, pixrect, size) ;
  159. X  m_flush() ;
  160. X  WRITE(mgr_outfd, (char *) ibuf, size) ;
  161. X
  162. X  local_mode &= ~LLITOUT ;
  163. X  IOCTL(mgr_outfd, TIOCLSET, &local_mode) ;
  164. X}
  165. X
  166. X
  167. Xmake_items(argc, argv)       /* Create icon, frame, canvas etc.. */
  168. Xint argc ;
  169. Xchar *argv[] ;
  170. X{
  171. X
  172. X#ifdef NO_43SELECT
  173. X  fullmask = 1 << mgr_infd ;
  174. X#else
  175. X  FD_ZERO(&fullmask) ;
  176. X  FD_SET(mgr_infd, &fullmask) ;
  177. X#endif /* NO_4.3SELECT */
  178. X 
  179. X  m_setevent(BUTTON_2U, "\032") ;   /* Middle mouse button released. */
  180. X  m_setevent(BUTTON_1U, "\033") ;   /* Right mouse button released. */
  181. X  m_setevent(DESTROY, "\034") ;     /* Window has been destroyed. */
  182. X  m_setevent(ACTIVATE, "\035") ;    /* Window has been activated. */
  183. X  m_setevent(RESHAPE, "\036") ;     /* Check for window being reshaped. */
  184. X  m_setevent(REDRAW, "\037") ;      /* Check for window being redrawn. */
  185. X
  186. X  m_movecursor(2500, 2500) ;        /* Move character cursor offscreen. */
  187. X  m_font(N_FONT) ;                  /* Default is the normal font. */
  188. X  load_icon(PR_ICON, icon_image) ;
  189. X  reshape(OPEN) ;
  190. X  m_clear() ;                       /* Clear popi window. */
  191. X  load_colors() ;                   /* Hardwired to monochrome. */
  192. X}
  193. X
  194. X
  195. Xreshape(type)
  196. Xint type ;
  197. X{
  198. X  int x, y, w, h ;      /* Position and size of calctool window. */
  199. X
  200. X  get_size(&x, &y, &w, &h) ;
  201. X  switch (type)
  202. X    {
  203. X      case ICONIC : m_shapewindow(x, y, ICONWIDTH+10, ICONHEIGHT+10) ;
  204. X                    m_clear() ;
  205. X                    m_bitcopyto(0, 0, ICONWIDTH, ICONHEIGHT,
  206. X                                0, 0, 0, PR_ICON) ;
  207. X                    break ;
  208. X      case OPEN   : m_shapewindow(x, y, TWIDTH+10, THEIGHT+10) ;
  209. X    }
  210. X  m_movecursor(2500, 2500) ;
  211. X}
  212. X
  213. X
  214. X/*ARGUSED*/
  215. Xset_cursor(type)      /* Doesn't appear to be any way to set the cursor. */
  216. Xenum cur_type type ;
  217. X{
  218. X}
  219. X
  220. X
  221. Xstart_tool()          /* Null routine. */
  222. X{
  223. X}
  224. Funky_Stuff
  225. echo "File mgr.c is complete"
  226. chmod 0444 mgr.c || echo "restore of mgr.c fails"
  227. set `wc -c mgr.c`;Sum=$1
  228. if test "$Sum" != "7681"
  229. then echo original size 7681, current size $Sum;fi
  230. echo "x - extracting graphics.h (Text)"
  231. sed 's/^X//' << 'Funky_Stuff' > graphics.h &&
  232. X
  233. X/*  @(#)graphics.h 1.1 89/12/12
  234. X *
  235. X *  External variable definitions used by the popi program
  236. X *  optional graphics module.
  237. X *
  238. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  239. X *  This version is based on the code in his Prentice Hall book,
  240. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  241. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  242. X *
  243. X *  Permission is given to distribute these extensions, as long as these
  244. X *  introductory messages are not removed, and no monies are exchanged.
  245. X *
  246. X *  No responsibility is taken for any errors or inaccuracies inherent
  247. X *  either to the comments or the code of this program, but if reported
  248. X *  (see README file) then an attempt will be made to fix them.
  249. X */
  250. X
  251. X/* External declarations for the variables declared in graphics.c. */
  252. X
  253. Xextern char geometry[] ;       /* X11 geometry information. */
  254. Xextern char nextline[] ;       /* Next input line to be parsed. */
  255. Xextern char x11_display[] ;    /* X11 display information. */
  256. X 
  257. Xextern unsigned char *mptr ;   /* Pointer to scanline data. */
  258. X 
  259. Xextern int iconic ;        /* Set if the window is in an iconic state. */
  260. Xextern int iscolor ;       /* Set if this is a color screen. */
  261. Xextern int ix ;            /* Initial X position of the icon. */
  262. Xextern int iy ;            /* Initial Y position of the icon. */
  263. Xextern int nfont_width ;   /* Width of normal font characters. */
  264. Xextern int ops[] ;         /* Rasterop functions. */
  265. Xextern int posspec ;       /* Set if -Wp or -g option is present (for X11) */
  266. Xextern int tptr ;          /* Input buffer pointer. */
  267. X
  268. Xextern int wx ;            /* Initial X position of the open window. */
  269. Xextern int wy ;            /* Initial Y position of the open window. */
  270. Funky_Stuff
  271. chmod 0444 graphics.h || echo "restore of graphics.h fails"
  272. set `wc -c graphics.h`;Sum=$1
  273. if test "$Sum" != "1762"
  274. then echo original size 1762, current size $Sum;fi
  275. echo "x - extracting news.c (Text)"
  276. sed 's/^X//' << 'Funky_Stuff' > news.c &&
  277. X/*LINTLIBRARY*/
  278. X
  279. X/*  @(#)news.c 1.8 89/12/11
  280. X *
  281. X *  C wrappers for News dependent graphics routines used by popi.
  282. X *  written by Rich Burridge - Sun Microsystems Australia.
  283. X *
  284. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  285. X *  This version is based on the code in his Prentice Hall book,
  286. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  287. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  288. X *
  289. X *  Permission is given to distribute these extensions, as long as these
  290. X *  introductory messages are not removed, and no monies are exchanged.
  291. X *
  292. X *  No responsibility is taken for any errors or inaccuracies inherent
  293. X *  either to the comments or the code of this program, but if reported
  294. X *  (see README file) then an attempt will be made to fix them.
  295. X */
  296. X
  297. X#include "popi.h"
  298. X#include "graphics.h"
  299. X#include <sys/types.h>
  300. X
  301. X/* Various pseudo events generated by the popi program. */
  302. X#define  KEYBOARD  100          /* Keyboard character was pressed. */
  303. X#define  REPAINT   101          /* Popi canvas needs repainting. */
  304. X
  305. Xextern FILE *PostScript ;
  306. Xextern FILE *PostScriptInput ;
  307. X
  308. Xunsigned short icon_image[] = {
  309. X#include "popi.icon"
  310. X} ;
  311. X
  312. X
  313. Xcleanup()            /* Null routine for the NeWS version. */
  314. X{
  315. X  FPRINTF(PostScript, "/destroy Frame send\n") ;
  316. X  FFLUSH(PostScript) ;
  317. X}
  318. X
  319. X
  320. Xdraw_scanline(line, y)      /* Display image scanline on the screen. */
  321. Xunsigned char *line ;
  322. Xint y ;
  323. X{
  324. X  int depth, i ;
  325. X
  326. X  depth = (iscolor) ? 8 : 1 ;
  327. X  FPRINTF(PostScript, "/ScanLine %1d 1 %1d { } { < \n", Xsize, depth) ;
  328. X  if (iscolor)
  329. X    {
  330. X      for (i = 0; i < Xsize; i++)
  331. X        FPRINTF(PostScript, "%.2X ", line[i]) ;
  332. X    }
  333. X  else
  334. X    {
  335. X      mptr = (unsigned char *) Emalloc((Xsize / 8) + 1) ;
  336. X      halftone(line, y) ;
  337. X      for (i = 0; i < (Xsize / 8) + 1; i++)
  338. X        FPRINTF(PostScript, "%.2X ", 255 - mptr[i]) ;
  339. X    }
  340. X  FPRINTF(PostScript, "> } buildimage def\n") ;
  341. X  FPRINTF(PostScript, "%1d PSDrawScanLine\n", y) ;
  342. X  FFLUSH(PostScript) ;
  343. X}
  344. X
  345. X
  346. Xdrawarea(x, y, width, height, op)
  347. Xint x, y, width, height ;
  348. Xenum op_type op ;
  349. X{
  350. X  FPRINTF(PostScript, "%d %d %d %d %d PSDrawArea\n",
  351. X          x, y, width, height, (int) op) ;
  352. X  FFLUSH(PostScript) ;
  353. X}
  354. X
  355. X
  356. Xdrawline(x1, y1, x2, y2)
  357. Xint x1, y1, x2, y2 ;
  358. X{
  359. X  FPRINTF(PostScript, "%d %d %d %d PSDrawLine\n", x1, y1, x2, y2) ;
  360. X}
  361. X
  362. X
  363. Xdrawtext(x, y, fontno, str)
  364. Xenum font_type fontno ;
  365. Xint x, y ;
  366. Xchar *str ;
  367. X{
  368. X  int i ;
  369. X  char font, fonttype[6], line[MAXLINE] ;
  370. X
  371. X       if (fontno == NFONT) STRCPY(fonttype, "NFont") ;
  372. X  else if (fontno == BFONT) STRCPY(fonttype, "BFont") ;
  373. X  line[0] = '\0' ;
  374. X  for (i = 0; i < strlen(str); i++)
  375. X    switch (str[i])
  376. X      {
  377. X        case '\\' : STRCAT(line,"\\\\") ;
  378. X                    break ;
  379. X        case '('  : STRCAT(line,"\\(") ;
  380. X                    break ;
  381. X        case ')'  : STRCAT(line,"\\)") ;
  382. X                    break ;
  383. X        default   : STRNCAT(line, &str[i], 1) ;
  384. X      }
  385. X  FPRINTF(PostScript, "%s %d %d (%s) PSDrawText\n", fonttype, x, y, line) ;
  386. X}
  387. X
  388. X
  389. Xget_next_char(c)    /* Process events, and return when character is typed. */
  390. Xchar *c ;
  391. X{
  392. X  int ch, type ;
  393. X
  394. X  for (;;)
  395. X    {
  396. X      FFLUSH(PostScript) ;
  397. X      if (pscanf(PostScriptInput, "%d", &type) == EOF) exit(0) ;
  398. X      switch (type)
  399. X        {
  400. X          case KEYBOARD : pscanf(PostScriptInput, "%d", &ch) ;
  401. X                          *c = ch ;
  402. X                          return ;
  403. X          case REPAINT  : paint_canvas() ;
  404. X        }
  405. X    }
  406. X/*NOTREACHED*/
  407. X}
  408. X
  409. X
  410. Xinit_fonts()
  411. X{
  412. X  FPRINTF(PostScript, "PSInitFonts\n") ;
  413. X  nfont_width = 9 ;
  414. X}
  415. X
  416. X
  417. Xinit_ws_type()
  418. X{
  419. X  if (ps_open_PostScript() < 0) return -1 ;
  420. X  if (send_ps_file(NEWSFILE) == -1)
  421. X    {
  422. X      FCLOSE(PostScript) ;
  423. X      return(-1) ;
  424. X    }
  425. X  FFLUSH(PostScript) ;
  426. X  if (ferror(PostScript))
  427. X    {
  428. X      FCLOSE(PostScript) ;
  429. X      return(-1) ;
  430. X    }
  431. X  FPRINTF(PostScript, "PSIsColor\n") ;
  432. X  pscanf(PostScriptInput, "%d", &iscolor) ;
  433. X  FPRINTF(PostScript, "PSInitialise\n") ;
  434. X  return(0) ;
  435. X}
  436. X
  437. X
  438. Xload_colors()    /* Create and load popi color map. */
  439. X{
  440. X  int i ;
  441. X  u_char red[CMAPLEN], green[CMAPLEN], blue[CMAPLEN] ;
  442. X
  443. X  for (i = 0; i < CMAPLEN; i++)
  444. X    red[i] = green[i] = blue[i] = 255 - i ;
  445. X 
  446. X  FPRINTF(PostScript, "%d PSMakeColorTable\n", 256) ;
  447. X  for (i = 0; i < 256; i++)
  448. X    FPRINTF(PostScript, "%d %d %d %d PSLoadColor\n",
  449. X                       red[i], green[i], blue[i], i) ;
  450. X}
  451. X
  452. X
  453. Xmake_icon()
  454. X{
  455. X  int i, j ;
  456. X
  457. X  FPRINTF(PostScript,"/PopiIcon 64 64 1 { } { <\n") ;
  458. X  for (i = 0; i < 32; i++)
  459. X    {
  460. X      for (j = 0; j < 8; j++) FPRINTF(PostScript,"%.4X ", icon_image[i*8+j]) ;
  461. X      FPRINTF(PostScript,"\n") ;
  462. X    }
  463. X  FPRINTF(PostScript,"> } buildimage def\n") ;
  464. X}
  465. X
  466. X
  467. Xmake_items(argc, argv)       /* Create icon, frame, canvas etc.. */
  468. Xint argc ;
  469. Xchar *argv[] ;
  470. X{
  471. X  make_icon() ;
  472. X  FPRINTF(PostScript, "%d %d %d %d %d %d %d PSMakeItems\n",
  473. X                     wx, wy, TWIDTH, THEIGHT,
  474. X                     ix, iy, iconic) ;
  475. X  load_colors() ;
  476. X}
  477. X
  478. X
  479. Xsend_ps_file(fname)
  480. Xchar *fname ;
  481. X{
  482. X  FILE *stream ;
  483. X  int c ;
  484. X
  485. X  if ((stream = fopen(fname,"r")) == NULL) return -1 ;
  486. X  while ((c = getc(stream)) != EOF) PUTC(c, PostScript) ;
  487. X  FCLOSE(stream) ;
  488. X  return 0 ;
  489. X}
  490. X
  491. X
  492. Xset_cursor(type)
  493. Xenum cur_type type ;
  494. X{
  495. X  FPRINTF(PostScript, "%d PSSetCursor\n", (int) type) ;
  496. X}
  497. X
  498. X
  499. Xstart_tool()          /* Null routine in the NeWS version. */
  500. X{
  501. X}
  502. Funky_Stuff
  503. chmod 0444 news.c || echo "restore of news.c fails"
  504. set `wc -c news.c`;Sum=$1
  505. if test "$Sum" != "5267"
  506. then echo original size 5267, current size $Sum;fi
  507. echo "x - extracting nulldev.c (Text)"
  508. sed 's/^X//' << 'Funky_Stuff' > nulldev.c &&
  509. X/*LINTLIBRARY*/
  510. X
  511. X/*  @(#)nulldev.c 1.7 89/12/11
  512. X *
  513. X *  Popi device driver for a null device.
  514. X *  written by Stephen Frede, Softway Pty Ltd.
  515. X *
  516. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  517. X *  This version is based on the code in his Prentice Hall book,
  518. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  519. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  520. X *
  521. X *  Permission is given to distribute these extensions, as long as these
  522. X *  introductory messages are not removed, and no monies are exchanged.
  523. X *
  524. X *  No responsibility is taken for any errors or inaccuracies inherent
  525. X *  either to the comments or the code of this program, but if reported
  526. X *  (see README file) then an attempt will be made to fix them.
  527. X */
  528. X
  529. X#include "popi.h"
  530. X
  531. X/*  There are ten exportable routines used by the popi program.
  532. X *
  533. X *  These are:
  534. X *
  535. X *  disp_init(argc, argv)    - called from main at the start.
  536. X *  disp_finish()            - called from main prior to exit.
  537. X *  disp_imgstart()          - called prior to drawing an image.
  538. X *  disp_imgend()            - called after drawing an image.
  539. X *  disp_putline(line, y)    - to draw an image scanline.
  540. X *  disp_getchar()           - to get the next character typed.
  541. X *  disp_ungetc(c)           - put back the last character typed.
  542. X *  disp_prompt()            - display popi prompt and clear input buffer.
  543. X *  disp_error(errtype)      - display error message.
  544. X *  disp_percentdone(n)      - display percentage value of conversion.
  545. X */
  546. X
  547. X/*ARGSUSED*/
  548. Xvoid
  549. Xdisp_init(argc,argv)           /* called from main at the atart. */
  550. Xint argc;
  551. Xchar *argv[];
  552. X{
  553. X}
  554. X
  555. X
  556. Xvoid
  557. Xdisp_finish()                  /* called from main prior to exit. */
  558. X{
  559. X}
  560. X
  561. X
  562. Xvoid
  563. Xdisp_imgstart()                /* called prior to drawing an image. */
  564. X{
  565. X}
  566. X
  567. X
  568. Xvoid
  569. Xdisp_imgend()                  /* called after drawing an image. */
  570. X{
  571. X}
  572. X
  573. X
  574. Xvoid
  575. Xdisp_putline(line, y)        /* called to draw image scanline y. */
  576. Xpixel_t *line;
  577. Xint y;
  578. X{
  579. X}
  580. X
  581. X
  582. Xdisp_getchar()                 /* get next user typed character. */
  583. X{
  584. X    return(getchar());
  585. X}
  586. X
  587. X
  588. X/*ARGSUSED*/
  589. Xvoid
  590. Xdisp_ungetc(c)                 /* put back the last character typed. */
  591. Xchar c;
  592. X{
  593. X    UNGETC(c, stdin);
  594. X}
  595. X
  596. X
  597. Xdisp_prompt()                  /* display popi prompt. */
  598. X{
  599. X    char    *prompt = "-> ";
  600. X
  601. X    PRINTF(prompt);
  602. X    return sizeof prompt - 1;
  603. X}
  604. X
  605. X
  606. Xvoid
  607. Xdisp_error(errtype, pos)            /* display error message. */
  608. Xint    errtype,
  609. X    pos;
  610. X{
  611. X    extern int  errno;
  612. X    extern char *sys_errlist[];
  613. X
  614. X    if (errtype & ERR_PARSE)
  615. X    {
  616. X        int     i;
  617. X 
  618. X        for (i=1; i < pos; ++i)
  619. X            PUTC('-', stderr);
  620. X        PUTC('^', stderr);
  621. X        PUTC('\n', stderr);
  622. X    }
  623. X 
  624. X    FPRINTF(stderr, "%s\n", ErrBuf);
  625. X    /* we assume errno hasn't been reset by the preceding output */
  626. X    if (errtype & ERR_SYS)
  627. X        FPRINTF(stderr, "\t(%s)\n", sys_errlist[errno]);
  628. X}
  629. X
  630. Xvoid
  631. Xdisp_percentdone(percent)
  632. Xint    percent;
  633. X{
  634. X    static int    lastpercent = 100;
  635. X
  636. X    if (!Verbose)
  637. X    return;
  638. X    if (percent == 100)
  639. X    {
  640. X    printf("\r    \n");
  641. X    return;
  642. X    }
  643. X    if (percent != lastpercent && percent % 5 == 0)
  644. X    {
  645. X    printf("\r%2d%% ", percent);
  646. X    fflush(stdout);
  647. X    lastpercent = percent;
  648. X    }
  649. X}
  650. Funky_Stuff
  651. chmod 0444 nulldev.c || echo "restore of nulldev.c fails"
  652. set `wc -c nulldev.c`;Sum=$1
  653. if test "$Sum" != "3179"
  654. then echo original size 3179, current size $Sum;fi
  655. echo "x - extracting patchlevel.h (Text)"
  656. sed 's/^X//' << 'Funky_Stuff' > patchlevel.h &&
  657. X
  658. X/* @(#)patchlevel.h 1.11 89/12/11
  659. X *
  660. X *  This is the current patchlevel for this version of popi.
  661. X *
  662. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  663. X *  This version is based on the code in his Prentice Hall book,
  664. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  665. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  666. X *
  667. X *  Permission is given to distribute these extensions, as long as these
  668. X *  introductory messages are not removed, and no monies are exchanged.
  669. X *
  670. X *  No responsibility is taken for any errors or inaccuracies inherent
  671. X *  either to the comments or the code of this program, but if reported
  672. X *  (see README file) then an attempt will be made to fix them.
  673. X */
  674. X
  675. X#define  PATCHLEVEL  2
  676. Funky_Stuff
  677. chmod 0444 patchlevel.h || echo "restore of patchlevel.h fails"
  678. set `wc -c patchlevel.h`;Sum=$1
  679. if test "$Sum" != "764"
  680. then echo original size 764, current size $Sum;fi
  681. echo "x - extracting polar.c (Text)"
  682. sed 's/^X//' << 'Funky_Stuff' > polar.c &&
  683. X
  684. X/*  @(#)polar.c 1.6 89/12/11
  685. X *
  686. X *  Polar coordinate handling routines used by the popi program.
  687. X *
  688. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  689. X *  This version is based on the code in his Prentice Hall book,
  690. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  691. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  692. X *
  693. X *  Permission is given to distribute these extensions, as long as these
  694. X *  introductory messages are not removed, and no monies are exchanged.
  695. X *
  696. X *  No responsibility is taken for any errors or inaccuracies inherent
  697. X *  either to the comments or the code of this program, but if reported
  698. X *  (see README file) then an attempt will be made to fix them.
  699. X */
  700. X
  701. X#include <stdio.h>
  702. X#include "popi.h"
  703. X
  704. Xshort
  705. X    *avals = 0,
  706. X    *rvals = 0;
  707. X
  708. X/*
  709. X *      +y
  710. X *       ^
  711. X *       2 | 1
  712. X * -x <----+----> +x
  713. X *       3 | 4
  714. X *       v
  715. X *      -y
  716. X */
  717. X
  718. X#ifdef AMIGA
  719. Xdouble
  720. Xhypot(x, y)
  721. Xdouble x, y;
  722. X{
  723. X    return(sqrt(x*x + y*y));
  724. X}
  725. X#endif    /* AMIGA */
  726. X
  727. Xvoid
  728. XMakePolar()
  729. X{
  730. X    short    *ap,    /* pointer to angle array */
  731. X        *rp,    /* pointer into radius array */
  732. X        *a1,    /* tmp pointer to angle array */
  733. X        *r1;    /* tmp pointer to radius array */
  734. X    int        x,
  735. X        y,
  736. X        xmin,
  737. X        xmax,
  738. X        ymin,
  739. X        ymax;
  740. X
  741. X    if (avals)
  742. X    return;        /* previously calculated */
  743. X
  744. X    avals = (short *) LINT_CAST(Emalloc((unsigned)Xsize * Ysize * sizeof(short)));
  745. X    rvals = (short *) LINT_CAST(Emalloc((unsigned)Xsize * Ysize * sizeof(short)));
  746. X
  747. X    ymax =  Ysize / 2;
  748. X    ymin = -(Ysize - 1) / 2;
  749. X    xmin = -Xsize / 2;
  750. X    xmax =  (Xsize - 1) / 2;
  751. X
  752. X    rp = rvals;
  753. X    ap = avals;
  754. X
  755. X    for (y = ymax; y >= 0; --y)
  756. X    {
  757. X    /* Quadrant 2 */
  758. X    for (x = xmin; x < 0; ++x)
  759. X    {
  760. X        *ap++ = (short) (RtoD(atan2((double) y, (double) x)) + 0.5);
  761. X        *rp++ = (short) hypot((double) y, (double) x);
  762. X    }
  763. X    /* x == 0 */
  764. X    if (y == 0)
  765. X    {
  766. X        *ap++ = 0;    /* prevent a domain error calling atan2() */
  767. X        *rp++ = 0;
  768. X    }
  769. X    else
  770. X    {
  771. X        *ap++ = (short) (RtoD(atan2((double) y, (double) x)) + 0.5);
  772. X        *rp++ = (short) hypot((double) y, (double) x);
  773. X    }
  774. X    ++x;
  775. X    /* remember location just before the 0 value */
  776. X    r1 = rp -2;
  777. X    a1 = ap - 2;
  778. X    /* Quadrant 1 */
  779. X    for (; x <= xmax; ++x)
  780. X    {
  781. X        *ap++ = 180 - *a1--;
  782. X        *rp++ = *r1--;
  783. X    }
  784. X    }
  785. X    r1 = rp - Xsize - 1;
  786. X    a1 = ap - Xsize - 1;
  787. X    for (; y >= ymin; --y)
  788. X    {
  789. X    /* Quadrant 3, 4 */
  790. X    for (x = xmin; x <= xmax; ++x)
  791. X    {
  792. X        *rp++ = *r1--;
  793. X        *ap++ = *a1-- + 180;
  794. X    }
  795. X    }
  796. X}
  797. Funky_Stuff
  798. chmod 0444 polar.c || echo "restore of polar.c fails"
  799. set `wc -c polar.c`;Sum=$1
  800. if test "$Sum" != "2418"
  801. then echo original size 2418, current size $Sum;fi
  802. echo "x - extracting popi.h (Text)"
  803. sed 's/^X//' << 'Funky_Stuff' > popi.h &&
  804. X/* @(#)popi.h 1.10 89/12/11
  805. X *
  806. X *  Definitions and constants used by the popi program.
  807. X *
  808. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  809. X *  This version is based on the code in his Prentice Hall book,
  810. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  811. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  812. X *
  813. X *  Permission is given to distribute these extensions, as long as these
  814. X *  introductory messages are not removed, and no monies are exchanged.
  815. X *
  816. X *  No responsibility is taken for any errors or inaccuracies inherent
  817. X *  either to the comments or the code of this program, but if reported
  818. X *  (see README file) then an attempt will be made to fix them.
  819. X */
  820. X
  821. X#ifndef    POPI_DEFINED
  822. X#define POPI_DEFINED
  823. X
  824. X#if defined(MSDOS) && defined(M_I86)
  825. X/* Assume we are Microsoft C */
  826. X# define __MSC__ 1
  827. X#endif    /* MSC */
  828. X
  829. X/*
  830. X * Some compilers are near enough to ANSI for our purposes.
  831. X * In some situations the compiler has a true ANSI mode which
  832. X * we should set if possible. But sometimes we can't because
  833. X * we need non-standard features of the compiler (eg far pointers
  834. X * under DOS). We can't just set __STDC__ ourselves in these cases
  835. X * because their include files need to know the truth. So we
  836. X * set the token STDC which means that as far as we're concerned
  837. X * we are ANSI.
  838. X */
  839. X
  840. X#if defined(__STDC__) || defined(__TURBOC__) || defined(__MSC__)
  841. X# define STDC    1
  842. X#endif    /* __STDC__ || __TURBOC__ || __MSC__ */
  843. X
  844. X#if defined(STDC) && ! defined(apollo)
  845. X
  846. X# include <stdlib.h>
  847. X
  848. X#else    /* ! STDC || apollo */
  849. X
  850. X/* No <stdlib.h> */
  851. X/* We can't define these as well as including <stdlib.h> because
  852. X * some compilers (eg Turbo C) use silly nonstandard keywords (which
  853. X * we can't #define away) as part of the type.
  854. X */
  855. Xextern char
  856. X        *malloc(),
  857. X        *getenv(),
  858. X# ifdef       BSD
  859. X        *sprintf();
  860. X# endif  /* BSD */
  861. X#endif    /* STDC && !apollo */
  862. X
  863. X#if defined(STDC) || ! defined(BSD)
  864. X# include <string.h>
  865. X#else
  866. X# include <strings.h>
  867. X#endif    /* STDC || ! BSD */
  868. X
  869. X/*
  870. X *    For all function declarations, if ANSI then use a prototype.
  871. X */
  872. X#if    defined(STDC)
  873. X# define P(args)    args
  874. X#else    /* ! STDC */
  875. X# define P(args)    ()
  876. X#endif    /* STDC */
  877. X
  878. X#ifndef    FILE
  879. X# include    <stdio.h>
  880. X#endif    /* FILE */
  881. X#ifndef assert
  882. X# include    <assert.h>
  883. X#endif    /* assert */
  884. X
  885. X/*
  886. X * The assumption we make here is that not all versions of <math.h>
  887. X * define M_PI, but they all define HUGE.
  888. X */
  889. X#ifndef M_PI
  890. X# ifndef    HUGE
  891. X#  include <math.h>
  892. X# endif        /* HUGE */
  893. X
  894. X# ifndef    M_PI
  895. X#  define M_PI    3.14159265358979323846
  896. X# endif        /* M_PI */
  897. X#endif /* M_PI */
  898. Xextern double
  899. X    pow P((double, double)),
  900. X    sin P((double)),
  901. X    cos P((double)),
  902. X    atan2 P((double, double)),
  903. X    hypot P((double, double)),
  904. X    log P((double)),
  905. X    sqrt P((double));
  906. X
  907. X#define NELS(arr)    (sizeof (arr) / sizeof (*(arr)))
  908. X
  909. X#define DtoR(degrees)    ((degrees) * M_PI * 2.0 / 360.0)
  910. X#define RtoD(radians)    ((radians) / (M_PI * 2.0 / 360.0))
  911. X
  912. X#define BITSINBYTE    8
  913. X
  914. X/*
  915. X * define RANDOM to be an expression which returns a value
  916. X * between 0 and some large number (like maxint or maxlong).
  917. X */
  918. X#if    defined(BSD)
  919. X# define RANDOM        random()
  920. Xextern long        random P((void));
  921. X#else    /* ! BSD */
  922. X# if    defined(SYSV)
  923. X#  define RANDOM        lrand48()
  924. Xextern long        lrand48 P((void));
  925. X# else    /* ! SYSV */
  926. X#  define RANDOM        rand()
  927. Xextern int        rand P((void));
  928. X# endif    /* SYSV */
  929. X#endif    /* BSD */
  930. X
  931. Xtypedef long        stack_t;
  932. Xtypedef long        parse_t;
  933. Xtypedef unsigned char    pixel_t;
  934. Xtypedef int        bool;
  935. X
  936. X#ifndef    FALSE
  937. X# define FALSE        0
  938. X# define TRUE        1
  939. X#endif    /* FALSE */
  940. X
  941. X
  942. X/* To make lint happy. */
  943. X
  944. X#define FCLOSE        (void) fclose
  945. X#define FFLUSH          (void) fflush
  946. X#define FPRINTF      (void) fprintf
  947. X#define FPUTS        (void) fputs
  948. X#define FREAD        (void) fread
  949. X#define FWRITE       (void) fwrite
  950. X#define IOCTL           (void) ioctl
  951. X#define PCLOSE        (void) pclose
  952. X#define PRINTF       (void) printf
  953. X#define PUTC            (void) putc
  954. X#define SELECT          (void) select
  955. X#define SIGNAL          (void) signal
  956. X#define SPRINTF         (void) sprintf
  957. X#define STRCAT          (void) strcat
  958. X#define STRCPY       (void) strcpy
  959. X#define STRNCAT        (void) strncat
  960. X#define STRNCPY        (void) strncpy
  961. X#define UNGETC       (void) ungetc
  962. X#define WRITE           (void) write
  963. X
  964. X#ifndef LINT_CAST
  965. X#ifdef lint
  966. X#define LINT_CAST(arg)  (arg ? 0 : 0)
  967. X#else
  968. X#define LINT_CAST(arg)  (arg)
  969. X#endif /* lint */
  970. X#endif /* LINT_CAST */
  971. X
  972. X#define PUTCHAR(ch)    (void) putc(ch, stderr)
  973. X
  974. X#define BACKSPACE       8            /* for input line parsing. */
  975. X#define DEL             127
  976. X#define LINEFEED        13
  977. X#define RETURN          10
  978. X
  979. X#define BITSPERPIXEL    8
  980. X#define BOXH            40           /* height of input dialog box. */
  981. X#define BOXW            (TWIDTH-40)  /* width of input dialog box. */
  982. X#define BOXX            20           /* x position of input dialog box. */
  983. X#define BOXY            10           /* y position of input dialog box. */
  984. X#define CMAPLEN         256          /* length of the color map. */
  985. X#define DEF_X           512          /* image width */
  986. X#define DEF_Y           512          /* image height */
  987. X#define DEF_ZSIZE       (1 << BITSPERPIXEL)
  988. X#define MAXIMG          128
  989. X
  990. X#ifndef MAXLINE
  991. X#define MAXLINE         80           /* length of character strings. */
  992. X#endif  /*MAXLINE*/
  993. X
  994. X#define MAXOPS        2            /* number of pseudo rasterop functions. */
  995. X#define MAXTOKENS    128
  996. X
  997. X#ifndef  SIGRET
  998. X#define  SIGRET         int
  999. X#endif /* SIGRET */
  1000. X
  1001. X#define THEIGHT         612          /* total height of the popi window. */
  1002. X#define TWIDTH          512          /* total width of the popi canvas. */
  1003. X
  1004. X#define ERR_NONE    0
  1005. X#define ERR_SYS        (1<<0)       /* system error (errno set) */
  1006. X#define ERR_PARSE    (1<<1)         /* syntax error while parsing input */
  1007. X#define ERR_SNARK    (1<<2)         /* internal program error */
  1008. X#define ERR_WARN    (1<<3)         /* just a warning */
  1009. X
  1010. X/* larger than any char token. */
  1011. X#define CRVAL    257    /* cartesian image coordinate rval */
  1012. X#define CLVAL    258    /* cartesian image coordinate lval */
  1013. X#define INAME    259    /* image name */
  1014. X#define VALUE    260
  1015. X#define NAME    261
  1016. X#define NEW    262
  1017. X#define AND    264    /* && */
  1018. X#define OR    265    /* || */
  1019. X#define EQ    266    /* == */
  1020. X#define NE    267    /* != */
  1021. X#define GE    268    /* >= */
  1022. X#define LE    269    /* <= */
  1023. X#define UMIN    270    /* unary minus */
  1024. X#define POW    271    /* ** */
  1025. X#define LSHIFT    272    /* << */
  1026. X#define RSHIFT    273    /* >> */
  1027. X#define SPECIAL    274
  1028. X#define INUM    275    /* integer number */
  1029. X#define FNUM    276    /* floating point number */
  1030. X#define PLVAL    277    /* polar image coordinate lval */
  1031. X#define PRVAL    278    /* polar image coordinate rval */
  1032. X#define FNAME    279    /* Filename */
  1033. X#define SIN    300    /* sine() * Z */
  1034. X#define COS    301    /* cosine() * Z */
  1035. X#define ATAN    302    /* atan2(y, x) */
  1036. X#define ABS    303    /* abs() */
  1037. X#define LOG    304    /* natural log */
  1038. X#define SQRT    305
  1039. X#define RAND    306    /* RANDOM() as defined above */
  1040. X#define HYPOT    307    /* hypot(x, y) == sqrt(x*x + y*y) */
  1041. X
  1042. X#ifdef    NDEBUG
  1043. X#  define DEBUG(stuff)
  1044. X#else    /* ! NDEBUG */
  1045. X#  define DEBUG(stuff)    if (Debug) FPRINTF stuff
  1046. X#endif    /* ! NDEBUG */
  1047. X
  1048. Xenum cur_type { BUSY_CUR, NORMAL_CUR } ; /* cursor types. */
  1049. X
  1050. Xenum font_type { BFONT, NFONT } ;        /* fonts used by popi. */
  1051. X
  1052. Xenum op_type  { GCLR, GSET } ;           /* pseudo rasterop functions. */
  1053. X
  1054. Xstruct SRC
  1055. X{
  1056. X    pixel_t        **pix;    /* pix[y][x] */
  1057. X    char        *str;
  1058. X};
  1059. X
  1060. X/* An element of the execution string.
  1061. X * Each such item will perform some operation on the
  1062. X * evaluation stack.
  1063. X */
  1064. Xtypedef
  1065. Xstruct exec
  1066. X{
  1067. X    int        op;
  1068. X    union
  1069. X    {
  1070. X    long    i;    /* integer */
  1071. X    float    f;    /* floating point */
  1072. X    } value;
  1073. X} exec_t;
  1074. X
  1075. X#if    SEQPAR
  1076. X#ifndef    sequent
  1077. X#include "Sorry, this will only work on a sequent"
  1078. X#endif    /* sequent */
  1079. X#define malloc    shmalloc
  1080. X#endif    /* SEQPAR */
  1081. X
  1082. X/* External declarations */
  1083. X
  1084. X/* main.c */
  1085. Xextern char    *Emalloc P((unsigned int));
  1086. Xextern void    PrStrs P((char **));
  1087. Xextern void    version P((void));
  1088. X
  1089. X/* io.c */
  1090. Xextern pixel_t    **ImgAlloc P((void));
  1091. Xextern void    ImgFree P((struct SRC *));
  1092. Xextern void    Efclose P((FILE *));
  1093. Xextern FILE    *EfopenR P((char *)),
  1094. X        *EfopenW P((char *));
  1095. Xextern void    getpix P((char *, char *));
  1096. Xextern void    putpix P((struct SRC *, char *));
  1097. Xextern void    showfiles P((void));
  1098. X
  1099. X/* lex.c */
  1100. Xextern void    Skip P((void));
  1101. Xextern void    lex P((void));
  1102. Xextern void    error P((int));
  1103. Xextern void    pushback P((int));
  1104. X
  1105. X/* expr.c */
  1106. Xextern void    transform P((void));
  1107. X
  1108. X/* special.c */
  1109. Xextern void    help P((void));
  1110. Xextern void    OpenLog P((void));
  1111. Xextern void    special P((void));
  1112. X
  1113. X/* run.c */
  1114. Xextern void    SwapOldNew P((void));
  1115. Xextern void    run P((void));
  1116. X
  1117. X/* polar.c */
  1118. Xextern void    MakePolar P((void));
  1119. X
  1120. X/* driver routines */
  1121. Xvoid    disp_init P((int, char**));
  1122. Xvoid    disp_finish P((void));
  1123. Xvoid    disp_imgstart P((void));
  1124. Xvoid    disp_imgend P((void));
  1125. Xvoid    disp_putline P((pixel_t *, int));
  1126. Xvoid    disp_error P((int, int));
  1127. Xvoid    disp_ungetc P((int));
  1128. Xvoid    disp_percentdone P((int));
  1129. Xint    disp_prompt P((void));
  1130. Xint    disp_getchar P((void));
  1131. X
  1132. X/* External variable declarations */
  1133. X
  1134. Xextern char ErrBuf[] ;
  1135. Xextern char *ProgName ;        /* Name of this program. */
  1136. Xextern char nextline[] ;       /* Next input line to be parsed. */
  1137. Xextern char text[] ;
  1138. Xextern char *LogFile ;         /* Name of file for logging commands */
  1139. X
  1140. Xextern FILE *Debug ;           /* Debugging stream */
  1141. Xextern FILE *LogStr ;          /* command logging stream */
  1142. X
  1143. Xextern double lexfract ;
  1144. X
  1145. Xextern short CUROLD ;
  1146. Xextern short CURNEW ;
  1147. X
  1148. Xextern long parsed[] ;
  1149. X
  1150. Xextern int CharPos ;           /* Position in input line. */
  1151. Xextern int OldPos ;
  1152. Xextern int RangeCheck ;
  1153. Xextern int Xsize ;
  1154. Xextern int Ysize ;
  1155. Xextern int Zsize ;
  1156. Xextern pixel_t Zmax ;
  1157. Xextern short *avals ;
  1158. Xextern int lat ;          /* Lookahead token. */
  1159. Xextern int lexval ;
  1160. Xextern int noerr ;        /* Indicates if an error has occured. */
  1161. Xextern int nsrc ;
  1162. Xextern int prs ;
  1163. Xextern short *rvals ;
  1164. Xextern int Verbose ;
  1165. Xextern void Skip() ;
  1166. Xextern int Truncate ;
  1167. X
  1168. Xextern struct SRC src[MAXIMG] ;
  1169. X
  1170. Xextern int disp_active ;       /* Display results after each operation. */
  1171. X
  1172. X#if       SEQPAR
  1173. Xextern int ncpus;          /* No. cpus to use in parallel */
  1174. X#endif /* SEQPAR */
  1175. X
  1176. X#endif    /* POPI_DEFINED */
  1177. Funky_Stuff
  1178. chmod 0444 popi.h || echo "restore of popi.h fails"
  1179. set `wc -c popi.h`;Sum=$1
  1180. if test "$Sum" != "9927"
  1181. then echo original size 9927, current size $Sum;fi
  1182. echo "x - extracting popi.icon (Text)"
  1183. sed 's/^X//' << 'Funky_Stuff' > popi.icon &&
  1184. X/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16
  1185. X */
  1186. X    0xFFFF,0xFFFF,0xFFFF,0xFFFF,0x8000,0x0000,0x0001,0x0001,
  1187. X    0x8000,0x0000,0x0001,0x7F81,0x8000,0x0000,0x0001,0x30C1,
  1188. X    0x8000,0x0000,0x0001,0x3061,0x8000,0x0000,0x0001,0x3061,
  1189. X    0x8000,0x0000,0x0001,0x3061,0x8000,0x0000,0x0001,0x30C1,
  1190. X    0x8000,0x7600,0x0001,0x3781,0x8000,0xDF80,0x0001,0x3001,
  1191. X    0x8001,0x76E8,0x0001,0x3001,0x8001,0xFF00,0x0001,0x3001,
  1192. X    0x8002,0x7BFC,0x0001,0x3001,0x8002,0xDE03,0x0001,0x3001,
  1193. X    0x800A,0xD5F8,0x0001,0x3001,0x804A,0xBF45,0xC001,0x7801,
  1194. X    0x801A,0xE97C,0x0001,0x0001,0x81D3,0xAFEB,0x6001,0x0001,
  1195. X    0x823F,0xFBBE,0x1001,0x0F81,0x82EF,0xEAFF,0xF401,0x11C1,
  1196. X    0x857F,0xABFF,0x8401,0x20E1,0x857F,0xE87F,0xF801,0x6061,
  1197. X    0x87FF,0x007F,0xFE01,0x6061,0x8BFF,0x000F,0xF801,0x6061,
  1198. X    0x8FFC,0x0005,0xFE01,0x6061,0x87FE,0x01FF,0xFF01,0x7041,
  1199. X    0x8FFB,0xF37F,0xFE01,0x3881,0x87EF,0xF1E0,0xFF81,0x1F01,
  1200. X    0x8FF8,0xF1FE,0xFF81,0x0001,0x8FFF,0xB110,0x5D01,0x0001,
  1201. X    0x87E2,0xD0C4,0x5FC1,0x0001,0x8FEA,0x0010,0x3FC1,0x77C1,
  1202. X    0x87A0,0xA045,0x1FC1,0x38E1,0x87F4,0xA030,0x5F81,0x3071,
  1203. X    0x87D2,0x8001,0x3F81,0x3031,0x85D6,0xC014,0xBF81,0x3031,
  1204. X    0x87F0,0x39C5,0xBF01,0x3031,0x87DE,0x8F85,0xFE01,0x3031,
  1205. X    0x83EA,0x3FF4,0x3E01,0x3021,0x83FC,0xA85D,0xF801,0x3841,
  1206. X    0x81F7,0xFFE5,0xB801,0x3F81,0x81FE,0xA005,0xF801,0x3001,
  1207. X    0x807E,0x9007,0xF001,0x3001,0x807F,0x96C3,0xF801,0x3001,
  1208. X    0x80FE,0x8A8F,0xFC01,0x3001,0x80FF,0xCBA2,0xFE01,0x7801,
  1209. X    0x80FF,0xD69F,0xFF01,0x0001,0x807F,0xD5D7,0xFC01,0x0001,
  1210. X    0x81FF,0xF77F,0xFC01,0x0601,0x80FF,0xFDDF,0xFE01,0x0601,
  1211. X    0x80FF,0xEFFE,0xFE01,0x0001,0x81FE,0xFFFD,0xFF81,0x0001,
  1212. X    0x87FE,0xFFFD,0xFFC1,0x1E01,0x9FEF,0xBFF5,0xABF1,0x0601,
  1213. X    0xBFFB,0x7FDF,0xFFFD,0x0601,0xFFCF,0xD7F3,0xC7FF,0x0601,
  1214. X    0xFFFF,0xFFDF,0xFFFF,0x0601,0xFFFF,0x6FF7,0xFFFF,0x0601,
  1215. X    0xFFFF,0xFFFF,0xFFFF,0x0601,0xFFFF,0xEFCF,0xFFFF,0x0601,
  1216. X    0xFFFF,0xFFFF,0xFFFF,0x0601,0xFFFF,0xFFFF,0xFFFF,0x1F81,
  1217. X    0xFFFF,0xFFFF,0xFFFF,0x0001,0xFFFF,0xFFFF,0xFFFF,0xFFFF
  1218. Funky_Stuff
  1219. chmod 0444 popi.icon || echo "restore of popi.icon fails"
  1220. set `wc -c popi.icon`;Sum=$1
  1221. if test "$Sum" != "1933"
  1222. then echo original size 1933, current size $Sum;fi
  1223. echo "x - extracting popi.ps (Text)"
  1224. sed 's/^X//' << 'Funky_Stuff' > popi.ps &&
  1225. X
  1226. X%  @(#)popi.ps 1.5 89/12/04
  1227. X%
  1228. X%  NeWS dependent graphics routines used by the popi program.
  1229. X%  written by Rich Burridge - Sun Microsystems Australia.
  1230. X%
  1231. X%  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  1232. X%  This version is based on the code in his Prentice Hall book,
  1233. X%  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  1234. X%  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc.
  1235. X%
  1236. X%  Permission is given to distribute these extensions, as long as these
  1237. X%  introductory messages are not removed, and no monies are exchanged.
  1238. X%
  1239. X%  No responsibility is taken for any errors on inaccuracies inherent
  1240. X%  either to the comments or the code of this program, but if reported
  1241. X%  to me, then an attempt will be made to fix them.
  1242. X
  1243. X/edef { exch def } def
  1244. X
  1245. X/PSDrawArea          % x y width height op => -
  1246. X{
  1247. X  5 dict begin
  1248. X    /Op edef
  1249. X    /Height edef
  1250. X    /Width edef
  1251. X    /Y edef
  1252. X    /Y CanvasHeight Y sub Height sub def
  1253. X    /X edef
  1254. X
  1255. X    Canvas setcanvas
  1256. X    newpath
  1257. X      X Y moveto
  1258. X      Width Height rect
  1259. X      Op [
  1260. X        GSET { 0 setgray }
  1261. X        GCLR { 1 setgray }
  1262. X      ] case
  1263. X    fill
  1264. X  end
  1265. X} def
  1266. X
  1267. X
  1268. X/PSDrawLine          % x1 y1 x2 y2 => -
  1269. X{
  1270. X  4 dict begin
  1271. X    /Y2 edef
  1272. X    /Y2 CanvasHeight Y2 sub def
  1273. X    /X2 edef
  1274. X    /Y1 edef
  1275. X    /Y1 CanvasHeight Y1 sub def
  1276. X    /X1 edef
  1277. X
  1278. X    Canvas setcanvas
  1279. X    0 setgray
  1280. X    X2 Y2 moveto X1 Y1 lineto stroke
  1281. X  end
  1282. X} def
  1283. X
  1284. X
  1285. X/PSDrawScanLine      % y => -
  1286. X{
  1287. X  /Y edef
  1288. X  /Y CanvasHeight Y sub 100 sub def
  1289. X
  1290. X  gsave
  1291. X    Canvas setcanvas
  1292. X    0 Y translate
  1293. X    512 1 scale
  1294. X    ScanLine imagecanvas
  1295. X  grestore
  1296. X} def
  1297. X
  1298. X
  1299. X/PSDrawText          % font x y text => -
  1300. X{
  1301. X  4 dict begin
  1302. X    /Text edef
  1303. X    /Y edef
  1304. X    /Y CanvasHeight Y sub def
  1305. X    /X edef
  1306. X    /Font edef
  1307. X
  1308. X    Canvas setcanvas
  1309. X    Font setfont
  1310. X    0 setgray
  1311. X    X Y moveto Text show
  1312. X  end
  1313. X} def
  1314. X
  1315. X
  1316. X/PSInitFonts         % - => -
  1317. X{
  1318. X  /NFont /Courier findfont 14 scalefont def
  1319. X  /BFont /Courier-Bold findfont 14 scalefont def
  1320. X} def
  1321. X
  1322. X
  1323. X/PSInitialise        % - => -
  1324. X{
  1325. X  /GCLR 0 def
  1326. X  /GSET 1 def
  1327. X  /KEYBOARD 100 def
  1328. X  /REPAINT  101 def
  1329. X  /BUSY_CUR 0 def
  1330. X  /NORMAL_CUR 1 def
  1331. X} def
  1332. X
  1333. X
  1334. X/PSIsColor           % - => iscolorscreen
  1335. X{
  1336. X  /Color? framebuffer /Color get def
  1337. X  Color? {1} {0} ifelse typedprint
  1338. X} def
  1339. X
  1340. X
  1341. X/PSLoadColor         % red green blue index => -
  1342. X{
  1343. X  4 dict begin
  1344. X    /ColorIndex edef
  1345. X    /BlueValue edef
  1346. X    /GreenValue edef
  1347. X    /RedValue edef
  1348. X
  1349. X    /CColor RedValue 255 div GreenValue 255 div BlueValue 255 div rgbcolor def
  1350. X    ColorTable ColorIndex CColor put
  1351. X  end
  1352. X} def
  1353. X
  1354. X
  1355. X/PSMakeColorTable    % size => -
  1356. X{
  1357. X  /TableSize edef
  1358. X 
  1359. X  /ColorTable TableSize array def
  1360. X} def
  1361. X
  1362. X
  1363. X/PSMakeItems         % wx wy width height ix iy iconic => -
  1364. X{
  1365. X  [ /IsIcon /IconY /IconX /FrameHeight /FrameWidth /FrameY /FrameX ]
  1366. X  { exch def } forall
  1367. X 
  1368. X  clippath pathbbox /ScreenHeight edef pop pop pop
  1369. X  /Frame framebuffer /new DefaultWindow send def
  1370. X  FrameX FrameY IconX IconY
  1371. X    {
  1372. X      [ /IconY /IconX /FrameY /FrameX ] { exch def } forall
  1373. X      /BorderTop 5 def
  1374. X      /BorderLeft 5 def
  1375. X      /BorderBottom 5 def
  1376. X      /BorderRight 5 def
  1377. X      /ControlSize 0 def
  1378. X      /PaintClient
  1379. X        {
  1380. X          REPAINT typedprint
  1381. X        } def
  1382. X      /PaintIcon
  1383. X        {
  1384. X          gsave
  1385. X            IconCanvas setcanvas
  1386. X            1 fillcanvas
  1387. X            clippath pathbbox
  1388. X            scale pop pop
  1389. X            0 setgray
  1390. X            true PopiIcon imagemaskcanvas
  1391. X          grestore
  1392. X        } def
  1393. X    } Frame send
  1394. X  FrameX
  1395. X  ScreenHeight FrameHeight sub FrameY sub
  1396. X  FrameWidth 10 add FrameHeight /reshape Frame send
  1397. X  /map Frame send
  1398. X
  1399. X  /Canvas Frame /ClientCanvas get def
  1400. X  Canvas
  1401. X      begin
  1402. X        /Transparent false def
  1403. X        /Mapped true def
  1404. X        /Retained true def
  1405. X      end
  1406. X  /CanvasHeight FrameHeight def
  1407. X
  1408. X  /KbdEvent
  1409. X    {
  1410. X      begin
  1411. X        Action /DownTransition eq
  1412. X          {
  1413. X            KEYBOARD typedprint Name typedprint
  1414. X          } if
  1415. X      end
  1416. X    } def
  1417. X 
  1418. X  /EventMgrKbdInterest
  1419. X    {
  1420. X      [3 1 roll] { MakeEventMgrKbdInterest} append cvx
  1421. X    } def
  1422. X 
  1423. X  /MakeEventMgrKbdInterest
  1424. X    {
  1425. X      addkbdinterests
  1426. X      { /ClientData 10 dict dup /CallBack 5 index put put } forall
  1427. X      pop
  1428. X    } def
  1429. X 
  1430. X  /EventMgr
  1431. X    [
  1432. X      { KbdEvent } Canvas EventMgrKbdInterest
  1433. X    ] forkeventmgr def
  1434. X} def
  1435. X
  1436. X
  1437. X/PSSetCursor         % type => -
  1438. X{
  1439. X  [
  1440. X    BUSY_CUR   { /hourg /hourg_m }
  1441. X    NORMAL_CUR { /ptr /ptr_m }
  1442. X  ] case
  1443. X  Canvas setstandardcursor
  1444. X} def
  1445. Funky_Stuff
  1446. chmod 0444 popi.ps || echo "restore of popi.ps fails"
  1447. set `wc -c popi.ps`;Sum=$1
  1448. if test "$Sum" != "4365"
  1449. then echo original size 4365, current size $Sum;fi
  1450. echo "x - extracting run.c (Text)"
  1451. sed 's/^X//' << 'Funky_Stuff' > run.c &&
  1452. X/*  @(#)run.c 1.9 89/12/11
  1453. X *
  1454. X *  Run time interpreter used by the popi program.
  1455. X *
  1456. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  1457. X *  This version is based on the code in his Prentice Hall book,
  1458. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  1459. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  1460. X *
  1461. X *  Permission is given to distribute these extensions, as long as these
  1462. X *  introductory messages are not removed, and no monies are exchanged.
  1463. X *
  1464. X *  No responsibility is taken for any errors or inaccuracies inherent
  1465. X *  either to the comments or the code of this program, but if reported
  1466. X *  (see README file) then an attempt will be made to fix them.
  1467. X */
  1468. X
  1469. X#include <ctype.h>
  1470. X#include "popi.h"
  1471. X#if    SEQPAR
  1472. X#include <parallel/microtask.h>
  1473. X#endif    /* SEQPAR */
  1474. X
  1475. X#define    STACKSIZE    128
  1476. X
  1477. X#define  dop(OP)  a = *--sp ; tp = sp-1 ; *tp = (*tp OP (stack_t) a)
  1478. X
  1479. X/* local function prototypes */
  1480. Xvoid    prun P((void));
  1481. X
  1482. Xvoid
  1483. XSwapOldNew()
  1484. X{
  1485. X    CUROLD = CURNEW;
  1486. X    CURNEW = 1 - CUROLD;
  1487. X}
  1488. X
  1489. Xstatic void
  1490. Xprun()
  1491. X{
  1492. X    long    *ParseEnd;    /* after end of parse string */
  1493. X    int        x,
  1494. X        y;              /* coordinates */
  1495. X    int        nrange = 0;    /* no. range errors */
  1496. X
  1497. X    ParseEnd = &parsed[prs];
  1498. X
  1499. X    if (Debug)
  1500. X    {
  1501. X    register long
  1502. X        *CurrParse;    /* pointer to current item in parse string */
  1503. X    FPRINTF(Debug, "Parse string\n");
  1504. X    for (CurrParse = parsed; CurrParse != ParseEnd; ++CurrParse)
  1505. X        FPRINTF(Debug, "'%c' (%ld)\n", (char) *CurrParse, *CurrParse);
  1506. X    FPRINTF(Debug, "---\n");
  1507. X    }
  1508. X
  1509. X    /*
  1510. X     * Warning: Microsoft Quick C generates incorrect code
  1511. X     * for the following loop when optimisation is turned on.
  1512. X     */
  1513. X#ifndef SEQPAR
  1514. X    for (y = 0; y < Ysize; ++y)
  1515. X#else    /* ! SEQPAR */
  1516. X    for (y = m_myid; y < Ysize; y += m_numprocs)
  1517. X#endif    /* ! SEQPAR */
  1518. X    {
  1519. X    short    *ap,        /* precalculated polar angles */
  1520. X        *rp;        /* precalculated polar radius */
  1521. X    register pixel_t
  1522. X        *p;        /* default destination */
  1523. X
  1524. X    ap = &avals[y * Xsize];
  1525. X    rp = &rvals[y * Xsize];
  1526. X
  1527. X    p = src[CURNEW].pix[y];
  1528. X
  1529. X    DEBUG((Debug, "y = %d\n", y));
  1530. X    for (x = 0; x < Xsize; ++x, ++p)
  1531. X    {
  1532. X        stack_t
  1533. X        Stack[STACKSIZE];    /* the stack */
  1534. X        register stack_t
  1535. X        *sp,        /* stack pointer (top of stack) */
  1536. X        *tp;            /* temp stack pointer */
  1537. X        stack_t
  1538. X        a,
  1539. X        b;
  1540. X        int
  1541. X        c;              /* scratch */
  1542. X        register pixel_t
  1543. X        *u;        /* explicit destination */
  1544. X        register long
  1545. X        *CurrParse;    /* pointer to current item in parse string */
  1546. X
  1547. X        for (CurrParse = parsed, sp = Stack; CurrParse != ParseEnd; ++CurrParse)
  1548. X        {
  1549. X            if (*CurrParse == VALUE)
  1550. X        {
  1551. X            *sp++ = (stack_t) *++CurrParse;
  1552. X            continue;
  1553. X        }
  1554. X            if (*CurrParse == '@')
  1555. X        {
  1556. X            --sp;
  1557. X            if (Truncate)
  1558. X            {
  1559. X            if (*sp > Zmax)
  1560. X                *sp = Zmax;
  1561. X            else if (*sp < 0)
  1562. X                *sp = 0;
  1563. X            }
  1564. X            *p = (pixel_t) *sp;
  1565. X            continue;
  1566. X        }
  1567. X            switch ((int) *CurrParse)
  1568. X        {
  1569. X            case '+':
  1570. X            dop(+);
  1571. X            break;
  1572. X            case '-':
  1573. X            dop(-);
  1574. X            break;
  1575. X            case '*':
  1576. X            dop(*);
  1577. X            break;
  1578. X            case '/':
  1579. X            a = *--sp;
  1580. X            tp = sp-1;
  1581. X            if (a == 0)
  1582. X                *tp = Zmax;
  1583. X            else
  1584. X                *tp = (*tp / (stack_t) a);
  1585. X            break;
  1586. X            case '%':
  1587. X            a = *--sp;
  1588. X            tp = sp-1;
  1589. X            if (a == 0)
  1590. X                *tp = 0;
  1591. X            else
  1592. X                *tp = (*tp % (stack_t) a);
  1593. X            break;
  1594. X            case '>':
  1595. X            dop(>);
  1596. X            break;
  1597. X            case '<':
  1598. X            dop(<);
  1599. X            break;
  1600. X            case GE:
  1601. X            dop(>=);
  1602. X            break;
  1603. X            case LE:
  1604. X            dop(<=);
  1605. X            break;
  1606. X            case EQ:
  1607. X            dop(==);
  1608. X            break;
  1609. X            case NE:
  1610. X            dop(!=);
  1611. X            break;
  1612. X            case AND:
  1613. X            dop(&&);
  1614. X            break;
  1615. X            case OR:
  1616. X            dop(||);
  1617. X            break;
  1618. X            case '^':
  1619. X            dop(^);
  1620. X            break;
  1621. X            case '|':
  1622. X            dop(|);
  1623. X            break;
  1624. X            case '&':
  1625. X            dop(&);
  1626. X            break;
  1627. X            case 'x':
  1628. X            *sp++ = (stack_t) x;
  1629. X            break;
  1630. X            case 'y':
  1631. X            *sp++ = (stack_t) y;
  1632. X            break;
  1633. X            case UMIN:
  1634. X            tp = sp-1;
  1635. X            *tp = -(*tp);
  1636. X            break;
  1637. X            case '!':
  1638. X            tp = sp-1;
  1639. X            *tp = !(*tp);
  1640. X            break;
  1641. X            case '=':
  1642. X            a = *--sp;
  1643. X            u = (pixel_t *) *--sp;
  1644. X            if (Truncate)
  1645. X            {
  1646. X                if (a > Zmax)
  1647. X                a = Zmax;
  1648. X                else if (a < 0)
  1649. X                a = 0;
  1650. X            }
  1651. X            *u = (pixel_t) a;
  1652. X            break;
  1653. X            case CRVAL:
  1654. X            a = *--sp;        /* y */
  1655. X            b = *--sp;        /* x */
  1656. X            tp = sp-1;
  1657. X            c = (int) *tp;
  1658. X            *tp = (stack_t) src[c].pix[a][b];
  1659. X            break;
  1660. X            case CLVAL:
  1661. X            a = *--sp;        /* y */
  1662. X            b = *--sp;        /* x */
  1663. X            tp = sp-1;
  1664. X            c = (int) *tp;
  1665. X            if
  1666. X            (
  1667. X                RangeCheck &&
  1668. X                (
  1669. X                a > Xsize - 1 || a < 0
  1670. X                ||
  1671. X                b > Ysize - 1 || b < 0
  1672. X                )
  1673. X            )
  1674. X            {
  1675. X                if (nrange++ == 0)
  1676. X                FPRINTF(stderr,
  1677. X                    "Range err at (%d,%d) => %s[%d, %d]\n",
  1678. X                    x, y, src[c].str, b, a);
  1679. X            }
  1680. X            if (a >= Ysize)
  1681. X                a = Ysize - 1;
  1682. X            if (a < 0)
  1683. X                a = 0;
  1684. X            if (b >= Xsize)
  1685. X                b = Xsize - 1;
  1686. X            if (b < 0)
  1687. X                b = 0;
  1688. X            *tp = (stack_t) &(src[c].pix[a][b]);
  1689. X            break;
  1690. X            case PRVAL:
  1691. X            {
  1692. X                int        xval,
  1693. X                    yval;
  1694. X
  1695. X                a = *--sp;        /* angle */
  1696. X                b = *--sp;        /* radius */
  1697. X
  1698. X                xval = (int) (b * cos((double) DtoR(a)) + Xsize / 2.0);
  1699. X                yval = (int) (- b * sin((double) DtoR(a)) + Ysize / 2.0);
  1700. X
  1701. X                tp = sp - 1;
  1702. X                c = (int) *tp;
  1703. X
  1704. X                if (RangeCheck &&
  1705. X                (xval < 0 || xval >= Xsize ||
  1706. X                yval < 0 || yval >= Ysize))
  1707. X                {
  1708. X                if (nrange++ == 0)
  1709. X                    FPRINTF(stderr,
  1710. X                    "Range err at (%d,%d) => %s{%d,%d} [%d,%d]\n",
  1711. X                    x, y, src[c].str, b, a, xval, yval);
  1712. X                }
  1713. X
  1714. X                if (xval < 0)
  1715. X                xval = 0;
  1716. X                if (xval >= Xsize)
  1717. X                xval = Xsize - 1;
  1718. X                if (yval < 0)
  1719. X                yval = 0;
  1720. X                if (yval >= Ysize)
  1721. X                yval = Ysize - 1;
  1722. X
  1723. X                *tp = (stack_t) src[c].pix[yval][xval];
  1724. X            }
  1725. X            break;
  1726. X
  1727. X            case PLVAL:
  1728. X            {
  1729. X                int        xval,
  1730. X                    yval;
  1731. X
  1732. X                a = *--sp;        /* angle */
  1733. X                b = *--sp;        /* radius */
  1734. X
  1735. X                xval = (int) (b * cos((double) DtoR(a)) + Xsize / 2.0);
  1736. X                yval = (int) (- b * sin((double) DtoR(a)) + Ysize / 2.0);
  1737. X
  1738. X                tp = sp - 1;
  1739. X                c = (int) *tp;
  1740. X
  1741. X                if (RangeCheck &&
  1742. X                (xval < 0 || xval >= Xsize ||
  1743. X                yval < 0 || yval >= Ysize))
  1744. X                {
  1745. X                if (nrange++ == 0)
  1746. X                    FPRINTF(stderr,
  1747. X                    "Range err at (%d,%d) => %s{%d,%d} [%d,%d]\n",
  1748. X                    x, y, src[c].str, b, a, xval, yval);
  1749. X                }
  1750. X
  1751. X                if (xval < 0)
  1752. X                xval = 0;
  1753. X                if (xval >= Xsize)
  1754. X                xval = Xsize - 1;
  1755. X                if (yval < 0)
  1756. X                yval = 0;
  1757. X                if (yval >= Ysize)
  1758. X                yval = Ysize - 1;
  1759. X
  1760. X                *tp = (stack_t) &(src[c].pix[yval][xval]);
  1761. X            }
  1762. X            break;
  1763. X
  1764. X            case POW:
  1765. X            a = *--sp;    /* exponent */
  1766. X            tp = sp-1;
  1767. X            *tp = (stack_t) pow((double) *tp, (double) a);
  1768. X            break;
  1769. X            case 'a':
  1770. X#if    NOMEM
  1771. X            *sp++ = (stack_t)
  1772. X                RtoD(atan2((double) y, (double) x)) + 0.5;
  1773. X#else    /* !NOMEM */
  1774. X            *sp++ = (stack_t) *ap;
  1775. X#endif    /* !NOMEM */
  1776. X            break;
  1777. X            case 'r':
  1778. X            *sp++ = (stack_t) *rp;
  1779. X            break;
  1780. X            case SIN:
  1781. X            tp = sp-1;
  1782. X            *tp = (stack_t) (sin((double) DtoR(*tp)) * (double)Zmax);
  1783. X            break;
  1784. X            case COS:
  1785. X            tp = sp-1;
  1786. X            *tp = (stack_t) (cos((double) DtoR(*tp)) * (double)Zmax);
  1787. X            break;
  1788. X            case ATAN:
  1789. X            a = *--sp;
  1790. X            tp = sp-1;
  1791. X            *tp = (stack_t) RtoD(atan2((double) *tp, (double) a));
  1792. X            break;
  1793. X            case HYPOT:
  1794. X            a = *--sp;
  1795. X            tp = sp - 1;
  1796. X            *tp = (stack_t) hypot((double) *tp, (double) a);
  1797. X            break;
  1798. X            case ABS:
  1799. X            tp = sp-1;
  1800. X            *tp = *tp < 0 ? - *tp : *tp;
  1801. X            break;
  1802. X            case LOG:
  1803. X            tp = sp-1;
  1804. X            *tp = (stack_t) log((double) *tp);
  1805. X            break;
  1806. X            case SQRT:
  1807. X            tp = sp-1;
  1808. X            *tp = (stack_t) sqrt((double) *tp);
  1809. X            break;
  1810. X            case RAND:
  1811. X#if 0
  1812. X            tp = sp -1;
  1813. X            *tp = (stack_t) RANDOM % *tp;
  1814. X#else
  1815. X            *sp++ = (stack_t) RANDOM;
  1816. X#endif
  1817. X            break;
  1818. X            case LSHIFT:
  1819. X            dop(<<);
  1820. X            break;
  1821. X            case RSHIFT:
  1822. X            dop(>>);
  1823. X            break;
  1824. X            case '?':
  1825. X            a = *--sp;
  1826. X            CurrParse++;
  1827. X            if (!a)
  1828. X                CurrParse = &parsed[*CurrParse];
  1829. X            break;
  1830. X            case ':':
  1831. X            CurrParse = &parsed[CurrParse[1]];
  1832. X            break;
  1833. X
  1834. X            default:
  1835. X            if (*CurrParse < 127 && isprint(*CurrParse))
  1836. X                SPRINTF(ErrBuf, "run: unknown operator '%c' (%d)",
  1837. X                *CurrParse, *CurrParse);
  1838. X            else
  1839. X                SPRINTF(ErrBuf, "run: unknown operator %d", *CurrParse);
  1840. X            error(ERR_SNARK);
  1841. X            return;
  1842. X        }
  1843. X        }
  1844. X        ++ap;
  1845. Funky_Stuff
  1846. echo "End of part 3"
  1847. echo "File run.c is continued in part 4"
  1848. echo "4" > s2_seq_.tmp
  1849. exit 0
  1850.  
  1851.