home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume37 / astrolog / part03 < prev    next >
Encoding:
Text File  |  1993-05-18  |  60.8 KB  |  1,722 lines
  1. Newsgroups: comp.sources.misc
  2. From: astrolog@u.washington.edu (Astrolog)
  3. Subject: v37i072:  astrolog - Generation of astrology charts v3.05, Part03/12
  4. Message-ID: <1993May19.061531.11217@sparky.imd.sterling.com>
  5. X-Md4-Signature: b3f14a56716e73cde4857c8ab5f0d7ca
  6. Date: Wed, 19 May 1993 06:15:31 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: astrolog@u.washington.edu (Astrolog)
  10. Posting-number: Volume 37, Issue 72
  11. Archive-name: astrolog/part03
  12. Environment: UNIX, DOS, VMS
  13. Supersedes: astrolog: Volume 30, Issue 62-69
  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 3 (of 12)."
  22. # Contents:  charts.c xdata.c
  23. # Wrapped by pul@hardy on Sun May 16 22:23:16 1993
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. if test -f 'charts.c' -a "${1}" != "-c" ; then 
  26.   echo shar: Will not clobber existing file \"'charts.c'\"
  27. else
  28. echo shar: Extracting \"'charts.c'\" \(43383 characters\)
  29. sed "s/^X//" >'charts.c' <<'END_OF_FILE'
  30. X/*
  31. X** Astrolog (Version 3.05) File: charts.c
  32. X**
  33. X** IMPORTANT: The planetary calculation routines used in this program
  34. X** have been Copyrighted and the core of this program is basically a
  35. X** conversion to C of the routines created by James Neely as listed in
  36. X** Michael Erlewine's 'Manual of Computer Programming for Astrologers',
  37. X** available from Matrix Software. The copyright gives us permission to
  38. X** use the routines for our own purposes but not to sell them or profit
  39. X** from them in any way.
  40. X**
  41. X** IN ADDITION: the graphics database and chart display routines used in
  42. X** this program are Copyright (C) 1991-1993 by Walter D. Pullen. Permission
  43. X** is granted to freely use and distribute these routines provided one
  44. X** doesn't sell, restrict, or profit from them in any way. Modification
  45. X** is allowed provided these notices remain with any altered or edited
  46. X** versions of the program.
  47. X*/
  48. X
  49. X#include "astrolog.h"
  50. X
  51. X
  52. X/*
  53. X*******************************************************************************
  54. X** Display subprograms
  55. X*******************************************************************************
  56. X*/
  57. X
  58. X/* This function is used by the interpretation routines to print out lines  */
  59. X/* of text with newlines inserted just before the end of screen is reached. */
  60. X
  61. Xvoid FieldWord(string)
  62. Xchar *string;
  63. X{
  64. X  static char line[STRING*2];
  65. X  static int cursor = 0;
  66. X  int i, j;
  67. X
  68. X  /* Hack: Dump buffer if function called with a null string. */
  69. X
  70. X  if (*string == 0) {
  71. X    line[cursor] = 0;
  72. X    printf("%s\n", line);
  73. X    cursor = 0;
  74. X    return;
  75. X  }
  76. X  if (cursor)
  77. X    line[cursor++] = ' ';
  78. X  for (i = 0; (line[cursor] = string[i]); i++, cursor++)
  79. X    ;
  80. X
  81. X  /* When buffer overflows 80 columns, print out one line and start over. */
  82. X
  83. X  while (cursor >= STRING-1) {
  84. X    for (i = STRING-1; line[i] != ' '; i--)
  85. X      ;
  86. X    line[i] = 0;
  87. X    printf("%s\n", line);
  88. X    line[0] = line[1] = ' ';
  89. X    for (j = 2; (line[j] = line[i+j-1]) != 0; j++)
  90. X      ;
  91. X    cursor -= (i-1);
  92. X  }
  93. X}
  94. X
  95. X
  96. X/* Print the interpretation of each planet in sign and house, as specified */
  97. X/* with the -I switch. This is basically array accessing combining the     */
  98. X/* meanings of each planet, sign, and house, and a couple of other things. */
  99. X
  100. Xvoid InterpretLocation(general)
  101. Xint general;
  102. X{
  103. X  int i, j;
  104. X  char c;
  105. X
  106. X  /* If parameter 'general' set, then, instead of an interpretation, just */
  107. X  /* print out what each sign, house, and planet means, as in -I0 switch. */
  108. X
  109. X  if (general) {
  110. X    printf("Signs of the zodiac represent psychological characteristics.\n\n");
  111. X    for (i = 1; i <= SIGNS; i++) {
  112. X      AnsiColor(elemansi[i-1 & 3]);
  113. X      sprintf(string, "%s is", signname[i]); FieldWord(string);
  114. X      sprintf(string, "%s, and", description[i]); FieldWord(string);
  115. X      sprintf(string, "%s.", desire[i]); FieldWord(string);
  116. X      FieldWord("");
  117. X    }
  118. X    AnsiColor(-1);
  119. X    printf("\nHouses represent different areas within one's life.\n\n");
  120. X    for (i = 1; i <= SIGNS; i++) {
  121. X      AnsiColor(elemansi[i-1 & 3]);
  122. X      sprintf(string, "The %d%s House is the area of life dealing with",
  123. X        i, post[i]); FieldWord(string);
  124. X      sprintf(string, "%s.", lifearea[i]); FieldWord(string);
  125. X      FieldWord("");
  126. X    }
  127. X    AnsiColor(-1);
  128. X    printf("\nPlanets represent various parts of one's mind or self.\n\n");
  129. X    for (i = 1; i <= OBJECTS; i++) if (!ignore[i]) {
  130. X      AnsiColor(objectansi[i]);
  131. X      sprintf(string, "%s%s%s%s represents one's",
  132. X        i < 3 || i >= 16 ? "The " : "",
  133. X        i == 16 ? "North " : (i == 17 ? "Part of " : ""), objectname[i],
  134. X        i == 13 ? " Athena" : ""); FieldWord(string);
  135. X      sprintf(string, "%s.", mindpart[i]); FieldWord(string);
  136. X      FieldWord("");
  137. X    }
  138. X    AnsiColor(-1);
  139. X    return;
  140. X  }
  141. X
  142. X  /* If parameter 'general' not set, then print out interpretation. */
  143. X
  144. X  putchar('\n');
  145. X  for (i = 1; i <= OBJECTS; i++) if (!ignore[i]) {
  146. X    AnsiColor(objectansi[i]);
  147. X    j = (int) (planet[i]/30.0)+1; c = Dignify(i, j);
  148. X    sprintf(string, "%s%s%s%s in %s", ret[i] < 0.0 ? "Retrograde " : "",
  149. X      i == 16 ? "North " : (i == 17 ? "Part of " : ""), objectname[i],
  150. X      i == 13 ? " Athena" : "", signname[j]);
  151. X    FieldWord(string);
  152. X    sprintf(string, "and %d%s House:", inhouse[i], post[inhouse[i]]);
  153. X    FieldWord(string);
  154. X    FieldWord("This person's"); FieldWord(mindpart[i]); FieldWord("is");
  155. X    if (((int) planet[i]) % 30 < 10)
  156. X      FieldWord("very");
  157. X    sprintf(string, "%s, and", description[j]); FieldWord(string);
  158. X    sprintf(string, "%s.", desire[j]); FieldWord(string);
  159. X    FieldWord("Most often this manifests");
  160. X    if (ret[i] < 0.0 && i != 16)
  161. X      FieldWord("in an independent, backward, introverted manner, and");
  162. X    FieldWord("in the area of life dealing with");
  163. X    sprintf(string, "%s.", lifearea[inhouse[i]]); FieldWord(string);
  164. X
  165. X    /* Extra information if planet is in its ruling, falling, etc, sign. */
  166. X
  167. X    if (c == 'R')
  168. X      FieldWord("This is a major aspect of the person's psyche!");
  169. X    else if (c == 'F')
  170. X      FieldWord("(This bit plays only a minor part in the person's psyche.)");
  171. X    else if (c == 'e')
  172. X      FieldWord("It is easy for them to express this part of themself.");
  173. X    else if (c == 'd')
  174. X      FieldWord("It is difficult for them to express this part of themself.");
  175. X    FieldWord("");
  176. X  }
  177. X}
  178. X
  179. X
  180. X/* Print the straight listing of planet and house positions and specified */
  181. X/* by the -v switch, along with the element table, etc.                   */
  182. X
  183. Xvoid ChartLocation(general)
  184. Xint general;
  185. X{
  186. X  int elemode[4][3], elem[4], mo[3], pos = 0, abo = 0, lef = 0, lea = 0;
  187. X  int count = 0, i, j, k;
  188. X
  189. X  if (general) {                /* If parameter 'general' set, then ignore */
  190. X    InterpretLocation(TRUE);    /* chart, and display general meanings of  */
  191. X    return;                     /* signs, houses, and planets.             */
  192. X  }
  193. X  for (i = 0; i < 4; i++)
  194. X    elem[i] = 0;
  195. X  for (j = 0; j < 3; j++)
  196. X    mo[j] = 0;
  197. X  for (i = 0; i < 4; i++)
  198. X    for (j = 0; j < 3; j++)
  199. X      elemode[i][j] = 0;
  200. X
  201. X  /* Calculate number of objects in each element, mode, hemisphere, etc. */
  202. X
  203. X  for (i = 1; i <= total; i++) if (!ignore[i]) {
  204. X    count++;
  205. X    j = (int) (planet[i]/30.0) + 1;
  206. X    elemode[(j-1)%4][(j-1)%3]++;
  207. X    elem[(j-1)%4]++; mo[(j-1)%3]++;
  208. X    pos += (j & 1);
  209. X    lea += (j <= 6);
  210. X    j = inhouse[i];
  211. X    abo += (j >= 7);
  212. X    lef += (j < 4 || j >= 10);
  213. X  }
  214. X
  215. X  /* Print header showing time and date of the chart being displayed. */
  216. X
  217. X  printf("%s (%s) chart ", appname, VERSION);
  218. X  if (Mon == -1)
  219. X    printf("(no time or space)\n");
  220. X  else if (relation == DASHrc)
  221. X    printf("(composite)\n");
  222. X  else {
  223. X    i = (int) (FRACT(dabs(Tim))*100.0+0.5);
  224. X    j = (int) (FRACT(dabs(Zon))*100.0+0.5);
  225. X    printf("for %d %s %d %.0f:%d%d (%c%.0f:%d%d GMT) ",
  226. X      (int) Day, monthname[(int) Mon], (int) Yea, floor(Tim), 
  227. X      i/10, i%10, Zon > 0.0 ? '-' : '+', dabs(Zon), j/10, j%10);
  228. X    printf("%s\n", StringLocation(Lon, Lat, 100.0));
  229. X  }
  230. X  if (interpret) {
  231. X    InterpretLocation(FALSE);    /* Print interpretation if -I in effect. */
  232. X    return;
  233. X  }
  234. X  printf("Body  Locat. Ret. Decl. Rul.      House  Rul. Veloc.    ");
  235. X  printf("%s Houses.\n\n", systemname[housesystem]);
  236. X
  237. X  /* Ok, now print out each location of each object. */
  238. X
  239. X  for (i = 1, j = 1; i <= BASE; i++, j++)
  240. X    if (i <= OBJECTS || (i > C_HI && !ignore[i])) {
  241. X    while (i <= OBJECTS && j <= OBJECTS && ignore[j])
  242. X      j++;
  243. X    if (i <= OBJECTS && j > OBJECTS)
  244. X      PrintTab(' ', 51);
  245. X    else {
  246. X      if (i > OBJECTS)
  247. X        j = i;
  248. X      AnsiColor(objectansi[j]);
  249. X      printf("%-4.4s: ", objectname[j]);
  250. X      PrintMinute(planet[j]);
  251. X      printf(" %c ", ret[j] >= 0.0 ? ' ' : 'R');
  252. X      if (j <= THINGS || j > OBJECTS)
  253. X        PrintAltitude(planetalt[i]);
  254. X      else
  255. X        printf("_______");
  256. X      printf(" (%c)", Dignify(j, (int)planet[i]/30+1));
  257. X      k = inhouse[j];
  258. X      AnsiColor(elemansi[k-1 & 3]);
  259. X      printf(" [%2d%c%c house]", k, post[k][0], post[k][1]);
  260. X      AnsiColor(-1);
  261. X      printf(" [%c]", Dignify(j, k));
  262. X      if (j != 2 && j < THINGS || j > C_HI)
  263. X        printf(" %c%5.3f", ret[i] < 0.0 ? '-' : '+', RTOD(dabs(ret[j])));
  264. X      else
  265. X        printf(" ______");
  266. X    }
  267. X
  268. X    /* For some lines, we have to append the house cusp positions. */
  269. X
  270. X    if (i <= SIGNS) {
  271. X      printf("  -  ");
  272. X      AnsiColor(elemansi[i-1 & 3]);
  273. X      printf("House cusp %2d: ", i);
  274. X      PrintMinute(house[i]);
  275. X    }
  276. X
  277. X    /* For some lines, we have to append the element table information. */
  278. X
  279. X    if (i == SIGNS+2)
  280. X      printf("     Car Fix Mut TOT");
  281. X    else if (i > SIGNS+2 && i < SIGNS+7) {
  282. X      k = i-(SIGNS+2)-1;
  283. X      AnsiColor(elemansi[k]);
  284. X      printf("  %c%c%c%3d %3d %3d %3d",
  285. X        element[k][0], element[k][1], element[k][2],
  286. X        elemode[k][0], elemode[k][1], elemode[k][2], elem[k]);
  287. X      AnsiColor(-1);
  288. X    } else if (i == SIGNS+7)
  289. X      printf("  TOT %2d %3d %3d %3d", mo[0], mo[1], mo[2], count);
  290. X    else if (i == OBJECTS)
  291. X      PrintTab(' ', 23);
  292. X    else if (i >= U_LO)
  293. X      printf("  Uranian #%d", i-U_LO+1);
  294. X    switch (i-SIGNS-1) {
  295. X    case 1: printf("   +:%2d", pos);       break;
  296. X    case 2: printf("   -:%2d", count-pos); break;
  297. X    case 3: printf("   M:%2d", abo);       break;
  298. X    case 4: printf("   N:%2d", count-abo); break;
  299. X    case 5: printf("   A:%2d", lef);       break;
  300. X    case 6: printf("   D:%2d", count-lef); break;
  301. X    case 7: printf(   "<:%2d", lea);       break;
  302. X    }
  303. X    putchar('\n');
  304. X  }
  305. X
  306. X  /* Do another loop to print out the stars in their specified order. */
  307. X
  308. X  if (universe) for (i = S_LO; i <= S_HI; i++) if (!ignore[i]) {
  309. X    j = BASE+starname[i-BASE];
  310. X    AnsiColor(objectansi[j]);
  311. X    printf("%.4s: ", objectname[j]);
  312. X    PrintMinute(planet[j]);
  313. X    printf("   ");
  314. X    PrintAltitude(planetalt[j]);
  315. X    k = inhouse[j];
  316. X    printf("     [%2d%c%c house]", k, post[k][0], post[k][1]);
  317. X    printf("     ______  Star #%2d: %5.2f\n", i-BASE, starbright[j-BASE]);
  318. X  }
  319. X}
  320. X
  321. X
  322. X/* Print an interpretation for a particular aspect in effect in a chart. */
  323. X/* This is called from the InterpretGrid and ChartAspect routines.       */
  324. X
  325. Xvoid InterpretAspect(x, y)
  326. Xint x, y;
  327. X{
  328. X  int n;
  329. X
  330. X  n = grid->n[x][y];
  331. X  if (n > 0 && n <= ASPECTI && x <= OBJECTS && y <= OBJECTS) {
  332. X    AnsiColor(aspectansi[n]);
  333. X    sprintf(string, "%s %s %s: This person's", objectname[x],
  334. X      aspectname[n], objectname[y]);
  335. X    FieldWord(string); FieldWord(mindpart[x]);
  336. X    sprintf(string, interact[n],
  337. X      modifier[MIN(abs(grid->v[x][y])/150, 2)][n-1]);
  338. X    FieldWord(string);
  339. X    sprintf(string, "their %s.", mindpart[y]); FieldWord(string);
  340. X    if (therefore[n][0]) {
  341. X      sprintf(string, "%s.", therefore[n]); FieldWord(string);
  342. X    }
  343. X    FieldWord("");
  344. X  }
  345. X}
  346. X
  347. X
  348. X/* Print the interpretation of each aspect in the aspect grid, as specified */
  349. X/* with the -g -I switch. Again, this is basically array accessing of the   */
  350. X/* meanings of the two planets in aspect and of the aspect itself.          */
  351. X
  352. Xvoid InterpretGrid(general)
  353. Xint general;
  354. X{
  355. X  int i, j;
  356. X
  357. X  /* Again, if parameter 'general' is set, then ignore chart and print */
  358. X  /* general meanings of each aspect as specified with the -I0 switch. */
  359. X
  360. X  if (general) {
  361. X    printf("\nAspects are different relationships between planets.\n\n");
  362. X    for (i = 1; i <= MIN(aspects, ASPECTI); i++) {
  363. X      AnsiColor(aspectansi[i]);
  364. X      sprintf(string, "When planets are %s, one", aspectname[i]);
  365. X      FieldWord(string); sprintf(string, interact[i], ""); FieldWord(string);
  366. X      FieldWord("another.");
  367. X      if (therefore[i][0]) {
  368. X        sprintf(string, "%s.", therefore[i]); FieldWord(string);
  369. X      }
  370. X      FieldWord("");
  371. X    }
  372. X    return;
  373. X  }
  374. X
  375. X  /* If parameter 'general' not set, then actually do the interpretation. */
  376. X
  377. X  for (i = 1; i < OBJECTS; i++) if (!ignore[i])
  378. X    for (j = i+1; j <= OBJECTS; j++) if (!ignore[j])
  379. X      InterpretAspect(i, j);
  380. X}
  381. X
  382. X
  383. X/* Print out the aspect and midpoint grid for a chart, as specified with the */
  384. X/* -g switch. (Each grid row takes up 4 lines of text.)                      */
  385. X
  386. Xvoid ChartGrid(general)
  387. Xint general;
  388. X{
  389. X  int i, j, k, l, temp;
  390. X
  391. X  if (general || interpret) {                   /* If -I or -I0 in effect, */
  392. X    InterpretGrid(general);                     /* ignore chart and print  */
  393. X    return;                                     /* interpretation.         */
  394. X  }
  395. X  for (j = 1; j <= total; j++) if (!ignore[j])
  396. X    for (k = 1; k <= 4; k++) {
  397. X      for (l = 0, i = 1; i <= total; i++) if (!ignore[i]) {
  398. X        if (i > 1 && j+k > 2)
  399. X          putchar(k > 1 ? BOXV : BOXC);
  400. X        if (k > 1) {
  401. X          temp = grid->n[i][j];
  402. X
  403. X          /* Print aspect rows. */
  404. X
  405. X          if (i < j) {
  406. X            if (temp);
  407. X              AnsiColor(aspectansi[temp]);
  408. X            if (k == 2)
  409. X              printf("%s", aspectabbrev[temp]);
  410. X            else if (!temp)
  411. X              printf("   ");
  412. X            else
  413. X              if (k == 3) {
  414. X                if (grid->v[i][j] < 600)
  415. X                  printf("%c%2d", exdisplay & DASHga ?
  416. X                    (grid->v[i][j] < 0 ? 'a' : 's') :
  417. X                    (grid->v[i][j] < 0 ? '-' : '+'), abs(grid->v[i][j])/60);
  418. X                else
  419. X                  printf("%3d", abs(grid->v[i][j])/60);
  420. X              } else {
  421. X                temp = abs(grid->v[i][j])%60;
  422. X                printf("%d%d'", temp/10, temp%10);
  423. X              }
  424. X
  425. X          /* Print midpoint rows. */
  426. X
  427. X          } else if (i > j) {
  428. X            AnsiColor(elemansi[temp-1 & 3]);
  429. X            if (k == 2) {
  430. X              temp = grid->n[i][j];
  431. X              printf("%c%c%c", SIGNAM(temp));
  432. X            } else if (k == 3) {
  433. X              printf("%2d%c", grid->v[i][j]/60, DEGR2);
  434. X            } else {
  435. X              temp = grid->v[i][j]%60;
  436. X              printf("%d%d'", temp/10, temp%10);
  437. X            }
  438. X
  439. X          /* Print the diagonal of object names. */
  440. X
  441. X          } else {
  442. X            if (k == 2) {
  443. X              AnsiColor(objectansi[j]);
  444. X              printf("%c%c%c", OBJNAM(j));
  445. X            } else {
  446. X              temp = (int)(planet[j]/30.0)+1;
  447. X              AnsiColor(elemansi[i-1 & 3]);
  448. X              if (k == 3)
  449. X                printf("%2d%c", (int)planet[j] - (temp-1)*30, DEGR2);
  450. X              else
  451. X                printf("%c%c%c", SIGNAM(temp));
  452. X            }
  453. X          }
  454. X          AnsiColor(-1);
  455. X        } else
  456. X          if (j > 1)
  457. X            PrintTab(BOXH, 3);
  458. X        l++;
  459. X        if (column80 && l >= 20)
  460. X          i = total;
  461. X      }
  462. X      if (j+k > 2)
  463. X        putchar('\n');
  464. X    }
  465. X}
  466. X
  467. X
  468. X/* This is a subprocedure of DisplayGrands(). Here we print out one aspect */
  469. X/* configuration found by the parent procedure.                            */
  470. X
  471. Xvoid PrintGrand(nam, i1, i2, i3, i4)
  472. Xchar nam;
  473. Xint i1, i2, i3, i4;
  474. X{
  475. X  switch (nam) {
  476. X  case '.': printf("Stellium   "); break;
  477. X  case 't': printf("Grand Trine"); break;
  478. X  case 's': printf("T-Square   "); break;
  479. X  case 'y': printf("Yod        "); break;
  480. X  case 'g': printf("Grand Cross"); break;
  481. X  case 'c': printf("Cradle     "); break;
  482. X  default: ;
  483. X  }
  484. X  printf(" %s ", nam == '.' || nam == 't' || nam == 'g' ? "with" : "from");
  485. X  printf("%c%c%c: ", OBJNAM(i1));
  486. X  PrintMinute(planet[i1]);
  487. X  printf(" %s %c%c%c: ", nam == '.' || nam == 't' ? "and" : "to ", OBJNAM(i2));
  488. X  PrintMinute(planet[i2]);
  489. X  printf(" %s %c%c%c: ", nam == 'g' || nam == 'c' ? "to " : "and", OBJNAM(i3));
  490. X  PrintMinute(planet[i3]);
  491. X  if (nam == 'g' || nam == 'c') {
  492. X    printf(" to %c%c%c: ", OBJNAM(i4));
  493. X    PrintMinute(planet[i4]);
  494. X  }
  495. X  printf("\n");
  496. X}
  497. X
  498. X
  499. X/* Scan the aspect grid of a chart and print out any major configurations, */
  500. X/* as specified with the -g0 switch.                                       */
  501. X
  502. Xvoid DisplayGrands()
  503. X{
  504. X  int count = 0, i, j, k, l;
  505. X
  506. X  for (i = 1; i <= OBJECTS; i++) if (!ignore[i])
  507. X    for (j = 1; j <= OBJECTS; j++) if (j != i && !ignore[j])
  508. X      for (k = 1; k <= OBJECTS; k++) if (k != i && k != j && !ignore[k]) {
  509. X
  510. X        /* Is there a Stellium among the current three planets? */
  511. X
  512. X        if (i < j && j < k && grid->n[i][j] == 1 &&
  513. X            grid->n[i][k] == 1 && grid->n[j][k] == 1) {
  514. X          count++;
  515. X          PrintGrand('.', i, j, k, l);
  516. X
  517. X        /* Is there a Grand Trine? */
  518. X
  519. X        } else if (i < j && j < k && grid->n[i][j] == 4 &&
  520. X            grid->n[i][k] == 4 && grid->n[j][k] == 4) {
  521. X          count++;
  522. X          PrintGrand('t', i, j, k, l);
  523. X
  524. X        /* Is there a T-Square? */
  525. X
  526. X        } else if (j < k && grid->n[j][k] == 2 &&
  527. X            grid->n[MIN(i, j)][MAX(i, j)] == 3 &&
  528. X            grid->n[MIN(i, k)][MAX(i, k)] == 3) {
  529. X          count++;
  530. X          PrintGrand('s', i, j, k, l);
  531. X
  532. X        /* Is there a Yod? */
  533. X
  534. X        } else if (j < k && grid->n[j][k] == 5 &&
  535. X            grid->n[MIN(i, j)][MAX(i, j)] == 6 &&
  536. X            grid->n[MIN(i, k)][MAX(i, k)] == 6) {
  537. X          count++;
  538. X          PrintGrand('y', i, j, k, l);
  539. X        }
  540. X        for (l = 1; l <= OBJECTS; l++) if (!ignore[l]) {
  541. X
  542. X          /* Is there a Grand Cross among the current four planets? */
  543. X
  544. X          if (i < j && i < k && i < l && j < l && grid->n[i][j] == 3 &&
  545. X              grid->n[MIN(j, k)][MAX(j, k)] == 3 &&
  546. X              grid->n[MIN(k, l)][MAX(k, l)] == 3 &&
  547. X              grid->n[i][l] == 3 && MinDistance(planet[i], planet[k]) > 150.0
  548. X              && MinDistance(planet[j], planet[l]) > 150.0) {
  549. X            count++;
  550. X            PrintGrand('g', i, j, k, l);
  551. X
  552. X          /* Is there a Cradle? */
  553. X
  554. X          } else if (i < l && grid->n[MIN(i, j)][MAX(i, j)] == 5 &&
  555. X              grid->n[MIN(j, k)][MAX(j, k)] == 5 &&
  556. X              grid->n[MIN(k, l)][MAX(k, l)] == 5 &&
  557. X              MinDistance(planet[i], planet[l]) > 150.0) {
  558. X            count++;
  559. X            PrintGrand('c', i, j, k, l);
  560. X          }
  561. X        }
  562. X      }
  563. X  if (!count)
  564. X    printf("No major configurations in aspect grid.\n");
  565. X}
  566. X
  567. X
  568. Xbyte wheel[SIGNS][WHEELROWS];    /* Array used by ChartWheel(). */
  569. X
  570. X/* This is a subprocedure of ChartWheel(). Here we print out one line in a */
  571. X/* particular house cell (which may be blank).                             */
  572. X
  573. Xvoid PrintWheelSlot(house, row)
  574. Xint house, row;
  575. X{
  576. X  int i;
  577. X
  578. X  i = wheel[house-1][row];
  579. X  if (i) {
  580. X    AnsiColor(objectansi[i]);
  581. X    printf(" %c%c%c ", OBJNAM(i));    /* Print planet and its position. */
  582. X    PrintMinute(planet[i]);
  583. X    printf("%c ", ret[i] < 0.0 ? 'r' : ' ');
  584. X    PrintTab(' ', WHEELCOLS-14-1);
  585. X  } else
  586. X    PrintTab(' ', WHEELCOLS-1);       /* This particular line is blank. */
  587. X}
  588. X
  589. X
  590. X/* Another subprocedure of ChartWheel(). Here we print out the location */
  591. X/* of a particular house cusp as well as what house cusp number it is.  */
  592. X
  593. Xvoid PrintHouse(i, left)
  594. Xint i, left;
  595. X{
  596. X  if (!left)
  597. X    PrintMinute(house[i]);
  598. X  AnsiColor(elemansi[i-1 & 3]);
  599. X  printf("<%d>", i);
  600. X  if (left)
  601. X    PrintMinute(house[i]);
  602. X  else
  603. X    AnsiColor(-1);
  604. X}
  605. X
  606. X
  607. X/* Display all the objects in a wheel format on the screen, as specified */
  608. X/* with the -w switch. The wheel is divided into the 12 houses and the   */
  609. X/* planets are placed accordingly.                                       */
  610. X
  611. Xvoid ChartWheel()
  612. X{
  613. X  int i, j, k, l, count = 0;
  614. X
  615. X  for (i = 0; i < SIGNS; i++)
  616. X    for (j = 0; j < wheelrows; j++)    /* Clear out array from the */
  617. X      wheel[i][j] = 0;                 /* last time we used it.    */
  618. X
  619. X  /* This section of code places each object in the wheel house array. */
  620. X
  621. X  for (i = 1; i <= total && count < wheelrows*12; i++) {
  622. X    if (ignore[i] || !(i < 18 || i == 20 || i > C_HI))
  623. X      continue;
  624. X
  625. X    /* Try to put object in its proper house. If no room, */
  626. X    /* then overflow over to the succeeding house.        */
  627. X
  628. X    for (j = inhouse[i]-1; j < SIGNS; j = j < SIGNS ? (j+1)%SIGNS : j) {
  629. X
  630. X      /* Now try to find the proper place in the house to put the object. */
  631. X      /* This is in sorted order, although a check is made for 0 Aries.   */
  632. X
  633. X      if (wheel[j][wheelrows-1] > 0)
  634. X        continue;
  635. X      l = house[j+1] > house[Mod12(j+2)];
  636. X      for (k = 0; wheel[j][k] > 0 &&
  637. X           (planet[i] >= planet[wheel[j][k]] ||
  638. X            (l && planet[i] < 180.0 && planet[wheel[j][k]] > 180.0)) &&
  639. X           !(l && planet[i] > 180.0 && planet[wheel[j][k]] < 180.0); k++)
  640. X        ;
  641. X
  642. X      /* Actually insert object in proper place. */
  643. X
  644. X      if (wheel[j][k] <= 0)
  645. X        wheel[j][k] = i;
  646. X      else {
  647. X        for (l = wheelrows-1; l > k; l--)
  648. X          wheel[j][l] = wheel[j][l-1];
  649. X        wheel[j][k] = i;
  650. X      }
  651. X      count++;
  652. X      j = SIGNS;
  653. X    }
  654. X  }
  655. X
  656. X  /* Now, if this is really the -w switch and not -w0, then reverse the */
  657. X  /* order of objects in western houses for more intuitive reading.     */
  658. X
  659. X  if (!(exdisplay & DASHw0))
  660. X    for (i = 3; i < 9; i++)
  661. X      for (j = 0; j < wheelrows/2; j++) {
  662. X        k = wheelrows-1-j;
  663. X        l = wheel[i][j]; wheel[i][j] = wheel[i][k]; wheel[i][k] = l;
  664. X      }
  665. X
  666. X  /* Here we actually print the wheel and the objects in it. */
  667. X
  668. X  putchar(BOXNW); PrintTab(BOXH, WHEELCOLS-8); PrintHouse(11, TRUE);
  669. X  PrintTab(BOXH, WHEELCOLS-11); PrintHouse(10, TRUE);
  670. X  PrintTab(BOXH, WHEELCOLS-10); PrintHouse(9, TRUE);
  671. X  PrintTab(BOXH, WHEELCOLS-4); printf("%c\n", BOXNE);
  672. X  for (i = 0; i < wheelrows; i++) {
  673. X    for (j = 11; j >= 8; j--) {
  674. X      putchar(BOXV); PrintWheelSlot(j, i);
  675. X    }
  676. X    printf("%c\n", BOXV);
  677. X  }
  678. X  PrintHouse(12, TRUE); PrintTab(BOXH, WHEELCOLS-11);
  679. X  putchar(BOXC); PrintTab(BOXH, WHEELCOLS-1); putchar(BOXJN);
  680. X  PrintTab(BOXH, WHEELCOLS-1); putchar(BOXC); PrintTab(BOXH, WHEELCOLS-10);
  681. X  PrintHouse(8, FALSE); putchar('\n');
  682. X  for (i = 0; i < wheelrows; i++) {
  683. X    putchar(BOXV); PrintWheelSlot(12, i); putchar(BOXV);
  684. X
  685. X    /* For some rows, we have to insert the chart header information. */
  686. X
  687. X    if (i) {
  688. X      PrintTab(' ', WHEELCOLS-11);
  689. X      if (i == 1)
  690. X        printf("%s (%s) chart", appname, VERSION);
  691. X      else if (i == 2) {
  692. X        j = (int) Mon;
  693. X        k = ((long) MdyToJulian(Mon, Day, Yea) + 1) % 7;
  694. X        printf("%c%c%c %2d %c%c%c ",
  695. X          dayname[k][0], dayname[k][1], dayname[k][2], (int) Day,
  696. X          monthname[j][0], monthname[j][1], monthname[j][2]);
  697. X        k = (int) (FRACT(dabs(Tim))*100.0+0.5);
  698. X        printf("%4d %2.0f:%d%d", (int) Yea, floor(Tim), k/10, k%10);
  699. X      } else if (i == 3) {
  700. X        printf("%c%d%d:", Zon > 0.0 ? '-' : '+',
  701. X          (int)dabs(Zon)/10, (int)dabs(Zon)%10);
  702. X        j = (int) (FRACT(dabs(Zon))*100.0+0.5);
  703. X        printf("%d%d %s", j/10, j%10, StringLocation(Lon, Lat, 100.0));
  704. X      } else
  705. X        PrintTab(' ', 21);
  706. X      PrintTab(' ', WHEELCOLS-11);
  707. X
  708. X    } else
  709. X      PrintTab(' ', WHEELCOLS*2-1);
  710. X    putchar(BOXV); PrintWheelSlot(7, i); printf("%c\n", BOXV);
  711. X  }
  712. X  PrintHouse(1, TRUE); PrintTab(BOXH, WHEELCOLS-10);
  713. X  putchar(BOXJW); PrintTab(' ', WHEELCOLS-11);
  714. X  printf("%s", systemname[housesystem]);
  715. X  PrintTab(' ', 14-StringLen(systemname[housesystem]));
  716. X  printf("Houses."); PrintTab(' ', WHEELCOLS-11); putchar(BOXJE);
  717. X  PrintTab(BOXH, WHEELCOLS-10); PrintHouse(7, FALSE); putchar('\n');
  718. X  for (i = 0; i < wheelrows; i++) {
  719. X    putchar(BOXV); PrintWheelSlot(1, i); putchar(BOXV);
  720. X    PrintTab(' ', WHEELCOLS*2-1); putchar(BOXV); PrintWheelSlot(6, i);
  721. X    printf("%c\n", BOXV);
  722. X  }
  723. X  PrintHouse(2, TRUE); PrintTab(BOXH, WHEELCOLS-10);
  724. X  putchar(BOXC); PrintTab(BOXH, WHEELCOLS-1); putchar(BOXJS);
  725. X  PrintTab(BOXH, WHEELCOLS-1); putchar(BOXC);
  726. X  PrintTab(BOXH, WHEELCOLS-10); PrintHouse(6, FALSE); putchar('\n');
  727. X  for (i = 0; i < wheelrows; i++) {
  728. X    for (j = 2; j <= 5; j++) {
  729. X      putchar(BOXV); PrintWheelSlot(j, i);
  730. X    }
  731. X    printf("%c\n", BOXV);
  732. X  }
  733. X  putchar(BOXSW); PrintTab(BOXH, WHEELCOLS-4); PrintHouse(3, FALSE);
  734. X  PrintTab(BOXH, WHEELCOLS-10); PrintHouse(4, FALSE);
  735. X  PrintTab(BOXH, WHEELCOLS-10); PrintHouse(5, FALSE);
  736. X  PrintTab(BOXH, WHEELCOLS-7); printf("%c\n", BOXSE);
  737. X}
  738. X
  739. X
  740. X/* Display all aspects between objects in the chart, one per line, in       */
  741. X/* sorted order based on the total "power" of the aspect, as specified with */
  742. X/* the -m0 switch. The same influences used for -I charts are used here.    */
  743. X
  744. Xvoid ChartAspect()
  745. X{
  746. X  int pcut = 30000, icut, jcut, phi, ihi, jhi, ahi, p, i, j, k, count = 0;
  747. X  real ip, jp;
  748. X
  749. X  while (TRUE) {
  750. X    phi = -1;
  751. X
  752. X    /* Search for the next most powerful aspect in the aspect grid. */
  753. X
  754. X    for (i = 2; i <= TOTAL; i++) if (!ignore[i])
  755. X      for (j = 1; j < i; j++) if (!ignore[j])
  756. X        if (k = grid->n[j][i]) {
  757. X          ip = i <= OBJECTS ? objectinf[i] : 2.5;
  758. X          jp = j <= OBJECTS ? objectinf[j] : 2.5;
  759. X          p = (int) (aspectinf[k]*(ip+jp)/2.0*
  760. X            (1.0-dabs((real)(grid->v[j][i]))/60.0/aspectorb[k])*1000.0);
  761. X          if ((p < pcut || (p == pcut && (i > icut ||
  762. X            (i == icut && j > jcut)))) && p > phi) {
  763. X            ihi = i; jhi = j; phi = p; ahi = k;
  764. X          }
  765. X        }
  766. X    if (phi < 0)    /* Exit when no less powerful aspect found. */
  767. X      break;
  768. X    pcut = phi; icut = ihi; jcut = jhi;
  769. X    count++;                               /* Display the current aspect. */
  770. X    if (interpret)
  771. X      InterpretAspect(jhi, ihi);
  772. X    else {
  773. X      printf("%3d:", count);
  774. X      AnsiColor(objectansi[jhi]);
  775. X      printf(" %7.7s ", objectname[jhi]);
  776. X      k = (int) planet[jhi]/30;
  777. X      AnsiColor(elemansi[k & 3]);
  778. X      printf("%c%c%c%c%c", ret[jhi] >= 0.0 ? '(' : '[', SIGNAM(k+1),
  779. X        ret[jhi] >= 0.0 ? ')' : ']');
  780. X      AnsiColor(aspectansi[ahi]);
  781. X      printf(" %s ", aspectabbrev[ahi]);
  782. X      k = (int) planet[ihi]/30.0;
  783. X      AnsiColor(elemansi[k & 3]);
  784. X      printf("%c%c%c%c%c", ret[ihi] >= 0.0 ? '(' : '[', SIGNAM(k+1),
  785. X        ret[ihi] >= 0.0 ? ')' : ']');
  786. X      AnsiColor(objectansi[ihi]);
  787. X      printf(" %s", objectname[ihi]);
  788. X      PrintTab(' ', 11-StringLen(objectname[ihi]));
  789. X      AnsiColor(-1);
  790. X      k = grid->v[jhi][ihi];
  791. X      printf("- orb: %c%d,%d%d' - power:%6.2f\n",
  792. X        exdisplay & DASHga ? (k < 0 ? 'a' : 's') : (k < 0 ? '-' : '+'),
  793. X        abs(k)/60, abs(k)%60/10, abs(k)%60%10, (real) phi/1000.0);
  794. X    }
  795. X  }
  796. X}
  797. X
  798. X
  799. X/* Display locations of all midpoints between objects in the chart, */
  800. X/* one per line, in sorted zodiac order from zero Aries onward, as  */
  801. X/* specified with the -m switch.                                    */
  802. X
  803. Xvoid ChartMidpoint()
  804. X{
  805. X  int mcut = -1, icut, jcut, mlo, ilo, jlo, m, i, j, k, count = 0;
  806. X
  807. X  if (exdisplay & DASHm0) {
  808. X    ChartAspect();
  809. X    return;
  810. X  }
  811. X  while (TRUE) {
  812. X    mlo = 21600;
  813. X
  814. X    /* Search for the next closest midpoint farther down in the zodiac. */ 
  815. X
  816. X    for (i = 1; i < TOTAL; i++) if (!ignore[i])
  817. X      for (j = i+1; j <= TOTAL; j++) if (!ignore[j]) {
  818. X        m = (grid->n[j][i]-1)*30*60 + grid->v[j][i];
  819. X        if ((m > mcut || (m == mcut && (i > icut ||
  820. X          (i == icut && j > jcut)))) && m < mlo) {
  821. X          ilo = i; jlo = j; mlo = m;
  822. X        }
  823. X      }
  824. X    if (mlo >= 21600)    /* Exit when no midpoint farther in zodiac found. */
  825. X      break;
  826. X    mcut = mlo; icut = ilo; jcut = jlo;
  827. X    count++;                               /* Display the current midpoint. */
  828. X    printf("%4d: ", count);
  829. X    PrintMinute((real) mlo/60.0);
  830. X    AnsiColor(objectansi[ilo]);
  831. X    printf(" %7.7s ", objectname[ilo]);
  832. X    k = (int) planet[ilo]/30;
  833. X    AnsiColor(elemansi[k & 3]);
  834. X    printf("%c%c%c%c%c", ret[ilo] >= 0.0 ? '(' : '[', SIGNAM(k+1),
  835. X      ret[ilo] >= 0.0 ? ')' : ']');
  836. X    AnsiColor(WHITE);
  837. X    printf(" & ");
  838. X    k = (int) planet[jlo]/30.0;
  839. X    AnsiColor(elemansi[k & 3]);
  840. X    printf("%c%c%c%c%c", ret[jlo] >= 0.0 ? '(' : '[', SIGNAM(k+1),
  841. X      ret[jlo] >= 0.0 ? ')' : ']');
  842. X    AnsiColor(objectansi[jlo]);
  843. X    printf(" %s", objectname[jlo]);
  844. X    PrintTab(' ', 11-StringLen(objectname[jlo]));
  845. X    AnsiColor(-1);
  846. X    printf("-%4d degree span.\n", (int) MinDistance(planet[ilo], planet[jlo]));
  847. X  }
  848. X}
  849. X
  850. X
  851. X/* Display locations of the objects on the screen with respect to the local */
  852. X/* horizon, as specified with the -Z switch.                                */
  853. X
  854. Xvoid ChartHorizon()
  855. X{
  856. X  real lon, lat, sx, sy, vx, vy,
  857. X    lonz[TOTAL+1], latz[TOTAL+1], azi[TOTAL+1], alt[TOTAL+1];
  858. X  int i, j, k;
  859. X
  860. X  lon = DTOR(Mod(Lon)); lat = DTOR(Lat);
  861. X
  862. X  /* First find zenith location on Earth of each object. */
  863. X
  864. X  for (i = 1; i <= total; i++) {
  865. X    lonz[i] = DTOR(planet[i]); latz[i] = DTOR(planetalt[i]);
  866. X    ecltoequ(&lonz[i], &latz[i]);
  867. X  }
  868. X
  869. X  /* Then, convert this to local horizon altitude and azimuth. */
  870. X
  871. X  for (i = 1; i <= total; i++) if (i != 18) {
  872. X    lonz[i] = DTOR(Mod(RTOD(lonz[18]-lonz[i]+lon)));
  873. X    lonz[i] = DTOR(Mod(RTOD(lonz[i]-lon+PI/2.0)));
  874. X    equtolocal(&lonz[i], &latz[i], PI/2.0-lat);
  875. X    azi[i] = DEGREES-RTOD(lonz[i]); alt[i] = RTOD(latz[i]);
  876. X  }
  877. X
  878. X  /* Now, actually print the location of each object. */
  879. X
  880. X  printf("Body Altitude Azimuth  Azi. Vector   %s Vector    Moon Vector\n\n",
  881. X    centerplanet ? " Sun" : " Earth");
  882. X  for (k = 1; k <= total; k++) {
  883. X    i = k <= BASE ? k : BASE+starname[k-BASE];
  884. X    if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  885. X      AnsiColor(objectansi[i]);
  886. X      printf("%-4.4s: ", objectname[i]);
  887. X      PrintAltitude(alt[i]);
  888. X
  889. X      /* Determine directional vector based on azimuth. */
  890. X
  891. X      j = (int) (FRACT(azi[i])*60.0);
  892. X      printf(" %3d%c%d%d'", (int) azi[i], DEGR1, j/10, j%10);
  893. X      sx = cos(DTOR(azi[i])); sy = sin(DTOR(azi[i]));
  894. X      if (dabs(sx) < dabs(sy)) {
  895. X        vx = dabs(sx / sy); vy = 1.0;
  896. X      } else {
  897. X        vy = dabs(sy / sx); vx = 1.0;
  898. X      }
  899. X      printf(" (%.2f%c %.2f%c)",
  900. X        vy, sy < 0.0 ? 's' : 'n', vx, sx > 0.0 ? 'e' : 'w');
  901. X
  902. X      /* Determine distance vector of current object from Sun and Moon. */
  903. X
  904. X      vx = azi[1]-azi[i]; vy = azi[2]-azi[i];
  905. X      printf(" [%6.1f%6.1f] [%6.1f%6.1f]",
  906. X        dabs(vx) < 180.0 ? vx : Sgn(vx)*(DEGREES-dabs(vx)), alt[1]-alt[i],
  907. X        dabs(vy) < 180.0 ? vy : Sgn(vy)*(DEGREES-dabs(vy)), alt[2]-alt[i]);
  908. X      if (i >= U_LO) {
  909. X        if (i <= U_HI)
  910. X          printf("  Uranian #%d", i-U_LO+1);
  911. X        else
  912. X          printf("  Star #%2d", i-S_LO+1);
  913. X      }
  914. X      putchar('\n');
  915. X    }
  916. X  }
  917. X  AnsiColor(-1);
  918. X}
  919. X
  920. X
  921. X/* Display x,y,z locations of each body (in AU) with respect to the Sun */
  922. X/* (or whatever the specified center planet is), as in the -S switch.   */
  923. X/* These values were already determined when calculating the planet     */
  924. X/* positions themselves, so this procedure is basically just a loop.    */
  925. X
  926. Xvoid ChartSpace()
  927. X{
  928. X  real x, y, z;
  929. X  int i;
  930. X
  931. X  printf("Body     Angle    X axis    Y axis    Z axis    Length\n");
  932. X  for (i = 0; i <= BASE; i++)
  933. X    if (!ignore[i] && i != 2 && (i < THINGS || i > C_HI)) {
  934. X      AnsiColor(objectansi[i]);
  935. X      printf("%c%c%c%c: ", OBJNAM(i),
  936. X        objectname[i][3] ? objectname[i][3] : ' ');
  937. X      x = spacex[i]; y = spacey[i]; z = spacez[i];
  938. X      printf("[%7.2f] [%7.2f] [%7.3f] [%7.3f] [%7.3f]",
  939. X        planet[i], x, y, z, sqrt(x*x+y*y+z*z));
  940. X      if (i >= U_LO) {
  941. X        if (i <= U_HI)
  942. X          printf("  Uranian #%d", i-U_LO+1);
  943. X        else
  944. X          printf("  Star #%2d", i-S_LO+1);
  945. X      }
  946. X      printf("\n");
  947. X    }
  948. X  AnsiColor(-1);
  949. X}
  950. X
  951. X
  952. X/* This is a subprocedure of ChartInfluence(). Based on the values in the */
  953. X/* array parameter 'value', store numbers in array 'rank' reflecting the  */
  954. X/* relative order, e.g. value[x] 2nd greatest array value -> rank[x] = 2. */
  955. X
  956. Xvoid SortRank(value, rank, size)
  957. Xreal *value;
  958. Xint *rank;
  959. X{
  960. X  int h, i, j, k;
  961. X
  962. X  value[0] = -1.0;
  963. X  for (i = 1; i <= size; i++)
  964. X    rank[i] = -1;
  965. X  for (h = 1, i = 0; h <= size; h++) if (!ignore[h] || size == SIGNS) {
  966. X    i++;
  967. X    k = 0;
  968. X    for (j = 1; j <= size; j++) if (!ignore[j] || size == SIGNS)
  969. X      if (value[j] > value[k] && rank[j] < 0)
  970. X        k = j;
  971. X
  972. X        /* 'k' is the current position of the 'i'th place planet. */
  973. X
  974. X    rank[k] = i;
  975. X  }
  976. X}
  977. X
  978. X
  979. X/* Print out a list of power values and relative rankings, based on the */
  980. X/* placements of the planets, and their aspects in the aspect grid, as  */
  981. X/* specified with the -j "find influences" switch.                      */
  982. X
  983. Xvoid ChartInfluence()
  984. X{
  985. X  real power[OBJECTS+1], power1[OBJECTS+1], power2[OBJECTS+1],
  986. X    total, total1, total2, x;
  987. X  int rank[OBJECTS+1], rank1[OBJECTS+1], rank2[OBJECTS+1], i, j, k, l;
  988. X  char c;
  989. X
  990. X  for (i = 1; i <= OBJECTS; i++) {
  991. X    power1[i] = power2[i] = 0.0;
  992. X  }
  993. X  total = total1 = total2 = 0.0;
  994. X
  995. X  /* First, for each object, find its power based on its placement alone. */
  996. X
  997. X  for (i = 1; i <= THINGS; i++) {
  998. X    j = (int)planet[i]/30+1;
  999. X    power1[i] += objectinf[i];            /* Influence of planet itself. */
  1000. X    power1[i] += houseinf[inhouse[i]];    /* Influence of house it's in. */
  1001. X    c = Dignify(i, j);
  1002. X    switch (c) {
  1003. X    case 'R': x = objectinf[21]; break;    /* Planets in signs they rule or  */
  1004. X    case 'e': x = objectinf[22]; break;    /* are exalted in have influence. */
  1005. X    default:  x =  0.0;
  1006. X    }
  1007. X    c = Dignify(i, inhouse[i]);
  1008. X    switch (c) {
  1009. X    case 'R': x += houseinf[13]; break;  /* Planet in house corresponding to */
  1010. X    case 'e': x += houseinf[14]; break;  /* sign it rules has influence.     */
  1011. X    default: ;
  1012. X    }
  1013. X    power1[i] += x;
  1014. X    if (i != rules[j])                         /* The planet ruling the sign */
  1015. X      power1[rules[j]] += objectinf[i]/2.0;    /* and the house that the     */
  1016. X    if (i != (j = rules[inhouse[i]]))          /* current planet is in, gets */
  1017. X      power1[j] += objectinf[i]/2.0;           /* extra influence.           */
  1018. X  }
  1019. X  for (i = 1; i <= SIGNS; i++) {        /* Various planets get influence */
  1020. X    j = (int)(house[i]/30.0)+1;         /* if house cusps fall in signs  */
  1021. X    power1[rules[j]] += houseinf[i];    /* they rule.                    */
  1022. X  }
  1023. X
  1024. X  /* Second, for each object, find its power based on aspects it makes. */
  1025. X
  1026. X  CreateGrid(FALSE);
  1027. X  for (j = 1; j <= OBJECTS; j++) if (!ignore[j])
  1028. X    for (i = 1; i <= OBJECTS; i++) if (!ignore[i] && i != j) {
  1029. X      k = grid->n[MIN(i, j)][MAX(i, j)];
  1030. X      if (k) {
  1031. X        l = grid->v[MIN(i, j)][MAX(i, j)];
  1032. X        power2[j] += aspectinf[k]*objectinf[i]*
  1033. X          (1.0-dabs((real)l)/60.0/aspectorb[k]);
  1034. X      }
  1035. X    }
  1036. X
  1037. X  /* Calculate total power of each planet. */
  1038. X
  1039. X  for (i = 1; i <= THINGS; i++) if (!ignore[i]) {
  1040. X    power[i] = power1[i]+power2[i]; total1 += power1[i]; total2 += power2[i];
  1041. X  }
  1042. X  total = total1+total2;
  1043. X
  1044. X  /* Finally, determine ranks of the arrays, then print everything out. */
  1045. X
  1046. X  SortRank(power1, rank1, THINGS); SortRank(power2, rank2, THINGS);
  1047. X  SortRank(power, rank, THINGS);
  1048. X  printf("  Planet:    Position      Aspects    Total Rank  Percent\n");
  1049. X  for (i = 1; i <= THINGS; i++) if (!ignore[i]) {
  1050. X    AnsiColor(objectansi[i]);
  1051. X    printf("%8.8s: ", objectname[i]);
  1052. X    printf("%6.1f (%2d) +%6.1f (%2d) =%7.1f (%2d) /%6.1f%%\n",
  1053. X      power1[i], rank1[i], power2[i], rank2[i],
  1054. X      power[i], rank[i], power[i]/total*100.0);
  1055. X  }
  1056. X  AnsiColor(-1);
  1057. X  printf("   Total: %6.1f      +%6.1f      =%7.1f      / 100.0%%\n",
  1058. X    total1, total2, total);
  1059. X
  1060. X  /* Now, print out a list of power values and relative rankings, based on  */
  1061. X  /* the power of each sign of the zodiac, as indicated by the placement of */
  1062. X  /* the planets above, in the chart, as specified with the -j0 switch.     */
  1063. X
  1064. X  if (!(exdisplay & DASHj0))
  1065. X    return;
  1066. X  for (i = 1; i <= SIGNS; i++) {
  1067. X    power1[i] = 0.0;
  1068. X  }
  1069. X
  1070. X  /* For each sign, determine its power based on the power of the object. */
  1071. X
  1072. X  for (i = 1; i <= OBJECTS; i++) if (!ignore[i]) {
  1073. X    power1[(int)planet[i]/30+1] +=
  1074. X      (i <= THINGS ? power[i] : objectinf[i]) / 2.0;
  1075. X    power1[inhouse[i]]  += (i <= THINGS ? power[i] : objectinf[i]) / 4.0;
  1076. X    power1[ruler1[i]]   += (i <= THINGS ? power[i] : objectinf[i]) / 3.0;
  1077. X    if (ruler2[i])
  1078. X      power1[ruler2[i]] += (i <= THINGS ? power[i] : objectinf[i]) / 4.0;
  1079. X  }
  1080. X  if (!ignore[THINGS]) {
  1081. X    power1[Mod12((int)planet[THINGS]/30+7)] += power[THINGS] / 2.0; /* South */
  1082. X    power1[Mod12(inhouse[THINGS]+6)]        += power[THINGS] / 4.0; /* Node. */
  1083. X  }
  1084. X  total1 = 0.0;
  1085. X  for (i = 1; i <= SIGNS; i++)
  1086. X    total1 += power1[i];
  1087. X
  1088. X  /* Again, determine ranks in the array, and print everything out. */
  1089. X
  1090. X  SortRank(power1, rank1, SIGNS);
  1091. X  printf("\n       Sign:  Power Rank  Percent  - Element  Power  Percent\n");
  1092. X  for (i = 1; i <= SIGNS; i++) {
  1093. X    AnsiColor(elemansi[i-1 & 3]);
  1094. X    printf("%11.11s: ", signname[i]);
  1095. X    printf("%6.1f (%2d) /%6.1f%%",
  1096. X      power1[i], rank1[i], power1[i]/total*100.0);
  1097. X    if (i <= 4) {
  1098. X      printf("  -%7.7s:", element[i-1]);
  1099. X      total2 = 0.0;
  1100. X      for (j = 1; j < SIGNS; j += 4)
  1101. X        total2 += power1[i+j-1];
  1102. X      printf("%7.1f /%6.1f%%", total2, total2/total1*100.0);
  1103. X    }
  1104. X    putchar('\n');
  1105. X  }
  1106. X  AnsiColor(-1);
  1107. X  printf("      Total:%7.1f      / 100.0%%\n", total1);
  1108. X}
  1109. X
  1110. X
  1111. X/* Print the locations of the astro-graph lines on the Earth as specified */
  1112. X/* with the -L switch. This includes Midheaven and Nadir lines, zenith    */
  1113. X/* positions, and locations of Ascendant and Descendant lines.            */
  1114. X
  1115. Xvoid ChartAstroGraph()
  1116. X{
  1117. X  real planet1[TOTAL+1], planet2[TOTAL+1], lat[MAXCROSS], lon[MAXCROSS],
  1118. X    mc[TOTAL+1], ic[TOTAL+1], as[TOTAL+1], ds[TOTAL+1], as1[TOTAL+1],
  1119. X    ds1[TOTAL+1], lo = Lon, longm, w, x, y, z, ad, oa, am, od, dm;
  1120. X  int obj1[MAXCROSS], obj2[MAXCROSS], occurcount = 0, tot = total,
  1121. X    i, j, k, l, m, n;
  1122. X
  1123. X  for (i = 1; i <= TOTAL; i++) {
  1124. X    planet1[i] = DTOR(planet[i]);
  1125. X    planet2[i] = DTOR(planetalt[i]);      /* Calculate zenith location on */
  1126. X    ecltoequ(&planet1[i], &planet2[i]);   /* Earth of each object.        */
  1127. X  }
  1128. X
  1129. X  /* Print header. */
  1130. X
  1131. X  printf("Object :");
  1132. X  for (j = 0, i = 1; i <= total; i++)
  1133. X    if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  1134. X      AnsiColor(objectansi[i]);
  1135. X      printf(" %c%c%c", OBJNAM(i));
  1136. X      j++;
  1137. X      if (column80 && j >= 17) {
  1138. X        tot = i;
  1139. X        i = total;
  1140. X      }
  1141. X    }
  1142. X  AnsiColor(-1);
  1143. X  printf("\n------ :");
  1144. X  for (i = 1; i <= tot; i++)
  1145. X    if (!ignore[i] && (i <= THINGS || i > C_HI))
  1146. X      printf(" ###");
  1147. X
  1148. X  /* Print the longitude locations of the Midheaven lines. */
  1149. X
  1150. X  printf("\nMidheav: ");
  1151. X  if (lo < 0.0)
  1152. X    lo += DEGREES;
  1153. X  for (i = 1; i <= tot; i++)
  1154. X    if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  1155. X    AnsiColor(objectansi[i]);
  1156. X    x = DTOR(MC)-planet1[i];
  1157. X    if (x < 0.0)
  1158. X      x += 2.0*PI;
  1159. X    if (x > PI)
  1160. X      x -= 2.0*PI;
  1161. X    z = lo+RTOD(x);
  1162. X    if (z > 180.0)
  1163. X      z -= DEGREES;
  1164. X    mc[i] = z;
  1165. X    printf("%3.0f%c", dabs(z), z < 0.0 ? 'e' : 'w');
  1166. X  }
  1167. X  AnsiColor(-1);
  1168. X
  1169. X  /* The Nadir lines are just always 180 degrees away from the Midheaven. */
  1170. X
  1171. X  printf("\nNadir  : ");
  1172. X  for (i = 1; i <= tot; i++)
  1173. X    if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  1174. X    AnsiColor(objectansi[i]);
  1175. X    z = mc[i] + 180.0;
  1176. X    if (z > 180.0)
  1177. X      z -= DEGREES;
  1178. X    ic[i] = z;
  1179. X    printf("%3.0f%c", dabs(z), z < 0.0 ? 'e' : 'w');
  1180. X  }
  1181. X  AnsiColor(-1);
  1182. X
  1183. X  /* Print the Zenith latitude locations. */
  1184. X
  1185. X  printf("\nZenith : ");
  1186. X  for (i = 1; i <= tot; i++)
  1187. X    if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  1188. X      AnsiColor(objectansi[i]);
  1189. X      y = RTOD(planet2[i]);
  1190. X      printf("%3.0f%c", dabs(y), y < 0.0 ? 's' : 'n');
  1191. X      as[i] = ds[i] = as1[i] = ds1[i] = 1000.0;
  1192. X    }
  1193. X  printf("\n\n");
  1194. X
  1195. X  /* Now print the locations of Ascendant and Descendant lines. Since these */
  1196. X  /* are curvy, we loop through the latitudes, and for each object at each  */
  1197. X  /* latitude, print the longitude location of the line in question.        */
  1198. X
  1199. X  longm = DTOR(Mod(MC+lo));
  1200. X  for (j = 80; j >= -80; j -= graphstep) {
  1201. X    AnsiColor(-1); 
  1202. X    printf("Asc@%2d%c: ", j >= 0 ? j : -j, j < 0 ? 's' : 'n');
  1203. X    for (i = 1; i <= tot; i++)
  1204. X      if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  1205. X      AnsiColor(objectansi[i]);
  1206. X      ad = tan(planet2[i])*tan(DTOR(j));
  1207. X      if (ad*ad > 1.0) {
  1208. X        printf(" -- ");
  1209. X        as1[i] = ds1[i] = ret2[i] = 1000.0;
  1210. X      } else {
  1211. X        ad = ASIN(ad);
  1212. X        oa = planet1[i]-ad;
  1213. X        if (oa < 0.0)
  1214. X          oa += 2.0*PI;
  1215. X        am = oa-PI/2.0;
  1216. X        if (am < 0.0)
  1217. X          am += 2.0*PI;
  1218. X        z = longm-am;
  1219. X        if (z < 0.0)
  1220. X          z += 2.0*PI;
  1221. X        if (z > PI)
  1222. X          z -= 2.0*PI;
  1223. X        as1[i] = as[i];
  1224. X        as[i] = z = RTOD(z);
  1225. X        ret2[i] = ad;
  1226. X        printf("%3.0f%c", dabs(z), z < 0.0 ? 'e' : 'w');
  1227. X      }
  1228. X    }
  1229. X
  1230. X    /* Again, the Descendant position is related to the Ascendant's,  */
  1231. X    /* being a mirror image, so it can be calculated somewhat easier. */
  1232. X
  1233. X    AnsiColor(-1);
  1234. X    printf("\nDsc@%2d%c: ", j >= 0 ? j : -j, j < 0 ? 's' : 'n');
  1235. X    for (i = 1; i <= tot; i++)
  1236. X      if (!ignore[i] && (i <= THINGS || i > C_HI)) {
  1237. X      AnsiColor(objectansi[i]);
  1238. X      ad = ret2[i];
  1239. X      if (ad == 1000.0)
  1240. X        printf(" -- ");
  1241. X      else {
  1242. X        od = planet1[i]+ad;
  1243. X        dm = od+PI/2.0;
  1244. X        z = longm-dm;
  1245. X        if (z < 0.0)
  1246. X          z += 2.0*PI;
  1247. X        if (z > PI)
  1248. X          z -= 2.0*PI;
  1249. X        ds1[i] = ds[i];
  1250. X        ds[i] = z = RTOD(z);
  1251. X        printf("%3.0f%c", dabs(z), z < 0.0 ? 'e' : 'w');
  1252. X      }
  1253. X    }
  1254. X    putchar('\n');
  1255. X
  1256. X    /* Now, if the -L0 switch is in effect, then take these line positions, */
  1257. X    /* which we saved in an array above as we were printing them, and       */
  1258. X    /* calculate and print the latitude crossings.                          */
  1259. X
  1260. X    if (exdisplay & DASHL0)
  1261. X      for (l = 1; l <= total; l++) if (!ignore[l] && (l <= THINGS || l > C_HI))
  1262. X        for (k = 1; k <= total; k++)
  1263. X        if (!ignore[k] && (k <= THINGS || k > C_HI))
  1264. X        for (n = 0; n <= 1; n++) {
  1265. X        x = n ? ds1[l] : as1[l];
  1266. X        y = n ? ds[l] : as[l];
  1267. X        for (m = 0; m <= 1; m++) {
  1268. X
  1269. X        /* Check if Ascendant/Descendant cross Midheaven/Nadir. */
  1270. X
  1271. X        z = m ? ic[k] : mc[k];
  1272. X        if (occurcount < MAXCROSS &&
  1273. X          dabs(x-y) < 180.0 && Sgn(z-x) != Sgn(z-y)) {
  1274. X          obj1[occurcount] = n ? -l : l;
  1275. X          obj2[occurcount] = m ? -k : k;
  1276. X          lat[occurcount] = (real)j+5.0*dabs(z-y)/dabs(x-y);
  1277. X          lon[occurcount] = z;
  1278. X          occurcount++;
  1279. X        }
  1280. X
  1281. X        /* Check if Ascendant/Descendant cross another Asc/Des. */
  1282. X
  1283. X        w = m ? ds1[k] : as1[k];
  1284. X        z = m ? ds[k] : as[k];
  1285. X        if (occurcount < MAXCROSS && k > l &&
  1286. X            dabs(x-y)+dabs(w-z) < 180.0 && Sgn(w-x) != Sgn(z-y)) {
  1287. X          obj1[occurcount] = n ? -l : l;
  1288. X          obj2[occurcount] = 100+(m ? -k : k);
  1289. X          lat[occurcount] = (real)j+5.0*
  1290. X            dabs(y-z)/(dabs(x-w)+dabs(y-z));
  1291. X          lon[occurcount] = MIN(x, y)+dabs(x-y)*
  1292. X            dabs(y-z)/(dabs(x-w)+dabs(y-z));
  1293. X          occurcount++;
  1294. X        }
  1295. X      }
  1296. X    }
  1297. X  }
  1298. X  if ((exdisplay & DASHL0) == 0)
  1299. X    return;
  1300. X  putchar('\n');
  1301. X
  1302. X  /* Now, print out all the latitude crossings we found.  */
  1303. X  /* First, we sort them in order of decreasing latitude. */
  1304. X
  1305. X  for (i = 1; i < occurcount; i++) {
  1306. X    j = i-1;
  1307. X    while (j >= 0 && lat[j] < lat[j+1]) {
  1308. X      SWAP(obj1[j], obj1[j+1]); SWAP(obj2[j], obj2[j+1]);
  1309. X      SwapReal(&lat[j], &lat[j+1]); SwapReal(&lon[j], &lon[j+1]);
  1310. X      j--;
  1311. X    }
  1312. X  }
  1313. X  for (i = 1; i < occurcount; i++) {
  1314. X    j = abs(obj1[i]);
  1315. X    AnsiColor(objectansi[j]);
  1316. X    printf("%c%c%c ", OBJNAM(j));
  1317. X    AnsiColor(elemansi[obj1[i] > 0 ? 0 : 2]);
  1318. X    printf("%s ", obj1[i] > 0 ? "Ascendant " : "Descendant");
  1319. X    AnsiColor(WHITE);
  1320. X    printf("crosses ");
  1321. X    j = abs(obj2[i] - (obj2[i] < 50 ? 0 : 100));
  1322. X    AnsiColor(objectansi[j]);
  1323. X    printf("%c%c%c ", OBJNAM(j));
  1324. X    AnsiColor(elemansi[obj2[i] < 50 ?
  1325. X      (obj2[i] > 0 ? 1 : 3) : (obj2[i] > 100 ? 0 : 2)]);
  1326. X    printf("%s ", obj2[i] < 50 ? (obj2[i] > 0 ? "Midheaven " :
  1327. X      "Nadir     ") : (obj2[i] > 100 ? "Ascendant " : "Descendant"));
  1328. X    j = (int) (FRACT(dabs(lon[i]))*60.0);
  1329. X    AnsiColor(-1);
  1330. X    printf("at %3d%c%d%d'%c, ", (int) dabs(lon[i]), DEGR2,
  1331. X      j/10, j%10, lon[i] < 0.0 ? 'E' : 'W');
  1332. X    j = (int) (FRACT(dabs(lat[i]))*60.0);
  1333. X    printf("%2d%c%d%d'%c\n", (int) dabs(lat[i]), DEGR2,
  1334. X      j/10, j%10, lat[i] < 0.0 ? 'S' : 'N');
  1335. X  }
  1336. X  if (!occurcount) {
  1337. X    AnsiColor(-1);
  1338. X    printf("No latitude crossings.\n");
  1339. X  }
  1340. X}
  1341. X
  1342. X/* charts.c */
  1343. END_OF_FILE
  1344. if test 43383 -ne `wc -c <'charts.c'`; then
  1345.     echo shar: \"'charts.c'\" unpacked with wrong size!
  1346. fi
  1347. # end of 'charts.c'
  1348. fi
  1349. if test -f 'xdata.c' -a "${1}" != "-c" ; then 
  1350.   echo shar: Will not clobber existing file \"'xdata.c'\"
  1351. else
  1352. echo shar: Extracting \"'xdata.c'\" \(15016 characters\)
  1353. sed "s/^X//" >'xdata.c' <<'END_OF_FILE'
  1354. X/*
  1355. X** Astrolog (Version 3.05) File: xdata.c
  1356. X**
  1357. X** IMPORTANT: The planetary calculation routines used in this program
  1358. X** have been Copyrighted and the core of this program is basically a
  1359. X** conversion to C of the routines created by James Neely as listed in
  1360. X** Michael Erlewine's 'Manual of Computer Programming for Astrologers',
  1361. X** available from Matrix Software. The copyright gives us permission to
  1362. X** use the routines for our own purposes but not to sell them or profit
  1363. X** from them in any way.
  1364. X**
  1365. X** IN ADDITION: the graphics database and chart display routines used in
  1366. X** this program are Copyright (C) 1991-1993 by Walter D. Pullen. Permission
  1367. X** is granted to freely use and distribute these routines provided one
  1368. X** doesn't sell, restrict, or profit from them in any way. Modification
  1369. X** is allowed provided these notices remain with any altered or edited
  1370. X** versions of the program.
  1371. X*/
  1372. X
  1373. X#include "astrolog.h"
  1374. X
  1375. X#ifdef GRAPH
  1376. X
  1377. X
  1378. X/*
  1379. X*******************************************************************************
  1380. X** Graphics global variables
  1381. X*******************************************************************************
  1382. X*/
  1383. X
  1384. Xbitmap bm;
  1385. Xchar modex = 'c', bitmapmode = BITMAPMODE,
  1386. X  *dispname = NULL, outputfile[STRING] = "tty";
  1387. X#ifdef WIN
  1388. Xint xbitmap = FALSE;
  1389. X#else
  1390. Xint xbitmap = TRUE;
  1391. X#endif
  1392. Xint xmono = FALSE, xcolor = TRUE, xreverse = FALSE, xroot = FALSE,
  1393. X  xtext = TRUE, bonus = FALSE, label = TRUE,
  1394. X  xeast = 0, turtlex = 0, turtley = 0, scale = 200,
  1395. X  chartx = DEFAULTX, charty = DEFAULTY, xnow = 0, degree = 0;
  1396. Xreal tilt = 0.0;
  1397. X
  1398. X/* Color tables for Astrolog's graphic palette. */
  1399. X
  1400. Xcolor rgbbmp[] = {
  1401. X  0x000000, 0x00007F, 0x007F00, 0x007F7F,
  1402. X  0x7F0000, 0x7F007F, 0x7F7F00, 0xBFBFBF,
  1403. X  0x7F7F7F, 0x0000FF, 0x00FF00, 0x00FFFF,
  1404. X  0xFF0000, 0xFF00FF, 0xFFFF00, 0xFFFFFF};
  1405. X#ifdef MSC
  1406. Xcolor rgb[] = {
  1407. X  _BLACK, _RED, _GREEN, _BROWN,
  1408. X  _BLUE, _MAGENTA, _CYAN, _WHITE,
  1409. X  _GRAY, _LIGHTRED, _LIGHTGREEN, _YELLOW,
  1410. X  _LIGHTBLUE, _LIGHTMAGENTA, _LIGHTCYAN, _BRIGHTWHITE};
  1411. X#endif
  1412. X#ifdef X11
  1413. Xchar *rgbname[] = {
  1414. X  "black", "orangered3", "green4", "darkorange2",
  1415. X  "blue4", "violet", "cyan4", "grey65",
  1416. X  "grey35", "orangered1", "green1", "yellow1",
  1417. X  "blue1", "pink", "cyan1", "white"};
  1418. Xcolor rgbind[16];
  1419. X#endif
  1420. X
  1421. X/* These are the actual color arrays and variables used by the program.      */
  1422. X/* Technically, Astrolog always assumes we are drawning on a color terminal; */
  1423. X/* for B/W graphics, all the values below are filled with black or white.    */
  1424. X
  1425. Xcolor fg, bg, on, off, hilite, gray,
  1426. X  maincolor[6+1], rainbowcolor[7+1],
  1427. X  elemcolor[4], aspectcolor[ASPECTS+1], objectcolor[TOTAL+1];
  1428. X
  1429. X/* A bunch of physical X window variables dealing with the window itself. */
  1430. X
  1431. X#ifdef X11
  1432. XColormap cmap;
  1433. XDisplay *disp;
  1434. XGC gc, pmgc;
  1435. XKeySym key;
  1436. XPixmap pixmap, icon;
  1437. XWindow window, root;
  1438. XXEvent event;
  1439. XXSizeHints hint;
  1440. X/*XWMHints *wmhint;*/
  1441. Xint screen, depth;
  1442. Xchar xkey[10];
  1443. X#endif
  1444. X
  1445. X
  1446. X/*
  1447. X*******************************************************************************
  1448. X** Astrolog icon
  1449. X*******************************************************************************
  1450. X*/
  1451. X
  1452. X#ifdef X11
  1453. X/* This information used to define Astrolog's X icon (Rainbow over Third */
  1454. X/* Eye) is identical to the output format used by the bitmap program.    */
  1455. X/* You could extract this section and run xsetroot -bitmap on it.        */
  1456. X
  1457. X#define icon_width 63
  1458. X#define icon_height 32
  1459. X/*static*/ char icon_bits[] = {
  1460. X 0x00,0x00,0x00,0xa8,0x0a,0x00,0x00,0x00,0x00,0x00,0x40,0x55,0x55,0x01,0x00,
  1461. X 0x00,0x00,0x00,0xa8,0xaa,0xaa,0x0a,0x00,0x00,0x00,0x00,0x54,0xf5,0x57,0x15,
  1462. X 0x00,0x00,0x00,0x80,0xaa,0xaa,0xaa,0xaa,0x00,0x00,0x00,0x40,0xd5,0xff,0xff,
  1463. X 0x55,0x01,0x00,0x00,0xa0,0xaa,0xaa,0xaa,0xaa,0x02,0x00,0x00,0x50,0xfd,0xff,
  1464. X 0xff,0x5f,0x05,0x00,0x00,0xa8,0xaa,0x2a,0xaa,0xaa,0x0a,0x00,0x00,0xd4,0xff,
  1465. X 0xaf,0xfa,0xff,0x15,0x00,0x00,0xaa,0x2a,0x00,0x00,0xaa,0x2a,0x00,0x00,0xf5,
  1466. X 0xbf,0xaa,0xaa,0xfe,0x57,0x00,0x80,0xaa,0x02,0x00,0x00,0xa0,0xaa,0x00,0x40,
  1467. X 0xfd,0xab,0xfa,0xaf,0xea,0x5f,0x01,0xa0,0xaa,0x80,0xff,0xff,0x80,0xaa,0x02,
  1468. X 0x50,0xff,0xea,0xff,0xff,0xab,0x7f,0x05,0xa0,0x2a,0xf0,0xff,0xff,0x07,0xaa,
  1469. X 0x02,0xd0,0xbf,0xfa,0x0f,0xf8,0xaf,0x7e,0x05,0xa8,0x0a,0xfc,0x01,0xc0,0x1f,
  1470. X 0xa8,0x0a,0xd4,0xaf,0x7e,0x00,0x00,0xbf,0xfa,0x15,0xa8,0x0a,0x3f,0x00,0x00,
  1471. X 0x7e,0xa8,0x0a,0xf4,0xaf,0x1f,0xe0,0x03,0xfc,0xfa,0x15,0xaa,0x82,0x0f,0xdc,
  1472. X 0x1d,0xf8,0xa0,0x2a,0xf4,0xab,0x07,0x23,0x62,0xf0,0xea,0x17,0xaa,0xc2,0x87,
  1473. X 0x91,0xc4,0xf0,0xa1,0x2a,0xf4,0xeb,0xc3,0xd0,0x85,0xe1,0xeb,0x17,0xaa,0xe0,
  1474. X 0x83,0x91,0xc4,0xe0,0x83,0x2a,0xf5,0xeb,0x03,0x23,0x62,0xe0,0xeb,0x57,0xaa,
  1475. X 0xe0,0x01,0xdc,0x1d,0xc0,0x83,0x2a,0xf5,0xeb,0x01,0xe0,0x03,0xc0,0xeb,0x57,
  1476. X 0xaa,0xe0,0x01,0x00,0x00,0xc0,0x83,0x2a,0xfd,0xeb,0x01,0x00,0x00,0xc0,0xeb,
  1477. X 0x5f};
  1478. X#endif
  1479. X
  1480. X
  1481. X/*
  1482. X*******************************************************************************
  1483. X** Graphics table data
  1484. X*******************************************************************************
  1485. X*/
  1486. X
  1487. Xchar *signdraw[] = {"",
  1488. X  "ND4HU2HLGDFBR6EUHLGD2G",                /* Aries */
  1489. X  "BL3D2F2R2E2U2H2NE2L2NH2G2",             /* Taurus */
  1490. X  "BLU3LHBR7GLNL3D6NL3RFBL7ERU3",          /* Gemini */
  1491. X  "BGNDHLGDFRNEFR2EREBU3NHDGLHUENRHL2GLG", /* Cancer */
  1492. X  "BF4H2UEU2H2L2G2D2FDGH",                 /* Leo */
  1493. X  "BF4BLHNGNHEU5GHND5HGND6HGND6H",         /* Virgo */
  1494. X  "BGNL3HUER2FDGR3BD2L8",                  /* Libra */
  1495. X  "BH4FND6EFND6EFD6FREU",                  /* Scorpio */
  1496. X  "BG4E3NH2NF2E5NL2D2",                    /* Sagittarius */
  1497. X  "BH3NLNUD3FND2EU2ENF2UFERFDGLF2D2G",     /* Capricorn */
  1498. X  "BG4EUEDFDEUEDFDEUEBU5GDGUHUGDGUHUGDG",  /* Aquarius */
  1499. X  "NL4NR4BH4F2D4G2BR8H2U4E2"};             /* Pisces */
  1500. X
  1501. Xchar *objectdraw[] = {"ND4NL4NR4U4LGLDGD2FDRFR2ERUEU2HULHL", /* Earth */
  1502. X  "U0BH3DGD2FDRFR2ERUEU2HULHL2GL",          /* Sun */
  1503. X  "BG3E2U2H2ER2FRDFD2GDLGL2H",              /* Moon */
  1504. X  "BD4UNL2NR2U2REU2HNEL2NHGD2FR",           /* Mercury */
  1505. X  "LHU2ER2FD2GLD2NL2NR2D2",                 /* Venus */
  1506. X  "HLG2DF2RE2UHE4ND2L2",                    /* Mars */
  1507. X  "BH3RFDGDGDR5NDNR2U6E",                   /* Jupiter */
  1508. X  "BH3R2NUNR2D3ND3RERFDGDF",                /* Saturn */
  1509. X  "BD4NEHURBFULU3NUNR2L2NU2DGBU5NFBR6GD3F", /* Uranus */
  1510. X  "BD4U2NL2NR2U5NUNRLBL2NUNLDF2R2E2UNRU",   /* Neptune */
  1511. X  "D2NL2NR2D2BU8GFEHBL3D2F2R2E2U2",         /* Pluto */
  1512. X  "BG2LDFEULU3NURFRFBU5GLGLU2",             /* Chiron */
  1513. X  "BD4UNL3NR3U2RE2UH2L2G",                  /* Ceres */
  1514. X  "BD4UNL3NR3UE2HUHNUGDGF2",                /* Pallas Athena */
  1515. X  "BD4UNL2NR2U4NL4NR4NE3NF3NG3NH3U3",       /* Juno */
  1516. X  "BU4DBG3NLFDF2E2UERBH2GDGHUH",            /* Vesta */
  1517. X  "BG2LGFEU2HU2E2R2F2D2GD2FEHL",            /* North Node */
  1518. X  "NE2NF2NG2H2GD2F2R2E2U2H2L2G",            /* Part of Fortune */
  1519. X  "BG4U8F4E4D8",                            /* Midheaven */
  1520. X  "NR4L4ND4UE3R2F3D5",                      /* Ascendant */
  1521. X  "U2NHNEBD4NGNFU2L2NHNGR4NEF"};            /* Vertex */
  1522. X
  1523. Xchar *housedraw[] = {"",
  1524. X  "BD2NLNRU4L", "BHBUR2D2L2D2R2", "BHBUR2D2NL2D2L2",
  1525. X  "BHBUD2R2NU2D2", "BEBUL2D2R2D2L2", "NLRD2L2U4R2",
  1526. X  "BHBUR2DG2D", "NRLU2R2D4L2U2", "NRLU2R2D4L2",
  1527. X  "BH2NLD4NLRBR2U4R2D4L2", "BH2NLD4NLRBR2RNRU4L", "BH2NLD4NLRBR2NR2U2R2U2L2"};
  1528. X
  1529. Xchar *aspectdraw[] = {"",
  1530. X  "HLG2DF2RE2UHE4", "BGL2GDFREU2E2U2ERFDGL2", "BH4R8D8L8U8",
  1531. X  "BU4GDGDGDGDR8UHUHUHUH", "BLNH3NG3RNU4ND4RNE3F3",
  1532. X  "BG4EUEUEUEUNL4NR4BDFDFDFDF", "BH4FDFDFDFDNL4NR4BUEUEUEUE", "BE4G8R8",
  1533. X  "BD2L3U6R6D6L3D2R2", "F4BU3U2HULHL2GLDGD2FDRFR2E3", "BD2U3NR3NU3L3BD5R6",
  1534. X  "BU2D3NR3ND3L3BU5R6", "BH3R6G6", "BR3L5HUER4FD4GL4H",
  1535. X  "BF2UHL2GFR3DGL3BE6LNLU2NRLBL4LNLD2NLR", "BL2R4G4BE6LNLU2NRLBL4LNLD2NLR",
  1536. X  "BL2R4G4BE6L7NLU2NLR3ND2R3ND2R", "BF2UHL2GFR3DGL3BU6LNLU2NLRBR2F2E2"};
  1537. X
  1538. Xchar *asciidraw[] = {"",
  1539. X  "BR2D4BD2D0", "BRD2BR2U2", "BD2R4BD2L4BFU4BR2D4", "BR2D6BENL3EHL2HER3",
  1540. X  "RDLNUBR4G4BR4DLUR", "BD2NF4UEFDG2DFRE2", "BR2DG", "BR3G2D2F2", "BRF2D2G2",
  1541. X  "BD2FNGRNU2ND2RNEF", "BD3R2NU2ND2R2", "BD5BR2DG", "BD3R4", "BD6BRRULD",
  1542. X  "BD5E4", /* Special Characters */
  1543. X  "BDD4NE4FR2EU4HL2G", "BFED6NLR", "BDER2FDG4R4", "BDER2FDGNLFDGL2H",
  1544. X  "D3R3NU3ND3R", "NR4D3R3FDGL2H", "BR3NFL2GD4FR2EUHL3", "R4DG4D",
  1545. X  "BDDFNR2GDFR2EUHEUHL2G", "BD5FR2EU4HL2GDFR3", /* Numbers */
  1546. X  "BR2BD2D0BD2D0", "BR2BD2D0BD2G", "BR3G3F3", "BD2R4BD2L4", "BRF3G3",
  1547. X  "BDER2FDGLDBD2D0", "BF2DFEU2HL2GD4FR2", /* Special Characters */
  1548. X  "BD6U4E2F2D2NL4D2", "D6R3EUHNL3EUHL3", "BR3NFL2GD4FR2E", "D6R2E2U2H2L2",
  1549. X  "NR4D3NR3D3R4", "NR4D3NR3D3", "BR3NFL2GD4FR2EU2L2", "D3ND3R4NU3D3",
  1550. X  "BRRNRD6NLR", "BD4DFR2EU5", "D3ND3RNE3F3", "D6R4", "ND6F2NDE2D6",
  1551. X  "ND6F4ND2U4", "BDD4FR2EU4HL2G", "R3FDGL3NU3D3", "BDD4FRENHNFEU3HL2G",
  1552. X  "ND6R3FDGL2NLF3", "BR3NFL2GDFR2FDGL2H", "R2NR2D6", "D5FR2EU5",
  1553. X  "D2FDFNDEUEU2", "D6E2NUF2U6", "DF4DBL4UE4U", "D2FRND3REU2",
  1554. X  "R4DG4DR4", /* Upper Case Letters */
  1555. X  "BR3L2D6R2", "BDF4", "BRR2D6L2", "BD2E2F2", "BD6R4", "BR2DF", /* Symbols */
  1556. X  "BF4G2LHU2ER2FD3", "D5NDFR2EU2HL2G", "BF4BUHL2GD2FR2E", "BR4D5NDGL2HU2ER2F",
  1557. X  "BF4NL4UHL2GD2FR3", "BD3RNR3ND3U2ERF", "BD8R3EU4HL2GD2FR2E", "D3ND3ER2FD3",
  1558. X  "BR2D0BD2D4", "BR2D0BD2D5GLH", "D4ND2REREBD4HLH", "BR2D6", "BD2DND3EFNDEFD3",
  1559. X  "BD2DND3ER2FD3", "BD3D2FR2EU2HL2G", "BD2DND5ER2FD2GL2H",
  1560. X  "BR4BD8U5HL2GD2FR2E", "BD2DND3ER2F", "BD6R3EHL2HER3", "BR2D2NL2NR2D4",
  1561. X  "BD2D3FRE2NU2D2", "BD2DFDFEUEU", "BD2D3FENUFEU3", "BD2F2NG2NE2F2",
  1562. X  "BD2D3FR2ENU3D2GL3", "BD2R4G4R4", /* Lower Case Letters */
  1563. X  "BR3GDGFDF", "BR2D2BD2D2", "BRFDFGDG", "BFEFE", "BD6R4"}; /* Symbols */
  1564. X
  1565. Xchar *worlddata[] = {
  1566. X"-031+70",
  1567. X"LLRRHLLLLDULLGLLLDULGLLLGLRREDEGGLGGLGLGLLGDRLDRLFFRRERFDFRRREUEEHLUERERUERRF\
  1568. XGLGLDDFRRRRREFRLGLLLLLGEFDLHGDDLGHLGLLHGLHURDLRRELLLRHUGLDFDLGLLFHGGLGLLLDLLLD\
  1569. XRRFFDDGLLLLLLGDFGDDRRFRERREEUEREUEFRRERRFFFRFRDDLLLLRFRUREURULHLHHHEF",
  1570. X"5EUROPE",
  1571. X"+006+50", "RRERRRRUELLUHHLLREULLELLDGHDUFDEGRDRRLFDLLRGRRGGL", "5ENGLAND",
  1572. X"+008+55", "GLFGRRREUULL", "5IRELAND",
  1573. X"+023+64", "RRFRERRREHLLLLLGHLLRFLLRFL", "5ICELAND",
  1574. X"-011+80", "DDURFRERLGRRLLFRRREEFRRRLHGELLLHRRFRRRRERLLLLLLLLLLLDHGULLL",
  1575. X"5SVALBARD",
  1576. X"-014+45",
  1577. X"FRFRFDDFRDRRLLFRURFHHUERRRRRHUUEERRRRGRDERRLHLRRERRGGRFRFFGLLLLHLLLLGLLDLLLFG\
  1578. XRFFRERFRERDDDGDGLLDFFEUDDFFDFFDDFFFDFDDDRRERRERRRUERRERURUEEHHLHUGGLLLUUGUHUHU\
  1579. XRRFFRFRRRDRRFRRRRRRRF",
  1580. X"5MIDDLE EAST",
  1581. X"-009+41", "DDRUULEUGD", "5SARDINIA",
  1582. X"-024+35", "RRLL", "5CRETE",
  1583. X"-032+35", "RRLL", "5CYPRUS",
  1584. X"-052+37", "LLHUURHUHUHERERRRDDLLLFFDDURFLLDFDDL", "0CASPAIN SEA",
  1585. X"-060+44", "LLUEERDFLDL", "0ARAL SEA",
  1586. X"-068+24",
  1587. X"FRGFRREDDDDDFDFDDFDDFERUEUUUUEEEEEREURRREFDFRDDDDRREFDDFDDGDDRFDDFDFFRUHUUHHH\
  1588. XULUEUUURDRFDFRDEEREUUUHHHUUEERRDDEURRERREREEEUEULLREUHUHLEERRHLGLULUREERDLDRER\
  1589. XRFGRFDGRRREUHHUREUE",
  1590. X"6ASIA S",
  1591. X"-140+36",
  1592. X"DEUUEUHURREREEGLLHHDDGLDRGDDGGLGLLLGGLDLRDFEUHRRGEERDLLRGLRERRERRE",
  1593. X"6JAPAN",
  1594. X"-121+25", "GDFUEUL", "6TAIWAN",
  1595. X"-080+10", "DDDDREUHH", "6SRI LANKA",
  1596. X"-121+18", "LDDDRDDRHRRFFDDDLLEHDULRHDFDDGERDDREUUULUUHHLHEUUL",
  1597. X"2PHILIPPINES",
  1598. X"-131+43",
  1599. X"EFREEREEEUUUEUHLLUDLULEERERERRRRRRERRFLRRRRLUERERRRDRERURRGDLGLGLGLGGDDFDFEUR\
  1600. XRUERUURULEEREDERRFRERERRRERRHLHLRRRREURDRRFRFRUURRHLLLDHHLLHLLHLLLLLLLDLLHRLLL\
  1601. XLLLLGHULLLLLLLLLLULLLGL",
  1602. X"6SIBERIA",
  1603. X"-145+71",
  1604. X"RELLRHLLLLGDHGHLLLLGLLHUHLLLLLDLLLLHLLLLLDULUDLGLLLLRRERERRRELHLLLLLLLELLLLGD\
  1605. XLLLLLUDLLLLLGLLLDLLLLLLLDFRDDHELLLLLLDRRLLHUDLGFGRRRRFRLHLLDGLGLLHRRREUHUUULLG\
  1606. XGLDRFGHLLLHLLLLRFGHLGLLLULGLLLGLLHRHLDDDLLLLDLLLFLLHUHLRRFRRRREHLLHLLLHLL",
  1607. X"6RUSSIA",
  1608. X"-143+54", "GDDDDDDDEDUUURUUHUU", "6SAKHALIN",
  1609. X"-180+72", "GRRRRULLL", "6WRANGEL I.",
  1610. X"-137+76", "DRRRRRRRELLLLLLLL", "6SIBERIAN I.",
  1611. X"-091+80", "FERDRRRRRRULLLLLRRULLLLGL", "6SEVERNAYA",
  1612. X"-101+79", "GRRRRELLLL", "6ZEMLYA",
  1613. X"-068+77", "LLGLLLLLLGLLGGLGLRFRRRRLHERERERRRERRRREL", "6NOVAYA",
  1614. X"+123+49",
  1615. X"FGULLFDDDGFDDDFFDFRFRFDFFFDLFFRDFFEHHHHUHHUFRDFFFRDFFFDFGFRFRFRRFRRRRFFRRFRFF\
  1616. XDRFFRFEUUGLHHUUEUHLLLLLEUUEULLLGDLLGLHHUHUUUEHEERERRFRRHRREFRRFDFDFEUUHUUUEERE\
  1617. XRUUUHFDEUHFEURRRELUERRE",
  1618. X"4NORTH AMERICA S",
  1619. X"+113+42", "FH", "0SALT LAKE",
  1620. X"+156+20", "DRULHLHL", "4HAWAII",
  1621. X"+085+22", "RERFRRFRGRRRRHLHLHLLLLLG", "4CUBA",
  1622. X"+070+18", "RRHHLLLFLLLFRRRRRR", "4HAITI",
  1623. X"+078+18", "RRHLLF", "4JAMAICA",
  1624. X"+066+18", "ELLDR", "4PUERTO RICO",
  1625. X"+078+24", "UD", "4NASSAU",
  1626. X"+067+45",
  1627. X"REFLGDERERREHDLLLHUELLLGLGLREEERRRRRRREERRGGDGRRRFEFUUHLLLEUUHHGLRELLHHUHHHDG\
  1628. XLGHHULLHLLLLLDFGFDDGLLFDDGHHUULLLLHLLHLLLUHUUEREEREERRRREUUHLLLDDGHULLLHLUHLGD\
  1629. XRFGGULLLLLLLLLHLLGFLHLLLLLRHLLLLLHLLLLLLHGLLLLGUGLLLHLL",
  1630. X"4CANADA",
  1631. X"+088+49",
  1632. X"LGLGRRRRRRRFLLLGRGDDREUURUFRGRFGFERERREEREERLGGLGLLLGRLLGLEUERHLLLHULHL",
  1633. X"0GREAT LAKES",
  1634. X"+117+61", "REHRFRRERGLGLLLL", "0SLAVE LAKE",
  1635. X"+125+66", "RRERRRGREDLFHGLLLERLLLL", "0BEAR LAKE",
  1636. X"+097+50", "UULHURFDFG", "0LAKE WINNIPEG",
  1637. X"+090+72",
  1638. X"FRRLLFRRRRRRRRRRFRRGLLGRREEFRFLGLFLLLLFRERFRFRRFRRHLHFRRRUHLHRRFRURELLHLLLHRR\
  1639. XHLHLHGHLHLLGLLEHFRRRHLLLLLLGLDFHLUELLGG",
  1640. X"4BAFFIN I.",
  1641. X"+125+72",
  1642. X"RFRREERRRLLGFFRRRRRLLLLLFRRRRRRRREFRRRRHRRLHLHHLRRULGLFLHLDLLULLLLHLLLLLLLDG",
  1643. X"4VICTORIA I.",
  1644. X"+141+70",
  1645. X"LLLLLLLLHGLHLLLHGLLGLLGLLDRRFRRDLLLULGLLFRRRRRRDLGLLGFDRRRDRRRRRGGGLLGLLGGLLR\
  1646. XRERERRRERREERRELEERRRLLGDRERRURRFRRRRRFRRFUDRUDDHFDURDURLURDDLFRULURDHFFRGFEGR\
  1647. XFFRFRFLHLHLFFRFE",
  1648. X"4ALASKA",
  1649. X"+045+60",
  1650. X"REUEREUERRRRERERRRERRRRERLLLLLLHRRRGERHFRRRRHLUDLLHLRERFRERLEUHRRHLEERLLURRRR\
  1651. XRRRRELLLLLLLLLLGLLLRERHGLRELLLLLLLELLLLLLLLLLGLLLLLLGLLLLLLGLULLLLLLLFRLLLLLGL\
  1652. XRRRGLLLLLLLGRRRRRRRGLLLLRRFRRRRRRRRRRFDFDLFREFRDLLLDERRFGLLGFFDRFFFRRRF",
  1653. X"4GREENLAND",
  1654. X"+080+10",
  1655. X"DRFDFDDGGGDDGRDGDDFFDFDFFDFFRFFFDDDDDDGDDDDGDDDDGDGFGDDDEUDDDGUDDLDRGDDDFDFRF\
  1656. XRRFERRLHLUHUURUEELHEREURULURREURREREUHUUDFRREEEEEUEUUEERERRREUEUEUUUUUEEEEUUUH\
  1657. XLHLHLLLLHLHLGEHLGEUHUUHLHLLLHHLHULEDLLELLGHLLHLGDDHUELLGLGDGHHL",
  1658. X"3SOUTH AMERICA",
  1659. X"+060-51", "LDRRELL", "3FALKLAND ISLANDS",
  1660. X"+092+00", "FUL", "3GALAPAGOS I.",
  1661. X"-032+32",
  1662. X"LLGLHLLLLHLGDGHLLHHLLHLEUULLLLLLLLLGLGLLLLHDGLGDGDGGLDGGGDGDFDDDDGDDFFFFDFRFF\
  1663. XRRRRRRRRERERRFFRRFFDDDGDFFFDFDDDFDGDGDDDFDFDFDDDFDFDFDDFFERRRRREEEEEEEUUEREUUH\
  1664. XUEEEREEUUUUHUUUHUEUEEEEEREEUEUEEUUULLLLGLLHUHHLHUHHUUHHUUHUHHUU",
  1665. X"1AFRICA",
  1666. X"-049-12", "DGGGLGDDDDGDDFFREUEUEUUUEUUUUH", "1MADAGASCAR",
  1667. X"-032+00", "DDDREUELLL", "0LAKE VICTORIA",
  1668. X"-014+14", "LRFLU", "0LAKE CHAD",
  1669. X"-124-16",
  1670. X"LGDGGLGLLGLDDDGFDDFDFDGFRRRERRRRURERRRRRRRFFFEEDDRFDFRFREFRERRUUEUEEUUUUUUUHH\
  1671. XHHHHHUUHHHUULDDDDGDGHLHLHEUELLLHLFLLULDRGDDLLHLGG",
  1672. X"2AUSTRALIA",
  1673. X"-173-35", "FFDGFDREURULHHHL", "2NEW ZEALAND N",
  1674. X"-174-41", "LLDGLGLGGRFREEUREEU", "2NEW ZEALAND S",
  1675. X"-145-41", "DFRRUUUDLLL", "2TASMANIA",
  1676. X"-178-17", "GRRURUGDH", "2FIJI",
  1677. X"-130+00", "FRFRLGFEFRFRFDGRRFRRUERFFFRRRLHHHHRHLHHLHLLHGGLHUHLGH",
  1678. X"2NEW GUINEA",
  1679. X"-115-04", "RUUEEURHUUEHHGGGGLLDDHLDDFDDRRDERF", "2BORNEO",
  1680. X"-095+06", "DFFFFFFDFFFFRUUUHFRHLHLUHHHHHLLH", "2SUMATRA",
  1681. X"-106-06", "GRFRRRRRRFRRHLHLLLLLHL", "2JAVA",
  1682. X"-120+00", "DGDDRDFHUEDFRHUHREFHLGHURRRRELLLLG", "2CELEBES",
  1683. X"+000-70",
  1684. X"ULDLLLLLLLLGLLGLLLGLLGLLLLGLGLLGLLLLGLLLLLHLGLLLLLHLLLLLHLLLLHLLUERLEUUUUUUEE\
  1685. XRRRULLGLLLLGLGGLLLDRUDRDLGHLLGLLFGRRFLLLLLLLDHLLLLHLLLLLGLLLLHLLLLLLLGRFDLLLUL\
  1686. XLLGHLLLLLLLLLLHGHLLGLLLLLLLGLLLLLLLLLLLGLLLGLLLLLLLLGLLLLLLLLLLLLLLLLLLLLL",
  1687. X"7ANTARCTICA W",
  1688. X"+180-78",
  1689. X"LLLLLLLHLLGHLLGHLUEERRERREHLLLLHLLLLLLHLLLLLLLLLLLHLHLLLLLHLLULDLLLLLDLLHLLLL\
  1690. XGHFLLLLLHLLLLLLGLHLLHLGLLLLHLGLLGLLLULLLGLLHDFLLLGLGLLLELLLLHLLLLLLLLLLHLLLHLL\
  1691. XLLGGHGHGLLLGLDLLLLHLLGHGLLLLLLLLLLLLLLHLGLLLLLLLLLLLLLL",
  1692. X"7ANTARCTICA E",
  1693. X"", "", ""};
  1694. X#endif
  1695. X
  1696. X/* xdata.c */
  1697. END_OF_FILE
  1698. if test 15016 -ne `wc -c <'xdata.c'`; then
  1699.     echo shar: \"'xdata.c'\" unpacked with wrong size!
  1700. fi
  1701. # end of 'xdata.c'
  1702. fi
  1703. echo shar: End of archive 3 \(of 12\).
  1704. cp /dev/null ark3isdone
  1705. MISSING=""
  1706. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  1707.     if test ! -f ark${I}isdone ; then
  1708.     MISSING="${MISSING} ${I}"
  1709.     fi
  1710. done
  1711. if test "${MISSING}" = "" ; then
  1712.     echo You have unpacked all 12 archives.
  1713.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1714. else
  1715.     echo You still need to unpack the following archives:
  1716.     echo "        " ${MISSING}
  1717. fi
  1718. ##  End of shell archive.
  1719. exit 0
  1720.  
  1721. exit 0 # Just in case...
  1722.