home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / source / star.lzh / star.7 < prev    next >
Encoding:
Text File  |  1990-03-27  |  47.7 KB  |  1,690 lines

  1. #! /bin/sh
  2. # This is a shell archive.  Remove anything before this line, then unpack
  3. # it by saving it into a file and typing "sh file".  To overwrite existing
  4. # files, type "sh file -c".  You can also feed this as standard input via
  5. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  6. # will see the following message at the end:
  7. #        "End of archive 7 (of 32)."
  8. # Contents:  observe/orbcalc.c observe/outsif.c observe/tablecalc.c
  9. #   starchart/descrip.mms
  10. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  11. if test -f 'observe/orbcalc.c' -a "${1}" != "-c" ; then 
  12.   echo shar: Will not clobber existing file \"'observe/orbcalc.c'\"
  13. else
  14. echo shar: Extracting \"'observe/orbcalc.c'\" \(11271 characters\)
  15. sed "s/^X//" >'observe/orbcalc.c' <<'END_OF_FILE'
  16. X/*
  17. X * orbcalc.c
  18. X * calculate positions of body in elliptical or parabolic orbit
  19. X *
  20. X * Copyright (c) 1990 by Craig Counterman. All rights reserved.
  21. X *
  22. X * This software may be redistributed freely, not sold.
  23. X * This copyright notice and disclaimer of warranty must remain
  24. X *    unchanged. 
  25. X *
  26. X * No representation is made about the suitability of this
  27. X * software for any purpose.  It is provided "as is" without express or
  28. X * implied warranty, to the extent permitted by applicable law.
  29. X *
  30. X */
  31. X
  32. X#ifndef  lint
  33. Xstatic char rcsid[] =
  34. X  "$Header: orbcalc.c,v 1.8 90/02/19 17:20:47 ccount Exp $";
  35. X#endif
  36. X
  37. X
  38. X#include <stdio.h>
  39. X#include <math.h>
  40. X#ifndef SYSV
  41. X#include <strings.h>
  42. X#else
  43. X#include <string.h>
  44. X#endif
  45. X#include "observe.h"
  46. X#include "degree.h"
  47. X#include "date.h"
  48. X
  49. Xextern char *malloc();
  50. X
  51. X
  52. X/* example 
  53. XFormat 
  54. Xskip  three lines, then for each asteroid
  55. XName i Omega omega a n e M Epoch_date Equinox_year type G H
  56. XEpoch_date must be Month day year
  57. XEquinox_year, e.g. 2000.0
  58. X
  59. Xif type is comet, H and G are g and kappa
  60. X
  61. XVesta 7.139 104.015 150.175 2.3613 0.27163 0.0906 43.314 Oct 1 1989 2000.0 Asteroid 3.16 0.34
  62. X
  63. X*/
  64. X
  65. Xvoid read_elliptical(infile, bodies, nbodies_p, maxbodies)
  66. X     FILE *infile;
  67. X     wanderer_data_t bodies[];
  68. X     int *nbodies_p;
  69. X     int maxbodies;
  70. X{
  71. X  char in_line[1000], *linep;
  72. X  char name[100], H[100], G[100], i[100], Omega[100], omega[100],
  73. X      a[100], n[100], body_type[100],
  74. X      e[100], M[100], Month[100], day[100], year[100], equinox_year[100];
  75. X  char epoch_date_str[300];
  76. X  double epoch_date;
  77. X  int j, nscanned;
  78. X  char *cp;
  79. X
  80. X  fgets(in_line, 1000, infile);
  81. X  fgets(in_line, 1000, infile);
  82. X  fgets(in_line, 1000, infile);
  83. X
  84. X  
  85. X  j = 0;
  86. X  while ((j < maxbodies) && (!feof(infile))) {
  87. X    linep = fgets(in_line, 1000, infile);
  88. X    if (linep != NULL)
  89. X      nscanned = sscanf(linep, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
  90. X         name, i, Omega, omega, a, n,
  91. X         e, M, Month, day, year, equinox_year, body_type, H, G);
  92. X    else nscanned = 0;
  93. X    if (nscanned < 15) continue;
  94. X
  95. X    sprintf(epoch_date_str, "%s %s %s", Month, day, year);
  96. X    str_to_jd(epoch_date_str, 0, &epoch_date);
  97. X
  98. X
  99. X    cp = name;
  100. X    while (*cp) {
  101. X      if (*cp == '_') *cp = ' ';
  102. X      cp++;
  103. X    };
  104. X
  105. X    bodies[j].name = (char *) malloc((unsigned) (strlen(name)+1));
  106. X    if (bodies[j].name != NULL) strcpy(bodies[j].name, name);
  107. X    else bodies[j].name = "";
  108. X
  109. X    bodies[j].orbit_type = elliptical_orbit;
  110. X    bodies[j].elliptical_elements.epoch_jd = epoch_date;
  111. X    bodies[j].elliptical_elements.equinox_year = atof(equinox_year);
  112. X    bodies[j].elliptical_elements.a = atof(a);
  113. X    bodies[j].elliptical_elements.e = atof(e);
  114. X    bodies[j].elliptical_elements.i = atof(i);
  115. X    bodies[j].elliptical_elements.Omega = atof(Omega);
  116. X    bodies[j].elliptical_elements.omega = atof(omega);
  117. X    bodies[j].elliptical_elements.n = atof(n);
  118. X    bodies[j].elliptical_elements.M = atof(M);
  119. X    if ((body_type[0] == 'c') || (body_type[0] == 'C')) {
  120. X      bodies[j].body_type = comet;
  121. X      bodies[j].g = atof(G);
  122. X      bodies[j].kappa = atof(H);
  123. X    } else {
  124. X      bodies[j].body_type = asteroid;
  125. X      bodies[j].H = atof(H);
  126. X      bodies[j].G = atof(G);
  127. X    };
  128. X
  129. X    j++;
  130. X  };
  131. X  *nbodies_p = j;
  132. X}
  133. X
  134. X
  135. Xvoid elliptical_pos(T, sun_data, data)
  136. X     double T;            /* time, jd */
  137. X     sun_data_t sun_data;
  138. X     wanderer_data_t *data;
  139. X{
  140. X  double epsilon;
  141. X  double a_;            /* semimajor axis, A.U. */
  142. X  double e_;            /* eccentricity */
  143. X  double i_;            /* inclination (degrees) */
  144. X  double omega_;        /* argument of perihelion */
  145. X  double Omega_;        /* longitude of ascending node */
  146. X  double n_;            /* mean motion (degrees/day) */
  147. X  double M_;            /* mean anomaly at epoch */
  148. X
  149. X  double a, b, c, A, B, C;
  150. X  double F, G, H, P, Q, R;
  151. X  double M, E, nu, r;
  152. X  double x, y, z, X, Y, Z;
  153. X  double Delta;
  154. X  double Psi_1, Psi_2, psi_t; /* For asteroid mag. calculation */
  155. X  double alpha, delta, alpha2000, delta2000;
  156. X
  157. X  a_ = data->elliptical_elements.a;
  158. X  e_ = data->elliptical_elements.e;
  159. X  i_ = data->elliptical_elements.i;
  160. X  omega_ = data->elliptical_elements.omega;
  161. X  Omega_ = data->elliptical_elements.Omega;
  162. X  n_ = data->elliptical_elements.n;
  163. X  M_ = data->elliptical_elements.M;
  164. X
  165. X
  166. X  epsilon = obl_year(data->elliptical_elements.equinox_year);
  167. X  F = DCOS(Omega_);
  168. X  G = DSIN(Omega_)*DCOS(epsilon);
  169. X  H = DSIN(Omega_)*DSIN(epsilon);
  170. X  P = -DSIN(Omega_)*DCOS(i_);
  171. X  Q = DCOS(Omega_)*DCOS(i_)*DCOS(epsilon) - DSIN(i_)*DSIN(epsilon);
  172. X  R = DCOS(Omega_)*DCOS(i_)*DSIN(epsilon) + DSIN(i_)*DCOS(epsilon);
  173. X
  174. X  A = atan2(F,P)*RAD_TO_DEG;
  175. X  B = atan2(G,Q)*RAD_TO_DEG;
  176. X  C = atan2(H,R)*RAD_TO_DEG;
  177. X
  178. X    
  179. X  a = sqrt(F*F + P*P);
  180. X  b = sqrt(G*G + Q*Q);
  181. X  c = sqrt(H*H + R*R);
  182. X
  183. X  /* Calculate M, E, nu, r */
  184. X  M = into_range(M_ + n_ * (T - data->elliptical_elements.epoch_jd));
  185. X  anom_calc(M, e_, &E, &nu);
  186. X  r = a_ * (1 - e_ * DCOS(E));
  187. X
  188. X  x = r * a * DSIN(A + omega_ + nu);
  189. X  y = r * b * DSIN(B + omega_ + nu);
  190. X  z = r * c * DSIN(C + omega_ + nu);
  191. X
  192. X  sun_rect(T, data->elliptical_elements.equinox_year,
  193. X       sun_data.R, sun_data.Theta, &X, &Y, &Z);
  194. X
  195. X
  196. X  Delta = sqrt((X+x)*(X+x) + (Y+y)*(Y+y) + (Z+z)*(Z+z));
  197. X  R = sqrt(X*X + Y*Y + Z*Z);
  198. X
  199. X
  200. X  data->alpha = atan2(Y+y, X+x)*RAD_TO_DEG;
  201. X  if (data->alpha < 0) data->alpha += 360.0;
  202. X  data->delta = asin((Z+z)/Delta)*RAD_TO_DEG;
  203. X  data->r = r;
  204. X  data->Delta = Delta;
  205. X
  206. X  if (data->elliptical_elements.equinox_year != 2000.0) {
  207. X    alpha = data->alpha;
  208. X    delta = data->delta;
  209. X    precess(data->elliptical_elements.equinox_year, 2000.0,
  210. X        alpha, delta, &alpha2000, &delta2000);
  211. X    data->alpha2000 = alpha2000;
  212. X    data->delta2000 = delta2000;
  213. X  } else {
  214. X    data->alpha2000 = data->alpha;
  215. X    data->delta2000 = data->delta;
  216. X  };
  217. X/* Can't set l, b, lambda */
  218. X
  219. X  data->psi = acos((R*R + Delta*Delta - r*r)/ (2*R*Delta))*RAD_TO_DEG;
  220. X  data->beta = acos((r*r + Delta*Delta - R*R)/ (2*r*Delta))*RAD_TO_DEG;
  221. X
  222. X  if (data->body_type == asteroid) {
  223. X    G = data->G;
  224. X    H = data->H;
  225. X    psi_t = exp(log(DTAN(data->beta/2.0))*0.63);
  226. X    Psi_1 = exp(-3.33*psi_t);
  227. X    psi_t = exp(log(DTAN(data->beta/2.0))*1.22);
  228. X    Psi_2 = exp(-1.87*psi_t);
  229. X    data->mag = 5.0 * log10(r*Delta) + H
  230. X      - 2.5* log10((1-G)*Psi_1 + G*Psi_2);
  231. X  } else if (data->body_type == comet) {
  232. X    data->mag = data->g + 5.0 * log10(Delta)
  233. X      + 2.5 * data->kappa * log10(r);
  234. X  } else {
  235. X    data->mag = 1.0;
  236. X  }
  237. X}
  238. X
  239. X
  240. X
  241. X
  242. X/* example 
  243. XFormat 
  244. Xskip  three lines, then for each asteroid
  245. XName i Omega omega q Epoch_date Equinox_year g kappa
  246. XEpoch_date must be Month day year
  247. XEquinox_year, e.g. 2000.0
  248. X
  249. XBorsen-metcalf 7.139 104.015 150.175 0.4 Oct 1 1989 2000.0 3.16 0.34
  250. X
  251. X*/
  252. X
  253. X
  254. Xvoid read_parabolic(infile, bodies, nbodies_p, maxbodies)
  255. X     FILE *infile;
  256. X     wanderer_data_t bodies[];
  257. X     int *nbodies_p;
  258. X     int maxbodies;
  259. X{
  260. X  char in_line[1000], *linep;
  261. X  char name[100], g[100], kappa[100], i[100], Omega[100], omega[100],
  262. X      q[100], Month[100], day[100], year[100], equinox_year[100];
  263. X  char perihelion_date_str[300];
  264. X  double perihelion_date;
  265. X  int j, nscanned;
  266. X
  267. X  fgets(in_line, 1000, infile);
  268. X  fgets(in_line, 1000, infile);
  269. X  fgets(in_line, 1000, infile);
  270. X
  271. X  
  272. X  j = 0;
  273. X  while ((j < maxbodies) && (!feof(infile))) {
  274. X    linep = fgets(in_line, 1000, infile);
  275. X    if (linep != NULL)
  276. X      nscanned = sscanf(linep, "%s %s %s %s %s %s %s %s %s %s %s",
  277. X         name, i, Omega, omega, q, Month, day, year, equinox_year,
  278. X            g, kappa);
  279. X    else nscanned = 0;
  280. X    if (nscanned < 11) continue;
  281. X
  282. X    sprintf(perihelion_date_str, "%s %s %s", Month, day, year);
  283. X    str_to_jd(perihelion_date_str, 0, &perihelion_date);
  284. X
  285. X    bodies[j].name = (char *) malloc((unsigned) (strlen(name)+1));
  286. X    if (bodies[j].name != NULL) strcpy(bodies[j].name, name);
  287. X    else bodies[j].name = "";
  288. X
  289. X    bodies[j].orbit_type = parabolic_orbit;
  290. X    bodies[j].body_type = comet;
  291. X    bodies[j].parabolic_elements.perihelion_date = perihelion_date;
  292. X    bodies[j].parabolic_elements.equinox_year = atof(equinox_year);
  293. X    bodies[j].parabolic_elements.q = atof(q);
  294. X    bodies[j].parabolic_elements.i = atof(i);
  295. X    bodies[j].parabolic_elements.Omega = atof(Omega);
  296. X    bodies[j].parabolic_elements.omega = atof(omega);
  297. X    bodies[j].g = atof(g);
  298. X    bodies[j].kappa = atof(kappa);
  299. X
  300. X    j++;
  301. X  };
  302. X  *nbodies_p = j;
  303. X}
  304. X
  305. X
  306. Xvoid parabolic_pos(T, sun_data, data)
  307. X     double T;            /* time, jd */
  308. X     sun_data_t sun_data;
  309. X     wanderer_data_t *data;
  310. X{
  311. X  double epsilon;
  312. X  double q_;            /* perihelion distance, A.U. */
  313. X  double i_;            /* inclination (degrees) */
  314. X  double omega_;        /* argument of perihelion */
  315. X  double Omega_;        /* longitude of ascending node */
  316. X  double T_0;            /* Time of passage in perihelion */
  317. X
  318. X  double W, s, gamma, gamma_1, beta;
  319. X  double nu, r;
  320. X  double A, B, C, a, b, c;
  321. X  double F, G, H, P, Q, R;
  322. X  double x, y, z, X, Y, Z;
  323. X  double Delta;
  324. X  double Psi_1, Psi_2, psi_t; /* For asteroid mag. calculation */
  325. X  double alpha, delta, alpha2000, delta2000;
  326. X
  327. X  q_ = data->parabolic_elements.q;
  328. X  i_ = data->parabolic_elements.i;
  329. X  omega_ = data->parabolic_elements.omega;
  330. X  Omega_ = data->parabolic_elements.Omega;
  331. X  T_0 = data->parabolic_elements.perihelion_date;
  332. X
  333. X  W = 0.0364911624 * (T - T_0)/(q_ * sqrt(q_));
  334. X  beta = atan2(2.0,W); /* note, beta in radians */
  335. X  gamma_1 = tan(beta/2.0);
  336. X  if (gamma_1 < 0) {
  337. X    gamma = atan(-exp(log(-gamma_1)/3.0));
  338. X  } else {
  339. X    gamma = atan(exp(log(gamma_1)/3.0));
  340. X  };
  341. X  s = 2.0/tan(2*gamma);
  342. X
  343. X  nu = 2.0 * DATAN(s);
  344. X
  345. X  r = q_ * (1 + s*s);
  346. X
  347. X  epsilon = obl_year(data->parabolic_elements.equinox_year);
  348. X  F = DCOS(Omega_);
  349. X  G = DSIN(Omega_)*DCOS(epsilon);
  350. X  H = DSIN(Omega_)*DSIN(epsilon);
  351. X
  352. X  P = -DSIN(Omega_)*DCOS(i_);
  353. X  Q = DCOS(Omega_)*DCOS(i_)*DCOS(epsilon) - DSIN(i_)*DSIN(epsilon);
  354. X  R = DCOS(Omega_)*DCOS(i_)*DSIN(epsilon) + DSIN(i_)*DCOS(epsilon);
  355. X
  356. X  A = atan2(F,P)*RAD_TO_DEG;
  357. X  B = atan2(G,Q)*RAD_TO_DEG;
  358. X  C = atan2(H,R)*RAD_TO_DEG;
  359. X
  360. X    
  361. X  a = sqrt(F*F + P*P);
  362. X  b = sqrt(G*G + Q*Q);
  363. X  c = sqrt(H*H + R*R);
  364. X
  365. X
  366. X  x = r * a * DSIN(A + omega_ + nu);
  367. X  y = r * b * DSIN(B + omega_ + nu);
  368. X  z = r * c * DSIN(C + omega_ + nu);
  369. X
  370. X  sun_rect(T, data->parabolic_elements.equinox_year,
  371. X       sun_data.R, sun_data.Theta, &X, &Y, &Z);
  372. X
  373. X  Delta = sqrt((X+x)*(X+x) + (Y+y)*(Y+y) + (Z+z)*(Z+z));
  374. X  R = sqrt(X*X + Y*Y + Z*Z);
  375. X
  376. X
  377. X  data->alpha = atan2(Y+y, X+x)*RAD_TO_DEG;
  378. X  if (data->alpha < 0) data->alpha += 360.0;
  379. X  data->delta = asin((Z+z)/Delta)*RAD_TO_DEG;
  380. X  data->r = r;
  381. X  data->Delta = Delta;
  382. X
  383. X  if (data->parabolic_elements.equinox_year != 2000.0) {
  384. X    alpha = data->alpha;
  385. X    delta = data->delta;
  386. X    precess(data->parabolic_elements.equinox_year, 2000.0,
  387. X        alpha, delta, &alpha2000, &delta2000);
  388. X    data->alpha2000 = alpha2000;
  389. X    data->delta2000 = delta2000;
  390. X  } else {
  391. X    data->alpha2000 = data->alpha;
  392. X    data->delta2000 = data->delta;
  393. X  };
  394. X/* Can't set l, b, lambda */
  395. X
  396. X  data->psi = acos((R*R + Delta*Delta - r*r)/ (2*R*Delta))*RAD_TO_DEG;
  397. X  data->beta = acos((r*r + Delta*Delta - R*R)/ (2*r*Delta))*RAD_TO_DEG;
  398. X
  399. X  if (data->body_type == asteroid) {
  400. X    G = data->G;
  401. X    H = data->H;
  402. X    psi_t = exp(log(DTAN(data->beta/2.0))*0.63);
  403. X    Psi_1 = exp(-3.33*psi_t);
  404. X    psi_t = exp(log(DTAN(data->beta/2.0))*1.22);
  405. X    Psi_2 = exp(-1.87*psi_t);
  406. X    data->mag = 5.0 * log10(r*Delta) + H
  407. X      - 2.5* log10((1-G)*Psi_1 + G*Psi_2);
  408. X  } else if (data->body_type == comet) {
  409. X    data->mag = data->g + 5.0 * log10(Delta)
  410. X      + 2.5 * data->kappa * log10(r);
  411. X  } else {
  412. X    data->mag = 1.0;
  413. X  }
  414. X
  415. X}
  416. X
  417. END_OF_FILE
  418. if test 11271 -ne `wc -c <'observe/orbcalc.c'`; then
  419.     echo shar: \"'observe/orbcalc.c'\" unpacked with wrong size!
  420. fi
  421. # end of 'observe/orbcalc.c'
  422. fi
  423. if test -f 'observe/outsif.c' -a "${1}" != "-c" ; then 
  424.   echo shar: Will not clobber existing file \"'observe/outsif.c'\"
  425. else
  426. echo shar: Extracting \"'observe/outsif.c'\" \(9823 characters\)
  427. sed "s/^X//" >'observe/outsif.c' <<'END_OF_FILE'
  428. X/*
  429. X * outsif.c
  430. X * Output .sif and .star files for object(s)
  431. X *
  432. X * Copyright (c) 1990 by Craig Counterman. All rights reserved.
  433. X *
  434. X * This software may be redistributed freely, not sold.
  435. X * This copyright notice and disclaimer of warranty must remain
  436. X *    unchanged. 
  437. X *
  438. X * No representation is made about the suitability of this
  439. X * software for any purpose.  It is provided "as is" without express or
  440. X * implied warranty, to the extent permitted by applicable law.
  441. X *
  442. X */
  443. X
  444. X#ifndef  lint
  445. Xstatic char rcsid[] =
  446. X  "$Header: outsif.c,v 1.13 90/03/06 00:10:00 ccount Exp $";
  447. X#endif
  448. X
  449. X
  450. X#include <stdio.h>
  451. X#ifndef SYSV
  452. X#include <strings.h>
  453. X#else
  454. X#include <string.h>
  455. X#endif
  456. X#include "observe.h"
  457. X#include "date.h"
  458. X
  459. X
  460. Xvoid write_files(), tosizestr();
  461. X
  462. X
  463. X/* Output .sif and .star files for object(s) */
  464. Xvoid out_sif(o_sif, o_star, do_sif, do_star, one_day,
  465. X        sun_data, moon_data, planets, bodies, nbodies, objects, nobjects)
  466. X     FILE *o_sif, *o_star;
  467. X     int do_sif, do_star;    /* output sif file , .star file */
  468. X     int one_day;        /* only doing one day */
  469. X     sun_data_t sun_data;
  470. X     moon_data_t moon_data;
  471. X     planet_data_t planets[];
  472. X     wanderer_data_t bodies[];
  473. X     int nbodies;
  474. X     obj_data_t objects[];
  475. X     int nobjects;
  476. X{
  477. X  int i;
  478. X  char moon_phase[20];
  479. X  char *typefield;
  480. X
  481. X  if (one_day) {
  482. X                /* print all */
  483. X    write_files(o_sif, o_star, do_sif, do_star,
  484. X        sun_data.alpha2000/15.0, sun_data.delta2000,
  485. X        -26.0,
  486. X        "PS", "G2", sun_data.size,
  487. X        "   ", "Sol", "");
  488. X
  489. X    sprintf(moon_phase, "%6.1f %6.1f", moon_data.phase, moon_data.chi);
  490. X    write_files(o_sif, o_star, do_sif, do_star,
  491. X        moon_data.alpha2000/15.0, moon_data.delta2000,
  492. X        moon_data.mag,
  493. X        "PL", "G2", moon_data.size,
  494. X        "   ", "Moon", moon_phase);
  495. X
  496. X    for (i = 0; i < 7; i++)
  497. X      if (planets[i].name[0])
  498. X    write_files(o_sif, o_star, do_sif, do_star,
  499. X            planets[i].alpha2000/15.0, planets[i].delta2000,
  500. X            planets[i].mag,
  501. X            planets[i].type, planets[i].color, planets[i].size,
  502. X            "   ", planets[i].name, "");
  503. X
  504. X    for (i = 0; i < nbodies; i++) {
  505. X      if (bodies[i].body_type == asteroid)
  506. X    typefield = "PA";
  507. X      else if (bodies[i].body_type == comet)
  508. X    typefield = "PC";
  509. X      else
  510. X    typefield = "P?";
  511. X
  512. X      write_files(o_sif, o_star, do_sif, do_star,
  513. X          bodies[i].alpha2000/15.0, bodies[i].delta2000,
  514. X          bodies[i].mag,
  515. X          typefield, "  ", -1.0,
  516. X          "   ", bodies[i].name, "");
  517. X    };
  518. X   for (i = 0; i < nobjects; i++)
  519. X      write_files(o_sif, o_star, do_sif, do_star,
  520. X          objects[i].alpha2000/15.0, objects[i].delta2000,
  521. X          objects[i].mag,
  522. X          objects[i].type, "  ", objects[i].size,
  523. X          "   ", objects[i].name, "");
  524. X  } else {
  525. X                /* only print object list */
  526. X    for (i = 0; i < nobjects; i++)
  527. X      write_files(o_sif, o_star, do_sif, do_star,
  528. X          objects[i].alpha2000/15.0, objects[i].delta2000,
  529. X          objects[i].mag,
  530. X          objects[i].type, "  ", objects[i].size,
  531. X          "   ", objects[i].name, "");
  532. X  }
  533. X}
  534. X
  535. X
  536. X/* Output .sif and .star files for a planet */
  537. Xvoid out_sif_planet(o_sif, o_star, do_sif, do_star, one_day,
  538. X         planet, jd)
  539. X     FILE *o_sif, *o_star;
  540. X     int do_sif, do_star;    /* output sif file , .star file */
  541. X     int one_day;        /* only doing one day */
  542. X     planet_data_t planet;
  543. X     double jd;
  544. X{
  545. X  static char *namep = "";
  546. X  char *vectfield;
  547. X  char datestr[15];
  548. X  char name_date[96];
  549. X
  550. X  if (namep == planet.name) {    /* we've done this before */
  551. X    vectfield = "VS";
  552. X  } else {            /* this is a new one */
  553. X    namep = planet.name;
  554. X    vectfield = "VM";
  555. X  };
  556. X
  557. X  jd_to_str(jd, datestr);
  558. X  sprintf(name_date, "%s %s", planet.name, datestr);
  559. X
  560. X  write_files(o_sif, o_star, do_sif, do_star,
  561. X          planet.alpha2000/15.0, planet.delta2000,
  562. X          planet.mag,
  563. X          planet.type, "  ", planet.size,
  564. X          "   ", name_date, "");
  565. X  write_files(o_sif, o_star, do_sif, do_star,
  566. X          planet.alpha2000/15.0, planet.delta2000,
  567. X          planet.mag + 1.0,
  568. X          vectfield, "  ", planet.size,
  569. X          "   ", name_date, "");
  570. X}
  571. X
  572. X/* Output .sif and .star files for a body */
  573. Xvoid out_sif_body(o_sif, o_star, do_sif, do_star, one_day,
  574. X         body, jd)
  575. X     FILE *o_sif, *o_star;
  576. X     int do_sif, do_star;    /* output sif file , .star file */
  577. X     int one_day;        /* only doing one day */
  578. X     wanderer_data_t body;
  579. X     double jd;
  580. X{
  581. X  static char *namep = "";
  582. X  char *vectfield, *typefield;
  583. X  char datestr[15];
  584. X  char name_date[96];
  585. X
  586. X  if (namep == body.name) {    /* we've done this before */
  587. X    vectfield = "VS";
  588. X  } else {            /* this is a new one */
  589. X    namep = body.name;
  590. X    vectfield = "VM";
  591. X  };
  592. X
  593. X  if (body.body_type == asteroid)
  594. X    typefield = "PA";
  595. X  else if (body.body_type == comet)
  596. X    typefield = "PC";
  597. X  else
  598. X    typefield = "P?";
  599. X
  600. X  jd_to_str(jd, datestr);
  601. X  sprintf(name_date, "%s %s", body.name, datestr);
  602. X
  603. X  write_files(o_sif, o_star, do_sif, do_star,
  604. X          body.alpha2000/15.0, body.delta2000,
  605. X          body.mag,
  606. X          typefield, "  ", -1.0,
  607. X          "   ", name_date, "");
  608. X  write_files(o_sif, o_star, do_sif, do_star,
  609. X          body.alpha2000/15.0, body.delta2000,
  610. X          body.mag + 1.0,
  611. X          vectfield, "  ", -1.0,
  612. X          "   ", name_date, "");
  613. X}
  614. X
  615. X/* output sun */
  616. Xvoid out_sif_sun(o_sif, o_star, do_sif, do_star, one_day,
  617. X         sun_data, jd)
  618. X     FILE *o_sif, *o_star;
  619. X     int do_sif, do_star;    /* output sif file , .star file */
  620. X     int one_day;        /* only doing one day */
  621. X     sun_data_t sun_data;
  622. X     double jd;
  623. X{
  624. X  static char *namep = "";
  625. X  char *vectfield;
  626. X  char datestr[15];
  627. X  char name_date[96];
  628. X
  629. X  if (!strcmp(namep,"Sol")) {    /* we've done this before */
  630. X    vectfield = "VS";
  631. X  } else {            /* this is a new one */
  632. X    namep = "Sol";
  633. X    vectfield = "VM";
  634. X  };
  635. X
  636. X  jd_to_str(jd, datestr);
  637. X  sprintf(name_date, "%s %s", "Sol", datestr);
  638. X
  639. X  write_files(o_sif, o_star, do_sif, do_star,
  640. X          sun_data.alpha2000/15.0, sun_data.delta2000,
  641. X          -26.0,
  642. X          "PS", "G2", sun_data.size,
  643. X          "   ", name_date, "");
  644. X  write_files(o_sif, o_star, do_sif, do_star,
  645. X          sun_data.alpha2000/15.0, sun_data.delta2000,
  646. X          -25.0,
  647. X          vectfield, "  ", sun_data.size,
  648. X          "   ", name_date, "");
  649. X}
  650. X/* output moon */
  651. Xvoid out_sif_moon(o_sif, o_star, do_sif, do_star, one_day,
  652. X         moon_data, jd)
  653. X     FILE *o_sif, *o_star;
  654. X     int do_sif, do_star;    /* output sif file , .star file */
  655. X     int one_day;        /* only doing one day */
  656. X     moon_data_t moon_data;
  657. X     double jd;
  658. X{
  659. X  static char *namep = "";
  660. X  char *vectfield;
  661. X  char datestr[15];
  662. X  char name_date[96];
  663. X  char moon_phase[20];
  664. X
  665. X  if (!strcmp(namep,"moon")) {    /* we've done this before */
  666. X    vectfield = "VS";
  667. X  } else {            /* this is a new one */
  668. X    namep = "moon";
  669. X    vectfield = "VM";
  670. X  };
  671. X
  672. X  jd_to_str(jd, datestr);
  673. X  sprintf(name_date, "%s %s", "Moon", datestr);
  674. X  sprintf(moon_phase, "%6.1f %6.1f", moon_data.phase, moon_data.chi);
  675. X
  676. X  write_files(o_sif, o_star, do_sif, do_star,
  677. X          moon_data.alpha2000/15.0, moon_data.delta2000,
  678. X          moon_data.mag,
  679. X          "PL", "G2", moon_data.size,
  680. X          "   ", name_date, moon_phase);
  681. X  write_files(o_sif, o_star, do_sif, do_star,
  682. X          moon_data.alpha2000/15.0, moon_data.delta2000,
  683. X          moon_data.mag + 1.0,
  684. X          vectfield, "  ", moon_data.size,
  685. X          "   ", name_date, "");
  686. X}
  687. X
  688. X
  689. Xvoid write_files(o_sif, o_star, do_sif, do_star, ra, dec, mag, type, color,
  690. X         size, constell, name, comment)
  691. X     FILE *o_sif, *o_star;
  692. X     int do_sif, do_star;    /* output sif file , .star file */
  693. X     double ra, dec, mag;
  694. X     char type[3], color[3];
  695. X     double size;
  696. X     char constell[4];
  697. X     char *name;
  698. X     char *comment;
  699. X{
  700. X  int rah, ram, ras, dld, dlm, d_d, d_m, d_s, sign;
  701. X  double dec_t;
  702. X  int i;
  703. X  char magstr[4];
  704. X  char sizestr[3];
  705. X
  706. X  rah = ra;
  707. X  ra -= rah;
  708. X  ram = ra*60.0;
  709. X  ra -= ram/60.0;
  710. X  ras = ra*3600.0 + 0.5;
  711. X  if (ras == 60) {
  712. X    ras = 0;
  713. X    ram++;
  714. X  }
  715. X  if (ram == 60) {
  716. X    ram = 0;
  717. X    rah++;
  718. X  }
  719. X  if (rah == 24) rah = 0;
  720. X
  721. X  /* dec -> degrees and minutes */
  722. X  dec_t = dec;
  723. X  sign = (dec_t < 0.0);
  724. X  if (sign) dec_t = -dec_t;
  725. X  dld = dec_t;
  726. X  dec_t -= dld;
  727. X  dlm = dec_t * 60.0 + 0.5;
  728. X  if (dlm == 60) {
  729. X    dlm = 0;
  730. X    dld++;
  731. X  }
  732. X
  733. X  /* dec -> degrees, minutes and seconds */
  734. X  dec_t = dec;
  735. X  if (sign) dec_t = -dec_t;
  736. X  d_d = (int) dec_t;
  737. X  d_m = (int)((dec_t - d_d)*60);
  738. X  d_s = (int)((dec_t - d_d - d_m/60.0)*3600 + 0.5);
  739. X  if (d_s == 60) {
  740. X    d_s = 0;
  741. X    d_m++;
  742. X  }
  743. X  if (d_m == 60) {
  744. X    d_m = 0;
  745. X    d_d++;
  746. X  }
  747. X
  748. X  if (mag < 0.0) {
  749. X    if (mag < -10.0) strcpy(magstr,"-99");
  750. X    else {
  751. X      i = -mag*10 + .5;
  752. X      sprintf(magstr,"-%02d", i);
  753. X    };
  754. X  } else if (mag < 10.0) {
  755. X    i = mag*100 + .5;
  756. X    sprintf(magstr,"%03d", i);
  757. X  } else {
  758. X    i = mag*100 + .5;
  759. X    i %= 1000;
  760. X    sprintf(magstr,"%03d", i);
  761. X    magstr[0] = ((int) (mag - 10.0)) + 'A';
  762. X  };
  763. X
  764. X  if (size >= 0.0)
  765. X    tosizestr(size, sizestr);
  766. X  else
  767. X    strcpy(sizestr, "  ");
  768. X
  769. X  if (do_star)
  770. X    if (comment[0])
  771. X      fprintf(o_star, "%02d%02d%02d%c%02d%02d%s%s%s%s%s%s,%s\n",
  772. X          rah, ram, ras, sign ? '-':'+', dld, dlm,
  773. X          magstr,
  774. X          type, color,
  775. X          sizestr,
  776. X          constell, name, comment);
  777. X    else
  778. X      fprintf(o_star, "%02d%02d%02d%c%02d%02d%s%s%s%s%s%s\n",
  779. X          rah, ram, ras, sign ? '-':'+', dld, dlm,
  780. X          magstr,
  781. X          type, color,
  782. X          sizestr,
  783. X          constell, name);
  784. X
  785. X  if (do_sif)
  786. X    fprintf(o_sif, "%2d %2d %2d; %c%02d %2d %d; %.3f;%s;%s;%s;%s;%s;%s\n",
  787. X        rah, ram, ras, sign ? '-':'+', d_d, d_m, d_s,
  788. X        mag,
  789. X        type, color,
  790. X        sizestr,
  791. X        constell, name, comment);
  792. X}
  793. X
  794. Xvoid tosizestr(sze, str)
  795. X     double sze;
  796. X     char str[];
  797. X{
  798. X  if (sze < 99.5) sprintf(str, "%2d",(int) (sze + 0.5));
  799. X  else if (sze < 995.0) {
  800. X    sprintf(str, "%2d",(int) ((sze + 5.0)/10.0));
  801. X    str[0] = 'A' + str[0] - '0' - 1;
  802. X  }  else if (sze < 9950.0) {
  803. X    sprintf(str, "%2d",(int) ((sze + 50.0)/100.0));
  804. X    str[0] = 'J' + str[0] - '0' - 1;
  805. X  }  else if (sze < 89500.0) {
  806. X    sprintf(str, "%2d",(int) ((sze + 500.0)/1000.0));
  807. X    str[0] = 'S' + str[0] - '0' - 1;
  808. X  } else sprintf(str , "Z9");
  809. X}
  810. END_OF_FILE
  811. if test 9823 -ne `wc -c <'observe/outsif.c'`; then
  812.     echo shar: \"'observe/outsif.c'\" unpacked with wrong size!
  813. fi
  814. # end of 'observe/outsif.c'
  815. fi
  816. if test -f 'observe/tablecalc.c' -a "${1}" != "-c" ; then 
  817.   echo shar: Will not clobber existing file \"'observe/tablecalc.c'\"
  818. else
  819. echo shar: Extracting \"'observe/tablecalc.c'\" \(12025 characters\)
  820. sed "s/^X//" >'observe/tablecalc.c' <<'END_OF_FILE'
  821. X/*
  822. X * tablecalc.c
  823. X * calculate positions by interpolation of a table
  824. X *
  825. X * Copyright (c) 1990 by Craig Counterman. All rights reserved.
  826. X *
  827. X * This software may be redistributed freely, not sold.
  828. X * This copyright notice and disclaimer of warranty must remain
  829. X *    unchanged. 
  830. X *
  831. X * No representation is made about the suitability of this
  832. X * software for any purpose.  It is provided "as is" without express or
  833. X * implied warranty, to the extent permitted by applicable law.
  834. X *
  835. X */
  836. X
  837. X#ifndef  lint
  838. Xstatic char rcsid[] =
  839. X  "$Header: tablecalc.c,v 1.8 90/02/19 17:21:52 ccount Exp $";
  840. X#endif
  841. X
  842. X
  843. X#include <stdio.h>
  844. X#include <math.h>
  845. X#include <ctype.h>
  846. X
  847. X#ifndef SYSV
  848. X#include <strings.h>
  849. X#else
  850. X#include <string.h>
  851. X#endif /* SYSV */
  852. X#include "observe.h"
  853. X#include "date.h"
  854. X
  855. X
  856. X#ifndef FALSE
  857. X#define FALSE 0
  858. X#endif
  859. X#ifndef TRUE
  860. X#define TRUE 1
  861. X#endif
  862. X
  863. X#ifndef MAX
  864. X#define MAX(x,y) ((x)>(y)?(x):(y))
  865. X#endif
  866. X#ifndef MIN
  867. X#define MIN(x,y) ((x)<(y)?(x):(y))
  868. X#endif
  869. X
  870. Xstatic double polint();
  871. Xstatic void readfile();
  872. X
  873. X#define MAXPTS 300
  874. X
  875. Xstatic double dates[MAXPTS], ra[MAXPTS], dec[MAXPTS],
  876. X  mag[MAXPTS], r[MAXPTS], Delta[MAXPTS];
  877. Xstatic int Nread;
  878. Xstatic double from_equinox;
  879. X
  880. Xvoid tabulated_pos(jd, sun_data, body)
  881. X     double jd;
  882. X     sun_data_t sun_data;
  883. X     wanderer_data_t *body;
  884. X{
  885. X  double alpha, delta;
  886. X  double alpha2000, delta2000;
  887. X  double error;
  888. X
  889. X  alpha = 15.0 * polint(dates, ra, Nread, jd, &error);
  890. X  delta = polint(dates, dec, Nread, jd, &error);
  891. X  precess(from_equinox, 2000.0, alpha, delta, &alpha2000, &delta2000);
  892. X
  893. X  body->alpha = alpha;
  894. X  body->delta = delta;
  895. X  body->alpha2000 = alpha2000;
  896. X  body->delta2000 = delta2000;
  897. X  body->mag = polint(dates, mag, Nread, jd, &error);
  898. X  body->r = polint(dates, r, Nread, jd, &error);
  899. X  body->Delta = polint(dates, Delta, Nread, jd, &error);
  900. X  body->body_type = no_type;
  901. X
  902. X  /* Unknown */
  903. X  body->beta = -999.0;
  904. X  body->psi = -999.0;
  905. X}
  906. X
  907. Xvoid read_table(infile, in_type)
  908. X     FILE *infile;
  909. X     fformat_t in_type;
  910. X{
  911. X  double ra_1, ra_2;
  912. X  int i;
  913. X  int yr;
  914. X  int adjust_ra;
  915. X
  916. X
  917. X
  918. X  /* Prepare for epoch change */
  919. X  switch (in_type) {
  920. X  case emp:
  921. X    from_equinox = 1950.0;
  922. X    break;
  923. X  case empb:
  924. X    from_equinox = 1950.0;
  925. X    break;
  926. X  case aa:
  927. X    from_equinox = 2000.0;
  928. X    break;
  929. X  case st:
  930. X    from_equinox = 2000.0;
  931. X    break;
  932. X  case iau:
  933. X    from_equinox = 1950.0;
  934. X    break;
  935. X  default:
  936. X    break;
  937. X  }
  938. X
  939. X  yr = now_year();
  940. X  readfile(infile, in_type, yr);
  941. X
  942. X
  943. X  /* Adjust ra to be continuous */
  944. X  /* If the difference between adjacent numbers is greater than
  945. X     the difference if you subtract 24 from the larger,
  946. X     then shift all by 24 hrs */
  947. X  adjust_ra = FALSE;
  948. X  for (i = 0; i < Nread-1; i++) {
  949. X    ra_2 = MAX(ra[i],ra[i+1]);
  950. X    ra_1 = MIN(ra[i],ra[i+1]);
  951. X    if (fabs(ra_2-ra_1) > fabs(ra_2-24-ra_1))
  952. X      adjust_ra = TRUE;
  953. X  }
  954. X  if (adjust_ra)
  955. X    for (i = 0; i < Nread; i++)
  956. X      if (ra[i] < 12.0) ra[i] += 24.0;
  957. X}
  958. X
  959. X
  960. Xstatic void readfile(fptr, fform, year)
  961. X     FILE *fptr;
  962. X     fformat_t fform;
  963. X     int year;
  964. X{
  965. X  char lbuf[1000], *bufp;
  966. X  char s1[100], s2[100], s3[100], s4[100], s5[100], s6[100], s7[100], s8[100],
  967. X       s9[100], s10[100], s11[100];
  968. X  int i, n;
  969. X  int mo, last_mo, yr;
  970. X  double dy;
  971. X
  972. X  mo = -1;
  973. X  last_mo = -2;
  974. X  dy = -1;
  975. X  yr = year;
  976. X
  977. X  fgets(lbuf, 1000, fptr);
  978. X  n = sscanf(lbuf, "year %d", &i);
  979. X  if (n == 1) yr = i;
  980. X  fgets(lbuf, 1000, fptr);
  981. X  n = sscanf(lbuf, "year %d", &i);
  982. X  if (n == 1) yr = i;
  983. X  fgets(lbuf, 1000, fptr);
  984. X  n = sscanf(lbuf, "year %d", &i);
  985. X  if (n == 1) yr = i;
  986. X
  987. X
  988. X  switch (fform) {
  989. X  case emp:
  990. X/*
  991. Xmonth day ra ra     dec dec
  992. X1     2    3 4       5  6
  993. XVIII  17   0 23.7   -13 48
  994. X      27   0 19.1   -14 51
  995. X
  996. X*/
  997. X    i = 0;
  998. X    while (!feof(fptr)) {
  999. X      bufp = fgets(lbuf, 1000, fptr);
  1000. X      if (bufp != NULL)
  1001. X    n = sscanf(bufp, "%s %s %s %s %s %s",
  1002. X           s1, s2, s3, s4, s5, s6);
  1003. X      else n = 0;
  1004. X      if (n < 5) continue;
  1005. X      if ((lbuf[0] == ' ') || (lbuf[0] == '\t')) {
  1006. X    /* use current month */
  1007. X    dy = atof(s1);
  1008. X
  1009. X    ra[i] = atof(s2) + atof(s3)/60.0;
  1010. X    dec[i] = atof(s4);
  1011. X    dec[i] += (atof(s5)/60.0)*(s4[0] == '-' ? -1 : 1);
  1012. X                /* Beware of the sign */
  1013. X
  1014. X    mag[i] = 0.0;        /* don't know it */
  1015. X    r[i] = -1.0;        /* don't know it */
  1016. X    Delta[i] = -1.0;    /* don't know it */
  1017. X      } else {
  1018. X    mo = tr_mname(s1);
  1019. X    if (mo < last_mo) yr++;
  1020. X    last_mo = mo;
  1021. X    dy = atof(s2);
  1022. X
  1023. X    ra[i] = atof(s3) + atof(s4)/60.0;
  1024. X    dec[i] = atof(s5);
  1025. X    dec[i] += (atof(s6)/60.0)*(s5[0] == '-' ? -1 : 1);
  1026. X                /* Beware of the sign */
  1027. X
  1028. X    mag[i] = 0.0;        /* don't know it */
  1029. X    r[i] = -1.0;        /* don't know it */
  1030. X    Delta[i] = -1.0;    /* don't know it */
  1031. X      }
  1032. X
  1033. X      cal_to_jd(dy, mo, yr, &dates[i]);
  1034. X      i++;
  1035. X    };
  1036. X    Nread = i;
  1037. X    break;
  1038. X  case empb:
  1039. X/*
  1040. Xmonth day ra ra     dec dec r    Delta   V    beta
  1041. X1     2   3  4     5    6    7    8       9   10
  1042. XX      6  23 48.36 -18  5.5 2.958 2.033   7.8 8.8
  1043. X      16  23 41.45 -18 13.1 2.955 2.095   8.0 11.6
  1044. X*/
  1045. X    i = 0;
  1046. X    while (!feof(fptr)) {
  1047. X      bufp = fgets(lbuf, 1000, fptr);
  1048. X      if (bufp != NULL)
  1049. X    n = sscanf(bufp, "%s %s %s %s %s %s %s %s %s %s",
  1050. X           s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
  1051. X      else n = 0;
  1052. X      if (n < 5) continue;
  1053. X      if ((lbuf[0] == ' ') || (lbuf[0] == '\t')) {
  1054. X    /* use current month */
  1055. X    dy = atof(s1);
  1056. X
  1057. X    ra[i] = atof(s2) + atof(s3)/60.0;
  1058. X    dec[i] = atof(s4);
  1059. X    dec[i] += (atof(s5)/60.0)*(s4[0] == '-' ? -1 : 1);
  1060. X                /* Beware of the sign */
  1061. X
  1062. X    r[i] = atof(s6);
  1063. X    Delta[i] = atof(s7);
  1064. X    mag[i] = atof(s8);
  1065. X/*    beta[i] = atof(s9);*/
  1066. X      } else {
  1067. X    mo = tr_mname(s1);
  1068. X    if (mo < last_mo) yr++;
  1069. X    last_mo = mo;
  1070. X    dy = atof(s2);
  1071. X
  1072. X    ra[i] = atof(s3) + atof(s4)/60.0;
  1073. X    dec[i] = atof(s5);
  1074. X    dec[i] += (atof(s6)/60.0)*(s5[0] == '-' ? -1 : 1);
  1075. X                /* Beware of the sign */
  1076. X
  1077. X    r[i] = atof(s7);
  1078. X    Delta[i] = atof(s8);
  1079. X    mag[i] = atof(s9);
  1080. X/*    beta[i] = atof(s10);*/
  1081. X      }
  1082. X
  1083. X      cal_to_jd(dy, mo, yr, &dates[i]);
  1084. X
  1085. X      i++;
  1086. X    };
  1087. X    Nread = i;
  1088. X    break;
  1089. X  case aa:
  1090. X/*
  1091. Xdate     RA          DEC       r    Ephemeris Transit
  1092. X1     2  3  4  5     6  7  8  9     10  11
  1093. XOct.  1  23 54 52.1 -17 37 21 2.011 23 10.0
  1094. X      3  23 53 16.1 -17 42 32 2.019 23 00.5
  1095. X*/
  1096. X    i = 0;
  1097. X    while (!feof(fptr)) {
  1098. X      bufp = fgets(lbuf, 1000, fptr);
  1099. X      if (bufp != NULL)
  1100. X    n = sscanf(bufp, "%s %s %s %s %s %s %s %s %s %s %s",
  1101. X           s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11);
  1102. X      else n = 0;
  1103. X      if (n < 7) continue;
  1104. X      if ((lbuf[0] == ' ') || (lbuf[0] == '\t')) {
  1105. X    /* use current month */
  1106. X    dy = atof(s1);
  1107. X
  1108. X    ra[i] = atof(s2) + atof(s3)/60.0 + atof(s4)/3600.0;
  1109. X    dec[i] = atof(s5);
  1110. X    dec[i] += (atof(s6)/60.0 + atof(s7)/3600.0)*(s5[0] == '-' ? -1 : 1);
  1111. X                /* Beware of the sign */
  1112. X
  1113. X    r[i] = atof(s8);
  1114. X
  1115. X    mag[i] = 0.0;        /* don't know it */
  1116. X    Delta[i] = -1.0;    /* don't know it */
  1117. X      } else {
  1118. X    mo = tr_mname(s1);
  1119. X    if (mo < last_mo) yr++;
  1120. X    last_mo = mo;
  1121. X    dy = atof(s2);
  1122. X
  1123. X    ra[i] = atof(s3) + atof(s4)/60.0 + atof(s5)/3600.0;
  1124. X    dec[i] = atof(s6);
  1125. X    dec[i] += (atof(s7)/60.0 + atof(s8)/3600.0)*(s6[0] == '-' ? -1 : 1);
  1126. X                /* Beware of the sign */
  1127. X    r[i] = atof(s9);
  1128. X    
  1129. X    mag[i] = 0.0;        /* don't know it */
  1130. X    Delta[i] = -1.0;    /* don't know it */
  1131. X      }
  1132. X
  1133. X      cal_to_jd(dy, mo, yr, &dates[i]);
  1134. X
  1135. X      i++;
  1136. X    };
  1137. X    Nread = i;
  1138. X    break;
  1139. X  case st:
  1140. X/*
  1141. XDate    RA       DEC   Elongation Mag.
  1142. X1    2  3  4     5 6   7   8
  1143. XOct  1  14 07.6  4 06  25  5.4
  1144. X     6  14 52.3  3 28  32  6.5
  1145. X*/
  1146. X    i = 0;
  1147. X    while (!feof(fptr)) {
  1148. X      bufp = fgets(lbuf, 1000, fptr);
  1149. X      if (bufp != NULL)
  1150. X    n = sscanf(bufp, "%s %s %s %s %s %s %s %s",
  1151. X           s1, s2, s3, s4, s5, s6, s7, s8);
  1152. X      else n = 0;
  1153. X      if (n < 5) continue;
  1154. X      if ((lbuf[0] == ' ') || (lbuf[0] == '\t')) {
  1155. X    /* use current month */
  1156. X    dy = atof(s1);
  1157. X
  1158. X    ra[i] = atof(s2) + atof(s3)/60.0;
  1159. X    dec[i] = atof(s4);
  1160. X    dec[i] += (atof(s5)/60.0)*(s4[0] == '-' ? -1 : 1);
  1161. X                /* Beware of the sign */
  1162. X    mag[i] = atof(s7);
  1163. X
  1164. X    r[i] = -1.0;        /* don't know it */
  1165. X    Delta[i] = -1.0;    /* don't know it */
  1166. X      } else {
  1167. X    mo = tr_mname(s1);
  1168. X    if (mo < last_mo) yr++;
  1169. X    last_mo = mo;
  1170. X    dy = atof(s2);
  1171. X
  1172. X    ra[i] = atof(s3) + atof(s4)/60.0;
  1173. X    dec[i] = atof(s5);
  1174. X    dec[i] += (atof(s6)/60.0)*(s5[0] == '-' ? -1 : 1);
  1175. X                /* Beware of the sign */
  1176. X    mag[i] = atof(s8);
  1177. X
  1178. X    r[i] = -1.0;        /* don't know it */
  1179. X    Delta[i] = -1.0;    /* don't know it */
  1180. X      }
  1181. X
  1182. X      cal_to_jd(dy, mo, yr, &dates[i]);
  1183. X
  1184. X      i++;
  1185. X    };
  1186. X    Nread = i;
  1187. X    break;
  1188. X  case iau:
  1189. X/*
  1190. Xdate       RA          DEC      \Delta     r     (V or m1)
  1191. X     *Only gives \Delta r and V or m1  for every other date*
  1192. X
  1193. X1      2   3  4        5  6     7        8       9
  1194. XOct.   6   14 50.24    3 41.0   1.204    0.643   12.5
  1195. X      11   15 29.62    2 48.8
  1196. X      16   16 04.01    1 54.1   1.339    0.889   14.1
  1197. X      21   16 33.96    1 02.5
  1198. X*/
  1199. X    i = 0;
  1200. X    while (!feof(fptr)) {
  1201. X      bufp = fgets(lbuf, 1000, fptr);
  1202. X      if (bufp != NULL)
  1203. X    n = sscanf(bufp, "%s %s %s %s %s %s %s %s %s",
  1204. X           s1, s2, s3, s4, s5, s6, s7, s8, s9);
  1205. X      else n = 0;
  1206. X      if (n < 5) continue;
  1207. X      if ((lbuf[0] == ' ') || (lbuf[0] == '\t')) {
  1208. X    /* use current month */
  1209. X    dy = atof(s1);
  1210. X
  1211. X    ra[i] = atof(s2) + atof(s3)/60.0;
  1212. X    dec[i] = atof(s4);
  1213. X    dec[i] += (atof(s5)/60.0)*(s4[0] == '-' ? -1 : 1);
  1214. X                /* Beware of the sign */
  1215. X    if (n > 5) {
  1216. X      Delta[i] = atof(s6);
  1217. X      r[i] = atof(s7);
  1218. X      mag[i] = atof(s8);
  1219. X    } else {
  1220. X      Delta[i] =
  1221. X      r[i] =
  1222. X      mag[i] =
  1223. X        -9999.0;
  1224. X    }
  1225. X      } else {
  1226. X    mo = tr_mname(s1);
  1227. X    if (mo < last_mo) yr++;
  1228. X    last_mo = mo;
  1229. X    dy = atof(s2);
  1230. X
  1231. X    ra[i] = atof(s3) + atof(s4)/60.0;
  1232. X    dec[i] = atof(s5);
  1233. X    dec[i] += (atof(s6)/60.0)*(s5[0] == '-' ? -1 : 1);
  1234. X                /* Beware of the sign */
  1235. X    if (n > 5) {
  1236. X      Delta[i] = atof(s7);
  1237. X      r[i] = atof(s8);
  1238. X      mag[i] = atof(s9);
  1239. X    } else {
  1240. X      Delta[i] =
  1241. X      r[i] =
  1242. X      mag[i] =
  1243. X        -9999.0;
  1244. X    }
  1245. X      }
  1246. X
  1247. X      cal_to_jd(dy, mo, yr, &dates[i]);
  1248. X
  1249. X      i++;
  1250. X    };
  1251. X    Nread = i;
  1252. X
  1253. X    /* now fix mag, r, and Delta */
  1254. X    for (i = 0; i < Nread; i++) {
  1255. X      if (mag[i] < -1000.0)
  1256. X    mag[i] = (mag[i-1] + mag[i-1])/2.0;
  1257. X      if (r[i] < -1000.0)
  1258. X    r[i] = (r[i-1] + r[i-1])/2.0;
  1259. X      if (Delta[i] < -1000.0)
  1260. X    Delta[i] = (Delta[i-1] + Delta[i-1])/2.0;
  1261. X    };
  1262. X    break;
  1263. X  default:
  1264. X    break;
  1265. X  }
  1266. X}
  1267. X
  1268. X
  1269. X
  1270. X/* Maximum number of points */
  1271. X#define NMAX MAXPTS
  1272. X
  1273. X/* Polymomial interpolation (or extrapolation) function
  1274. XAdopted from Numerical Recipies
  1275. XGiven arrays xa and ya, each of length N, and given a value x, this routine 
  1276. Xreturns a value y and an error estimate dy.  If P(x) is the polynomial of
  1277. Xdegree N-1 such that P(xa[i]) = ya[i], i = 1, ..., N then the returned
  1278. Xvalue y = P(x);  */
  1279. Xstatic double polint(xa, ya, N, x, dy)
  1280. X     double xa[], ya[];        /* value arrays */
  1281. X     int N;            /* Order */
  1282. X     double x;            /* x point desired */
  1283. X     double *dy;        /* error estimate */
  1284. X{
  1285. X  int i, NS, M;
  1286. X  double dif, dift, c[NMAX], d[NMAX], ho, hp, w, den, y;
  1287. X
  1288. X  NS = 0;
  1289. X  dif = fabs(x-xa[0]);
  1290. X  /* Find the index NS of closest table entry */
  1291. X  for (i = 0; i < N; i++) {
  1292. X    dift = fabs(x - xa[i]);
  1293. X    if (dift < dif) {
  1294. X      NS = i;
  1295. X      dif = dift;
  1296. X    }
  1297. X    /* initialize the 'tableau' of c's and d's */
  1298. X    c[i] =
  1299. X    d[i] = ya[i];
  1300. X  }
  1301. X  y = ya[NS];            /* Initial approximation to Y. */
  1302. X  NS--;
  1303. X  /* For each column of the tableay, we loop over the current c's and d's
  1304. X     and update them */
  1305. X  for (M = 1; M <= N-1; M++) {
  1306. X    for (i = 0; i < N-M; i++) {
  1307. X      ho = xa[i] - x;
  1308. X      hp = xa[i+M] - x;
  1309. X      w = c[i+1] - d[i];
  1310. X      den = ho - hp;
  1311. X      if (den == 0.0) {
  1312. X    /* This can occur only if two input xa's are identical */
  1313. X    fprintf(stderr, "Error in routine polint\n");
  1314. X    exit(1);
  1315. X      }
  1316. X      den = w/den;
  1317. X      d[i] = hp*den;
  1318. X      c[i] = ho*den;
  1319. X    }
  1320. X
  1321. X    /* After each column in the tableau is completed, we decide
  1322. X       which correction, c or d, we want to add to our accumulating value of y,
  1323. X       i.e. which path to take throught the tableau -- forking up or down.
  1324. X       We do this in such a way as to take the most "straight line" route
  1325. X       through the tableau to its apex, updating NS accordingly to keep track
  1326. X       of where we are.  This route keeps the apartial approximations centered
  1327. X       (insofar as possible) on the target x.  The last dy added is thus
  1328. X       the error indication. */
  1329. X    if ((NS+1)*2 < N-M)
  1330. X      *dy = c[NS+1];
  1331. X    else {
  1332. X      *dy = d[NS];
  1333. X      NS--;
  1334. X    }
  1335. X    y = y + *dy;
  1336. X  }
  1337. X
  1338. X  return y;
  1339. X}
  1340. END_OF_FILE
  1341. if test 12025 -ne `wc -c <'observe/tablecalc.c'`; then
  1342.     echo shar: \"'observe/tablecalc.c'\" unpacked with wrong size!
  1343. fi
  1344. # end of 'observe/tablecalc.c'
  1345. fi
  1346. if test -f 'starchart/descrip.mms' -a "${1}" != "-c" ; then 
  1347.   echo shar: Will not clobber existing file \"'starchart/descrip.mms'\"
  1348. else
  1349. echo shar: Extracting \"'starchart/descrip.mms'\" \(11285 characters\)
  1350. sed "s/^X//" >'starchart/descrip.mms' <<'END_OF_FILE'
  1351. X###########################################################################
  1352. X#
  1353. X#    DESCRIP.MMS - a 'makefile' for VAX/VMS and VAX C V3.0 or greater
  1354. X#        by Michael Campanella (campanella@cvg.enet.dec.com)
  1355. X#
  1356. X# $Header: descrip.mms,v 1.5 90/01/13 14:41:44 ccount Exp $
  1357. X#
  1358. X###########################################################################
  1359. X#    Makefile for starchart programs
  1360. X#
  1361. X#    $Header: descrip.mms,v 1.5 90/01/13 14:41:44 ccount Exp $
  1362. X#
  1363. X#list ONLY the programs you want to use at your site
  1364. XTARGS= \
  1365. X    stardsp.exe \
  1366. X    starX11.exe \
  1367. X    starXaw.exe \
  1368. X    starpost.exe \
  1369. X    startek.exe
  1370. X#    staruplot
  1371. X#    starsunv
  1372. X#    starlaser 
  1373. X#    starX10 
  1374. X# startool must be made specially, see below.
  1375. X# Also consider "postconv.awk"
  1376. X
  1377. X#SITE DEPENDENCIES
  1378. X#
  1379. X# Uncomment out the version appropriate for your site.
  1380. X# At present dependencies for sysV UNIX
  1381. X#
  1382. X#LOCAL=-DSYSV -Dindex=strchr
  1383. X#LOCAL = /define=(SYSV,"index=strchr","unlink=delete")
  1384. X
  1385. X# FOR ALL
  1386. X# define OLD_GREEK if you have the old yale.star file, with a
  1387. X#                slightly different greek encoding
  1388. X# To produce programs which allow keyboard user interaction with the -u flag, 
  1389. X#    see COBJ and starmain.OBJ below.
  1390. X# FOR X11
  1391. X# define USE_X_DASHES if your server can draw dashed lines
  1392. X# define RELEASE3_FONTS if you want to use the X11R3 font names
  1393. X# define X11R4 if you are using Release 4  (for the athena widgets).
  1394. X# FOR POSTSCRIPT
  1395. X# define USE_FINE_MACROS if you want to use finer macros than usual:
  1396. X#     star size varies continuously with magnitude.
  1397. X#        Needs printer with lots of available memory
  1398. X#
  1399. X#DEFINES= -DRELEASE3_FONTS -DUSE_X_DASHES -DUSE_FINE_MACROS
  1400. X#DEFINES= -DRELEASE3_FONTS -DUSE_X_DASHES
  1401. X#DEFINES = /define=(USE_X_DASHES,RELEASE3_FONTS)
  1402. X
  1403. X#destination for 'make install', otherwise not important
  1404. XBINDIR = "/usr/local"
  1405. X
  1406. X#XINCLUDES is for DECwindows UWS 2.0
  1407. X#XINCLUDES = -I/usr/include/mit
  1408. XXINCLUDES =
  1409. X
  1410. X#list ALL header files
  1411. XHDRS=icon.h parse_input.h star3.h starXaw.h starXawDlog.h patchlevel.h
  1412. X#list ALL source files, whether or not you use them
  1413. XSRCS= interact.c parse_input.c readfile.c starX10.c starX11.c starXaw.c \
  1414. X    starXawDlog.c starXawHelp.c starXawMwin.c starcust.c \
  1415. X    stardsp.c starimages.c starlaser.c starm2.c starmain.c \
  1416. X    starpost.c starsample.c starsunv.c starsupp.c startek.c staruplot.c
  1417. X
  1418. X#list ALL object files which could be produced
  1419. XOBJS= interact.OBJ parse_input.OBJ readfile.OBJ starX10.OBJ \
  1420. X    starX11.OBJ starX11_aw.OBJ starXaw.OBJ starXawDlog.OBJ \
  1421. X    starXawHelp.OBJ starXawMwin.OBJ starcust.OBJ stardsp.OBJ \
  1422. X    starimages.OBJ starimages_a.OBJ starlaser.OBJ starm2.OBJ starm2_i.OBJ \
  1423. X    starmain.OBJ starmain_i.OBJ starpost.OBJ starsunv.OBJ starsupp.OBJ \
  1424. X    startek.OBJ staruplot.OBJ
  1425. X
  1426. XATHENA_OBJS = command.obj form.obj label.obj simple.obj text.obj vpaned.obj -
  1427. X    asciitext.obj box.obj asciisink.obj strtojust.obj disksrc.obj -
  1428. X    intrinsic.obj stringsrc.obj utils.obj lower.obj dialog.obj scroll.obj -
  1429. X    strtoornt.obj graypixmap.obj
  1430. X
  1431. XSTARTOOL=startool.tt startool.icon startool.sh
  1432. XSUPP=postconv.awk
  1433. XVMSFILES=decwxtk.opt descrip.mms starchart_init.com vaxcrtl.opt
  1434. XIBMFILES=pcstar.h Starchar.MSC staribm.c
  1435. XFILES = Makefile. README. ${SRCS} ${HDRS} ${STARTOOL} ${SUPP} \
  1436. X    ${VMSFILES} ${IBMFILES}
  1437. X
  1438. XDISTDIR=../../dist/starchart
  1439. X
  1440. X#The following may be defined here to set default data file locations
  1441. X# filename    filetype    description
  1442. X# STARFILE    STARFTYPE    bright star data (yale)
  1443. X# INDEXFILE    INDEXFTYPE    index to fainter stars (SAO)
  1444. X# NEBFILE    NEBFTYPE    nebulae
  1445. X# BOUNDFILE    BOUNDFTYPE    constellation boundaries
  1446. X# PATTERNFILE    PATTFTYPE    constellation patterns
  1447. X# CNAMEFILE    CNAMEFTYPE    constellation names
  1448. X# PLANETFILE    PLANETFTYPE    planet positions
  1449. X
  1450. X# other files
  1451. X# CONSTFILE    constellation locations
  1452. X# RCFILE    resource file
  1453. X
  1454. X# Define as needed only
  1455. X# Remember, there are defaults in the code
  1456. X
  1457. X# Example
  1458. XFILEROOT=/starchart/
  1459. XSTAR="${FILEROOT}/yale.star"
  1460. XSTART=LINEREAD
  1461. XINDEX="${FILEROOT}/index.indx"
  1462. XINDEXT=INDEXTYPE
  1463. X# only currently valid index file type
  1464. XNEB="${FILEROOT}/neb.star"
  1465. XNEBT=LINEREAD
  1466. XBOUND="${FILEROOT}/boundaries.star"
  1467. XBOUNDT=LINEREAD
  1468. XPATT="${FILEROOT}/pattern.star"
  1469. XPATTTY=LINEREAD
  1470. XCNAME="${FILEROOT}/cnames.star"
  1471. XCNAMET=LINEREAD
  1472. XPLANET="./planet.star"
  1473. X# Planets move, so make it local
  1474. XPLANETTY=LINEREAD
  1475. XCONS="${FILEROOT}/con.locs"
  1476. XRC="./.starrc"
  1477. X
  1478. XFILEFLAGS= \
  1479. X        -DSTARFILE='$(STAR)' \
  1480. X        -DSTARFTYPE='$(START)' \
  1481. X        -DINDEXFILE='$(INDEX)' \
  1482. X        -DINDEXFTYPE='$(INDEXT)' \
  1483. X        -DNEBFILE='$(NEB)' \
  1484. X        -DNEBFTYPE='$(NEBT)' \
  1485. X        -DBOUNDFILE='$(BOUND)' \
  1486. X        -DBOUNDFTYPE='$(BOUNDT)' \
  1487. X        -DPATTERNFILE='$(PATT)' \
  1488. X        -DPATTFTYPE='$(PATTTY)' \
  1489. X        -DCNAMEFILE='$(CNAME)' \
  1490. X        -DCNAMEFTYPE='$(CNAMET)' \
  1491. X        -DPLANETFILE='$(PLANET)' \
  1492. X        -DPLANETFTYPE='$(PLANETTY)' \
  1493. X        -DCONSTFILE='$(CONS)' \
  1494. X        -DRCFILE='$(RC)'
  1495. X
  1496. X.first
  1497. X    pu/nolog/keep=3
  1498. X    set prot=(g:rwed,w:re)/default
  1499. X    define sys sys$library
  1500. X    define x11 decw$include,sys$disk:[]
  1501. X
  1502. X.last
  1503. X    pu/nolog
  1504. X
  1505. Xall : $(TARGS)
  1506. X    ! Done !
  1507. X
  1508. X#CFLAGS= ${FILEFLAGS} ${LOCAL} ${DEFINES} -g
  1509. XCFLAGS = -
  1510. X/list/define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1511. X#LDFLAGS = -g
  1512. XLINKFLAGS = /nodebug/trace
  1513. X
  1514. X#Include interact.OBJ in COBJ to support keyboard user interaction
  1515. X#COBJ=starmain.OBJ starm2.OBJ starsupp.OBJ readfile.OBJ parse_input.OBJ
  1516. XCOBJ=starmain.OBJ starm2.OBJ starsupp.OBJ readfile.OBJ parse_input.OBJ -
  1517. X    interact.OBJ 
  1518. XCOBJIM=$(COBJ) starimages.OBJ
  1519. XCOBJIMA=$(COBJ) starimages_a.OBJ
  1520. X
  1521. Xstardsp.exe : $(COBJ) stardsp.OBJ starcust.OBJ
  1522. X    $ define/user lnk$library sys$library:vaxcrtl.olb
  1523. X    $ link/exe=$(mms$target) $(LINKFLAGS) $(mms$source_list)
  1524. X#    $(CC) $(LDFLAGS) ${COBJ} stardsp.OBJ starcust.OBJ -lm -o $@
  1525. X
  1526. Xstarlaser.exe : $(COBJIMA) starlaser.OBJ starcust.OBJ
  1527. X    $(CC) $(LDFLAGS) ${COBJIMA} starlaser.OBJ starcust.OBJ -lm -o $@
  1528. X
  1529. Xstarpost.exe : $(COBJ) starpost.OBJ starcust.OBJ
  1530. X    $ define/user lnk$library sys$library:vaxcrtl.olb
  1531. X    $ link/exe=$(mms$target) $(LINKFLAGS) $(mms$source_list)
  1532. X#    $(CC) $(LDFLAGS) $(COBJ) starpost.OBJ starcust.OBJ -lm -o $@
  1533. X
  1534. Xstartek.exe :  $(COBJIMA) startek.OBJ starcust.OBJ
  1535. X    $ define/user lnk$library sys$library:vaxcrtl.olb
  1536. X    $ link/exe=$(mms$target) $(LINKFLAGS) $(mms$source_list)
  1537. X#    $(CC) $(LDFLAGS) ${COBJIMA} startek.OBJ starcust.OBJ -lm -o $@
  1538. X
  1539. Xstaruplot.exe : $(COBJIMA) staruplot.OBJ starcust.OBJ
  1540. X    $(CC) $(LDFLAGS) ${COBJIMA} staruplot.OBJ starcust.OBJ -lm -lplot -o $@
  1541. X
  1542. XstarX10.exe : ${COBJIMA} starX10.OBJ starcust.OBJ
  1543. X    $(CC) $(LDFLAGS) ${COBJIMA} starX10.OBJ starcust.OBJ -lm -lX -o $@
  1544. X
  1545. XstarX11.exe : $(COBJIM) starX11.OBJ starcust.OBJ
  1546. X    $ define/user lnk$library sys$library:vaxcrtl.olb
  1547. X    $ link/exe=$(mms$target) $(LINKFLAGS) $(mms$source_list),decwxtk.opt/opt
  1548. X#    $(CC) $(LDFLAGS) ${COBJIM} starX11.OBJ starcust.OBJ -lm -lX11 -o $@
  1549. X
  1550. XstarXaw.exe : starmain_i.OBJ starm2_i.OBJ starsupp.OBJ readfile.OBJ starX11_aw.OBJ \
  1551. X        starXaw.OBJ starXawDlog.OBJ starXawHelp.OBJ starXawMwin.OBJ\
  1552. X        starcust.OBJ starimages.OBJ parse_input.OBJ $(ATHENA_OBJS)
  1553. X    $ define/user lnk$library sys$library:vaxcrtl.olb
  1554. X    $ link/exe=$(mms$target) $(LINKFLAGS) $(mms$source_list),decwxtk.opt/opt
  1555. X#    $(CC) $(LDFLAGS) starmain_i.OBJ starm2_i.OBJ starsupp.OBJ readfile.OBJ \
  1556. X#        starXaw.OBJ starXawDlog.OBJ starXawHelp.OBJ starXawMwin.OBJ \
  1557. X#         starX11_aw.OBJ starcust.OBJ starimages.OBJ parse_input.OBJ\
  1558. X#        -lm -lXaw -lXmu -lXt -lX11 -o $@
  1559. X
  1560. Xstarsunv.exe : starmain_i.OBJ starm2_i.OBJ starsupp.OBJ readfile.OBJ starsunv.OBJ \
  1561. X        starcust.OBJ starimages.OBJ parse_input.OBJ interact.OBJ
  1562. X    $(CC) $(LDFLAGS) starmain_i.OBJ starm2_i.OBJ starsupp.OBJ readfile.OBJ \
  1563. X        starsunv.OBJ starcust.OBJ starimages.OBJ parse_input.OBJ interact.OBJ \
  1564. X            -lm -lsuntool -lsunwindow -lpixrect -o $@
  1565. Xstartool.exe : starsunv
  1566. X    echo "You must edit startool, startool.tt and startool.sh,"
  1567. X    echo "    and install them"
  1568. X    echo "You must have the program tooltool,"
  1569. X    echo "    which is available from sun PD archives"
  1570. X    echo "tooltool -f startool.tt" > startool
  1571. X
  1572. X# use -DINTERACTIVE_CONTROL in starmain.OBJ and starm2.OBJ
  1573. X#     to allow keyboard user interaction
  1574. Xstarmain.OBJ : starmain.c Makefile star3.h parse_input.h
  1575. X    $(CC) $(CFLAGS) starmain.c -
  1576. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,INTERACTIVE_CONTROL)
  1577. X#    $(CC) $(CFLAGS) -DINTERACTIVE_CONTROL -c starmain.c
  1578. X
  1579. Xstarm2.OBJ : starm2.c Makefile star3.h
  1580. X    $(CC) $(CFLAGS) starm2.c -
  1581. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,INTERACTIVE_CONTROL)
  1582. X#    $(CC) $(CFLAGS) -DINTERACTIVE_CONTROL -c starm2.c
  1583. X
  1584. Xstarmain_i.OBJ : starmain.c Makefile star3.h parse_input.h
  1585. X    - copy starmain.OBJ starmain_n.OBJ
  1586. X    $(CC) $(CFLAGS) starmain.c -
  1587. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,INTERACTIVE_CONTROL)
  1588. X#    $(CC) $(CFLAGS) -DINTERACTIVE_CONTROL -c starmain.c
  1589. X    COPY starmain.OBJ starmain_i.OBJ
  1590. X    - copy starmain_n.OBJ starmain.OBJ
  1591. X
  1592. Xstarm2_i.OBJ : starm2.c Makefile star3.h
  1593. X    - copy starm2.OBJ starm2_n.OBJ
  1594. X    $(CC) $(CFLAGS) starm2.c -
  1595. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,INTERACTIVE_CONTROL)
  1596. X#    $(CC) $(CFLAGS) -DINTERACTIVE_CONTROL -c starm2.c
  1597. X    COPY starm2.OBJ starm2_i.OBJ
  1598. X    - copy starm2_n.OBJ starm2.OBJ
  1599. X
  1600. Xreadfile.OBJ : readfile.c star3.h
  1601. X    $(CC) $(CFLAGS) readfile.c -
  1602. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1603. X
  1604. Xstarimages.OBJ : starimages.c star3.h
  1605. X    $(CC) $(CFLAGS) starimages.c -
  1606. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1607. X#    $(CC) $(CFLAGS) -c starimages.c
  1608. X
  1609. X#starimages_a.OBJ defines area operations for drivers which otherwise don't
  1610. X#  support them
  1611. Xstarimages_a.OBJ : Makefile starimages.c star3.h
  1612. X    - copy starimages.OBJ starimages_n.OBJ
  1613. X    $(CC) $(CFLAGS) starimages.c -
  1614. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,AREAS)
  1615. X#    $(CC) $(CFLAGS) -DAREAS -c starimages.c
  1616. X    COPY starimages.OBJ starimages_a.OBJ
  1617. X    - copy starimages_n.OBJ starimages.OBJ
  1618. X
  1619. XstarX11.OBJ :  starX11.c Makefile icon.h star3.h
  1620. X    $(CC) $(CFLAGS) $(XINCLUDES) starX11.c -
  1621. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,STARX11)
  1622. X#    $(CC) $(CFLAGS) $(XINCLUDES) -DSTARX11 -c starX11.c
  1623. X
  1624. XstarX11_aw.OBJ : starX11.c Makefile icon.h star3.h
  1625. X    - copy starX11.OBJ starX11_n.OBJ
  1626. X    $(CC) $(CFLAGS) $(XINCLUDES) starX11.c -
  1627. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS,STARXAW)
  1628. X#    $(CC) $(CFLAGS) $(XINCLUDES) -DSTARXAW -c starX11.c
  1629. X    COPY starX11.OBJ starX11_aw.OBJ
  1630. X    - copy starX11_n.OBJ starX11.OBJ
  1631. X
  1632. XstarXaw.OBJ : starXaw.c star3.h starXaw.h icon.h
  1633. X    $(CC) $(CFLAGS) $(XINCLUDES) starXaw.c -
  1634. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1635. X#    $(CC) $(CFLAGS) $(XINCLUDES) -c starXaw.c
  1636. X
  1637. XstarXawDlog.OBJ : starXawDlog.c star3.h starXaw.h starXawDlog.h
  1638. X    $(CC) $(CFLAGS) $(XINCLUDES) starXawDlog.c -
  1639. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1640. X#    $(CC) $(CFLAGS) $(XINCLUDES) -c starXawDlog.c
  1641. X
  1642. XstarXawHelp.OBJ : starXawHelp.c star3.h starXaw.h
  1643. X    $(CC) $(CFLAGS) $(XINCLUDES) starXawHelp.c -
  1644. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1645. X#    $(CC) $(CFLAGS) $(XINCLUDES) -c starXawHelp.c
  1646. X
  1647. XstarXawMwin.OBJ : starXawMwin.c star3.h starXaw.h
  1648. X    $(CC) $(CFLAGS) $(XINCLUDES) starXawMwin.c -
  1649. X    /define=(SYSV,"index=strchr",USE_X_DASHES,RELEASE3_FONTS)
  1650. X#    $(CC) $(CFLAGS) $(XINCLUDES) -c starXawMwin.c
  1651. X
  1652. Xstarsunv.OBJ : star3.h
  1653. Xinteract.OBJ : star3.h parse_input.h
  1654. Xparse_input.OBJ : star3.h parse_input.h
  1655. Xstarcust.OBJ : star3.h 
  1656. Xstardsp.OBJ : star3.h 
  1657. Xstarlaser.OBJ : star3.h 
  1658. Xstarpost.OBJ : star3.h 
  1659. Xstarsample.OBJ : star3.h 
  1660. Xstarsupp.OBJ : star3.h 
  1661. Xstartek.OBJ : star3.h 
  1662. Xstaruplot.OBJ : star3.h 
  1663. END_OF_FILE
  1664. echo shar: 1 control character may be missing from \"'starchart/descrip.mms'\"
  1665. if test 11285 -ne `wc -c <'starchart/descrip.mms'`; then
  1666.     echo shar: \"'starchart/descrip.mms'\" unpacked with wrong size!
  1667. fi
  1668. # end of 'starchart/descrip.mms'
  1669. fi
  1670. echo shar: End of archive 7 \(of 32\).
  1671. cp /dev/null ark7isdone
  1672. MISSING=""
  1673. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ; do
  1674.     if test ! -f ark${I}isdone ; then
  1675.     MISSING="${MISSING} ${I}"
  1676.     fi
  1677. done
  1678. if test "${MISSING}" = "" ; then
  1679.     echo You have unpacked all 32 archives.
  1680.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1681. else
  1682.     echo You still need to unpack the following archives:
  1683.     echo "        " ${MISSING}
  1684. fi
  1685. ##  End of shell archive.
  1686. exit 0
  1687.  
  1688.  
  1689.