home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume9 / popi / part05 < prev    next >
Internet Message Format  |  1991-03-08  |  48KB
  1. From: richb@sunaus.sun.oz.AU (Rich Burridge)
  2. Newsgroups: comp.sources.misc
  3. Subject: v09i051: popi, The Digital Darkroom, Part05/09
  4. Message-ID: <2785@basser.oz>
  5. Date: 12 Dec 89 23:47:32 GMT
  6. Approved: john@cs.su.oz.AU (John Mackin - comp.sources.misc)
  7.  
  8. Posting-number: Volume 9, Issue 51
  9. Submitted-by: Rich Burridge <richb@sunaus.sun.oz.AU>
  10. Archive-name: popi/part05
  11.  
  12. ---- Cut Here and unpack ----
  13. #!/bin/sh
  14. # this is part 5 of a multipart archive
  15. # do not concatenate these parts, unpack them in order with /bin/sh
  16. # file special.c continued
  17. #
  18. CurArch=5
  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 special.c"
  29. sed 's/^X//' << 'Funky_Stuff' >> special.c
  30. X    { "write",        writeimg },
  31. X    { "genps",        genps },
  32. X    { "genepson",    genepson },
  33. X    { "list",        list },
  34. X    { "display",    displayimg },
  35. X    { "debug",        debug },
  36. X    { "version",    version },
  37. X    { "verbose",    verbose },
  38. X    { "truncate",    trunc },
  39. X    { "undo",        undo },
  40. X    { "help",        help },
  41. X    { "free",        freeimg },
  42. X    { "logfile",    dolog },
  43. X    { (char *) 0,    (void (*) P((void)) ) 0 }
  44. X};
  45. X
  46. Xvoid
  47. Xspecial()
  48. X{
  49. X    struct SpecialOp    *sp;
  50. X
  51. X    DEBUG((Debug, "special\n"));
  52. X    lex();
  53. X    if (! (lat == NAME || isalpha(lat)))
  54. X    {
  55. X    SPRINTF(ErrBuf, "Expected name of special operation");
  56. X    error(ERR_PARSE);
  57. X    return;
  58. X    }
  59. X
  60. X    sp = SpecialOps;
  61. X    for (sp = SpecialOps; sp->name && strcmp(text, sp->name) != 0; ++sp)
  62. X        ;
  63. X
  64. X    if (! sp->name)
  65. X    {
  66. X    SPRINTF(ErrBuf,
  67. X        "Special operation '%s' unrecognised",
  68. X        text);
  69. X    error(ERR_PARSE);
  70. X    return;
  71. X    }
  72. X
  73. X    DEBUG((Debug, "calling func '%s'\n", sp->name));
  74. X    (*(sp->func))();
  75. X
  76. X    if (lat != '\n')
  77. X    lex();
  78. X
  79. X    if (lat != '\n')
  80. X    {
  81. X    SPRINTF(ErrBuf, "Tokens after special command ignored");
  82. X    error(ERR_WARN);
  83. X    }
  84. X
  85. X    assert(lat == '\n');
  86. X}
  87. Funky_Stuff
  88. echo "File special.c is complete"
  89. chmod 0444 special.c || echo "restore of special.c fails"
  90. set `wc -c special.c`;Sum=$1
  91. if test "$Sum" != "18870"
  92. then echo original size 18870, current size $Sum;fi
  93. echo "x - extracting graphics.c (Text)"
  94. sed 's/^X//' << 'Funky_Stuff' > graphics.c &&
  95. X
  96. X/*  @(#)graphics.c 1.10 89/12/11
  97. X *
  98. X *  Independent graphics routines associated with the popi program.
  99. X *
  100. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  101. X *  This version is based on the code in his Prentice Hall book,
  102. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  103. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  104. X *
  105. X *  Permission is given to distribute these extensions, as long as these
  106. X *  introductory messages are not removed, and no monies are exchanged.
  107. X *
  108. X *  No responsibility is taken for any errors or inaccuracies inherent
  109. X *  either to the comments or the code of this program, but if reported
  110. X *  (see README file) then an attempt will be made to fix them.
  111. X */
  112. X
  113. X#include "popi.h"
  114. X#include "graphics.h"
  115. X
  116. X#define  RES  8
  117. X
  118. Xchar nextline[MAXLINE] ;          /* Next input line to be parsed. */
  119. X
  120. Xunsigned char *mptr ;     /* Pointer to scanline data. */
  121. X
  122. Xint errpos = -1 ;         /* Character position error occured at. */
  123. Xint iscolor ;             /* Set if this is a color screen. */
  124. Xint ix = 0 ;              /* Initial X position of the icon. */
  125. Xint iy = 0 ;              /* Initial Y position of the icon. */
  126. Xint nfont_width ;         /* Width of normal font characters. */
  127. Xint ops[MAXOPS] ;         /* Rasterop functions. */
  128. Xint posspec = 0 ;         /* Set if -g option is present (for X11) */
  129. Xint started = 0 ;         /* Set if we've drawn the percent dialog box. */
  130. Xint tptr = 0 ;            /* Input buffer pointer. */
  131. Xint wx = 0 ;              /* Initial X position of the open window. */
  132. Xint wy = 0 ;              /* Initial Y position of the open window. */
  133. X
  134. Xint thresh[RES][RES] = {        /* Array containing threshold values. */
  135. X  {   0, 128,  32, 160,   8, 136,  40, 168, },
  136. X  { 192,  64, 224,  96, 200,  72, 232, 104, },
  137. X  {  48, 176,  16, 144,  56, 184,  24, 152, },
  138. X  { 240, 112, 208,  80, 248, 120, 216,  88, },
  139. X  {  12, 140,  44, 172,   4, 132,  36, 164, },
  140. X  { 204,  76, 236, 108, 196,  68, 228, 100, },
  141. X  {  60, 188,  28, 156,  52, 180,  20, 148, },
  142. X  { 252, 124, 220,  92, 244, 116, 212,  84, },
  143. X} ;
  144. X
  145. Xextern int  errno ;
  146. Xextern char *sys_errlist[] ;
  147. X
  148. X
  149. X/*  There are ten exportable routines used by the popi program.
  150. X *
  151. X *  These are:
  152. X *
  153. X *  disp_init(argc, argv)    - called from main at the start.
  154. X *  disp_finish()            - called from main prior to exit.
  155. X *  disp_imgstart()          - called prior to drawing an image.
  156. X *  disp_imgend()            - called after drawing an image.
  157. X *  disp_putline(line, y)    - to draw an image scanline.
  158. X *  disp_getchar()           - to get the next character typed.
  159. X *  disp_ungetc(c)           - put back the last character typed.
  160. X *  disp_prompt()            - display popi prompt and clear input buffer.
  161. X *  disp_error(errtype, pos) - display error message.
  162. X *  disp_percentdone(n)      - display percentage value of conversion.
  163. X */
  164. X
  165. X
  166. Xvoid
  167. Xdisp_init(argc, argv)        /* Called from main at the start. */
  168. Xint argc ;
  169. Xchar *argv[] ;
  170. X{
  171. X  if (init_ws_type())        /* Determine window system type. */
  172. X    {
  173. X      FPRINTF(stderr, "Error initialising window system.\n") ;
  174. X      exit(1) ;
  175. X    }
  176. X  init_fonts() ;             /* Open required fonts. */
  177. X  make_items(argc, argv) ;   /* Create icon, frame, canvas etc.. */
  178. X  paint_canvas() ;           /* Draw dialog boxes. */
  179. X  start_tool() ;
  180. X}
  181. X
  182. X
  183. Xvoid
  184. Xdisp_finish()                /* Called from main prior to exit. */
  185. X{
  186. X  cleanup() ;
  187. X}
  188. X
  189. X
  190. Xvoid
  191. Xdisp_imgstart()              /* Called prior to drawing an image. */
  192. X{
  193. X}
  194. X
  195. X
  196. Xvoid
  197. Xdisp_imgend()                /* Called after drawing an image. */
  198. X{
  199. X}
  200. X
  201. X
  202. Xvoid
  203. Xdisp_putline(line, y)        /* Draw an image scanline. */
  204. Xunsigned char *line ;
  205. Xint y ;
  206. X{
  207. X  draw_scanline(line, y) ;
  208. X}
  209. X
  210. X
  211. Xdisp_getchar()       /* Get next user typed character. */
  212. X{
  213. X  char c ;
  214. X  int finished = 0 ;
  215. X 
  216. X  if (tptr >= strlen(nextline))
  217. X    {
  218. X      while (!finished)
  219. X        {
  220. X          get_next_char(&c) ;              /* Get next character typed. */
  221. X          if (c == '\0') continue ;
  222. X          if (errpos != -1)
  223. X            {
  224. X              drawarea(BOXX+100+errpos*nfont_width, BOXY+BOXH-9,
  225. X                       nfont_width, 4, GCLR) ;
  226. X              drawarea(BOXX+91, BOXY+51, BOXW-102, BOXH-22, GCLR) ;
  227. X              errpos = -1 ;
  228. X            }
  229. X          if (c == BACKSPACE || c == DEL)
  230. X            nextline[strlen(nextline)-1] = '\0' ;
  231. X          else if (c == RETURN || c == LINEFEED)
  232. X            {
  233. X              set_cursor(BUSY_CUR) ;       /* We will now get busy! */
  234. X              c = '\n' ;
  235. X              STRNCAT(nextline, &c, 1) ;
  236. X              finished = 1 ;
  237. X            }
  238. X          else if (c >= 32) STRNCAT(nextline, &c, 1) ;
  239. X          drawarea(BOXX+91, BOXY+11, BOXW-102, BOXH-22, GCLR) ;
  240. X          put_text(BOXX, BOXY, BOXW, BOXH, nextline, 1) ;
  241. X        }
  242. X      tptr = 0 ;
  243. X    }    
  244. X  return(nextline[tptr++]) ;
  245. X}
  246. X
  247. X
  248. X/*ARGSUSED*/
  249. Xvoid
  250. Xdisp_ungetc(c)       /* Put back the last character typed. */
  251. Xchar c ;
  252. X{
  253. X  tptr-- ;
  254. X}
  255. X
  256. X
  257. Xdisp_prompt()        /* Display popi prompt and clear input line. */
  258. X{
  259. X  set_cursor(NORMAL_CUR) ;
  260. X  if (errpos == -1) drawarea(BOXX+91, BOXY+11, BOXW-102, BOXH-22, GCLR) ;
  261. X  STRCPY(nextline, "") ;
  262. X  tptr = 0 ;
  263. X  return 0 ;
  264. X}
  265. X
  266. X
  267. Xvoid
  268. Xdisp_error(errtype, pos)    /* Display error message. */
  269. Xint errtype ;
  270. Xint pos ;
  271. X{
  272. X  errpos = pos ;
  273. X  if (errtype & ERR_PARSE)
  274. X    drawarea(BOXX+100+errpos*nfont_width, BOXY+BOXH-9,
  275. X             nfont_width, 4, GSET) ;
  276. X
  277. X  put_text(BOXX, BOXY+40, BOXW, BOXH, ErrBuf, 0) ;
  278. X
  279. X/*  We assume errno hasn't been reset by the preceding output */
  280. X
  281. X  if (errtype & ERR_SYS)
  282. X    {
  283. X      sleep(2) ;
  284. X      SPRINTF(ErrBuf, "\t(%s)\n", sys_errlist[errno]) ;
  285. X      drawarea(BOXX+91, BOXY+51, BOXW-102, BOXH-22, GCLR) ;
  286. X      put_text(BOXX, BOXY+40, BOXW, BOXH, ErrBuf, 0) ;
  287. X    }
  288. X}
  289. X
  290. X/* These are other independent graphics routines used by popi. */
  291. X
  292. Xdraw_frame(x, y, width, height)
  293. Xint x, y, width, height ;
  294. X{
  295. X  drawarea(x,   y,   width,    height,    GSET) ;
  296. X  drawarea(x+1, y+1, width-2,  height-2,  GCLR) ;
  297. X  drawarea(x+3, y+3, width-6,  height-6,  GSET) ;
  298. X  drawarea(x+5, y+5, width-10, height-10, GCLR) ;
  299. X}
  300. X
  301. X
  302. X/*  Display a text box of given width and height with top left corner at
  303. X *  the given x,y location, displaying a title and the given text value.
  304. X */
  305. X
  306. Xdraw_textbox(x, y, w, h, title, str, showcur)
  307. Xint x, y, w, h, showcur ;
  308. Xchar *title, *str ;
  309. X{
  310. X  draw_frame(x, y, w, h) ;
  311. X  drawtext(x+10, y+h-15, BFONT, title) ;
  312. X  draw_rect(x+90, y+10, x+w-10, y+h-10) ;
  313. X  put_text(x, y, w, h, str, showcur) ;
  314. X}
  315. X
  316. X
  317. Xdraw_rect(x1, y1, x2, y2)
  318. Xint x1, y1, x2, y2 ;
  319. X{
  320. X  drawline(x1, y1, x2, y1) ;
  321. X  drawline(x1, y1, x1, y2) ;
  322. X  drawline(x2, y1, x2, y2) ;
  323. X  drawline(x1, y2, x2, y2) ;
  324. X}
  325. X
  326. X
  327. Xhalftone(line, y)                   /* Halftone 8bit scanline image. */
  328. Xunsigned char *line ;
  329. Xint y ;
  330. X{
  331. X  int x ;
  332. X
  333. X  for (x = 0; x < Xsize; x++)
  334. X    if (line[x] < thresh[y % RES][x % RES])
  335. X      mptr[x / 8] |= (1 << (7 - (x % 8))) ;        /* Set pixel black. */
  336. X    else mptr[x / 8] &= ~(1 << (7 - (x % 8))) ;    /* Set pixel white. */
  337. X}
  338. X
  339. X
  340. X/*  Paint the contents of the popi canvas. This consists of first clearing
  341. X *  the whole canvas, then drawing a line to distinguish between the image
  342. X *  drawing area and the command feedback area. Two text boxes are then
  343. X *  drawn, one for user input and the other to shown any error messages.
  344. X */
  345. X
  346. Xpaint_canvas()
  347. X{
  348. X  drawarea(0, 0, TWIDTH, THEIGHT, GCLR) ;
  349. X  drawline(0, 99, TWIDTH, 99) ;
  350. X  draw_textbox(BOXX, BOXY, BOXW, BOXH, "Command:", nextline, 1) ;
  351. X  draw_textbox(BOXX, BOXY+40, BOXW, BOXH, "Error:", "", 0) ;
  352. X}
  353. X
  354. X
  355. X/*  With the screen based window systems, display the character string
  356. X *  str at the given x,y location. The width of the dialog box is given,
  357. X *  so that if the text exceeds the displayable area, it is scrolled to
  358. X *  the left. A soft cursor in the form of a vertical line is shown if
  359. X *  so requested.
  360. X */
  361. X
  362. Xput_text(x, y, w, h, str, showcur)
  363. Xint x, y, w, h ;
  364. Xchar *str ;
  365. X{
  366. X  char dummy[MAXLINE] ;
  367. X  int limit, nochars ;
  368. X
  369. X  limit = ((w - 100) / nfont_width) - 1 ;
  370. X  nochars = (strlen(str) <= limit) ? strlen(str) : limit ;
  371. X  STRNCPY(dummy, &str[strlen(str) - nochars], nochars) ;
  372. X
  373. X  dummy[nochars] = '\0' ;
  374. X  drawtext(x+100, y+h-17, NFONT, dummy) ;
  375. X  if (showcur)
  376. X    drawline(x+100+strlen(dummy)*nfont_width, y+15,
  377. X             x+100+strlen(dummy)*nfont_width, y+h-15) ;
  378. X}
  379. X
  380. X
  381. X/*  Show the percentage of the image converted as a graphical slider using
  382. X *  the error dialog box. If the percentage is zero, then we are just starting,
  383. X *  so the box is relabeled (to % done:). If the percentage is 100, then we
  384. X *  are just finishing, and the box is relabel back (to Error:), and cleared.
  385. X *  Otherwise we show an intermediate percentage value.
  386. X */
  387. X
  388. Xvoid
  389. Xdisp_percentdone(percent)
  390. Xint percent ;
  391. X{
  392. X  if (!percent)
  393. X    {
  394. X      if (!started)
  395. X        draw_textbox(BOXX, BOXY+40, BOXW, BOXH, "% done:", "", 0) ;
  396. X      started = 1 ;
  397. X    }
  398. X  else if (percent == 100)
  399. X    {
  400. X      if (started)
  401. X        draw_textbox(BOXX, BOXY+40, BOXW, BOXH, "Error:", "", 0) ;
  402. X      started = 0 ;
  403. X    }
  404. X  else
  405. X    drawarea(BOXX+91, BOXY+51,
  406. X             (int) ((double) (BOXW-102) / 100 * percent), BOXH-20, GSET) ;
  407. X}
  408. Funky_Stuff
  409. chmod 0444 graphics.c || echo "restore of graphics.c fails"
  410. set `wc -c graphics.c`;Sum=$1
  411. if test "$Sum" != "9099"
  412. then echo original size 9099, current size $Sum;fi
  413. echo "x - extracting lex.c (Text)"
  414. sed 's/^X//' << 'Funky_Stuff' > lex.c &&
  415. X/*  @(#)lex.c 1.9 89/12/11
  416. X *
  417. X *  Lexical routines used by the popi program.
  418. X *
  419. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  420. X *  This version is based on the code in his Prentice Hall book,
  421. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  422. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  423. X *
  424. X *  Permission is given to distribute these extensions, as long as these
  425. X *  introductory messages are not removed, and no monies are exchanged.
  426. X *
  427. X *  No responsibility is taken for any errors or inaccuracies inherent
  428. X *  either to the comments or the code of this program, but if reported
  429. X *  (see README file) then an attempt will be made to fix them.
  430. X */
  431. X
  432. X#include <stdio.h>
  433. X#include <ctype.h>
  434. X#include <math.h>
  435. X#include "popi.h"
  436. X
  437. X/* prototypes for local functions */
  438. Xint    Getch P((void));
  439. Xint    getnumber P((int));
  440. Xint    getstring P((int));
  441. Xint    follow P((int, int, int));
  442. X
  443. Xint    CharPos = 0,    /* Current character pos on input line */
  444. X    OldPos = 0,    /* previous character pos on input line */
  445. X    TokPos = 0;    /* position of the beginning of the current token */
  446. Xchar    ErrBuf[256];
  447. Xdouble    lexfract;
  448. Xdouble    hypot();
  449. X
  450. Xstatic int
  451. XGetch()
  452. X{
  453. X    int    c;
  454. X
  455. X    c = disp_getchar();
  456. X
  457. X    OldPos = CharPos;
  458. X
  459. X    if (c == '\t')
  460. X    CharPos = (CharPos - 1) % 8 + 8;
  461. X    else if (c == '\n')
  462. X    CharPos = 0;
  463. X    else
  464. X    ++CharPos;
  465. X
  466. X    DEBUG((Debug, "Getch() => '%c'\n", c));
  467. X
  468. X    if (LogStr)
  469. X    PUTC(c, LogStr);
  470. X
  471. X    return c;
  472. X}
  473. X
  474. X/* Skip to the end of the line */
  475. Xvoid
  476. XSkip()
  477. X{
  478. X    while (lat != '\n' && lat != EOF)
  479. X    lat = Getch();
  480. X    lat = '\n';
  481. X}
  482. X
  483. Xvoid
  484. Xerror(errtype)
  485. Xint    errtype;
  486. X{
  487. X    DEBUG((Debug, "error: type %d, pos %d msg '%s'\n", errtype, TokPos, ErrBuf));
  488. X    if (!noerr)            /* Already printed a message */
  489. X    return;
  490. X    disp_error(errtype, TokPos);
  491. X    Skip();
  492. X    noerr = FALSE;        /* an error has occurred */
  493. X
  494. X    if (LogStr)
  495. X    FPRINTF(LogStr, "Error: %s\n", ErrBuf);
  496. X}
  497. X
  498. Xstatic int
  499. Xgetnumber(first)
  500. Xint first;
  501. X{
  502. X    int c;
  503. X
  504. X    lexval = first - '0';
  505. X    lexfract = 0.0;
  506. X    while (isdigit(c = Getch()))
  507. X    lexval = 10 * lexval + c - '0';
  508. X
  509. X    /* Some of the special routines use floating values */
  510. X    if (c == '.')
  511. X    {
  512. X    double div = 10.0;
  513. X
  514. X    while (isdigit(c = Getch()))
  515. X    {
  516. X        lexfract += (c - '0') / div;
  517. X        div *= 10.0;
  518. X    }
  519. X    }
  520. X    pushback(c);
  521. X    return VALUE;
  522. X}
  523. X
  524. Xstatic int
  525. Xgetstring(first)
  526. Xint first;
  527. X{
  528. X    int        c = first;
  529. X    char    *str = text;
  530. X
  531. X    do
  532. X    {
  533. X        *str++ = (char) c;
  534. X        c = Getch();
  535. X    }
  536. X    while (isalpha(c) || c == '_' || isdigit(c));
  537. X    *str = '\0';
  538. X    pushback(c);
  539. X
  540. X    if (strcmp(text, "new") == 0)        return NEW;
  541. X    else if (strcmp(text, "sin") == 0)        return SIN;
  542. X    else if (strcmp(text, "cos") == 0)        return COS;
  543. X    else if (strcmp(text, "atan") == 0)        return ATAN;
  544. X    else if (strcmp(text, "hypot") == 0)    return HYPOT;
  545. X    else if (strcmp(text, "abs") == 0)        return ABS;
  546. X    else if (strcmp(text, "log") == 0)        return LOG;
  547. X    else if (strcmp(text, "sqrt") == 0)        return SQRT;
  548. X    else if (strcmp(text, "rand") == 0)        return RAND;
  549. X
  550. X    for (c = 0; c < nsrc; c++)
  551. X    if (src[c].str && strcmp(src[c].str, text) == 0)
  552. X    {
  553. X        lexval = c - 1;
  554. X        return INAME;
  555. X    }
  556. X
  557. X    if (strlen(text) > 1)
  558. X    return NAME;
  559. X    return first;
  560. X}
  561. X
  562. Xstatic int
  563. Xfollow(tok, ifyes, ifno)
  564. Xint tok, ifyes, ifno;
  565. X{
  566. X    int c;
  567. X
  568. X    if ((c = Getch()) == tok)
  569. X    return ifyes;
  570. X    pushback(c);
  571. X    return ifno;
  572. X}
  573. X
  574. X/*
  575. X *    Set the global lookahead token "lat".
  576. X */
  577. Xvoid
  578. Xlex()
  579. X{
  580. X    DEBUG((Debug, "lex():\n"));
  581. X
  582. X    do        /* ignore white space */
  583. X    lat = Getch();
  584. X    while (lat == ' ' || lat == '\t');
  585. X
  586. X    TokPos = CharPos;
  587. X
  588. X    if (isdigit(lat))
  589. X    lat = getnumber(lat);
  590. X    else if (isalpha(lat) || lat == '_')
  591. X    lat = getstring(lat);
  592. X
  593. X    switch (lat)
  594. X    {
  595. X    case EOF:
  596. X        lat = 'q';
  597. X        break;
  598. X
  599. X    case '*':
  600. X        lat = follow('*', POW, lat);
  601. X        break;
  602. X
  603. X        case '>':
  604. X        lat = follow('=', GE, lat);
  605. X            lat = follow('>', RSHIFT, lat);
  606. X            break;
  607. X
  608. X        case '<':
  609. X        lat = follow('=', LE, lat);
  610. X            lat = follow('<', LSHIFT, lat);
  611. X            break;
  612. X
  613. X        case '!':
  614. X            lat = follow('=', NE, lat);
  615. X            break;
  616. X
  617. X        case '=':
  618. X        lat = follow('=', EQ, lat);
  619. X            break;
  620. X
  621. X        case '|':
  622. X        lat = follow('|', OR, lat);
  623. X            break;
  624. X
  625. X        case '&':
  626. X        lat = follow('&', AND, lat);
  627. X            break;
  628. X
  629. X        case 'Z':
  630. X        lat = VALUE;
  631. X            lexval = Zmax;
  632. X            break;
  633. X
  634. X        case 'Y':
  635. X        lat = VALUE;
  636. X            lexval = Ysize - 1;
  637. X            break;
  638. X
  639. X        case 'X':
  640. X        lat = VALUE;
  641. X            lexval = Xsize - 1;
  642. X            break;
  643. X
  644. X        case 'R':
  645. X        lat = VALUE;
  646. X            lexval = (int) hypot(Xsize / 2.0, Ysize / 2.0);
  647. X            break;
  648. X
  649. X        case 'A':
  650. X        lat = VALUE;
  651. X            lexval = 360;
  652. X            break;
  653. X
  654. X    case '"':
  655. X        {
  656. X        char    *str;
  657. X            
  658. X        str = text;
  659. X        while ((lat = Getch()) != EOF && lat != '\n' && lat != '"')
  660. X            *str++ = (char) lat;
  661. X        *str = '\0';
  662. X        if (lat != '"')
  663. X        {
  664. X            SPRINTF(ErrBuf, "Expected matching '\"'");
  665. X            error(ERR_PARSE);
  666. X            return;
  667. X        }
  668. X        }
  669. X        lat = FNAME;
  670. X        break;
  671. X
  672. X    case ';':    /* comment to end of line */
  673. X        Skip();
  674. X        lat = '\n';
  675. X        break;
  676. X
  677. X        default:
  678. X        break;
  679. X    }
  680. X
  681. X    if (Debug)
  682. X    {
  683. X    if (lat < 127 && isprint(lat))
  684. X        DEBUG((Debug, "lex() => '%c' (%d)\n", lat, lat));
  685. X    else
  686. X        DEBUG((Debug, "lex() => (%d)\n", lat));
  687. X    }
  688. X}
  689. X
  690. Xvoid
  691. Xpushback(c)
  692. Xint c;
  693. X{
  694. X    DEBUG((Debug, "pushback('%c')\n", c));
  695. X    disp_ungetc(c);
  696. X    CharPos = OldPos;
  697. X}
  698. Funky_Stuff
  699. chmod 0444 lex.c || echo "restore of lex.c fails"
  700. set `wc -c lex.c`;Sum=$1
  701. if test "$Sum" != "5493"
  702. then echo original size 5493, current size $Sum;fi
  703. echo "x - extracting sunview.c (Text)"
  704. sed 's/^X//' << 'Funky_Stuff' > sunview.c &&
  705. X/*LINTLIBRARY*/
  706. X
  707. X/*  @(#)sunview.c 1.10 89/12/11
  708. X *
  709. X *  SunView dependent graphics routines used by popi.
  710. X *  written by Rich Burridge - Sun Microsystems.
  711. X *
  712. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  713. X *  This version is based on the code in his Prentice Hall book,
  714. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  715. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  716. X *
  717. X *  Permission is given to distribute these extensions, as long as these
  718. X *  introductory messages are not removed, and no monies are exchanged.
  719. X *
  720. X *  No responsibility is taken for any errors or inaccuracies inherent
  721. X *  either to the comments or the code of this program, but if reported
  722. X *  (see README file) then an attempt will be made to fix them.
  723. X */
  724. X
  725. X#include "popi.h"
  726. X#include "graphics.h"
  727. X#include <suntool/sunview.h>
  728. X#include <suntool/canvas.h>
  729. X
  730. X#define  ICON_SET                       (void) icon_set
  731. X#define  NOTIFY_DISPATCH                (void) notify_dispatch
  732. X#define  NOTIFY_DO_DISPATCH             (void) notify_do_dispatch
  733. X#define  NOTIFY_INTERPOSE_DESTROY_FUNC  (void) notify_interpose_destroy_func
  734. X#define  PR_GETCOLORMAP                 (void) pr_getcolormap
  735. X#define  PW_PUTCOLORMAP                 (void) pw_putcolormap
  736. X#define  PW_ROP                         (void) pw_rop
  737. X#define  PW_SETCMSNAME                  (void) pw_setcmsname
  738. X#define  PW_TEXT                        (void) pw_text
  739. X#define  PW_VECTOR                      (void) pw_vector
  740. X#define  PW_WRITEBACKGROUND             (void) pw_writebackground
  741. X#define  WINDOW_DONE                    (void) window_done
  742. X#define  WINDOW_SET                     (void) window_set
  743. X
  744. X#define  BOLD_FONT      "/usr/lib/fonts/fixedwidthfonts/screen.b.14"
  745. X#define  NORMAL_FONT    "/usr/lib/fonts/fixedwidthfonts/screen.r.14"
  746. X
  747. XCanvas canvas ;
  748. XCursor busy_cursor, main_cursor ;
  749. XEvent event ;
  750. XFrame frame ;
  751. XIcon popi_icon ;
  752. XNotify_value destroy_proc() ;
  753. XPixfont *font, *nfont, *bfont ;
  754. XPixrect *pr ;                       /* Offscreen image area. */
  755. XPixwin *cpw ;
  756. X
  757. Xshort busy_cursor_array[] = {
  758. X#include <images/hglass.cursor>
  759. X} ;
  760. Xmpr_static(busy_cursor_pr, 16, 16, 1, busy_cursor_array) ;
  761. X
  762. Xunsigned short icon_image[] = {
  763. X#include "popi.icon"
  764. X} ;
  765. Xmpr_static(icon_pr, 64, 64, 1, icon_image) ;
  766. X
  767. Xint blocking ;       /* Set if in event blocking mode. */
  768. Xint gotevent ;       /* Set if we have an event to handle. */
  769. Xint nonblocking ;    /* Set if in event non-blocking mode. */
  770. Xint oktoshow ;       /* Set just before window is displayed. */
  771. X
  772. X
  773. X/*ARGSUSED*/
  774. Xvoid
  775. Xcanvas_proc(canvas, e)
  776. XCanvas canvas ;
  777. XEvent *e ;
  778. X{
  779. X  if (!oktoshow) return ;
  780. X  event = *e ;
  781. X  gotevent = 1 ;
  782. X  if (blocking) notify_stop() ;
  783. X}
  784. X
  785. X
  786. Xcleanup()            /* Null routine for the SunView version. */
  787. X{
  788. X}
  789. X
  790. X
  791. X/*ARGSUSED*/
  792. XNotify_value
  793. Xdestroy_proc(client, status)
  794. XNotify_client client ;
  795. XDestroy_status status ;
  796. X{
  797. X  exit(0) ;
  798. X}
  799. X
  800. X
  801. Xdraw_scanline(line, y)       /* Display image scanline on the screen. */
  802. Xunsigned char *line ;
  803. Xint y ;
  804. X{
  805. X  int i ;
  806. X
  807. X  mptr = (unsigned char *) ((struct mpr_data *) pr->pr_data)->md_image ;
  808. X  if (iscolor)
  809. X    for (i = 0; i < Xsize; i++) mptr[i] = 255 - line[i] ;
  810. X  else halftone(line, y) ;
  811. X  PW_ROP(cpw, 0, y+100, Xsize, 1, PIX_SRC, pr, 0, 0) ;
  812. X}
  813. X
  814. X
  815. Xdrawarea(x, y, width, height, op)
  816. Xint x, y, width, height ;
  817. Xenum op_type op ;
  818. X{
  819. X  PW_WRITEBACKGROUND(cpw, x, y, width, height, ops[(int) op]) ;
  820. X}
  821. X
  822. X
  823. Xdrawline(x1, y1, x2, y2)
  824. Xint x1, y1, x2, y2 ;
  825. X{
  826. X  PW_VECTOR(cpw, x1, y1, x2, y2, PIX_SET, 0) ;
  827. X}
  828. X
  829. X
  830. Xdrawtext(x, y, fontno, str)
  831. Xenum font_type fontno ;
  832. Xint x, y ;
  833. Xchar *str ;
  834. X{
  835. X  if (fontno == NFONT) font = nfont ;
  836. X  else if (fontno == BFONT) font = bfont ;
  837. X  PW_TEXT(cpw, x, y, PIX_SRC, font, str) ;
  838. X}
  839. X
  840. X
  841. XPixfont *
  842. Xget_font(name)
  843. Xchar *name ;
  844. X{
  845. X  Pixfont *font ;
  846. X
  847. X  font = pf_open(name) ;
  848. X  if (font == NULL) font = pf_default() ;
  849. X  if (font == NULL)
  850. X    {
  851. X      perror("couldn't get the default font.") ;
  852. X      exit(1) ;
  853. X    }
  854. X  return font ;
  855. X}
  856. X
  857. X
  858. Xget_event()       /* Get the next SunView event. */
  859. X{
  860. X  if (!gotevent) notify_start() ;  /* This blocks until notify_stop. */
  861. X  gotevent = 0 ;
  862. X}
  863. X
  864. X
  865. Xget_next_char(c)      /* Process events, and return when character typed. */
  866. Xchar *c ;
  867. X{
  868. X  for (;;)
  869. X    {
  870. X      get_event() ;
  871. X      if (event_is_ascii(&event))            /* Keyboard character? */
  872. X        {
  873. X          *c = event_id(&event) ;
  874. X          return ;
  875. X        }
  876. X      else window_default_event_proc(canvas, &event, (char *) 0) ;
  877. X    }
  878. X}
  879. X
  880. X
  881. Xinit_fonts()
  882. X{
  883. X  bfont = get_font(BOLD_FONT) ;
  884. X  nfont = get_font(NORMAL_FONT) ;
  885. X  nfont_width = nfont->pf_defaultsize.x ;
  886. X}
  887. X
  888. X
  889. Xinit_ws_type()
  890. X{
  891. X  if (getenv("WINDOW_PARENT") == NULL)
  892. X    {
  893. X      FPRINTF(stderr,"%s: Not a native SunView window\n", ProgName) ;
  894. X      return -1 ;
  895. X    }
  896. X  ops[(int) GCLR] = PIX_CLR ;
  897. X  ops[(int) GSET] = PIX_SET ;
  898. X  oktoshow = 0 ;        /* Kludge to correctly handle repaints. */
  899. X  blocking = 1 ;
  900. X  return 0 ;
  901. X}
  902. X
  903. X
  904. Xload_colors()    /* Create and load popi color map. */
  905. X{
  906. X  int i ;
  907. X  char cmsname[MAXLINE] ;
  908. X  u_char red[CMAPLEN], green[CMAPLEN], blue[CMAPLEN] ;
  909. X
  910. X  iscolor = (cpw->pw_pixrect->pr_depth == 8) ? 1 : 0 ;
  911. X
  912. X  if (iscolor)
  913. X    {
  914. X      for (i = 0; i < CMAPLEN; i++)
  915. X        red[i] = green[i] = blue[i] = 255 - i ;
  916. X
  917. X      SPRINTF(cmsname, "popi%10ld", getpid()) ;
  918. X      PW_SETCMSNAME(cpw, cmsname) ;
  919. X      PW_PUTCOLORMAP(cpw, 0, CMAPLEN, red, green, blue) ;
  920. X
  921. X      pr = mem_create(Xsize, 1, 8) ;
  922. X    }
  923. X  else pr = mem_create(Xsize, 1, 1) ;
  924. X}
  925. X
  926. X
  927. Xmake_items(argc, argv)       /* Create icon, frame, canvas etc.. */
  928. Xint argc ;
  929. Xchar *argv[] ;
  930. X{
  931. X  popi_icon = icon_create(ICON_IMAGE, &icon_pr, 0) ;
  932. X  frame = window_create((Window) 0, FRAME,
  933. X                        FRAME_ICON,       popi_icon,
  934. X                        FRAME_SHOW_LABEL, FALSE,
  935. X                        FRAME_NO_CONFIRM, TRUE,
  936. X                        FRAME_ARGS,       argc, argv,
  937. X                        0) ;
  938. X  canvas = window_create(frame, CANVAS,
  939. X                         WIN_WIDTH,      TWIDTH,
  940. X                         WIN_HEIGHT,     THEIGHT,
  941. X                         WIN_EVENT_PROC, canvas_proc,
  942. X                         0) ;
  943. X 
  944. X  WINDOW_SET(canvas, WIN_CONSUME_KBD_EVENTS, WIN_ASCII_EVENTS,
  945. X                     WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS,
  946. X                     WIN_UP_EVENTS, 0, 0) ;
  947. X  WINDOW_SET(canvas, WIN_IGNORE_PICK_EVENT, LOC_MOVE, 0) ;
  948. X  cpw = canvas_pixwin(canvas) ;
  949. X
  950. X  main_cursor = window_get(canvas, WIN_CURSOR) ;
  951. X  busy_cursor = cursor_create(CURSOR_IMAGE, &busy_cursor_pr, 0) ;
  952. X  load_colors() ;            /* Load the popi grayscale colormap. */
  953. X}
  954. X
  955. X
  956. Xset_cursor(type)
  957. Xenum cur_type type ;
  958. X{
  959. X  switch (type)
  960. X    {
  961. X      case BUSY_CUR   : WINDOW_SET(canvas, WIN_CURSOR, busy_cursor, 0) ;
  962. X                        break ;
  963. X      case NORMAL_CUR : WINDOW_SET(canvas, WIN_CURSOR, main_cursor, 0) ;
  964. X    }
  965. X}
  966. X
  967. X
  968. Xstart_tool()
  969. X{
  970. X  window_fit(frame) ;
  971. X  NOTIFY_INTERPOSE_DESTROY_FUNC(frame, destroy_proc) ;
  972. X  oktoshow = 1 ;
  973. X  WINDOW_SET(frame, WIN_SHOW, TRUE, 0) ;
  974. X  NOTIFY_DISPATCH() ;      /* Make the window appear. */
  975. X  NOTIFY_DO_DISPATCH() ;
  976. X}
  977. Funky_Stuff
  978. chmod 0444 sunview.c || echo "restore of sunview.c fails"
  979. set `wc -c sunview.c`;Sum=$1
  980. if test "$Sum" != "7006"
  981. then echo original size 7006, current size $Sum;fi
  982. echo "x - extracting x11.c (Text)"
  983. sed 's/^X//' << 'Funky_Stuff' > x11.c &&
  984. X/*LINTLIBRARY*/
  985. X
  986. X/*  @(#)x11.c 1.9 89/12/11
  987. X *
  988. X *  X11 dependent graphics routines used by popi.
  989. X *  written by Rich Burridge - Sun Microsystems.
  990. X *
  991. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  992. X *  This version is based on the code in his Prentice Hall book,
  993. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  994. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  995. X *
  996. X *  Permission is given to distribute these extensions, as long as these
  997. X *  introductory messages are not removed, and no monies are exchanged.
  998. X *
  999. X *  No responsibility is taken for any errors or inaccuracies inherent
  1000. X *  either to the comments or the code of this program, but if reported
  1001. X *  (see README file) then an attempt will be made to fix them.
  1002. X */
  1003. X
  1004. X#include "popi.h"
  1005. X#include "graphics.h"
  1006. X#include <X11/Xlib.h>
  1007. X#include <X11/Xutil.h>
  1008. X#include <X11/cursorfont.h>
  1009. X#include <X11/keysym.h>
  1010. X
  1011. X#define  BOLD_FONT    "helvetica-bold-14"
  1012. X#define  DEFFONT      "fixed"
  1013. X#define  NORMAL_FONT  "8x13"
  1014. X
  1015. X#define  POPI_BORDER_WIDTH  2
  1016. X
  1017. X#define  FRAME_MASK  (KeyPressMask | KeyReleaseMask | ExposureMask)
  1018. X
  1019. Xshort icon_image[] = {
  1020. X#include "popi.icon"
  1021. X} ;
  1022. X
  1023. XAtom protocol_atom, kill_atom ;
  1024. XCursor busy_cursor, main_cursor ;
  1025. XDisplay *dpy ;
  1026. XGC gc, pix_gc ;
  1027. XPixmap mpr, popi_icon, load_icon() ;
  1028. XVisual *visual ;
  1029. XWindow frame, frame_icon ;
  1030. XXColor current_col ;
  1031. XXEvent event ;
  1032. XXFontStruct *bfont, *font, *nfont ;
  1033. XXGCValues gc_val ;
  1034. XXSetWindowAttributes attributes ;
  1035. XXSizeHints size ;
  1036. XXVisualInfo vinfo ;
  1037. XXWMHints wm_hints ;
  1038. X
  1039. Xunsigned long gc_mask ;
  1040. Xint screen ;
  1041. Xunsigned int scr_depth ;
  1042. Xunsigned long backgnd, foregnd ;
  1043. Xunsigned long palette[CMAPLEN] ;
  1044. X
  1045. X/*  256-byte table for quickly reversing the bits in an unsigned 8-bit char,
  1046. X *  used to convert between MSBFirst and LSBFirst image formats.
  1047. X */
  1048. X
  1049. Xchar revtable[256] = {
  1050. X        0, -128,   64,  -64,   32,  -96,   96,  -32,
  1051. X       16, -112,   80,  -48,   48,  -80,  112,  -16,
  1052. X        8, -120,   72,  -56,   40,  -88,  104,  -24,
  1053. X       24, -104,   88,  -40,   56,  -72,  120,   -8,
  1054. X        4, -124,   68,  -60,   36,  -92,  100,  -28,
  1055. X       20, -108,   84,  -44,   52,  -76,  116,  -12,
  1056. X       12, -116,   76,  -52,   44,  -84,  108,  -20,
  1057. X       28, -100,   92,  -36,   60,  -68,  124,   -4,
  1058. X        2, -126,   66,  -62,   34,  -94,   98,  -30,
  1059. X       18, -110,   82,  -46,   50,  -78,  114,  -14,
  1060. X       10, -118,   74,  -54,   42,  -86,  106,  -22,
  1061. X       26, -102,   90,  -38,   58,  -70,  122,   -6,
  1062. X        6, -122,   70,  -58,   38,  -90,  102,  -26,
  1063. X       22, -106,   86,  -42,   54,  -74,  118,  -10,
  1064. X       14, -114,   78,  -50,   46,  -82,  110,  -18,
  1065. X       30,  -98,   94,  -34,   62,  -66,  126,   -2,
  1066. X        1, -127,   65,  -63,   33,  -95,   97,  -31,
  1067. X       17, -111,   81,  -47,   49,  -79,  113,  -15,
  1068. X        9, -119,   73,  -55,   41,  -87,  105,  -23,
  1069. X       25, -103,   89,  -39,   57,  -71,  121,   -7,
  1070. X        5, -123,   69,  -59,   37,  -91,  101,  -27,
  1071. X       21, -107,   85,  -43,   53,  -75,  117,  -11,
  1072. X       13, -115,   77,  -51,   45,  -83,  109,  -19,
  1073. X       29,  -99,   93,  -35,   61,  -67,  125,   -3,
  1074. X        3, -125,   67,  -61,   35,  -93,   99,  -29,
  1075. X       19, -109,   83,  -45,   51,  -77,  115,  -13,
  1076. X       11, -117,   75,  -53,   43,  -85,  107,  -21,
  1077. X       27, -101,   91,  -37,   59,  -69,  123,   -5,
  1078. X        7, -121,   71,  -57,   39,  -89,  103,  -25,
  1079. X       23, -105,   87,  -41,   55,  -73,  119,   -9,
  1080. X       15, -113,   79,  -49,   47,  -81,  111,  -17,
  1081. X       31,  -97,   95,  -33,   63,  -65,  127,   -1,
  1082. X} ;
  1083. X
  1084. Xcleanup()                   /* Null routine for the X11 version. */
  1085. X{
  1086. X}
  1087. X
  1088. X
  1089. X/*  This routine needs to be dramatically improved. It should be possible
  1090. X *  to avoid copying the data to a separate buffer and creating a pixmap,
  1091. X *  and send it direct to the popi frame.
  1092. X */
  1093. X
  1094. Xdraw_scanline(line, y)      /* Display image scanline on the screen. */
  1095. Xunsigned char *line ;
  1096. Xint y ;
  1097. X{
  1098. X  XImage *image ;
  1099. X  int i ;
  1100. X
  1101. X  if (iscolor)
  1102. X    {
  1103. X      mptr = (unsigned char *) Emalloc(Xsize) ;
  1104. X      for (i = 0; i < Xsize; i++) mptr[i] = palette[255 - line[i]] ;
  1105. X      image = XCreateImage(dpy, DefaultVisual(dpy, screen),
  1106. X                           scr_depth, ZPixmap, 0, mptr, Xsize, 1, 8, Xsize) ;
  1107. X      mpr = XCreatePixmap(dpy, RootWindow(dpy, screen),
  1108. X                          (unsigned) image->width,
  1109. X                          (unsigned) image->height, scr_depth) ;
  1110. X      XPutImage(dpy, mpr, pix_gc, image, 0, 0, 0, 0,
  1111. X                (unsigned) image->width, (unsigned) image->height) ;
  1112. X      XDestroyImage(image) ;
  1113. X    }
  1114. X  else
  1115. X    {
  1116. X      mptr = (unsigned char *) Emalloc((Xsize / 8) + 1) ;
  1117. X      halftone(line, y) ;
  1118. X      for (i = 0; i < (Xsize / 8) + 1; i++) mptr[i] = revtable[mptr[i]] ;
  1119. X      mpr = XCreatePixmapFromBitmapData(dpy, RootWindow(dpy, screen), mptr,
  1120. X                                        Xsize, 1, foregnd, backgnd, scr_depth) ;      free(mptr) ;
  1121. X    }
  1122. X  XCopyArea(dpy, mpr, frame, gc, 0, 0, Xsize, 1, 0, y+100) ;
  1123. X  XFreePixmap(dpy, mpr) ;
  1124. X}
  1125. X
  1126. X
  1127. Xdrawarea(x, y, width, height, op)
  1128. Xint x, y, width, height ;
  1129. Xenum op_type op ;
  1130. X{
  1131. X  gc_val.function = ops[(int) op] ;
  1132. X  XChangeGC(dpy, gc, GCFunction, &gc_val) ;
  1133. X  XFillRectangle(dpy, frame, gc, x, y,
  1134. X                 (unsigned int) width, (unsigned int) height) ;
  1135. X  XSync(dpy, 0) ;
  1136. X}
  1137. X
  1138. X
  1139. Xdrawline(x1, y1, x2, y2)
  1140. Xint x1, y1, x2, y2 ;
  1141. X{
  1142. X  gc_val.foreground = foregnd ;
  1143. X  gc_val.function = GXcopy ;
  1144. X  XChangeGC(dpy, gc, GCForeground | GCFunction, &gc_val) ;
  1145. X  XDrawLine(dpy, frame, gc, x1, y1, x2, y2) ;
  1146. X}
  1147. X
  1148. X
  1149. Xdrawtext(x, y, fontno, str)
  1150. Xenum font_type fontno ;
  1151. Xint x, y ;
  1152. Xchar *str ;
  1153. X{
  1154. X       if (fontno == NFONT) font = nfont ;
  1155. X  else if (fontno == BFONT) font = bfont ;
  1156. X  gc_val.font = font->fid ;
  1157. X  gc_val.function = GXcopy ;
  1158. X  XChangeGC(dpy, gc, GCFont | GCFunction, &gc_val) ;
  1159. X  XDrawString(dpy, frame, gc, x, y, str, strlen(str)) ;
  1160. X}
  1161. X
  1162. X
  1163. XXFontStruct *
  1164. Xget_font(name)
  1165. Xchar *name ;
  1166. X{
  1167. X  XFontStruct *font ;
  1168. X
  1169. X  if (!(font = XLoadQueryFont(dpy, name)))
  1170. X    if (!(font = XLoadQueryFont(dpy, DEFFONT)))
  1171. X      {
  1172. X        perror("couldn't get the default font.") ;
  1173. X        exit(1) ;
  1174. X      }
  1175. X  return(font) ;
  1176. X}
  1177. X
  1178. X
  1179. Xget_next_char(c)
  1180. Xchar *c ;
  1181. X{
  1182. X  XClientMessageEvent *ev ;
  1183. X  XKeyPressedEvent *key_event ;
  1184. X  KeySym keysym ;
  1185. X  char chs[2] ;
  1186. X
  1187. X  for (;;)
  1188. X    {
  1189. X      if (!XCheckMaskEvent(dpy, ExposureMask, &event))
  1190. X        XNextEvent(dpy, &event) ;
  1191. X
  1192. X      switch (event.type)
  1193. X        {
  1194. X          case ClientMessage    : /* Catch ICCCM kill from WM. */
  1195. X
  1196. X                                  ev = (XClientMessageEvent *) &event ;
  1197. X                                  if (ev->message_type == protocol_atom &&
  1198. X                                      ev->data.l[0] == kill_atom)
  1199. X                                    exit(0) ;
  1200. X                                  break ;
  1201. X
  1202. X          case Expose           : process_expose(&event) ;
  1203. X                                  break ;
  1204. X
  1205. X          case KeyPress         : key_event = (XKeyPressedEvent *) &event ;
  1206. X                                  (void) XLookupString(key_event, chs, 1,
  1207. X                                                       &keysym,
  1208. X                                                       (XComposeStatus *) NULL) ;
  1209. X                                  if (keysym == XK_Shift_L ||
  1210. X                                      keysym == XK_Shift_R) break ;
  1211. X                                  *c = chs[0] ;
  1212. X                                  return ;
  1213. X       }
  1214. X    }
  1215. X/*NOTREACHED*/
  1216. X}
  1217. X
  1218. X
  1219. Xinit_fonts()
  1220. X{
  1221. X  bfont = get_font(BOLD_FONT) ;
  1222. X  nfont = get_font(NORMAL_FONT) ;
  1223. X  nfont_width = 8 ;
  1224. X}
  1225. X
  1226. X
  1227. Xinit_ws_type()
  1228. X{
  1229. X  if ((dpy = XOpenDisplay(x11_display)) == NULL)
  1230. X    {
  1231. X      FPRINTF(stderr,"%s: Couldn't open display %s\n", ProgName,
  1232. X              (getenv ("DISPLAY") ? getenv("DISPLAY") : x11_display)) ;
  1233. X      exit(1) ;
  1234. X    }
  1235. X
  1236. X  screen = DefaultScreen(dpy) ;
  1237. X
  1238. X  if (!geometry)
  1239. X    STRCPY(geometry, XGetDefault(dpy, ProgName, "Geometry")) ;
  1240. X
  1241. X  foregnd = BlackPixel(dpy, screen) ;
  1242. X  backgnd = WhitePixel(dpy, screen) ;
  1243. X  scr_depth = DefaultDepth(dpy, screen) ;
  1244. X
  1245. X  ops[(int) GCLR] = GXclear ;
  1246. X  ops[(int) GSET] = GXset ;
  1247. X  return 0 ;
  1248. X}
  1249. X
  1250. X
  1251. X/*ARGSUSED*/
  1252. Xstatic Bool
  1253. Xis_exposed(dpy, ev, window)   /* Return True if window is being exposed */
  1254. XDisplay *dpy ;
  1255. XXEvent *ev ;
  1256. Xchar *window ;
  1257. X{
  1258. X  if (ev->type == Expose && *((Window *) window) == ev->xkey.window)
  1259. X    return True ;
  1260. X  return False ;
  1261. X}
  1262. X
  1263. X
  1264. Xload_colors()    /* Create and load popi color map. */
  1265. X{
  1266. X  u_char red[CMAPLEN], green[CMAPLEN], blue[CMAPLEN] ;
  1267. X  int i, numcolors ;
  1268. X
  1269. X  iscolor = 0 ;
  1270. X  if (DisplayCells(dpy, screen) > 2)
  1271. X    {
  1272. X      iscolor = 1 ;
  1273. X      numcolors = 0 ;
  1274. X      for (i = 0; i < CMAPLEN; i++)
  1275. X        {
  1276. X          current_col.flags = DoRed | DoGreen | DoBlue ;
  1277. X          current_col.red = current_col.green =
  1278. X          current_col.blue = (unsigned short) ((255 - i) << 8) ;
  1279. X          if (XAllocColor(dpy, DefaultColormap(dpy, screen), ¤t_col) == True)
  1280. X            palette[numcolors++] = current_col.pixel ;
  1281. X        }
  1282. X      if (numcolors < 2)
  1283. X        {
  1284. X          FPRINTF(stderr, "%s: cannot allocate colors.\n", ProgName) ;
  1285. X          exit(1) ;
  1286. X        }
  1287. X    }
  1288. X}
  1289. X
  1290. X
  1291. XPixmap
  1292. Xload_icon(sbuf)
  1293. Xshort sbuf[] ;
  1294. X{
  1295. X  char cbuf[512] ;
  1296. X  int i ;
  1297. X
  1298. X  for (i = 0; i < 256; i++)
  1299. X    {
  1300. X      cbuf[i*2+0] = revtable[(sbuf[i] >> 8) & 0xFF] ;
  1301. X      cbuf[i*2+1] = revtable[sbuf[i] & 0xFF] ;
  1302. X    }
  1303. X  return(XCreatePixmapFromBitmapData(dpy, RootWindow(dpy, screen), cbuf,
  1304. X                                     64, 64, foregnd, backgnd, scr_depth)) ;
  1305. X}
  1306. X
  1307. X
  1308. Xmake_items(argc, argv)       /* Create icon, frame, canvas etc.. */
  1309. Xint argc ;
  1310. Xchar *argv[] ;
  1311. X{
  1312. X  unsigned int h, w ;       /* Window dimensions. */
  1313. X  int flags ;
  1314. X  int x, y ;                /* Window position. */
  1315. X
  1316. X  load_colors() ;
  1317. X  popi_icon = load_icon(icon_image) ;
  1318. X
  1319. X  size.flags = PMinSize | PMaxSize | PPosition | PSize ;
  1320. X  size.x = 0 ;
  1321. X  size.y = 0 ;
  1322. X  size.max_width = size.min_width = size.width = TWIDTH ;
  1323. X  size.max_height = size.min_height = size.height = THEIGHT ;
  1324. X
  1325. X  if (strlen(geometry))
  1326. X    {
  1327. X      flags = XParseGeometry(geometry, &x, &y, &w, &h) ;
  1328. X      if (XValue & flags)
  1329. X        {
  1330. X          if (XNegative & flags)
  1331. X            x = DisplayWidth(dpy, screen) + x - size.width ;
  1332. X            size.flags |= USPosition ;
  1333. X            size.x = x ;
  1334. X        }
  1335. X      if (YValue & flags)
  1336. X        {
  1337. X          if (YNegative & flags)
  1338. X            y = DisplayHeight(dpy, screen) + y - size.height ;
  1339. X            size.flags |= USPosition ;
  1340. X            size.y = y ;
  1341. X        }
  1342. X    }
  1343. X
  1344. X  frame = XCreateSimpleWindow(dpy, RootWindow(dpy, screen),
  1345. X                              size.x, size.y, size.width, size.height,
  1346. X                              POPI_BORDER_WIDTH, foregnd, backgnd) ;
  1347. X
  1348. X  protocol_atom = XInternAtom(dpy, "WM_PROTOCOLS", False) ;
  1349. X  kill_atom = XInternAtom(dpy, "WM_DELETE_WINDOW", False) ;
  1350. X
  1351. X  XSetStandardProperties(dpy, frame, "popi", NULL, popi_icon,
  1352. X                         argv, argc, &size) ;
  1353. X
  1354. X  wm_hints.icon_x = ix ;
  1355. X  wm_hints.icon_y = iy ;
  1356. X  wm_hints.input = True ;
  1357. X  wm_hints.icon_pixmap = popi_icon ;
  1358. X  wm_hints.flags = IconPositionHint | InputHint | IconPixmapHint ;
  1359. X  if (iconic)
  1360. X    {
  1361. X      wm_hints.initial_state = IconicState ;
  1362. X      wm_hints.flags |= StateHint ;
  1363. X    }
  1364. X  XSetWMHints(dpy, frame, &wm_hints) ;
  1365. X
  1366. X  gc_mask = GCFont | GCForeground | GCBackground | GCGraphicsExposures ;
  1367. X  gc_val.font = nfont->fid ;
  1368. X  gc_val.foreground = foregnd ;
  1369. X  gc_val.background = backgnd ;
  1370. X  gc_val.graphics_exposures = False ;
  1371. X  gc = XCreateGC(dpy, RootWindow(dpy, screen), gc_mask, &gc_val) ;
  1372. X  XSetFunction(dpy, gc, GXcopy) ;
  1373. X  pix_gc = DefaultGC(dpy, screen) ;
  1374. X
  1375. X  main_cursor = XCreateFontCursor(dpy, XC_top_left_arrow) ;
  1376. X  busy_cursor = XCreateFontCursor(dpy, XC_coffee_mug) ;
  1377. X}
  1378. X
  1379. X
  1380. Xprocess_expose(event)
  1381. XXExposeEvent *event ;
  1382. X{
  1383. X  int doframe ;
  1384. X
  1385. X  doframe = 0 ;
  1386. X  do
  1387. X    {
  1388. X      if (event->count == 0)
  1389. X        if (event->window == frame) doframe++ ;
  1390. X    }    
  1391. X  while (XCheckMaskEvent(dpy, ExposureMask, event)) ;
  1392. X
  1393. X  if (doframe) paint_canvas() ;
  1394. X}
  1395. X
  1396. X
  1397. Xset_cursor(type)
  1398. Xenum cur_type type ;
  1399. X{
  1400. X  switch (type)
  1401. X    {
  1402. X      case BUSY_CUR   : XDefineCursor(dpy, frame, busy_cursor) ;
  1403. X                        break ;
  1404. X      case NORMAL_CUR : XDefineCursor(dpy, frame, main_cursor) ;
  1405. X    }
  1406. X}
  1407. X
  1408. X
  1409. Xstart_tool()
  1410. X{
  1411. X  XSelectInput(dpy, frame, FRAME_MASK) ;
  1412. X  XMapWindow(dpy, frame) ;
  1413. X}
  1414. Funky_Stuff
  1415. chmod 0444 x11.c || echo "restore of x11.c fails"
  1416. set `wc -c x11.c`;Sum=$1
  1417. if test "$Sum" != "12178"
  1418. then echo original size 12178, current size $Sum;fi
  1419. echo "x - extracting xview.c (Text)"
  1420. sed 's/^X//' << 'Funky_Stuff' > xview.c &&
  1421. X/*LINTLIBRARY*/
  1422. X
  1423. X/*  @(#)xview.c 1.8 89/12/11
  1424. X *
  1425. X *  XView dependent graphics routines used by popi.
  1426. X *  written by Rich Burridge - Sun Microsystems.
  1427. X *
  1428. X *  Popi was originally written by Gerard J. Holzmann - AT&T Bell Labs.
  1429. X *  This version is based on the code in his Prentice Hall book,
  1430. X *  "Beyond Photography - the digital darkroom," ISBN 0-13-074410-7,
  1431. X *  which is copyright (c) 1988 by Bell Telephone Laboratories, Inc. 
  1432. X *
  1433. X *  Permission is given to distribute these extensions, as long as these
  1434. X *  introductory messages are not removed, and no monies are exchanged.
  1435. X *
  1436. X *  No responsibility is taken for any errors or inaccuracies inherent
  1437. X *  either to the comments or the code of this program, but if reported
  1438. X *  (see README file) then an attempt will be made to fix them.
  1439. X */
  1440. X
  1441. X#include "popi.h"
  1442. X#include "graphics.h"
  1443. X#include <xview/xview.h>
  1444. X#include <xview/canvas.h>
  1445. X#include <xview/cms.h>
  1446. X#include <xview/cursor.h>
  1447. X#include <X11/Xlib.h>
  1448. X
  1449. X#define  NOTIFY_DISPATCH                (void) notify_dispatch
  1450. X#define  NOTIFY_INTERPOSE_DESTROY_FUNC  (void) notify_interpose_destroy_func
  1451. X#define  PW_WRITEBACKGROUND             (void) pw_writebackground
  1452. X#define  WINDOW_DONE                    (void) window_done
  1453. X#define  XV_SET                         (void) xv_set
  1454. X
  1455. X#define  BOLD_FONT      "/usr/lib/fonts/fixedwidthfonts/screen.b.14"
  1456. X#define  NORMAL_FONT    "/usr/lib/fonts/fixedwidthfonts/screen.r.14"
  1457. X
  1458. Xvoid repaint_canvas() ;
  1459. X
  1460. XCanvas canvas ;
  1461. XCanvas_paint_window cpw ;
  1462. XDisplay *dpy ;
  1463. XEvent event ;
  1464. XFrame frame ;
  1465. XIcon popi_icon ;
  1466. XNotify_value destroy_proc() ;
  1467. XPixfont *bfont, *font, *nfont, *xv_pf_default(), *xv_pf_open() ;
  1468. XPixrect *pr, *xv_mem_create() ;                /* Offscreen image area. */
  1469. XXv_cmsdata cms_data ;
  1470. XXv_Cursor busy_cursor, main_cursor ;
  1471. X
  1472. Xunsigned short busy_cursor_array[] = {
  1473. X#include <images/hglass.cursor>
  1474. X} ;
  1475. Xmpr_static(busy_cursor_pr, 16, 16, 1, busy_cursor_array) ;
  1476. X
  1477. Xunsigned short icon_image[] = {
  1478. X#include "popi.icon"
  1479. X} ;
  1480. Xmpr_static(icon_pr, 64, 64, 1, icon_image) ;
  1481. X
  1482. Xint blocking ;       /* Set if in event blocking mode. */
  1483. Xint gotevent ;       /* Set if we have an event to handle. */
  1484. Xint nonblocking ;    /* Set if in event non-blocking mode. */
  1485. Xint oktoshow ;       /* Set just before window is displayed. */
  1486. Xint win_depth ;      /* Depth in pixels of this display. */
  1487. X
  1488. X
  1489. X/*ARGSUSED*/
  1490. Xvoid
  1491. Xcanvas_proc(canvas, e, arg)
  1492. XCanvas canvas ;
  1493. XEvent *e ;
  1494. Xcaddr_t arg ;
  1495. X{
  1496. X  if (!oktoshow) return ;
  1497. X  event = *e ;
  1498. X  gotevent = 1 ;
  1499. X  if (blocking) (void) notify_stop() ;
  1500. X}
  1501. X
  1502. X
  1503. Xcleanup()            /* Null routine for the XView version. */
  1504. X{
  1505. X}
  1506. X
  1507. X
  1508. X/*ARGSUSED*/
  1509. XNotify_value
  1510. Xdestroy_proc(client, status)
  1511. XNotify_client client ;
  1512. XDestroy_status status ;
  1513. X{
  1514. X  exit(0) ;
  1515. X}
  1516. X
  1517. X
  1518. Xdraw_scanline(line, y)       /* Display image scanline on the screen. */
  1519. Xunsigned char *line ;
  1520. Xint y ;
  1521. X{
  1522. X  int i ;
  1523. X
  1524. X  mptr = (unsigned char *) ((struct mpr_data *) pr->pr_data)->md_image ;
  1525. X  if (iscolor)
  1526. X    for (i = 0; i < Xsize; i++) mptr[i] = 255 - line[i] ;
  1527. X  else halftone(line, y) ;
  1528. X  (void) pw_rop(cpw, 0, y+100, Xsize, 1, PIX_SRC, pr, 0, 0) ;
  1529. X}
  1530. X
  1531. X
  1532. Xdrawarea(x, y, width, height, op)
  1533. Xint x, y, width, height ;
  1534. Xenum op_type op ;
  1535. X{
  1536. X  PW_WRITEBACKGROUND(cpw, x, y, width, height, ops[(int) op]) ;
  1537. X  XSync(dpy, 0) ;
  1538. X}
  1539. X
  1540. X
  1541. Xdrawline(x1, y1, x2, y2)
  1542. Xint x1, y1, x2, y2 ;
  1543. X{
  1544. X  (void) pw_vector(cpw, x1, y1, x2, y2, PIX_SET, 0) ;
  1545. X}
  1546. X
  1547. X
  1548. Xdrawtext(x, y, fontno, str)
  1549. Xenum font_type fontno ;
  1550. Xint x, y ;
  1551. Xchar *str ;
  1552. X{
  1553. X  if (fontno == NFONT) font = nfont ;
  1554. X  else if (fontno == BFONT) font = bfont ;
  1555. X  (void) pw_text(cpw, x, y, PIX_SRC, font, str) ;
  1556. X}
  1557. X
  1558. X
  1559. XPixfont *
  1560. Xget_font(name)
  1561. Xchar *name ;
  1562. X{
  1563. X  Pixfont *font ;
  1564. X
  1565. X  font = xv_pf_open(name) ;
  1566. X  if (font == NULL) font = xv_pf_default() ;
  1567. X  if (font == NULL)
  1568. X    {
  1569. X      perror("couldn't get the default font.") ;
  1570. X      exit(1) ;
  1571. X    }
  1572. X  return font ;
  1573. X}
  1574. X
  1575. X
  1576. Xget_event()       /* Get the next XView event. */
  1577. X{
  1578. X  if (!gotevent)
  1579. X    {
  1580. X      XSync(dpy, 0) ;
  1581. X      notify_start() ;     /* This blocks until notify_stop. */
  1582. X    }
  1583. X  gotevent = 0 ;
  1584. X}
  1585. X
  1586. X
  1587. Xget_next_char(c)      /* Process events, and return when character typed. */
  1588. Xchar *c ;
  1589. X{
  1590. X  for (;;)
  1591. X    {
  1592. X      get_event() ;
  1593. X      if (event_is_ascii(&event) && event_is_up(&event))  /* Keyboard char? */
  1594. X        {
  1595. X          *c = event_id(&event) ;
  1596. X          return ;
  1597. X        }
  1598. X      else if (event_id(&event) == WIN_REPAINT) paint_canvas() ;
  1599. X    }
  1600. X}
  1601. X
  1602. X
  1603. Xinit_fonts()
  1604. X{
  1605. X  bfont = get_font(BOLD_FONT) ;
  1606. X  nfont = get_font(NORMAL_FONT) ;
  1607. X  nfont_width = nfont->pf_defaultsize.x ;
  1608. X}
  1609. X
  1610. X
  1611. Xinit_ws_type()
  1612. X{
  1613. X  ops[(int) GCLR] = PIX_CLR ;
  1614. X  ops[(int) GSET] = PIX_SET ;
  1615. X  oktoshow = 0 ;       /* Kludge to correctly handle repaints. */
  1616. X  blocking = 1 ;
  1617. X  return 0 ;
  1618. X}
  1619. X
  1620. X
  1621. Xmake_items(argc, argv)       /* Create icon, frame, canvas etc.. */
  1622. Xint argc ;
  1623. Xchar *argv[] ;
  1624. X{
  1625. X  int i ;
  1626. X  char cmsname[MAXLINE] ;
  1627. X  u_char red[CMAPLEN], green[CMAPLEN], blue[CMAPLEN] ;
  1628. X
  1629. X  xv_init(XV_INIT_ARGS, argc, argv, 0);
  1630. X  popi_icon = xv_create(0, ICON,
  1631. X                        ICON_IMAGE, &icon_pr,
  1632. X                        0) ;
  1633. X  frame = xv_create(0, FRAME,
  1634. X                    FRAME_ICON,       popi_icon,
  1635. X                    FRAME_SHOW_LABEL, FALSE,
  1636. X                    FRAME_NO_CONFIRM, TRUE,
  1637. X                    XV_HEIGHT,        THEIGHT,
  1638. X                    XV_WIDTH,         TWIDTH,
  1639. X                    0) ;
  1640. X  iscolor = ((win_depth = (int) xv_get(frame, WIN_DEPTH)) > 1) ? 1 : 0 ;
  1641. X
  1642. X  pr = xv_mem_create(Xsize, 1, win_depth) ;
  1643. X
  1644. X  SPRINTF(cmsname, "popi%10ld", getpid()) ;
  1645. X  for (i = 0; i < CMAPLEN; i++)
  1646. X    red[i] = green[i] = blue[i] = 255 - i ;
  1647. X
  1648. X  cms_data.type = XV_DYNAMIC_CMS ;
  1649. X  cms_data.size = 256 ;
  1650. X  cms_data.rgb_count = 256 ;
  1651. X  cms_data.index = 0 ;
  1652. X  cms_data.red = red ;
  1653. X  cms_data.green = green ;
  1654. X  cms_data.blue = blue ;
  1655. X
  1656. X  canvas = xv_create(frame, CANVAS,
  1657. X                     OPENWIN_AUTO_CLEAR,       FALSE,
  1658. X                     CANVAS_RETAINED,          TRUE,
  1659. X                     XV_WIDTH,                 TWIDTH,
  1660. X                     XV_HEIGHT,                THEIGHT,
  1661. X                     CANVAS_PAINTWINDOW_ATTRS,
  1662. X                         WIN_DYNAMIC_VISUAL,   TRUE,
  1663. X                         WIN_CONSUME_EVENTS,
  1664. X                           WIN_ASCII_EVENTS,
  1665. X                           WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS,
  1666. X                           0,
  1667. X                         WIN_IGNORE_EVENTS,
  1668. X                           LOC_MOVE, LOC_DRAG,
  1669. X                           0,
  1670. X                         WIN_EVENT_PROC, canvas_proc,
  1671. X                         0,
  1672. X                     0) ;
  1673. X 
  1674. X  cpw = canvas_paint_window(canvas) ;
  1675. X  XV_SET(/**canvas_pixwin(canvas),**/cpw,
  1676. X           WIN_CMS_NAME, cmsname,
  1677. X           WIN_CMS_DATA,  &cms_data,
  1678. X         0) ;
  1679. X  dpy = (Display *) xv_get(cpw, XV_DISPLAY) ;
  1680. X
  1681. X  main_cursor = xv_get(canvas, WIN_CURSOR) ;
  1682. X  busy_cursor = xv_create(NULL, CURSOR,
  1683. X                          CURSOR_IMAGE, &busy_cursor_pr,
  1684. X                          0) ;
  1685. X}
  1686. X
  1687. X
  1688. Xset_cursor(type)
  1689. Xenum cur_type type ;
  1690. X{
  1691. X  switch (type)
  1692. X    {
  1693. X      case BUSY_CUR   : XV_SET(canvas, WIN_CURSOR, busy_cursor, 0) ;
  1694. X                        break ;
  1695. X      case NORMAL_CUR : XV_SET(canvas, WIN_CURSOR, main_cursor, 0) ;
  1696. X    }
  1697. X  XSync(dpy, 0) ;
  1698. X}
  1699. X
  1700. X
  1701. Xstart_tool()
  1702. X{
  1703. X  window_fit(frame) ;
  1704. X  NOTIFY_INTERPOSE_DESTROY_FUNC(frame, destroy_proc) ;
  1705. X  XV_SET(frame, WIN_SHOW, TRUE, 0) ;
  1706. X  oktoshow = 1 ;
  1707. X  (void) xv_set(xv_default_server, SERVER_SYNC_AND_PROCESS_EVENTS) ;
  1708. X  NOTIFY_DISPATCH() ;
  1709. X}
  1710. Funky_Stuff
  1711. chmod 0444 xview.c || echo "restore of xview.c fails"
  1712. set `wc -c xview.c`;Sum=$1
  1713. if test "$Sum" != "7343"
  1714. then echo original size 7343, current size $Sum;fi
  1715. echo "x - extracting popi.msc (Text)"
  1716. sed 's/^X//' << 'Funky_Stuff' > popi.msc &&
  1717. X#
  1718. X# Program: Popi
  1719. X#
  1720. X# Make file for Microsoft braindamaged make.
  1721. X# In the Quick C environment, select
  1722. X#    File/Set Program List
  1723. X# and set to the name of this file (popi.qcl).
  1724. X# From the command line, use "make popi.qcl"
  1725. X# Quick C has fought hard against generating correct code,
  1726. X# but I believe the current version doesn't trigger any of
  1727. X# its many bugs. Do not enable run-time pointer checking or
  1728. X# it will wrongly complain about some valid pointer assignments.
  1729. X# Also, do not enable optimisation as incorrect code will be
  1730. X# generated in a loop inside run.c.
  1731. X#
  1732. X
  1733. XCC    = qcl
  1734. X
  1735. X.c.obj:
  1736. X    $(CC) -c -W3 -AS $*.c
  1737. X
  1738. Xmain.obj : main.c
  1739. X
  1740. Xexpr.obj : expr.c
  1741. X
  1742. Xio.obj : io.c
  1743. X
  1744. Xlex.obj : lex.c
  1745. X
  1746. Xpolar.obj : polar.c
  1747. X
  1748. Xrun.obj : run.c
  1749. X
  1750. Xspecial.obj : special.c
  1751. X
  1752. Xibmpc.obj : ibmpc.c
  1753. X
  1754. XPopi.exe : expr.obj ibmpc.obj io.obj lex.obj main.obj polar.obj run.obj  \
  1755. X        special.obj 
  1756. X    del Popi.lnk
  1757. X    echo expr.obj+ >>Popi.lnk
  1758. X    echo ibmpc.obj+ >>Popi.lnk
  1759. X    echo io.obj+ >>Popi.lnk
  1760. X    echo lex.obj+ >>Popi.lnk
  1761. X    echo main.obj+ >>Popi.lnk
  1762. X    echo polar.obj+ >>Popi.lnk
  1763. X    echo run.obj+ >>Popi.lnk
  1764. X    echo special.obj  >>Popi.lnk
  1765. X    echo Popi.exe >>Popi.lnk
  1766. X    echo Popi.map >>Popi.lnk
  1767. X    link @Popi.lnk /NOI $(LDFLAGS);
  1768. Funky_Stuff
  1769. chmod 0444 popi.msc || echo "restore of popi.msc fails"
  1770. set `wc -c popi.msc`;Sum=$1
  1771. if test "$Sum" != "1163"
  1772. then echo original size 1163, current size $Sum;fi
  1773. echo "x - extracting dmr.Z (Binary)"
  1774. sed 's/^X//' << 'Funky_Stuff' > s2_temp_.tmp &&
  1775. Xbegin 600 dmr.Z
  1776. Funky_Stuff
  1777. echo "End of part 5"
  1778. echo "File dmr.Z is continued in part 6"
  1779. echo "6" > s2_seq_.tmp
  1780. exit 0
  1781.  
  1782.