home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume8 / chaos / part08 < prev    next >
Internet Message Format  |  1990-08-20  |  59KB
  1. Path: uunet!cs.utexas.edu!sun-barr!newstop!sun!uunet.UU.NET
  2. From: balr!panasun!ken@uunet.UU.NET (Ken Marks (x2425))
  3. Newsgroups: comp.sources.x
  4. Subject: v08i084: chaos, Part08/10
  5. Message-ID: <140962@sun.Eng.Sun.COM>
  6. Date: 20 Aug 90 18:04:09 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 2939
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: balr!panasun!ken@uunet.UU.NET (Ken Marks (x2425))
  12. Posting-number: Volume 8, Issue 84
  13. Archive-name: chaos/part08
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then unpack
  17. # it by saving it into a file and typing "sh file".  To overwrite existing
  18. # files, type "sh file -c".  You can also feed this as standard input via
  19. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  20. # will see the following message at the end:
  21. #        "End of archive 8 (of 10)."
  22. # Contents:  common/file.c common/ipc.c drone/doPropNotify.c
  23. #   drone/propNotify.c headers/patchlevel.h maps/default.map
  24. #   maps/special3.map maps/special4.map maps/special8.map
  25. #   maps/white.map master/Chaos.ad master/messageDb.c master/queue.c
  26. #   master/task.c
  27. # Wrapped by ken@panasun on Mon Jul 30 14:59:50 1990
  28. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  29. if test -f 'common/file.c' -a "${1}" != "-c" ; then 
  30.   echo shar: Will not clobber existing file \"'common/file.c'\"
  31. else
  32. echo shar: Extracting \"'common/file.c'\" \(6004 characters\)
  33. sed "s/^X//" >'common/file.c' <<'END_OF_FILE'
  34. X/*
  35. X * Copyright (c) Ken W. Marks 1989, 1990.
  36. X */
  37. X
  38. X#include <stdio.h>
  39. X#include <fcntl.h>
  40. X#include <signal.h>
  41. X#include <string.h>
  42. X#include <ctype.h>
  43. X#include <X11/Xos.h>
  44. X#include <sys/dir.h>
  45. X#include <sys/stat.h>
  46. X#include <X11/Intrinsic.h>
  47. X#include <Chaos.h>
  48. X
  49. X#define FAIL        -1
  50. X#define LXOR(a,b)    ((!(a)&&(b)) || (!(b)&&(a)))
  51. X#define MALLOC_FACTOR    10
  52. X
  53. X
  54. X/*
  55. X * Function:    Match
  56. X *
  57. X * Purpose :    Given two strings, determine if they match.  The pattern
  58. X *        string can contain wildcards.
  59. X *        ?    Match any single character
  60. X *        *    Match any string of characters
  61. X *        [...]    Match any one of the enclosed characters. A
  62. X *            pair of characters separated by - matches any
  63. X *            character lexically between the pair, inclusive.
  64. X *            If the first character after the opening [ is a
  65. X *            ! then any character not enclosed is matched. A
  66. X *            - can included in the character set by putting it
  67. X *            as the first or last character.
  68. X *
  69. X * Returns:    1 if the string matches the pattern, 0 if not.
  70. X */
  71. X
  72. XMatch(pat, str)
  73. Xchar *pat;            /* the pattern */
  74. Xchar *str;            /* the string */
  75. X{
  76. X    char sc;
  77. X    char pc;
  78. X
  79. X    sc = *str++;
  80. X    switch (pc = *pat++)
  81. X    {
  82. X    case '[':
  83. X    {
  84. X        int ok = 0;        /* Has a match been made with the characters
  85. X                 * between the [] */
  86. X        int lc = -1;    /* Last character from pattern */
  87. X        int notflag = 0;    /* Include or exclude? */
  88. X
  89. X        if (*pat == '!')
  90. X        {
  91. X        notflag = 1;
  92. X        pat++;
  93. X        }
  94. X
  95. X        /* SUPPRESS 560 */
  96. X        while (pc = *pat++)
  97. X        {
  98. X        if (pc == ']')
  99. X            return (ok ? Match(pat, str) : 0);
  100. X        else if (pc == '-')
  101. X        {
  102. X            if (lc == -1 || *pat == ']')
  103. X            {
  104. X            if (LXOR((sc == pc), (notflag)))
  105. X                ok++;
  106. X            else if (notflag && sc == pc)
  107. X                return (0);
  108. X            }
  109. X            else if (notflag)
  110. X            if (lc > sc || sc > *(pat++))
  111. X                ok++;
  112. X            else
  113. X                return (0);
  114. X            else if (lc <= sc && sc <= (*pat++))
  115. X            ok++;
  116. X        }
  117. X        else if (notflag)
  118. X            if (sc != (lc = pc))
  119. X            ok++;
  120. X            else
  121. X            return (0);
  122. X        else if (sc == (lc = pc))
  123. X            ok++;
  124. X        }
  125. X        return (0);
  126. X    }
  127. X
  128. X    case '?':
  129. X    return (sc ? Match(pat, str) : 0);    /* Does the rest of the string
  130. X                         * match the rest of the
  131. X                         * pattern? */
  132. X
  133. X    case '*':
  134. X    if (*pat == '\0')
  135. X        return (1);        /* guaranteed match if we're at the end of the
  136. X                 * pattern */
  137. X
  138. X    /* Try to find a substring of s that will match the     */
  139. X    /* rest of the pattern.                     */
  140. X    --str;
  141. X    while (*str)
  142. X        if (Match(pat, str++))
  143. X        return (1);
  144. X    return (0);        /* couldn't find a substring - no match */
  145. X
  146. X    case '\0':            /* end of pattern */
  147. X    return (sc == '\0');    /* match if s ends as well */
  148. X
  149. X    default:
  150. X    if (pc != sc)
  151. X        return (0);
  152. X    return (sc ? Match(pat, str) : 0);    /* check to see if the rest of
  153. X                         * the strings match */
  154. X    }
  155. X}
  156. X
  157. X
  158. Xint compar(a, b)
  159. Xchar **a;
  160. Xchar **b;
  161. X{
  162. X    return (strcmp(*a, *b));
  163. X}
  164. X
  165. X
  166. Xchar **GetFileList(path, pattern)
  167. Xchar *path;
  168. Xchar *pattern;
  169. X{
  170. X#ifdef SYSV
  171. X    FILE *dirstr;
  172. X#else
  173. X    DIR *dirp;
  174. X#endif
  175. X    struct direct dirent;
  176. X    struct direct *pdirent = &dirent;
  177. X    struct stat status;
  178. X    char **files = NULL;
  179. X    int nitems = 0;
  180. X    int nitems_alloced = 0;
  181. X    char full_path[256];
  182. X    char *filename;
  183. X    extern int qsort();
  184. X    extern int errno;
  185. X
  186. X    (void) strcpy(full_path, path);
  187. X    filename = &full_path[strlen(path)];
  188. X    *filename++ = '/';
  189. X
  190. X#ifdef SYSV
  191. X    if ((dirstr = fopen(path, "r")) == NULL)
  192. X    {
  193. X    eprintf("Can't open %s (errno=%d)\n", path, errno);
  194. X    return (NULL);
  195. X    }
  196. X    while (fread((char *) &dirent, sizeof(struct direct), 1, dirstr) == 1)
  197. X#else
  198. X    if ((dirp = opendir(path)) == NULL)
  199. X    {
  200. X    eprintf("Can't open '%s'\n", path);
  201. X    return (NULL);
  202. X    }
  203. X    while ((pdirent = readdir(dirp)) != NULL)
  204. X#endif
  205. X    {
  206. X    (void) strcpy(filename, pdirent->d_name);
  207. X    if (stat(full_path, &status) == FAIL)
  208. X    {
  209. X        eprintf("Can't stat '%s' (errno=%d)\n",
  210. X          full_path, errno);
  211. X        if (files != NULL)
  212. X        free((char *) files);
  213. X        return (NULL);
  214. X    }
  215. X    if ((status.st_mode & S_IFMT) == S_IFREG &&
  216. X      Match(pattern, pdirent->d_name))
  217. X    {
  218. X        if (++nitems > nitems_alloced)
  219. X        {
  220. X        if (nitems_alloced == 0)
  221. X        {
  222. X            nitems_alloced = MALLOC_FACTOR;
  223. X            files = (char **) malloc((unsigned) (nitems_alloced *
  224. X            sizeof(char *)));
  225. X        }
  226. X        else
  227. X        {
  228. X            nitems_alloced += MALLOC_FACTOR;
  229. X            files = (char **) realloc((char *) files,
  230. X              (unsigned) (nitems_alloced * sizeof(char *)));
  231. X        }
  232. X        }
  233. X        files[nitems - 1] = strcpy(malloc(pdirent->d_namlen + 1),
  234. X          pdirent->d_name);
  235. X    }
  236. X    }
  237. X
  238. X#ifdef SYSV
  239. X    fclose(dirstr);
  240. X#else
  241. X    (void) closedir(dirp);
  242. X#endif
  243. X
  244. X    qsort((char *) files, nitems, sizeof(char *), compar);
  245. X
  246. X    if (files == NULL)
  247. X    files = (char **) malloc(sizeof(char *));
  248. X    else
  249. X    files = (char **) realloc((char *) files,
  250. X      (unsigned) ((nitems + 1) * sizeof(char *)));
  251. X
  252. X    files[nitems] = NULL;
  253. X    return (files);
  254. X}
  255. X
  256. X
  257. Xvoid FreeFileList(files)
  258. Xchar **files;
  259. X{
  260. X    char **ptr = files;
  261. X
  262. X    while (*ptr)
  263. X    free((char *) (*ptr++));
  264. X    free((char *) files);
  265. X}
  266. X
  267. X
  268. XBoolean FileExists(dir, filename)
  269. Xchar *dir;
  270. Xchar *filename;
  271. X{
  272. X    char path[128];
  273. X    int fd;
  274. X
  275. X    (void) sprintf(path, "%s/%s", dir, filename);
  276. X
  277. X    if ((fd = open(path, O_RDONLY)) > 0)
  278. X    {
  279. X    (void) close(fd);
  280. X    return (True);
  281. X    }
  282. X    return (False);
  283. X}
  284. X
  285. X
  286. XBoolean RemoveFile(dir, filename)
  287. Xchar *dir;
  288. Xchar *filename;
  289. X{
  290. X    char path[128];
  291. X
  292. X    (void) sprintf(path, "%s/%s", dir, filename);
  293. X
  294. X    if (unlink(path) != 0)
  295. X    return (False);
  296. X    else
  297. X    return (True);
  298. X}
  299. X
  300. X
  301. Xchar *FileCheckFilename(filename, extension)
  302. Xchar *filename;
  303. Xchar *extension;
  304. X{
  305. X    static char buffer[128];
  306. X    char *ptr;
  307. X    char *bptr = buffer;
  308. X    extern char *strrchr();
  309. X
  310. X    /* Attempt to strip off any and all path elements */
  311. X    ptr = strrchr(filename, '/');
  312. X    if (ptr == NULL)
  313. X    ptr = filename;
  314. X    else
  315. X    ++ptr;
  316. X
  317. X    /* Scan off any leading white space */
  318. X    while (isspace(*ptr))
  319. X    ++ptr;
  320. X
  321. X    while (*ptr != '\0' && *ptr != '.' && !isspace(*ptr))
  322. X    *bptr++ = *ptr++;
  323. X
  324. X    /* If there was not detectable base name */
  325. X    if (bptr == buffer)
  326. X    return (NULL);
  327. X
  328. X    /* Add extension */
  329. X    (void) strcpy(bptr, extension);
  330. X
  331. X    return (buffer);
  332. X}
  333. END_OF_FILE
  334. if test 6004 -ne `wc -c <'common/file.c'`; then
  335.     echo shar: \"'common/file.c'\" unpacked with wrong size!
  336. fi
  337. # end of 'common/file.c'
  338. fi
  339. if test -f 'common/ipc.c' -a "${1}" != "-c" ; then 
  340.   echo shar: Will not clobber existing file \"'common/ipc.c'\"
  341. else
  342. echo shar: Extracting \"'common/ipc.c'\" \(2887 characters\)
  343. sed "s/^X//" >'common/ipc.c' <<'END_OF_FILE'
  344. X/*
  345. X * Copyright (c) Ken W. Marks 1989, 1990.
  346. X */
  347. X
  348. X#include <stdio.h>
  349. X#include <X11/Intrinsic.h>
  350. X#include <X11/StringDefs.h>
  351. X#include <Chaos.h>
  352. X#include <Ipc.h>
  353. X
  354. Xstatic Cardinal pad_amount[] = {0, 3, 2, 1};
  355. X
  356. X/* macro for padding a length to an even multiple of 4 (uses pad_amount[]) */
  357. X#define PAD(length) ((length) + pad_amount[(length) & 3])
  358. X
  359. Xstatic Window recv_window;
  360. X
  361. XAtom CHAOS_WINDOW;
  362. XAtom MAILBOX;
  363. XAtom MESSAGE_TYPE;
  364. XAtom REGISTRATION_EVENT;
  365. X
  366. Xextern Display *dpy;
  367. X
  368. X
  369. XBoolean InitIpc(window)
  370. XWindow window;
  371. X{
  372. X    recv_window = window;
  373. X
  374. X    CHAOS_WINDOW = XInternAtom(dpy, "CHAOS_WINDOW", False);
  375. X    MAILBOX = XInternAtom(dpy, "MAILBOX", False);
  376. X    MESSAGE_TYPE = XInternAtom(dpy, "MESSAGE_TYPE", False);
  377. X    REGISTRATION_EVENT = XInternAtom(dpy, "REGISTRATION_EVENT", False);
  378. X
  379. X    return (CHAOS_WINDOW && MAILBOX && MESSAGE_TYPE && REGISTRATION_EVENT);
  380. X}
  381. X
  382. X
  383. Xvoid SetOwner(atom)
  384. XAtom atom;
  385. X{
  386. X    Window current_owner;
  387. X    char *atom_name;
  388. X
  389. X    if ((current_owner = XGetSelectionOwner(dpy, atom)) != NULL)
  390. X    {
  391. X    atom_name = XGetAtomName(dpy, atom);
  392. X    eprintf("%s is currently owned by window 0x%lx\n",
  393. X      atom_name, current_owner);
  394. X    exit(1);
  395. X    }
  396. X    XSetSelectionOwner(dpy, atom, recv_window, CurrentTime);
  397. X
  398. X    if (XGetSelectionOwner(dpy, CHAOS_WINDOW) != recv_window)
  399. X    {
  400. X    atom_name = XGetAtomName(dpy, atom);
  401. X    eprintf("Could not become owner of %s selection\n", atom_name);
  402. X    abort();
  403. X    }
  404. X}
  405. X
  406. X
  407. XWindow GetOwner(atom)
  408. XAtom atom;
  409. X{
  410. X    Window owner;
  411. X
  412. X    owner = XGetSelectionOwner(dpy, atom);
  413. X    return (owner);
  414. X}
  415. X
  416. X
  417. XBoolean SendMsg(window, msg_len, msg)
  418. XWindow window;
  419. Xunsigned msg_len;
  420. Xchar *msg;
  421. X{
  422. X    extern int error_status;
  423. X    extern int allow_errors;
  424. X
  425. X    XSync(dpy, False);        /* Flush out all other requests */
  426. X
  427. X    error_status = Success;    /* Feign optimism */
  428. X    allow_errors = True;    /* Don't protest if we generate an error */
  429. X
  430. X    XChangeProperty(dpy, window, MAILBOX, MESSAGE_TYPE, 8, PropModeAppend,
  431. X      msg, PAD(msg_len));
  432. X
  433. X    XSync(dpy, False);        /* Make sure this request has been sent */
  434. X
  435. X    allow_errors = False;    /* Report future errors */
  436. X
  437. X    return (error_status == Success);
  438. X}
  439. X
  440. X
  441. XBoolean RecvMsg(msg, msg_len)
  442. Xchar **msg;
  443. Xunsigned long *msg_len;
  444. X{
  445. X    Atom actual_type;
  446. X    int actual_format;
  447. X    unsigned long bytes_after;
  448. X    int result;
  449. X
  450. X    result = XGetWindowProperty(dpy, recv_window, MAILBOX, 0, 65536, True,
  451. X      AnyPropertyType, &actual_type, &actual_format, msg_len, &bytes_after,
  452. X      msg);
  453. X
  454. X    if (result == BadWindow)
  455. X    {
  456. X    eprintf("Invalid window (0x%lx)\n", recv_window);
  457. X    *msg = NULL;
  458. X    return (False);
  459. X    }
  460. X    if (actual_type == None)
  461. X    {
  462. X    eprintf("No message was read from property\n");
  463. X    *msg = NULL;
  464. X    return (False);
  465. X    }
  466. X    if (actual_type != MESSAGE_TYPE)
  467. X    {
  468. X    eprintf("Invalid message type (%d)\n", actual_type);
  469. X    free(*msg);        /* throw away erroneous message */
  470. X    *msg = NULL;
  471. X    return (False);
  472. X    }
  473. X    return (True);
  474. X}
  475. END_OF_FILE
  476. if test 2887 -ne `wc -c <'common/ipc.c'`; then
  477.     echo shar: \"'common/ipc.c'\" unpacked with wrong size!
  478. fi
  479. # end of 'common/ipc.c'
  480. fi
  481. if test -f 'drone/doPropNotify.c' -a "${1}" != "-c" ; then 
  482.   echo shar: Will not clobber existing file \"'drone/doPropNotify.c'\"
  483. else
  484. echo shar: Extracting \"'drone/doPropNotify.c'\" \(4875 characters\)
  485. sed "s/^X//" >'drone/doPropNotify.c' <<'END_OF_FILE'
  486. X/*
  487. X * Copyright (c) Ken W. Marks 1989, 1990.
  488. X */
  489. X
  490. X#include <stdio.h>
  491. X#include <X11/Intrinsic.h>
  492. X#include <Ipc.h>
  493. X#include <Chaos.h>
  494. X
  495. X/* This is the default static buffer size */
  496. X#define BUFFER_SIZE     10000
  497. X
  498. Xextern void SwapImageRequest();
  499. Xextern void SwapImageResponse();
  500. Xextern void ComputeMandelbrot();
  501. Xextern void ComputeJulia();
  502. X
  503. Xvoid DoPropNotify(event)
  504. XXPropertyEvent *event;
  505. X{
  506. X    extern Window master_window;
  507. X    char *msg;
  508. X    unsigned long msg_len;
  509. X    GenericMessage generic;
  510. X    ImageRequest *req;
  511. X    static int read_ahead = 0;
  512. X    static char buffer[BUFFER_SIZE];
  513. X    unsigned int data_size;
  514. X    long byte_order;
  515. X    ImageResponse *resp;
  516. X    XEvent dummy_event;
  517. X    extern void ByteSwapLong();
  518. X
  519. X    if (event->atom != MAILBOX)
  520. X    {
  521. X    /* must have been some other property (handle as usual) */
  522. X    return;
  523. X    }
  524. X    if (event->state != PropertyNewValue)
  525. X    {
  526. X    /* Generally, ignore the PropertyDelete events. they are generated by
  527. X     * our destructive reads on the property and since we can't stop them
  528. X     * we must simply ignore them. */
  529. X    return;
  530. X    }
  531. X
  532. X    /* The counter read_ahead will become greater than zero when multiple
  533. X     * messages are read from the property in response to a single
  534. X     * PropertyNotify event.  By keeping track of how many messages we have
  535. X     * "read ahead" of the events, we do not attempt to read from an empty
  536. X     * property. */
  537. X    if (--read_ahead > 0)
  538. X    return;
  539. X
  540. X    if (RecvMsg(&msg, &msg_len) == False)
  541. X    {
  542. X#ifdef DEBUG
  543. X    dprintf("Could not receive message\n");
  544. X#endif
  545. X    return;
  546. X    }
  547. X
  548. X    (void) memcpy((char *) &generic, msg, sizeof(GenericMessage));
  549. X
  550. X    if (generic.byte_order != 0x11223344)
  551. X    ByteSwapLong((char *) &generic, 2 * sizeof(long));
  552. X
  553. X    if (generic.type == TERMINATE_REQUEST)
  554. X    /* Goodbye cruel world... */
  555. X    exit(0);
  556. X    else if (generic.type != IMAGE_REQUEST)
  557. X    {
  558. X#ifdef DEBUG
  559. X    dprintf("Unknown message type: %d\n", generic.type);
  560. X#endif
  561. X    abort();
  562. X    }
  563. X
  564. X    /* Otherwise, must be an image request */
  565. X    req = (ImageRequest *) msg;
  566. X
  567. X    byte_order = req->byte_order;
  568. X
  569. X    if (byte_order != 0x11223344)
  570. X    ByteSwapLong((char *) req, 7 * sizeof(long));
  571. X
  572. X#ifdef DEBUG
  573. X    (void) printf("ImageRequest\n");
  574. X    (void) printf("  byte_order:   0x%x\n", req->byte_order);
  575. X    (void) printf("        type:   %d\n", req->type);
  576. X    (void) printf("      serial:   %d\n", req->serial);
  577. X    (void) printf("       width:   %d\n", req->width);
  578. X    (void) printf("      height:   %d\n", req->height);
  579. X    (void) printf("       limit:   %d\n", req->limit);
  580. X    (void) printf("      method:   %d\n", req->method);
  581. X    (void) printf("        p_lo:   %s\n", req->p_lo);
  582. X    (void) printf("        p_hi:   %s\n", req->p_hi);
  583. X    (void) printf("        q_lo:   %s\n", req->q_lo);
  584. X    (void) printf("        q_hi:   %s\n", req->q_hi);
  585. X    (void) printf("\n\n");
  586. X#endif
  587. X
  588. X    data_size = DATA_SIZE(req->width, req->height);
  589. X
  590. X    if (data_size > BUFFER_SIZE)
  591. X    {
  592. X    if ((resp = (ImageResponse *) malloc(data_size)) == NULL)
  593. X    {
  594. X#ifdef DEBUG
  595. X        dprintf("Can't allocate %d bytes\n", data_size);
  596. X#endif
  597. X        exit(1);
  598. X    }
  599. X    }
  600. X    else
  601. X    {
  602. X    resp = (ImageResponse *) buffer;
  603. X    }
  604. X
  605. X    switch (req->method)
  606. X    {
  607. X    case MANDELBROT:
  608. X    ComputeMandelbrot(req, resp);
  609. X    break;
  610. X
  611. X    case JULIA:
  612. X    /* This is here for future expansion.  Possibly, pressing the middle 
  613. X     * mouse button at a point within the Mandelbrot set will cause a 
  614. X     * popup window to be displayed which will draw the Julia set for the 
  615. X     * selected point. This window size would be set from the settings
  616. X     * dialogbox. */
  617. X
  618. X#ifdef DEBUG
  619. X    dprintf("Julia sets not implemented yet!\n");
  620. X#endif
  621. X    abort();
  622. X    break;
  623. X
  624. X    default:
  625. X#ifdef DEBUG
  626. X    dprintf("Invalid method: %d\n", req->method);
  627. X#endif
  628. X    abort();
  629. X    }
  630. X
  631. X    resp->type = IMAGE_RESPONSE;
  632. X
  633. X#ifdef DEBUG
  634. X    (void) printf("ImageResponse\n");
  635. X    (void) printf("  byte_order:   0x%x\n", resp->byte_order);
  636. X    (void) printf("        type:   %d\n", resp->type);
  637. X    (void) printf("      serial:   %d\n", resp->serial);
  638. X    (void) printf("       width:   %d\n", resp->width);
  639. X    (void) printf("      height:   %d\n", resp->height);
  640. X    (void) printf("    max_iter:   %d\n", resp->max_iter);
  641. X    (void) printf("\n\n");
  642. X#endif
  643. X
  644. X    /* Swap the response back to the master's byte order */
  645. X    if (byte_order != 0x11223344)
  646. X    ByteSwapLong((char *) resp, 6 * sizeof(long));
  647. X
  648. X    /* See if the master has terminated while we were busy computing the
  649. X     * response.  If there is a DestroyNotify event on the queue, then there
  650. X     * is no reason to go on... */
  651. X    if (XCheckTypedEvent(event->display, DestroyNotify, &dummy_event))
  652. X    exit(0);
  653. X
  654. X    if (SendMsg(master_window, data_size, (char *) resp) == False)
  655. X    {
  656. X#ifdef DEBUG
  657. X    dprintf("SendMsg failed - terminating\n");
  658. X#endif
  659. X    exit(1);
  660. X    }
  661. X
  662. X    /* Free the data (only if it was malloced) */
  663. X    if ((char *) resp != buffer)
  664. X    free((char *) resp);
  665. X
  666. X    free((char *) msg);
  667. X}
  668. END_OF_FILE
  669. if test 4875 -ne `wc -c <'drone/doPropNotify.c'`; then
  670.     echo shar: \"'drone/doPropNotify.c'\" unpacked with wrong size!
  671. fi
  672. # end of 'drone/doPropNotify.c'
  673. fi
  674. if test -f 'drone/propNotify.c' -a "${1}" != "-c" ; then 
  675.   echo shar: Will not clobber existing file \"'drone/propNotify.c'\"
  676. else
  677. echo shar: Extracting \"'drone/propNotify.c'\" \(4875 characters\)
  678. sed "s/^X//" >'drone/propNotify.c' <<'END_OF_FILE'
  679. X/*
  680. X * Copyright (c) Ken W. Marks 1989, 1990.
  681. X */
  682. X
  683. X#include <stdio.h>
  684. X#include <X11/Intrinsic.h>
  685. X#include <Ipc.h>
  686. X#include <Chaos.h>
  687. X
  688. X/* This is the default static buffer size */
  689. X#define BUFFER_SIZE     10000
  690. X
  691. Xextern void SwapImageRequest();
  692. Xextern void SwapImageResponse();
  693. Xextern void ComputeMandelbrot();
  694. Xextern void ComputeJulia();
  695. X
  696. Xvoid DoPropNotify(event)
  697. XXPropertyEvent *event;
  698. X{
  699. X    extern Window master_window;
  700. X    char *msg;
  701. X    unsigned long msg_len;
  702. X    GenericMessage generic;
  703. X    ImageRequest *req;
  704. X    static int read_ahead = 0;
  705. X    static char buffer[BUFFER_SIZE];
  706. X    unsigned int data_size;
  707. X    long byte_order;
  708. X    ImageResponse *resp;
  709. X    XEvent dummy_event;
  710. X    extern void ByteSwapLong();
  711. X
  712. X    if (event->atom != MAILBOX)
  713. X    {
  714. X    /* must have been some other property (handle as usual) */
  715. X    return;
  716. X    }
  717. X    if (event->state != PropertyNewValue)
  718. X    {
  719. X    /* Generally, ignore the PropertyDelete events. they are generated by
  720. X     * our destructive reads on the property and since we can't stop them
  721. X     * we must simply ignore them. */
  722. X    return;
  723. X    }
  724. X
  725. X    /* The counter read_ahead will become greater than zero when multiple
  726. X     * messages are read from the property in response to a single
  727. X     * PropertyNotify event.  By keeping track of how many messages we have
  728. X     * "read ahead" of the events, we do not attempt to read from an empty
  729. X     * property. */
  730. X    if (--read_ahead > 0)
  731. X    return;
  732. X
  733. X    if (RecvMsg(&msg, &msg_len) == False)
  734. X    {
  735. X#ifdef DEBUG
  736. X    dprintf("Could not receive message\n");
  737. X#endif
  738. X    return;
  739. X    }
  740. X
  741. X    (void) memcpy((char *) &generic, msg, sizeof(GenericMessage));
  742. X
  743. X    if (generic.byte_order != 0x11223344)
  744. X    ByteSwapLong((char *) &generic, 2 * sizeof(long));
  745. X
  746. X    if (generic.type == TERMINATE_REQUEST)
  747. X    /* Goodbye cruel world... */
  748. X    exit(0);
  749. X    else if (generic.type != IMAGE_REQUEST)
  750. X    {
  751. X#ifdef DEBUG
  752. X    dprintf("Unknown message type: %d\n", generic.type);
  753. X#endif
  754. X    abort();
  755. X    }
  756. X
  757. X    /* Otherwise, must be an image request */
  758. X    req = (ImageRequest *) msg;
  759. X
  760. X    byte_order = req->byte_order;
  761. X
  762. X    if (byte_order != 0x11223344)
  763. X    ByteSwapLong((char *) req, 7 * sizeof(long));
  764. X
  765. X#ifdef DEBUG
  766. X    (void) printf("ImageRequest\n");
  767. X    (void) printf("  byte_order:   0x%x\n", req->byte_order);
  768. X    (void) printf("        type:   %d\n", req->type);
  769. X    (void) printf("      serial:   %d\n", req->serial);
  770. X    (void) printf("       width:   %d\n", req->width);
  771. X    (void) printf("      height:   %d\n", req->height);
  772. X    (void) printf("       limit:   %d\n", req->limit);
  773. X    (void) printf("      method:   %d\n", req->method);
  774. X    (void) printf("        p_lo:   %s\n", req->p_lo);
  775. X    (void) printf("        p_hi:   %s\n", req->p_hi);
  776. X    (void) printf("        q_lo:   %s\n", req->q_lo);
  777. X    (void) printf("        q_hi:   %s\n", req->q_hi);
  778. X    (void) printf("\n\n");
  779. X#endif
  780. X
  781. X    data_size = DATA_SIZE(req->width, req->height);
  782. X
  783. X    if (data_size > BUFFER_SIZE)
  784. X    {
  785. X    if ((resp = (ImageResponse *) malloc(data_size)) == NULL)
  786. X    {
  787. X#ifdef DEBUG
  788. X        dprintf("Can't allocate %d bytes\n", data_size);
  789. X#endif
  790. X        exit(1);
  791. X    }
  792. X    }
  793. X    else
  794. X    {
  795. X    resp = (ImageResponse *) buffer;
  796. X    }
  797. X
  798. X    switch (req->method)
  799. X    {
  800. X    case MANDELBROT:
  801. X    ComputeMandelbrot(req, resp);
  802. X    break;
  803. X
  804. X    case JULIA:
  805. X    /* This is here for future expansion.  Possibly, pressing the middle 
  806. X     * mouse button at a point within the Mandelbrot set will cause a 
  807. X     * popup window to be displayed which will draw the Julia set for the 
  808. X     * selected point. This window size would be set from the settings
  809. X     * dialogbox. */
  810. X
  811. X#ifdef DEBUG
  812. X    dprintf("Julia sets not implemented yet!\n");
  813. X#endif
  814. X    abort();
  815. X    break;
  816. X
  817. X    default:
  818. X#ifdef DEBUG
  819. X    dprintf("Invalid method: %d\n", req->method);
  820. X#endif
  821. X    abort();
  822. X    }
  823. X
  824. X    resp->type = IMAGE_RESPONSE;
  825. X
  826. X#ifdef DEBUG
  827. X    (void) printf("ImageResponse\n");
  828. X    (void) printf("  byte_order:   0x%x\n", resp->byte_order);
  829. X    (void) printf("        type:   %d\n", resp->type);
  830. X    (void) printf("      serial:   %d\n", resp->serial);
  831. X    (void) printf("       width:   %d\n", resp->width);
  832. X    (void) printf("      height:   %d\n", resp->height);
  833. X    (void) printf("    max_iter:   %d\n", resp->max_iter);
  834. X    (void) printf("\n\n");
  835. X#endif
  836. X
  837. X    /* Swap the response back to the master's byte order */
  838. X    if (byte_order != 0x11223344)
  839. X    ByteSwapLong((char *) resp, 6 * sizeof(long));
  840. X
  841. X    /* See if the master has terminated while we were busy computing the
  842. X     * response.  If there is a DestroyNotify event on the queue, then there
  843. X     * is no reason to go on... */
  844. X    if (XCheckTypedEvent(event->display, DestroyNotify, &dummy_event))
  845. X    exit(0);
  846. X
  847. X    if (SendMsg(master_window, data_size, (char *) resp) == False)
  848. X    {
  849. X#ifdef DEBUG
  850. X    dprintf("SendMsg failed - terminating\n");
  851. X#endif
  852. X    exit(1);
  853. X    }
  854. X
  855. X    /* Free the data (only if it was malloced) */
  856. X    if ((char *) resp != buffer)
  857. X    free((char *) resp);
  858. X
  859. X    free((char *) msg);
  860. X}
  861. END_OF_FILE
  862. if test 4875 -ne `wc -c <'drone/propNotify.c'`; then
  863.     echo shar: \"'drone/propNotify.c'\" unpacked with wrong size!
  864. fi
  865. # end of 'drone/propNotify.c'
  866. fi
  867. if test -f 'headers/patchlevel.h' -a "${1}" != "-c" ; then 
  868.   echo shar: Will not clobber existing file \"'headers/patchlevel.h'\"
  869. else
  870. echo shar: Extracting \"'headers/patchlevel.h'\" \(21 characters\)
  871. sed "s/^X//" >'headers/patchlevel.h' <<'END_OF_FILE'
  872. X#define PATCHLEVEL 1
  873. END_OF_FILE
  874. if test 21 -ne `wc -c <'headers/patchlevel.h'`; then
  875.     echo shar: \"'headers/patchlevel.h'\" unpacked with wrong size!
  876. fi
  877. # end of 'headers/patchlevel.h'
  878. fi
  879. if test -f 'maps/default.map' -a "${1}" != "-c" ; then 
  880.   echo shar: Will not clobber existing file \"'maps/default.map'\"
  881. else
  882. echo shar: Extracting \"'maps/default.map'\" \(2830 characters\)
  883. sed "s/^X//" >'maps/default.map' <<'END_OF_FILE'
  884. X0 0 0
  885. X0 0 0
  886. X0 0 0
  887. X0 0 0
  888. X0 0 0
  889. X0 220 220
  890. X6 217 223
  891. X12 214 226
  892. X19 210 229
  893. X25 206 232
  894. X31 203 235
  895. X38 199 237
  896. X44 195 239
  897. X50 191 241
  898. X56 186 243
  899. X63 182 245
  900. X69 177 247
  901. X75 173 248
  902. X81 168 250
  903. X87 163 251
  904. X93 158 252
  905. X99 153 253
  906. X105 148 253
  907. X111 143 254
  908. X116 137 254
  909. X122 132 254
  910. X127 127 254
  911. X133 121 254
  912. X138 115 254
  913. X144 110 254
  914. X149 104 253
  915. X154 98 252
  916. X159 92 252
  917. X164 86 251
  918. X169 80 249
  919. X174 74 248
  920. X178 68 246
  921. X183 62 245
  922. X187 55 243
  923. X191 49 241
  924. X195 43 239
  925. X199 37 237
  926. X203 30 234
  927. X207 24 232
  928. X211 18 229
  929. X214 11 226
  930. X218 5 223
  931. X221 1 220
  932. X224 7 217
  933. X227 13 213
  934. X230 20 210
  935. X232 26 206
  936. X235 32 202
  937. X237 39 198
  938. X240 45 194
  939. X242 51 190
  940. X244 58 186
  941. X245 64 181
  942. X247 70 177
  943. X248 76 172
  944. X250 82 167
  945. X251 88 162
  946. X252 94 157
  947. X253 100 152
  948. X253 106 147
  949. X254 112 142
  950. X254 117 137
  951. X254 123 131
  952. X254 128 126
  953. X254 134 120
  954. X254 139 114
  955. X254 145 109
  956. X253 150 103
  957. X252 155 97
  958. X251 160 91
  959. X250 165 85
  960. X249 170 79
  961. X248 174 73
  962. X246 179 67
  963. X244 183 61
  964. X243 188 54
  965. X241 192 48
  966. X238 196 42
  967. X236 200 36
  968. X234 204 29
  969. X231 208 23
  970. X228 211 17
  971. X225 215 10
  972. X222 218 4
  973. X219 221 2
  974. X216 224 8
  975. X213 227 14
  976. X209 230 21
  977. X205 233 27
  978. X201 235 33
  979. X197 238 40
  980. X193 240 46
  981. X189 242 52
  982. X185 244 59
  983. X180 246 65
  984. X176 247 71
  985. X171 249 77
  986. X166 250 83
  987. X162 251 89
  988. X157 252 95
  989. X151 253 101
  990. X146 253 107
  991. X141 254 112
  992. X136 254 118
  993. X130 254 124
  994. X125 254 129
  995. X119 254 135
  996. X113 254 140
  997. X108 254 145
  998. X102 253 151
  999. X96 252 156
  1000. X90 251 161
  1001. X84 250 166
  1002. X78 249 170
  1003. X72 247 175
  1004. X66 246 180
  1005. X60 244 184
  1006. X53 242 188
  1007. X47 240 193
  1008. X41 238 197
  1009. X34 236 201
  1010. X28 233 205
  1011. X22 231 208
  1012. X15 228 212
  1013. X9 225 215
  1014. X3 222 219
  1015. X3 219 222
  1016. X9 215 225
  1017. X15 212 228
  1018. X22 208 231
  1019. X28 205 233
  1020. X34 201 236
  1021. X41 197 238
  1022. X47 193 240
  1023. X53 188 242
  1024. X60 184 244
  1025. X66 180 246
  1026. X72 175 247
  1027. X78 170 249
  1028. X84 166 250
  1029. X90 161 251
  1030. X96 156 252
  1031. X102 151 253
  1032. X108 145 254
  1033. X113 140 254
  1034. X119 135 254
  1035. X125 129 254
  1036. X130 124 254
  1037. X136 118 254
  1038. X141 112 254
  1039. X146 107 253
  1040. X151 101 253
  1041. X157 95 252
  1042. X162 89 251
  1043. X166 83 250
  1044. X171 77 249
  1045. X176 71 247
  1046. X180 65 246
  1047. X185 59 244
  1048. X189 52 242
  1049. X193 46 240
  1050. X197 40 238
  1051. X201 33 235
  1052. X205 27 233
  1053. X209 21 230
  1054. X213 14 227
  1055. X216 8 224
  1056. X219 2 221
  1057. X222 4 218
  1058. X225 10 215
  1059. X228 17 211
  1060. X231 23 208
  1061. X234 29 204
  1062. X236 36 200
  1063. X238 42 196
  1064. X241 48 192
  1065. X243 54 188
  1066. X244 61 183
  1067. X246 67 179
  1068. X248 73 174
  1069. X249 79 170
  1070. X250 85 165
  1071. X251 91 160
  1072. X252 97 155
  1073. X253 103 150
  1074. X254 109 145
  1075. X254 114 139
  1076. X254 120 134
  1077. X254 126 128
  1078. X254 131 123
  1079. X254 137 117
  1080. X254 142 112
  1081. X253 147 106
  1082. X253 152 100
  1083. X252 157 94
  1084. X251 162 88
  1085. X250 167 82
  1086. X248 172 76
  1087. X247 177 70
  1088. X245 181 64
  1089. X244 186 58
  1090. X242 190 51
  1091. X240 194 45
  1092. X237 198 39
  1093. X235 202 32
  1094. X232 206 26
  1095. X230 210 20
  1096. X227 213 13
  1097. X224 217 7
  1098. X221 220 1
  1099. X218 223 5
  1100. X214 226 11
  1101. X211 229 18
  1102. X207 232 24
  1103. X203 234 30
  1104. X199 237 37
  1105. X195 239 43
  1106. X191 241 49
  1107. X187 243 55
  1108. X183 245 62
  1109. X178 246 68
  1110. X174 248 74
  1111. X169 249 80
  1112. X164 251 86
  1113. X159 252 92
  1114. X154 252 98
  1115. X149 253 104
  1116. X144 254 110
  1117. X138 254 115
  1118. X133 254 121
  1119. X127 254 127
  1120. X122 254 132
  1121. X116 254 137
  1122. X111 254 143
  1123. X105 253 148
  1124. X99 253 153
  1125. X93 252 158
  1126. X87 251 163
  1127. X81 250 168
  1128. X75 248 173
  1129. X69 247 177
  1130. X63 245 182
  1131. X56 243 186
  1132. X50 241 191
  1133. X44 239 195
  1134. X38 237 199
  1135. X31 235 203
  1136. X25 232 206
  1137. X19 229 210
  1138. X12 226 214
  1139. X6 223 217
  1140. END_OF_FILE
  1141. if test 2830 -ne `wc -c <'maps/default.map'`; then
  1142.     echo shar: \"'maps/default.map'\" unpacked with wrong size!
  1143. fi
  1144. # end of 'maps/default.map'
  1145. fi
  1146. if test -f 'maps/special3.map' -a "${1}" != "-c" ; then 
  1147.   echo shar: Will not clobber existing file \"'maps/special3.map'\"
  1148. else
  1149. echo shar: Extracting \"'maps/special3.map'\" \(2824 characters\)
  1150. sed "s/^X//" >'maps/special3.map' <<'END_OF_FILE'
  1151. X0 0 0
  1152. X0 0 0
  1153. X0 0 0
  1154. X0 0 0
  1155. X0 0 0
  1156. X0 0 0
  1157. X0 220 220
  1158. X19 210 229
  1159. X38 199 237
  1160. X57 186 243
  1161. X75 172 248
  1162. X93 158 252
  1163. X111 142 254
  1164. X128 126 254
  1165. X144 109 254
  1166. X160 91 251
  1167. X174 73 248
  1168. X188 55 243
  1169. X200 36 236
  1170. X211 17 228
  1171. X221 2 219
  1172. X230 21 209
  1173. X238 40 197
  1174. X244 59 185
  1175. X249 77 171
  1176. X252 95 156
  1177. X254 113 141
  1178. X254 130 124
  1179. X254 146 107
  1180. X251 161 89
  1181. X247 176 71
  1182. X242 189 53
  1183. X235 201 34
  1184. X227 212 14
  1185. X218 222 4
  1186. X208 231 23
  1187. X196 239 42
  1188. X183 245 61
  1189. X169 249 79
  1190. X155 252 97
  1191. X139 254 115
  1192. X122 254 132
  1193. X105 253 148
  1194. X87 251 163
  1195. X69 247 177
  1196. X50 241 190
  1197. X31 235 203
  1198. X12 226 214
  1199. X6 217 223
  1200. X25 206 232
  1201. X44 195 239
  1202. X63 182 245
  1203. X81 168 250
  1204. X99 153 253
  1205. X117 137 254
  1206. X133 120 254
  1207. X149 103 253
  1208. X164 85 250
  1209. X179 67 246
  1210. X192 48 241
  1211. X204 29 234
  1212. X215 10 225
  1213. X224 8 216
  1214. X233 27 205
  1215. X240 46 193
  1216. X246 65 180
  1217. X250 83 166
  1218. X253 101 151
  1219. X254 119 135
  1220. X254 135 119
  1221. X253 151 101
  1222. X250 166 83
  1223. X246 180 65
  1224. X240 193 46
  1225. X233 205 27
  1226. X224 216 8
  1227. X215 225 10
  1228. X204 234 29
  1229. X192 241 48
  1230. X179 246 67
  1231. X164 250 85
  1232. X149 253 103
  1233. X133 254 120
  1234. X117 254 137
  1235. X99 253 153
  1236. X81 250 168
  1237. X63 245 182
  1238. X44 239 195
  1239. X25 232 206
  1240. X6 223 217
  1241. X12 214 226
  1242. X31 203 235
  1243. X50 190 241
  1244. X69 177 247
  1245. X87 163 251
  1246. X105 148 253
  1247. X122 132 254
  1248. X139 115 254
  1249. X155 97 252
  1250. X169 79 249
  1251. X183 61 245
  1252. X196 42 239
  1253. X208 23 231
  1254. X218 4 222
  1255. X227 14 212
  1256. X235 34 201
  1257. X242 53 189
  1258. X247 71 176
  1259. X251 89 161
  1260. X254 107 146
  1261. X254 124 130
  1262. X254 141 113
  1263. X252 156 95
  1264. X249 171 77
  1265. X244 185 59
  1266. X238 197 40
  1267. X230 209 21
  1268. X221 219 2
  1269. X211 228 17
  1270. X200 236 36
  1271. X188 243 55
  1272. X174 248 73
  1273. X160 251 91
  1274. X144 254 109
  1275. X128 254 126
  1276. X111 254 142
  1277. X93 252 158
  1278. X75 248 172
  1279. X57 243 186
  1280. X38 237 199
  1281. X19 229 210
  1282. X0 220 220
  1283. X19 210 229
  1284. X38 199 237
  1285. X57 186 243
  1286. X75 172 248
  1287. X93 158 252
  1288. X111 142 254
  1289. X128 126 254
  1290. X144 109 254
  1291. X160 91 251
  1292. X174 73 248
  1293. X188 55 243
  1294. X200 36 236
  1295. X211 17 228
  1296. X221 2 219
  1297. X230 21 209
  1298. X238 40 197
  1299. X244 59 185
  1300. X249 77 171
  1301. X252 95 156
  1302. X254 113 141
  1303. X254 130 124
  1304. X254 146 107
  1305. X251 161 89
  1306. X247 176 71
  1307. X242 189 53
  1308. X235 201 34
  1309. X227 212 14
  1310. X218 222 4
  1311. X208 231 23
  1312. X196 239 42
  1313. X183 245 61
  1314. X169 249 79
  1315. X155 252 97
  1316. X139 254 115
  1317. X122 254 132
  1318. X105 253 148
  1319. X87 251 163
  1320. X69 247 177
  1321. X50 241 190
  1322. X31 235 203
  1323. X12 226 214
  1324. X6 217 223
  1325. X25 206 232
  1326. X44 195 239
  1327. X63 182 245
  1328. X81 168 250
  1329. X99 153 253
  1330. X117 137 254
  1331. X133 120 254
  1332. X149 103 253
  1333. X164 85 250
  1334. X179 67 246
  1335. X192 48 241
  1336. X204 29 234
  1337. X215 10 225
  1338. X224 8 216
  1339. X233 27 205
  1340. X240 46 193
  1341. X246 65 180
  1342. X250 83 166
  1343. X253 101 151
  1344. X254 119 135
  1345. X254 135 119
  1346. X253 151 101
  1347. X250 166 83
  1348. X246 180 65
  1349. X240 193 46
  1350. X233 205 27
  1351. X224 216 8
  1352. X215 225 10
  1353. X204 234 29
  1354. X192 241 48
  1355. X179 246 67
  1356. X164 250 85
  1357. X149 253 103
  1358. X133 254 120
  1359. X117 254 137
  1360. X99 253 153
  1361. X81 250 168
  1362. X63 245 182
  1363. X44 239 195
  1364. X25 232 206
  1365. X6 223 217
  1366. X12 214 226
  1367. X31 203 235
  1368. X50 190 241
  1369. X69 177 247
  1370. X87 163 251
  1371. X105 148 253
  1372. X122 132 254
  1373. X139 115 254
  1374. X155 97 252
  1375. X169 79 249
  1376. X183 61 245
  1377. X196 42 239
  1378. X208 23 231
  1379. X218 4 222
  1380. X227 14 212
  1381. X235 34 201
  1382. X242 53 189
  1383. X247 71 176
  1384. X251 89 161
  1385. X254 107 146
  1386. X254 124 130
  1387. X254 141 113
  1388. X252 156 95
  1389. X249 171 77
  1390. X244 185 59
  1391. X238 197 40
  1392. X230 209 21
  1393. X221 219 2
  1394. X211 228 17
  1395. X200 236 36
  1396. X188 243 55
  1397. X174 248 73
  1398. X160 251 91
  1399. X144 254 109
  1400. X128 254 126
  1401. X111 254 142
  1402. X93 252 158
  1403. X75 248 172
  1404. X57 243 186
  1405. X38 237 199
  1406. X19 229 210
  1407. END_OF_FILE
  1408. if test 2824 -ne `wc -c <'maps/special3.map'`; then
  1409.     echo shar: \"'maps/special3.map'\" unpacked with wrong size!
  1410. fi
  1411. # end of 'maps/special3.map'
  1412. fi
  1413. if test -f 'maps/special4.map' -a "${1}" != "-c" ; then 
  1414.   echo shar: Will not clobber existing file \"'maps/special4.map'\"
  1415. else
  1416. echo shar: Extracting \"'maps/special4.map'\" \(2824 characters\)
  1417. sed "s/^X//" >'maps/special4.map' <<'END_OF_FILE'
  1418. X0 0 0
  1419. X0 0 0
  1420. X0 0 0
  1421. X0 0 0
  1422. X0 0 0
  1423. X0 0 0
  1424. X0 220 220
  1425. X25 206 232
  1426. X50 190 241
  1427. X75 172 248
  1428. X99 153 253
  1429. X122 132 254
  1430. X144 109 254
  1431. X164 85 250
  1432. X183 61 245
  1433. X200 36 236
  1434. X215 10 225
  1435. X227 14 212
  1436. X238 40 197
  1437. X246 65 180
  1438. X251 89 161
  1439. X254 113 141
  1440. X254 135 119
  1441. X252 156 95
  1442. X247 176 71
  1443. X240 193 46
  1444. X230 209 21
  1445. X218 222 4
  1446. X204 234 29
  1447. X188 243 55
  1448. X169 249 79
  1449. X149 253 103
  1450. X128 254 126
  1451. X105 253 148
  1452. X81 250 168
  1453. X57 243 186
  1454. X31 235 203
  1455. X6 223 217
  1456. X19 210 229
  1457. X44 195 239
  1458. X69 177 247
  1459. X93 158 252
  1460. X117 137 254
  1461. X139 115 254
  1462. X160 91 251
  1463. X179 67 246
  1464. X196 42 239
  1465. X211 17 228
  1466. X224 8 216
  1467. X235 34 201
  1468. X244 59 185
  1469. X250 83 166
  1470. X254 107 146
  1471. X254 130 124
  1472. X253 151 101
  1473. X249 171 77
  1474. X242 189 53
  1475. X233 205 27
  1476. X221 219 2
  1477. X208 231 23
  1478. X192 241 48
  1479. X174 248 73
  1480. X155 252 97
  1481. X133 254 120
  1482. X111 254 142
  1483. X87 251 163
  1484. X63 245 182
  1485. X38 237 199
  1486. X12 226 214
  1487. X12 214 226
  1488. X38 199 237
  1489. X63 182 245
  1490. X87 163 251
  1491. X111 142 254
  1492. X133 120 254
  1493. X155 97 252
  1494. X174 73 248
  1495. X192 48 241
  1496. X208 23 231
  1497. X221 2 219
  1498. X233 27 205
  1499. X242 53 189
  1500. X249 77 171
  1501. X253 101 151
  1502. X254 124 130
  1503. X254 146 107
  1504. X250 166 83
  1505. X244 185 59
  1506. X235 201 34
  1507. X224 216 8
  1508. X211 228 17
  1509. X196 239 42
  1510. X179 246 67
  1511. X160 251 91
  1512. X139 254 115
  1513. X117 254 137
  1514. X93 252 158
  1515. X69 247 177
  1516. X44 239 195
  1517. X19 229 210
  1518. X6 217 223
  1519. X31 203 235
  1520. X57 186 243
  1521. X81 168 250
  1522. X105 148 253
  1523. X128 126 254
  1524. X149 103 253
  1525. X169 79 249
  1526. X188 55 243
  1527. X204 29 234
  1528. X218 4 222
  1529. X230 21 209
  1530. X240 46 193
  1531. X247 71 176
  1532. X252 95 156
  1533. X254 119 135
  1534. X254 141 113
  1535. X251 161 89
  1536. X246 180 65
  1537. X238 197 40
  1538. X227 212 14
  1539. X215 225 10
  1540. X200 236 36
  1541. X183 245 61
  1542. X164 250 85
  1543. X144 254 109
  1544. X122 254 132
  1545. X99 253 153
  1546. X75 248 172
  1547. X50 241 190
  1548. X25 232 206
  1549. X0 220 220
  1550. X25 206 232
  1551. X50 190 241
  1552. X75 172 248
  1553. X99 153 253
  1554. X122 132 254
  1555. X144 109 254
  1556. X164 85 250
  1557. X183 61 245
  1558. X200 36 236
  1559. X215 10 225
  1560. X227 14 212
  1561. X238 40 197
  1562. X246 65 180
  1563. X251 89 161
  1564. X254 113 141
  1565. X254 135 119
  1566. X252 156 95
  1567. X247 176 71
  1568. X240 193 46
  1569. X230 209 21
  1570. X218 222 4
  1571. X204 234 29
  1572. X188 243 55
  1573. X169 249 79
  1574. X149 253 103
  1575. X128 254 126
  1576. X105 253 148
  1577. X81 250 168
  1578. X57 243 186
  1579. X31 235 203
  1580. X6 223 217
  1581. X19 210 229
  1582. X44 195 239
  1583. X69 177 247
  1584. X93 158 252
  1585. X117 137 254
  1586. X139 115 254
  1587. X160 91 251
  1588. X179 67 246
  1589. X196 42 239
  1590. X211 17 228
  1591. X224 8 216
  1592. X235 34 201
  1593. X244 59 185
  1594. X250 83 166
  1595. X254 107 146
  1596. X254 130 124
  1597. X253 151 101
  1598. X249 171 77
  1599. X242 189 53
  1600. X233 205 27
  1601. X221 219 2
  1602. X208 231 23
  1603. X192 241 48
  1604. X174 248 73
  1605. X155 252 97
  1606. X133 254 120
  1607. X111 254 142
  1608. X87 251 163
  1609. X63 245 182
  1610. X38 237 199
  1611. X12 226 214
  1612. X12 214 226
  1613. X38 199 237
  1614. X63 182 245
  1615. X87 163 251
  1616. X111 142 254
  1617. X133 120 254
  1618. X155 97 252
  1619. X174 73 248
  1620. X192 48 241
  1621. X208 23 231
  1622. X221 2 219
  1623. X233 27 205
  1624. X242 53 189
  1625. X249 77 171
  1626. X253 101 151
  1627. X254 124 130
  1628. X254 146 107
  1629. X250 166 83
  1630. X244 185 59
  1631. X235 201 34
  1632. X224 216 8
  1633. X211 228 17
  1634. X196 239 42
  1635. X179 246 67
  1636. X160 251 91
  1637. X139 254 115
  1638. X117 254 137
  1639. X93 252 158
  1640. X69 247 177
  1641. X44 239 195
  1642. X19 229 210
  1643. X6 217 223
  1644. X31 203 235
  1645. X57 186 243
  1646. X81 168 250
  1647. X105 148 253
  1648. X128 126 254
  1649. X149 103 253
  1650. X169 79 249
  1651. X188 55 243
  1652. X204 29 234
  1653. X218 4 222
  1654. X230 21 209
  1655. X240 46 193
  1656. X247 71 176
  1657. X252 95 156
  1658. X254 119 135
  1659. X254 141 113
  1660. X251 161 89
  1661. X246 180 65
  1662. X238 197 40
  1663. X227 212 14
  1664. X215 225 10
  1665. X200 236 36
  1666. X183 245 61
  1667. X164 250 85
  1668. X144 254 109
  1669. X122 254 132
  1670. X99 253 153
  1671. X75 248 172
  1672. X50 241 190
  1673. X25 232 206
  1674. END_OF_FILE
  1675. if test 2824 -ne `wc -c <'maps/special4.map'`; then
  1676.     echo shar: \"'maps/special4.map'\" unpacked with wrong size!
  1677. fi
  1678. # end of 'maps/special4.map'
  1679. fi
  1680. if test -f 'maps/special8.map' -a "${1}" != "-c" ; then 
  1681.   echo shar: Will not clobber existing file \"'maps/special8.map'\"
  1682. else
  1683. echo shar: Extracting \"'maps/special8.map'\" \(2824 characters\)
  1684. sed "s/^X//" >'maps/special8.map' <<'END_OF_FILE'
  1685. X0 0 0
  1686. X0 0 0
  1687. X0 0 0
  1688. X0 0 0
  1689. X0 0 0
  1690. X0 0 0
  1691. X0 220 220
  1692. X50 190 241
  1693. X99 153 253
  1694. X144 109 254
  1695. X183 61 245
  1696. X215 10 225
  1697. X238 40 197
  1698. X251 89 161
  1699. X254 135 119
  1700. X247 176 71
  1701. X230 209 21
  1702. X204 234 29
  1703. X169 249 79
  1704. X128 254 126
  1705. X81 250 168
  1706. X31 235 203
  1707. X19 210 229
  1708. X69 177 247
  1709. X117 137 254
  1710. X160 91 251
  1711. X196 42 239
  1712. X224 8 216
  1713. X244 59 185
  1714. X254 107 146
  1715. X253 151 101
  1716. X242 189 53
  1717. X221 219 2
  1718. X192 241 48
  1719. X155 252 97
  1720. X111 254 142
  1721. X63 245 182
  1722. X12 226 214
  1723. X38 199 237
  1724. X87 163 251
  1725. X133 120 254
  1726. X174 73 248
  1727. X208 23 231
  1728. X233 27 205
  1729. X249 77 171
  1730. X254 124 130
  1731. X250 166 83
  1732. X235 201 34
  1733. X211 228 17
  1734. X179 246 67
  1735. X139 254 115
  1736. X93 252 158
  1737. X44 239 195
  1738. X6 217 223
  1739. X57 186 243
  1740. X105 148 253
  1741. X149 103 253
  1742. X188 55 243
  1743. X218 4 222
  1744. X240 46 193
  1745. X252 95 156
  1746. X254 141 113
  1747. X246 180 65
  1748. X227 212 14
  1749. X200 236 36
  1750. X164 250 85
  1751. X122 254 132
  1752. X75 248 172
  1753. X25 232 206
  1754. X25 206 232
  1755. X75 172 248
  1756. X122 132 254
  1757. X164 85 250
  1758. X200 36 236
  1759. X227 14 212
  1760. X246 65 180
  1761. X254 113 141
  1762. X252 156 95
  1763. X240 193 46
  1764. X218 222 4
  1765. X188 243 55
  1766. X149 253 103
  1767. X105 253 148
  1768. X57 243 186
  1769. X6 223 217
  1770. X44 195 239
  1771. X93 158 252
  1772. X139 115 254
  1773. X179 67 246
  1774. X211 17 228
  1775. X235 34 201
  1776. X250 83 166
  1777. X254 130 124
  1778. X249 171 77
  1779. X233 205 27
  1780. X208 231 23
  1781. X174 248 73
  1782. X133 254 120
  1783. X87 251 163
  1784. X38 237 199
  1785. X12 214 226
  1786. X63 182 245
  1787. X111 142 254
  1788. X155 97 252
  1789. X192 48 241
  1790. X221 2 219
  1791. X242 53 189
  1792. X253 101 151
  1793. X254 146 107
  1794. X244 185 59
  1795. X224 216 8
  1796. X196 239 42
  1797. X160 251 91
  1798. X117 254 137
  1799. X69 247 177
  1800. X19 229 210
  1801. X31 203 235
  1802. X81 168 250
  1803. X128 126 254
  1804. X169 79 249
  1805. X204 29 234
  1806. X230 21 209
  1807. X247 71 176
  1808. X254 119 135
  1809. X251 161 89
  1810. X238 197 40
  1811. X215 225 10
  1812. X183 245 61
  1813. X144 254 109
  1814. X99 253 153
  1815. X50 241 190
  1816. X0 220 220
  1817. X50 190 241
  1818. X99 153 253
  1819. X144 109 254
  1820. X183 61 245
  1821. X215 10 225
  1822. X238 40 197
  1823. X251 89 161
  1824. X254 135 119
  1825. X247 176 71
  1826. X230 209 21
  1827. X204 234 29
  1828. X169 249 79
  1829. X128 254 126
  1830. X81 250 168
  1831. X31 235 203
  1832. X19 210 229
  1833. X69 177 247
  1834. X117 137 254
  1835. X160 91 251
  1836. X196 42 239
  1837. X224 8 216
  1838. X244 59 185
  1839. X254 107 146
  1840. X253 151 101
  1841. X242 189 53
  1842. X221 219 2
  1843. X192 241 48
  1844. X155 252 97
  1845. X111 254 142
  1846. X63 245 182
  1847. X12 226 214
  1848. X38 199 237
  1849. X87 163 251
  1850. X133 120 254
  1851. X174 73 248
  1852. X208 23 231
  1853. X233 27 205
  1854. X249 77 171
  1855. X254 124 130
  1856. X250 166 83
  1857. X235 201 34
  1858. X211 228 17
  1859. X179 246 67
  1860. X139 254 115
  1861. X93 252 158
  1862. X44 239 195
  1863. X6 217 223
  1864. X57 186 243
  1865. X105 148 253
  1866. X149 103 253
  1867. X188 55 243
  1868. X218 4 222
  1869. X240 46 193
  1870. X252 95 156
  1871. X254 141 113
  1872. X246 180 65
  1873. X227 212 14
  1874. X200 236 36
  1875. X164 250 85
  1876. X122 254 132
  1877. X75 248 172
  1878. X25 232 206
  1879. X25 206 232
  1880. X75 172 248
  1881. X122 132 254
  1882. X164 85 250
  1883. X200 36 236
  1884. X227 14 212
  1885. X246 65 180
  1886. X254 113 141
  1887. X252 156 95
  1888. X240 193 46
  1889. X218 222 4
  1890. X188 243 55
  1891. X149 253 103
  1892. X105 253 148
  1893. X57 243 186
  1894. X6 223 217
  1895. X44 195 239
  1896. X93 158 252
  1897. X139 115 254
  1898. X179 67 246
  1899. X211 17 228
  1900. X235 34 201
  1901. X250 83 166
  1902. X254 130 124
  1903. X249 171 77
  1904. X233 205 27
  1905. X208 231 23
  1906. X174 248 73
  1907. X133 254 120
  1908. X87 251 163
  1909. X38 237 199
  1910. X12 214 226
  1911. X63 182 245
  1912. X111 142 254
  1913. X155 97 252
  1914. X192 48 241
  1915. X221 2 219
  1916. X242 53 189
  1917. X253 101 151
  1918. X254 146 107
  1919. X244 185 59
  1920. X224 216 8
  1921. X196 239 42
  1922. X160 251 91
  1923. X117 254 137
  1924. X69 247 177
  1925. X19 229 210
  1926. X31 203 235
  1927. X81 168 250
  1928. X128 126 254
  1929. X169 79 249
  1930. X204 29 234
  1931. X230 21 209
  1932. X247 71 176
  1933. X254 119 135
  1934. X251 161 89
  1935. X238 197 40
  1936. X215 225 10
  1937. X183 245 61
  1938. X144 254 109
  1939. X99 253 153
  1940. X50 241 190
  1941. END_OF_FILE
  1942. if test 2824 -ne `wc -c <'maps/special8.map'`; then
  1943.     echo shar: \"'maps/special8.map'\" unpacked with wrong size!
  1944. fi
  1945. # end of 'maps/special8.map'
  1946. fi
  1947. if test -f 'maps/white.map' -a "${1}" != "-c" ; then 
  1948.   echo shar: Will not clobber existing file \"'maps/white.map'\"
  1949. else
  1950. echo shar: Extracting \"'maps/white.map'\" \(3036 characters\)
  1951. sed "s/^X//" >'maps/white.map' <<'END_OF_FILE'
  1952. X0 0 0
  1953. X0 0 0
  1954. X0 0 0
  1955. X0 0 0
  1956. X0 0 0
  1957. X0 0 0
  1958. X255 255 255
  1959. X255 255 255
  1960. X255 255 255
  1961. X255 255 255
  1962. X255 255 255
  1963. X255 255 255
  1964. X255 255 255
  1965. X255 255 255
  1966. X255 255 255
  1967. X255 255 255
  1968. X255 255 255
  1969. X255 255 255
  1970. X255 255 255
  1971. X255 255 255
  1972. X255 255 255
  1973. X255 255 255
  1974. X255 255 255
  1975. X255 255 255
  1976. X255 255 255
  1977. X255 255 255
  1978. X255 255 255
  1979. X255 255 255
  1980. X255 255 255
  1981. X255 255 255
  1982. X255 255 255
  1983. X255 255 255
  1984. X255 255 255
  1985. X255 255 255
  1986. X255 255 255
  1987. X255 255 255
  1988. X255 255 255
  1989. X255 255 255
  1990. X255 255 255
  1991. X255 255 255
  1992. X255 255 255
  1993. X255 255 255
  1994. X255 255 255
  1995. X255 255 255
  1996. X255 255 255
  1997. X255 255 255
  1998. X255 255 255
  1999. X255 255 255
  2000. X255 255 255
  2001. X255 255 255
  2002. X255 255 255
  2003. X255 255 255
  2004. X255 255 255
  2005. X255 255 255
  2006. X255 255 255
  2007. X255 255 255
  2008. X255 255 255
  2009. X255 255 255
  2010. X255 255 255
  2011. X255 255 255
  2012. X255 255 255
  2013. X255 255 255
  2014. X255 255 255
  2015. X255 255 255
  2016. X255 255 255
  2017. X255 255 255
  2018. X255 255 255
  2019. X255 255 255
  2020. X255 255 255
  2021. X255 255 255
  2022. X255 255 255
  2023. X255 255 255
  2024. X255 255 255
  2025. X255 255 255
  2026. X255 255 255
  2027. X255 255 255
  2028. X255 255 255
  2029. X255 255 255
  2030. X255 255 255
  2031. X255 255 255
  2032. X255 255 255
  2033. X255 255 255
  2034. X255 255 255
  2035. X255 255 255
  2036. X255 255 255
  2037. X255 255 255
  2038. X255 255 255
  2039. X255 255 255
  2040. X255 255 255
  2041. X255 255 255
  2042. X255 255 255
  2043. X255 255 255
  2044. X255 255 255
  2045. X255 255 255
  2046. X255 255 255
  2047. X255 255 255
  2048. X255 255 255
  2049. X255 255 255
  2050. X255 255 255
  2051. X255 255 255
  2052. X255 255 255
  2053. X255 255 255
  2054. X255 255 255
  2055. X255 255 255
  2056. X255 255 255
  2057. X255 255 255
  2058. X255 255 255
  2059. X255 255 255
  2060. X255 255 255
  2061. X255 255 255
  2062. X255 255 255
  2063. X255 255 255
  2064. X255 255 255
  2065. X255 255 255
  2066. X255 255 255
  2067. X255 255 255
  2068. X255 255 255
  2069. X255 255 255
  2070. X255 255 255
  2071. X255 255 255
  2072. X255 255 255
  2073. X255 255 255
  2074. X255 255 255
  2075. X255 255 255
  2076. X255 255 255
  2077. X255 255 255
  2078. X255 255 255
  2079. X255 255 255
  2080. X255 255 255
  2081. X255 255 255
  2082. X255 255 255
  2083. X255 255 255
  2084. X255 255 255
  2085. X255 255 255
  2086. X255 255 255
  2087. X255 255 255
  2088. X255 255 255
  2089. X255 255 255
  2090. X255 255 255
  2091. X255 255 255
  2092. X255 255 255
  2093. X255 255 255
  2094. X255 255 255
  2095. X255 255 255
  2096. X255 255 255
  2097. X255 255 255
  2098. X255 255 255
  2099. X255 255 255
  2100. X255 255 255
  2101. X255 255 255
  2102. X255 255 255
  2103. X255 255 255
  2104. X255 255 255
  2105. X255 255 255
  2106. X255 255 255
  2107. X255 255 255
  2108. X255 255 255
  2109. X255 255 255
  2110. X255 255 255
  2111. X255 255 255
  2112. X255 255 255
  2113. X255 255 255
  2114. X255 255 255
  2115. X255 255 255
  2116. X255 255 255
  2117. X255 255 255
  2118. X255 255 255
  2119. X255 255 255
  2120. X255 255 255
  2121. X255 255 255
  2122. X255 255 255
  2123. X255 255 255
  2124. X255 255 255
  2125. X255 255 255
  2126. X255 255 255
  2127. X255 255 255
  2128. X255 255 255
  2129. X255 255 255
  2130. X255 255 255
  2131. X255 255 255
  2132. X255 255 255
  2133. X255 255 255
  2134. X255 255 255
  2135. X255 255 255
  2136. X255 255 255
  2137. X255 255 255
  2138. X255 255 255
  2139. X255 255 255
  2140. X255 255 255
  2141. X255 255 255
  2142. X255 255 255
  2143. X255 255 255
  2144. X255 255 255
  2145. X255 255 255
  2146. X255 255 255
  2147. X255 255 255
  2148. X255 255 255
  2149. X255 255 255
  2150. X255 255 255
  2151. X255 255 255
  2152. X255 255 255
  2153. X255 255 255
  2154. X255 255 255
  2155. X255 255 255
  2156. X255 255 255
  2157. X255 255 255
  2158. X255 255 255
  2159. X255 255 255
  2160. X255 255 255
  2161. X255 255 255
  2162. X255 255 255
  2163. X255 255 255
  2164. X255 255 255
  2165. X255 255 255
  2166. X255 255 255
  2167. X255 255 255
  2168. X255 255 255
  2169. X255 255 255
  2170. X255 255 255
  2171. X255 255 255
  2172. X255 255 255
  2173. X255 255 255
  2174. X255 255 255
  2175. X255 255 255
  2176. X255 255 255
  2177. X255 255 255
  2178. X255 255 255
  2179. X255 255 255
  2180. X255 255 255
  2181. X255 255 255
  2182. X255 255 255
  2183. X255 255 255
  2184. X255 255 255
  2185. X255 255 255
  2186. X255 255 255
  2187. X255 255 255
  2188. X255 255 255
  2189. X255 255 255
  2190. X255 255 255
  2191. X255 255 255
  2192. X255 255 255
  2193. X255 255 255
  2194. X255 255 255
  2195. X255 255 255
  2196. X255 255 255
  2197. X255 255 255
  2198. X255 255 255
  2199. X255 255 255
  2200. X255 255 255
  2201. X255 255 255
  2202. X255 255 255
  2203. X255 255 255
  2204. X255 255 255
  2205. X255 255 255
  2206. X255 255 255
  2207. X255 255 255
  2208. END_OF_FILE
  2209. if test 3036 -ne `wc -c <'maps/white.map'`; then
  2210.     echo shar: \"'maps/white.map'\" unpacked with wrong size!
  2211. fi
  2212. # end of 'maps/white.map'
  2213. fi
  2214. if test -f 'master/Chaos.ad' -a "${1}" != "-c" ; then 
  2215.   echo shar: Will not clobber existing file \"'master/Chaos.ad'\"
  2216. else
  2217. echo shar: Extracting \"'master/Chaos.ad'\" \(2949 characters\)
  2218. sed "s/^X//" >'master/Chaos.ad' <<'END_OF_FILE'
  2219. X! dronePath specifies a path where the drone executable may
  2220. X! be found.  This is used by the master process when executing
  2221. X! remote drones via rsh.  The full path name is needed since
  2222. X! the drone executable will probably not be found in rsh's
  2223. X! PATH.
  2224. XChaos*dronePath: /usr/local/bin/X11/drone
  2225. X
  2226. X! mapDir specifies the pathname where colormap specification
  2227. X! files are stored.  These files have the extension ".map"
  2228. X! and are plain ASCII files consisting of red-green-blue 
  2229. X! triplets one to a line with values in the range 0-255.
  2230. X! New maps may be created by hand or with the help of the
  2231. X! gencmap utility.  This path should probably be changed
  2232. X! to some directory under the users home directory.
  2233. X! Currently it is set to work if chaos is executed from
  2234. X! chaos/master.
  2235. XChaos*mapDir: ../maps
  2236. X
  2237. X! imageDir specifies the pathname where images are to be
  2238. X! saved to and loaded from.  Images have filenames with
  2239. X! the extension ".cif" (chaos image format).  This format is
  2240. X! is an extension of the X window dump format which means
  2241. X! that chaos image format files may be loaded with xwud or
  2242. X! processed with any other conversion utility which recognizes
  2243. X! X window dump formatted images.  This path should be changed
  2244. X! to where the user wishes to store these images.
  2245. XChaos*imageDir: .
  2246. X
  2247. X! zoomDir specifies the pathname where the images of the zoom
  2248. X! stack are to be stored.  Zoom images have filenames of the
  2249. X! form "LEVEL##.cif".  This path should be changed to a 
  2250. X! directory where there is sufficient disk space to hold a
  2251. X! number of potentially large files.  The directory /tmp 
  2252. X! might be a good choice since this directory will be
  2253. X! periodically cleared of any old images.
  2254. XChaos*zoomDir: .
  2255. X
  2256. X! taskWidth and taskHeight are the width and height of the
  2257. X! tasks that the drawing region is divided into for 
  2258. X! computation by drone processes.
  2259. XChaos*taskWidth: 32
  2260. XChaos*taskHeight: 32
  2261. X
  2262. X! keepTasksSquare is a boolean value which determines if the
  2263. X! tasks should be forced to be square.  If the value is True,
  2264. X! taskWidth and taskHeight are set to their average and are
  2265. X! constrained to remain equal.  If the value is False, the
  2266. X! values may vary independently.
  2267. XChaos*keepTasksSquare: True
  2268. X
  2269. X! retainAspectRatio is a boolean value which determines if the
  2270. X! aspect ratio will be preserved while zooming.  If the value is
  2271. X! True, the zoom will occur around the center of the zoom
  2272. X! rectangle while preserving the same aspect ratio.  If the
  2273. X! value is False, the zoom will occur within the limits of the
  2274. X! zoom rectangle and the aspect ratio will be distorted.
  2275. XChaos*retainAspectRatio: True
  2276. X
  2277. X! iterationLimit specifies the maximum number of iterations
  2278. X! before a point will be considered to be within the Mandelbrot 
  2279. X! set (and colored black).
  2280. XChaos*iterationLimit: 256
  2281. X
  2282. X! hosts is a list of hostnames of machines which are available
  2283. X! to run one or more drone processes.  This resource should be
  2284. X! tailored to each site's environment.
  2285. XChaos*hosts: calvin hobbes
  2286. X
  2287. END_OF_FILE
  2288. if test 2949 -ne `wc -c <'master/Chaos.ad'`; then
  2289.     echo shar: \"'master/Chaos.ad'\" unpacked with wrong size!
  2290. fi
  2291. # end of 'master/Chaos.ad'
  2292. fi
  2293. if test -f 'master/messageDb.c' -a "${1}" != "-c" ; then 
  2294.   echo shar: Will not clobber existing file \"'master/messageDb.c'\"
  2295. else
  2296. echo shar: Extracting \"'master/messageDb.c'\" \(4553 characters\)
  2297. sed "s/^X//" >'master/messageDb.c' <<'END_OF_FILE'
  2298. X/*
  2299. X * Copyright (c) Ken W. Marks 1989, 1990.
  2300. X */
  2301. X
  2302. X#include <stdio.h>
  2303. X#include <signal.h>
  2304. X#include <ctype.h>
  2305. X#include <X11/Intrinsic.h>
  2306. X#include <X11/StringDefs.h>
  2307. X#include <X11/Xaw/Form.h>
  2308. X#include <X11/Shell.h>
  2309. X#include <LocalDefs.h>
  2310. X#include <Colormap.h>
  2311. X#include <Canvas.h>
  2312. X#include <DlgShell.h>
  2313. X#include <Push.h>
  2314. X#include <Label.h>
  2315. X
  2316. X#define CONFIRM_PUSH        cwidgets[0]
  2317. X#define CANCEL_PUSH        cwidgets[1]
  2318. X#define CONFIRM_LABEL        cwidgets[2]
  2319. X
  2320. X#define NUM_CONF_CONTROLS    (unsigned) 2
  2321. X
  2322. X#define DISMISS_PUSH            mwidgets[0]
  2323. X#define MESSAGE_LABEL        mwidgets[1]
  2324. X
  2325. X#define NUM_MESG_CONTROLS    (unsigned) 2
  2326. X
  2327. X#define NUM_LABELS        (unsigned) 1
  2328. X
  2329. Xstatic void CommonPushActivate();
  2330. X
  2331. Xstatic Widget popup, form;
  2332. Xstatic Widget cwidgets[NUM_CONF_CONTROLS + NUM_LABELS];
  2333. Xstatic Widget mwidgets[NUM_MESG_CONTROLS + NUM_LABELS];
  2334. X
  2335. Xstatic XtCallbackRec callbacks[] = {
  2336. X    {CommonPushActivate, NULL},
  2337. X    {NULL, NULL},
  2338. X    {NULL, NULL},
  2339. X};
  2340. X
  2341. Xstatic Arg PopupArgs[] = {
  2342. X    {XtNallowShellResize, (XtArgVal) True},
  2343. X    {XtNborderWidth, (XtArgVal) 3},
  2344. X};
  2345. X
  2346. Xstatic Arg LabelArgs[] = {
  2347. X    {XtNfromHoriz, (XtArgVal) NULL},
  2348. X    {XtNfromVert, (XtArgVal) NULL},
  2349. X    {XtNhorizDistance, (XtArgVal) 10},
  2350. X    {XtNvertDistance, (XtArgVal) 10},
  2351. X    {XtNlabel, (XtArgVal) "This will be changed"},
  2352. X    {XtNresizable, (XtArgVal) True},
  2353. X    {XtNborderWidth, (XtArgVal) 0},
  2354. X};
  2355. X
  2356. Xstatic Arg PushArgs[] = {
  2357. X    {XtNfromHoriz, (XtArgVal) NULL},
  2358. X    {XtNfromVert, (XtArgVal) NULL},
  2359. X    {XtNhorizDistance, (XtArgVal) 10},
  2360. X    {XtNvertDistance, (XtArgVal) 10},
  2361. X    {XtNlabel, (XtArgVal) NULL},
  2362. X    {XtNdialogbox, (XtArgVal) NULL},
  2363. X    {XtNcallback, (XtArgVal) callbacks},
  2364. X    {XtNresizable, (XtArgVal) False},
  2365. X};
  2366. X
  2367. Xstatic Arg ChangeArgs[] = {
  2368. X    {XtNcallback, (XtArgVal) callbacks},
  2369. X};
  2370. X
  2371. X
  2372. X/*ARGSUSED*/
  2373. Xstatic void CommonPushActivate(widget, client_data, call_data)
  2374. XWidget widget;
  2375. Xcaddr_t client_data;
  2376. Xcaddr_t call_data;
  2377. X{
  2378. X    /* For pushbuttons, the parent dialogbox widget id is sent as the
  2379. X     * call_data for the callback function. */
  2380. X    DialogPopdown((Widget) call_data);
  2381. X}
  2382. X
  2383. X
  2384. Xvoid MessageSetup(message, proc)
  2385. Xchar *message;
  2386. XXtCallbackProc proc;
  2387. X{
  2388. X    LabelChangeLabel(MESSAGE_LABEL, message);
  2389. X
  2390. X    callbacks[1].callback = proc;
  2391. X    XtSetValues(DISMISS_PUSH, ChangeArgs, XtNumber(ChangeArgs));
  2392. X}
  2393. X
  2394. X
  2395. XWidget MessageCreateDialogbox(parent)
  2396. XWidget parent;
  2397. X{
  2398. X    popup = XtCreatePopupShell("message_dialogbox_popup",
  2399. X      dialogShellWidgetClass, parent, PopupArgs, XtNumber(PopupArgs));
  2400. X
  2401. X    form = XtCreateManagedWidget("message_dialogbox_form",
  2402. X      formWidgetClass, popup, (ArgList) NULL, 0);
  2403. X
  2404. X    LabelArgs[0].value = (XtArgVal) NULL;
  2405. X    LabelArgs[1].value = (XtArgVal) NULL;
  2406. X    MESSAGE_LABEL = XtCreateManagedWidget("message_label",
  2407. X      labelWidgetClass, form, LabelArgs, XtNumber(LabelArgs));
  2408. X
  2409. X    PushArgs[0].value = (XtArgVal) NULL;
  2410. X    PushArgs[1].value = (XtArgVal) MESSAGE_LABEL;
  2411. X    PushArgs[4].value = (XtArgVal) "Dismiss";
  2412. X    PushArgs[5].value = (XtArgVal) popup;
  2413. X    DISMISS_PUSH = XtCreateManagedWidget("dismiss_push", pushWidgetClass,
  2414. X      form, PushArgs, XtNumber(PushArgs));
  2415. X
  2416. X    DialogSetFocusOrder(popup, mwidgets, NUM_MESG_CONTROLS);
  2417. X
  2418. X    return (popup);
  2419. X}
  2420. X
  2421. X
  2422. Xvoid ConfirmSetup(message, proc)
  2423. Xchar *message;
  2424. XXtCallbackProc proc;
  2425. X{
  2426. X    LabelChangeLabel(CONFIRM_LABEL, message);
  2427. X
  2428. X    callbacks[1].callback = proc;
  2429. X    XtSetValues(CONFIRM_PUSH, ChangeArgs, XtNumber(ChangeArgs));
  2430. X}
  2431. X
  2432. X
  2433. XWidget ConfirmCreateDialogbox(parent)
  2434. XWidget parent;
  2435. X{
  2436. X    popup = XtCreatePopupShell("confirm_dialogbox_popup",
  2437. X      dialogShellWidgetClass, parent, PopupArgs, XtNumber(PopupArgs));
  2438. X
  2439. X    form = XtCreateManagedWidget("confirm_dialogbox_form",
  2440. X      formWidgetClass, popup, (ArgList) NULL, (Cardinal) 0);
  2441. X
  2442. X    LabelArgs[0].value = (XtArgVal) NULL;
  2443. X    LabelArgs[1].value = (XtArgVal) NULL;
  2444. X    CONFIRM_LABEL = XtCreateManagedWidget("confirm_label",
  2445. X      labelWidgetClass, form, LabelArgs, XtNumber(LabelArgs));
  2446. X
  2447. X    PushArgs[0].value = (XtArgVal) NULL;
  2448. X    PushArgs[1].value = (XtArgVal) CONFIRM_LABEL;
  2449. X    PushArgs[4].value = (XtArgVal) "Confirm";
  2450. X    PushArgs[5].value = (XtArgVal) popup;
  2451. X    CONFIRM_PUSH = XtCreateManagedWidget("confirm_push", pushWidgetClass,
  2452. X      form, PushArgs, XtNumber(PushArgs));
  2453. X
  2454. X    PushArgs[0].value = (XtArgVal) CONFIRM_PUSH;
  2455. X    PushArgs[1].value = (XtArgVal) CONFIRM_LABEL;
  2456. X    PushArgs[4].value = (XtArgVal) "Cancel";
  2457. X    PushArgs[5].value = (XtArgVal) popup;
  2458. X    CANCEL_PUSH = XtCreateManagedWidget("cancel_push", pushWidgetClass,
  2459. X      form, PushArgs, XtNumber(PushArgs));
  2460. X
  2461. X    DialogSetFocusOrder(popup, cwidgets, NUM_CONF_CONTROLS);
  2462. X
  2463. X    return (popup);
  2464. X}
  2465. END_OF_FILE
  2466. if test 4553 -ne `wc -c <'master/messageDb.c'`; then
  2467.     echo shar: \"'master/messageDb.c'\" unpacked with wrong size!
  2468. fi
  2469. # end of 'master/messageDb.c'
  2470. fi
  2471. if test -f 'master/queue.c' -a "${1}" != "-c" ; then 
  2472.   echo shar: Will not clobber existing file \"'master/queue.c'\"
  2473. else
  2474. echo shar: Extracting \"'master/queue.c'\" \(3018 characters\)
  2475. sed "s/^X//" >'master/queue.c' <<'END_OF_FILE'
  2476. X/*
  2477. X * Copyright (c) Ken W. Marks 1989, 1990.
  2478. X */
  2479. X
  2480. X#include <stdio.h>
  2481. X#include <X11/Intrinsic.h>
  2482. X#include <Chaos.h>
  2483. X#include <Task.h>
  2484. X#include <Queue.h>
  2485. X
  2486. X/* tail pointers are stored in the previous pointer of the 1st node */
  2487. X
  2488. Xstatic Task *free_list;
  2489. Xstatic Task *run_list;
  2490. Xstatic Task *wait_list;
  2491. Xstatic Task *stale_list;
  2492. Xstatic Task *zombie_list;
  2493. Xstatic Task *unfinished_list;
  2494. X
  2495. X
  2496. XTask *AllocTask()
  2497. X{
  2498. X    Task *task;
  2499. X    int ii;
  2500. X
  2501. X    if (free_list == NULL)
  2502. X    {
  2503. X    free_list = (Task *) malloc(TASK_ALLOC_COUNT * sizeof(Task));
  2504. X    if (free_list == NULL)
  2505. X    {
  2506. X        eprintf("Could not malloc %d bytes!\n",
  2507. X          TASK_ALLOC_COUNT * sizeof(Task));
  2508. X        abort();
  2509. X    }
  2510. X    for (ii = 0; ii < TASK_ALLOC_COUNT - 1; ++ii)
  2511. X        free_list[ii].next = &free_list[ii + 1];
  2512. X    free_list[ii].next = NULL;
  2513. X    }
  2514. X    task = free_list;
  2515. X    free_list = free_list->next;
  2516. X    return (task);
  2517. X}
  2518. X
  2519. X
  2520. Xvoid FreeTask(task)
  2521. XTask *task;
  2522. X{
  2523. X    task->next = free_list;
  2524. X    free_list = task;
  2525. X}
  2526. X
  2527. X
  2528. XTask *TaskFind(qtype, window, serial)
  2529. XQueueType qtype;
  2530. XWindow window;
  2531. Xlong serial;
  2532. X{
  2533. X    Task *task;
  2534. X
  2535. X    switch (qtype)
  2536. X    {
  2537. X    case runQ:
  2538. X    task = run_list;
  2539. X    break;
  2540. X
  2541. X    case waitQ:
  2542. X    task = wait_list;
  2543. X    break;
  2544. X
  2545. X    case staleQ:
  2546. X    task = stale_list;
  2547. X    break;
  2548. X
  2549. X    case zombieQ:
  2550. X    task = zombie_list;
  2551. X    break;
  2552. X
  2553. X    case unfinishedQ:
  2554. X    task = unfinished_list;
  2555. X    break;
  2556. X
  2557. X    default:
  2558. X    eprintf("Now how the heck did you manage that?!\n");
  2559. X    abort();
  2560. X    }
  2561. X
  2562. X    while (task != NULL)
  2563. X    {
  2564. X    if ((window == NULL || task->window == window) &&
  2565. X      (serial == NULL || task->serial == serial))
  2566. X        break;
  2567. X    task = task->next;
  2568. X    }
  2569. X    return (task);
  2570. X}
  2571. X
  2572. X
  2573. Xvoid TaskNQ(qtype, task)
  2574. XQueueType qtype;
  2575. XTask *task;
  2576. X{
  2577. X    Task **queue;
  2578. X
  2579. X    switch (qtype)
  2580. X    {
  2581. X    case runQ:
  2582. X    queue = &run_list;
  2583. X    break;
  2584. X
  2585. X    case waitQ:
  2586. X    queue = &wait_list;
  2587. X    break;
  2588. X
  2589. X    case staleQ:
  2590. X    queue = &stale_list;
  2591. X    break;
  2592. X
  2593. X    case zombieQ:
  2594. X    queue = &zombie_list;
  2595. X    break;
  2596. X
  2597. X    case unfinishedQ:
  2598. X    queue = &unfinished_list;
  2599. X    break;
  2600. X
  2601. X    default:
  2602. X    eprintf("Now how the heck did you manage that?!\n");
  2603. X    abort();
  2604. X    }
  2605. X
  2606. X    task->next = NULL;
  2607. X
  2608. X    if (*queue == NULL)
  2609. X    *queue = task;
  2610. X    else
  2611. X    {
  2612. X    (*queue)->prev->next = task;
  2613. X    task->prev = (*queue)->prev;
  2614. X    }
  2615. X
  2616. X    (*queue)->prev = task;
  2617. X}
  2618. X
  2619. X
  2620. XTask *TaskDQ(qtype, window, serial)
  2621. XQueueType qtype;
  2622. XWindow window;
  2623. Xlong serial;
  2624. X{
  2625. X    Task *task;
  2626. X    Task **queue;
  2627. X
  2628. X    switch (qtype)
  2629. X    {
  2630. X    case runQ:
  2631. X    queue = &run_list;
  2632. X    break;
  2633. X
  2634. X    case waitQ:
  2635. X    queue = &wait_list;
  2636. X    break;
  2637. X
  2638. X    case staleQ:
  2639. X    queue = &stale_list;
  2640. X    break;
  2641. X
  2642. X    case zombieQ:
  2643. X    queue = &zombie_list;
  2644. X    break;
  2645. X
  2646. X    case unfinishedQ:
  2647. X    queue = &unfinished_list;
  2648. X    break;
  2649. X
  2650. X    default:
  2651. X    eprintf("Now how the heck did you manage that?!\n");
  2652. X    abort();
  2653. X    }
  2654. X
  2655. X    task = TaskFind(qtype, window, serial);
  2656. X    if (task == NULL)
  2657. X    return (NULL);
  2658. X
  2659. X    if (task->next == NULL)    /* taking last task (tail) */
  2660. X    (*queue)->prev = task->prev;
  2661. X    else
  2662. X    task->next->prev = task->prev;
  2663. X
  2664. X    if (task == *queue)        /* taking first task (head) */
  2665. X    *queue = task->next;
  2666. X    else
  2667. X    task->prev->next = task->next;
  2668. X
  2669. X    return (task);
  2670. X}
  2671. END_OF_FILE
  2672. if test 3018 -ne `wc -c <'master/queue.c'`; then
  2673.     echo shar: \"'master/queue.c'\" unpacked with wrong size!
  2674. fi
  2675. # end of 'master/queue.c'
  2676. fi
  2677. if test -f 'master/task.c' -a "${1}" != "-c" ; then 
  2678.   echo shar: Will not clobber existing file \"'master/task.c'\"
  2679. else
  2680. echo shar: Extracting \"'master/task.c'\" \(4989 characters\)
  2681. sed "s/^X//" >'master/task.c' <<'END_OF_FILE'
  2682. X/*
  2683. X * Copyright (c) Ken W. Marks 1989, 1990.
  2684. X */
  2685. X
  2686. X#include <stdio.h>
  2687. X#include <fcntl.h>
  2688. X#include <math.h>
  2689. X#include <X11/Intrinsic.h>
  2690. X#include <Chaos.h>
  2691. X#include <Ipc.h>
  2692. X#include <Canvas.h>
  2693. X#include <Task.h>
  2694. X#include <Queue.h>
  2695. X
  2696. X
  2697. Xvoid PrintTask(task)
  2698. XTask *task;
  2699. X{
  2700. X    (void) printf("serial=%d window=0x%x\n",
  2701. X      task->serial, task->window);
  2702. X
  2703. X    (void) printf("p_lo=%.20G p_hi=%.20G\n", task->p_lo, task->p_hi);
  2704. X    (void) printf("q_lo=%.20G q_hi=%.20G\n", task->q_lo, task->q_hi);
  2705. X
  2706. X    (void) printf("x=%d y=%d width=%d height=%d limit=%d method=%d\n\n",
  2707. X      task->x, task->y, task->width, task->height, task->limit, task->method);
  2708. X}
  2709. X
  2710. X
  2711. XBoolean SendTask(task)
  2712. XTask *task;
  2713. X{
  2714. X    ImageRequest req;
  2715. X
  2716. X    req.byte_order = 0x11223344;
  2717. X    req.type = IMAGE_REQUEST;
  2718. X    req.serial = task->serial;
  2719. X    req.width = task->width;
  2720. X    req.height = task->height;
  2721. X    req.limit = task->limit;
  2722. X    req.method = task->method;
  2723. X    (void) sprintf(req.p_lo, "%.20G", task->p_lo);
  2724. X    (void) sprintf(req.p_hi, "%.20G", task->p_hi);
  2725. X    (void) sprintf(req.q_lo, "%.20G", task->q_lo);
  2726. X    (void) sprintf(req.q_hi, "%.20G", task->q_hi);
  2727. X
  2728. X    return (SendMsg(task->window, (unsigned) sizeof(ImageRequest),
  2729. X    (char *) &req));
  2730. X}
  2731. X
  2732. X
  2733. Xvoid MakeTasksStale()
  2734. X{
  2735. X    Task *task;
  2736. X
  2737. X    while ((task = TaskDQ(runQ, (Window) NULL, (long) NULL)) != NULL)
  2738. X    {
  2739. X
  2740. X#ifdef DEBUG
  2741. X    dprintf("Moved following task from run queue to stale queue:\n");
  2742. X    PrintTask(task);
  2743. X#endif
  2744. X
  2745. X    TaskNQ(staleQ, task);
  2746. X    }
  2747. X}
  2748. X
  2749. X
  2750. Xvoid WasteTasks()
  2751. X{
  2752. X    Task *task;
  2753. X
  2754. X    while ((task = TaskDQ(zombieQ, (Window) NULL, (long) NULL)) != NULL)
  2755. X    {
  2756. X
  2757. X#ifdef DEBUG
  2758. X    dprintf("Removed following task from zombie queue:\n");
  2759. X    PrintTask(task);
  2760. X#endif
  2761. X
  2762. X    FreeTask(task);
  2763. X    }
  2764. X
  2765. X    while ((task = TaskDQ(unfinishedQ, (Window) NULL, (long) NULL)) != NULL)
  2766. X    {
  2767. X
  2768. X#ifdef DEBUG
  2769. X    dprintf("Removed following task from unfinished queue:\n");
  2770. X    PrintTask(task);
  2771. X#endif
  2772. X
  2773. X    FreeTask(task);
  2774. X    }
  2775. X}
  2776. X
  2777. X
  2778. Xvoid StartDrawing(widget)
  2779. XWidget widget;
  2780. X{
  2781. X    Task *task;
  2782. X
  2783. X    /* make sure we are unpaused */
  2784. X    CanvasUnpause(widget);
  2785. X
  2786. X    while ((task = TaskDQ(waitQ, (Window) NULL, (long) NULL)) != NULL)
  2787. X    {
  2788. X    CanvasFillTask(widget, task);
  2789. X
  2790. X#ifdef DEBUG
  2791. X    dprintf("Moved following task from wait queue to run queue:\n");
  2792. X    PrintTask(task);
  2793. X#endif
  2794. X
  2795. X    TaskNQ(runQ, task);
  2796. X    if (SendTask(task) == False)
  2797. X        eprintf("SendTask() failed\n");
  2798. X    }
  2799. X}
  2800. X
  2801. X
  2802. Xvoid WriteTask(fd, task)
  2803. Xint fd;
  2804. XTask *task;
  2805. X{
  2806. X    TaskSaveStruct package;
  2807. X    unsigned long swap_test = 1;
  2808. X    extern void ByteSwapLong();
  2809. X
  2810. X    package.serial = (long) task->serial;
  2811. X    package.x = (long) task->x;
  2812. X    package.y = (long) task->y;
  2813. X    package.width = (long) task->width;
  2814. X    package.height = (long) task->height;
  2815. X    package.limit = (long) task->limit;
  2816. X    package.method = (long) task->method;
  2817. X
  2818. X    /* do the necessary swapping before laying in the strings */
  2819. X    if (*(char *) &swap_test)
  2820. X    ByteSwapLong((char *) &package, sizeof(TaskSaveStruct));
  2821. X
  2822. X    (void) sprintf(package.p_lo, "%.20G", task->p_lo);
  2823. X    (void) sprintf(package.p_hi, "%.20G", task->p_hi);
  2824. X    (void) sprintf(package.q_lo, "%.20G", task->q_lo);
  2825. X    (void) sprintf(package.q_hi, "%.20G", task->q_hi);
  2826. X
  2827. X    (void) write(fd, (char *) &package, sizeof(TaskSaveStruct));
  2828. X}
  2829. X
  2830. X
  2831. Xvoid SaveTasks(fd, destructive)
  2832. Xint fd;
  2833. XBoolean destructive;
  2834. X{
  2835. X    Task *task;
  2836. X
  2837. X#ifdef DEBUG
  2838. X    dprintf("Saving the following task(s):\n");
  2839. X#endif
  2840. X
  2841. X    if (destructive)
  2842. X    while ((task = TaskDQ(runQ, (Window) NULL, (long) NULL)) != NULL)
  2843. X    {
  2844. X
  2845. X#ifdef DEBUG
  2846. X        PrintTask(task);
  2847. X#endif
  2848. X        TaskNQ(staleQ, task);
  2849. X        WriteTask(fd, task);
  2850. X    }
  2851. X    else
  2852. X    {
  2853. X    task = TaskFind(runQ, (Window) NULL, (long) NULL);
  2854. X    while (task != NULL)
  2855. X    {
  2856. X
  2857. X#ifdef DEBUG
  2858. X        PrintTask(task);
  2859. X#endif
  2860. X        WriteTask(fd, task);
  2861. X        task = task->next;
  2862. X    }
  2863. X    }
  2864. X}
  2865. X
  2866. X
  2867. XBoolean ReadTask(fd, task)
  2868. Xint fd;
  2869. XTask *task;
  2870. X{
  2871. X    TaskSaveStruct package;
  2872. X    unsigned long swap_test = 1;
  2873. X    extern void ByteSwapLong();
  2874. X
  2875. X    if (read(fd, (char *) &package, sizeof(TaskSaveStruct)) <
  2876. X      sizeof(TaskSaveStruct))
  2877. X    return (False);
  2878. X
  2879. X    /* grab the strings before doing the necessary swapping */
  2880. X    task->p_lo = atof(package.p_lo);
  2881. X    task->p_hi = atof(package.p_hi);
  2882. X    task->q_lo = atof(package.q_lo);
  2883. X    task->q_hi = atof(package.q_hi);
  2884. X
  2885. X    if (*(char *) &swap_test)
  2886. X    ByteSwapLong((char *) &package, sizeof(TaskSaveStruct));
  2887. X
  2888. X    task->serial = (short) package.serial;
  2889. X    task->x = (short) package.x;
  2890. X    task->y = (short) package.y;
  2891. X    task->width = (short) package.width;
  2892. X    task->height = (short) package.height;
  2893. X    task->limit = (short) package.limit;
  2894. X    task->method = (short) package.method;
  2895. X    return (True);
  2896. X}
  2897. X
  2898. X
  2899. Xvoid LoadTasks(fd)
  2900. Xint fd;
  2901. X{
  2902. X    Task task;
  2903. X    Task *ptask;
  2904. X
  2905. X#ifdef DEBUG
  2906. X    dprintf("Loading the following task(s):\n");
  2907. X#endif
  2908. X
  2909. X    while (ReadTask(fd, &task))
  2910. X    {
  2911. X
  2912. X#ifdef DEBUG
  2913. X    PrintTask(&task);
  2914. X#endif
  2915. X    ptask = AllocTask();
  2916. X    (void) memcpy((char *) ptask, (char *) &task, sizeof(Task));
  2917. X
  2918. X    /* put this task with all the other unfinished business */
  2919. X    TaskNQ(unfinishedQ, ptask);
  2920. X    }
  2921. X}
  2922. END_OF_FILE
  2923. if test 4989 -ne `wc -c <'master/task.c'`; then
  2924.     echo shar: \"'master/task.c'\" unpacked with wrong size!
  2925. fi
  2926. # end of 'master/task.c'
  2927. fi
  2928. echo shar: End of archive 8 \(of 10\).
  2929. cp /dev/null ark8isdone
  2930. MISSING=""
  2931. for I in 1 2 3 4 5 6 7 8 9 10 ; do
  2932.     if test ! -f ark${I}isdone ; then
  2933.     MISSING="${MISSING} ${I}"
  2934.     fi
  2935. done
  2936. if test "${MISSING}" = "" ; then
  2937.     echo You have unpacked all 10 archives.
  2938.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2939. else
  2940.     echo You still need to unpack the following archives:
  2941.     echo "        " ${MISSING}
  2942. fi
  2943. ##  End of shell archive.
  2944. exit 0
  2945.  
  2946. dan
  2947. ----------------------------------------------------
  2948. O'Reilly && Associates   argv@sun.com / argv@ora.com
  2949. Opinions expressed reflect those of the author only.
  2950.