home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / VOGLE.ZIP / VOGLE / SRC / MSFORT / TEST.C < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-11  |  15.7 KB  |  1,013 lines
  1. #include <stdio.h>
  2.  
  3. /*
  4.  * C routines to test the Microsoft Fortran interface.
  5.  */
  6.  
  7. void
  8. vinit(s)
  9.     char *s;
  10. {
  11.     printf("\nC-vinit: %s\n", s);
  12.     fflush(stdout);
  13. }
  14.  
  15. void
  16. voutput(s)
  17.     char *s;
  18. {
  19.     printf("\nC-voutput: %s\n", s);
  20.     fflush(stdout);
  21. }
  22.  
  23. void
  24. vnewdev(s)
  25.     char *s;
  26. {
  27.     printf("\nC-vnewdev: %s\n", s);
  28.     fflush(stdout);
  29. }
  30.  
  31. void
  32. vgetdev(s)
  33.     char *s;
  34. {
  35.     printf("\nC-vgetdev: A_device\n");
  36.     fflush(stdout);
  37.     strcpy(s, "A_device");
  38. }
  39.  
  40. void
  41. vexit()
  42. {
  43.     printf("\nC-vexit\n");
  44.     fflush(stdout);
  45. }
  46.  
  47. void
  48. clear()
  49. {
  50.     printf("\nC-clear\n");
  51.     fflush(stdout);
  52. }
  53.  
  54. void
  55. color(i)
  56.     int    i;
  57. {
  58.     printf("\nC-color: %d\n", i);
  59.     fflush(stdout);
  60. }
  61.  
  62. void
  63. mapcolor(i, r, g, b)
  64.     int    i, r, g, b;
  65. {
  66.     printf("\nC-mapcolor: %d %d %d %d\n", i, r, g, b);
  67.     fflush(stdout);
  68. }
  69.  
  70. void
  71. clipping(i)
  72.     int    i;
  73. {
  74.     printf("\nC-clipping: %d\n", i);
  75.     fflush(stdout);
  76. }
  77.  
  78. int
  79. getkey()
  80. {
  81.     printf("\nC-getkey: returning 11\n");
  82.     fflush(stdout);
  83.     return(11);
  84. }
  85.  
  86. int
  87. checkkey()
  88. {
  89.     printf("\nC-checkkey: returning 14\n");
  90.     fflush(stdout);
  91.     return(14);
  92. }
  93.  
  94. int
  95. getdepth()
  96. {
  97.     printf("\nC-getdepth: returning 111\n");
  98.     fflush(stdout);
  99.     return(111);
  100. }
  101.  
  102. int
  103. locator(x, y)
  104.     float    *x, *y;
  105. {
  106.     printf("\nC-locator: returning 13 as fn val, x = 23.4, y = 44.2\n");
  107.     fflush(stdout);
  108.     *x = 23.4;
  109.     *y = 44.2;
  110.     return (13);
  111. }
  112.  
  113. int
  114. slocator(x, y)
  115.     float    *x, *y;
  116. {
  117.     printf("\nC-slocator: returning 13 as fn val, x = 23.4, y = 44.2\n");
  118.     fflush(stdout);
  119.     *x = 23.4;
  120.     *y = 44.2;
  121.     return (13);
  122. }
  123.  
  124. void
  125. viewport(a, b, c, d)
  126.     float    a, b, c, d;
  127. {
  128.     printf("\nC-viewport: %f %f %f %f\n", a, b, c, d);
  129.     fflush(stdout);
  130. }
  131.  
  132. void
  133. getviewport(a, b, c, d)
  134.     float    *a, *b, *c, *d;
  135. {
  136.     printf("\nC-getviewport: returning 1.0, 2.0, 3.0, 4.0\n");
  137.     fflush(stdout);
  138.     *a = 1.0;
  139.     *b = 2.0;
  140.     *c = 3.0;
  141.     *d = 4.0;
  142. }
  143.  
  144. void
  145. pushviewport()
  146. {
  147.     printf("\nC-pushviewport\n");
  148.     fflush(stdout);
  149. }
  150.  
  151. void
  152. popviewport()
  153. {
  154.     printf("\nC-popviewport\n");
  155.     fflush(stdout);
  156. }
  157.  
  158. void
  159. pushattributes()
  160. {
  161.     printf("\nC-pushattributes\n");
  162.     fflush(stdout);
  163. }
  164.  
  165. void
  166. popattributes()
  167. {
  168.     printf("\nC-popattributes\n");
  169.     fflush(stdout);
  170. }
  171.  
  172. void
  173. ortho(a, b, c, d, e, f)
  174.     float    a, b, c, d, e, f;
  175. {
  176.     printf("\nC-ortho: %f %f %f %f %f %f\n", a, b, c, d, e, f);
  177.     fflush(stdout);
  178. }
  179.  
  180. void
  181. ortho2(a, b, c, d)
  182.     float    a, b, c, d;
  183. {
  184.     printf("\nC-ortho2: %f %f %f %f\n", a, b, c, d);
  185.     fflush(stdout);
  186. }
  187.  
  188. void
  189. perspective(a, b, c, d)
  190.     float    a, b, c, d;
  191. {
  192.     printf("\nC-perspective: %f %f %f %f\n", a, b, c, d);
  193.     fflush(stdout);
  194. }
  195.  
  196. void
  197. window(a, b, c, d, e, f)
  198.     float    a, b, c, d, e, f;
  199. {
  200.     printf("\nC-window: %f %f %f %f %f %f\n", a, b, c, d, e, f);
  201.     fflush(stdout);
  202. }
  203.  
  204. void
  205. pushmatrix()
  206. {
  207.     printf("\nC-pushmatrix\n");
  208.     fflush(stdout);
  209. }
  210.  
  211. void
  212. popmatrix()
  213. {
  214.     printf("\nC-popmatrix\n");
  215.     fflush(stdout);
  216. }
  217.  
  218.  
  219. void
  220. polarview(a, b, c, d)
  221.     float    a, b, c, d;
  222. {
  223.     printf("\nC-polarview: %f %f %f %f\n", a, b, c, d);
  224.     fflush(stdout);
  225. }
  226.  
  227. void
  228. lookat(a, b, c, d, e, f, g)
  229.     float    a, b, c, d, e, f, g;
  230. {
  231.     printf("\nC-lookat: %f %f %f %f %f %f %f\n", a, b, c, d, e, f, g);
  232.     fflush(stdout);
  233. }
  234.  
  235. void
  236. move(x, y, z)
  237.     float x, y, z;
  238. {
  239.     printf("\nC-move: %f %f %f\n", x, y, z);
  240.     fflush(stdout);
  241. }
  242.  
  243. void
  244. rmove(x, y, z)
  245.     float x, y, z;
  246. {
  247.     printf("\nC-rmove: %f %f %f\n", x, y, z);
  248.     fflush(stdout);
  249. }
  250.  
  251. void
  252. move2(x, y)
  253.     float x, y;
  254. {
  255.     printf("\nC-move2: %f %f\n", x, y);
  256.     fflush(stdout);
  257. }
  258.  
  259. void
  260. rmove2(x, y)
  261.     float x, y;
  262. {
  263.     printf("\nC-rmove2: %f %f\n", x, y);
  264.     fflush(stdout);
  265. }
  266.  
  267. void
  268. smove2(x, y)
  269.     float x, y;
  270. {
  271.     printf("\nC-smove2: %f %f\n", x, y);
  272.     fflush(stdout);
  273. }
  274.  
  275. void
  276. rsmove2(x, y)
  277.     float x, y;
  278. {
  279.     printf("\nC-rsmove2: %f %f\n", x, y);
  280.     fflush(stdout);
  281. }
  282.  
  283.  
  284.  
  285. void
  286. draw(x, y, z)
  287.     float x, y, z;
  288. {
  289.     printf("\nC-draw: %f %f %f\n", x, y, z);
  290.     fflush(stdout);
  291. }
  292.  
  293. void
  294. rdraw(x, y, z)
  295.     float x, y, z;
  296. {
  297.     printf("\nC-rdraw: %f %f %f\n", x, y, z);
  298.     fflush(stdout);
  299. }
  300.  
  301. void
  302. draw2(x, y)
  303.     float x, y;
  304. {
  305.     printf("\nC-draw2: %f %f\n", x, y);
  306.     fflush(stdout);
  307. }
  308.  
  309. void
  310. rdraw2(x, y)
  311.     float x, y;
  312. {
  313.     printf("\nC-rdraw2: %f %f\n", x, y);
  314.     fflush(stdout);
  315. }
  316.  
  317. void
  318. sdraw2(x, y)
  319.     float x, y;
  320. {
  321.     printf("\nC-sdraw2: %f %f\n", x, y);
  322.     fflush(stdout);
  323. }
  324.  
  325. void
  326. rsdraw2(x, y)
  327.     float x, y;
  328. {
  329.     printf("\nC-rsdraw2: %f %f\n", x, y);
  330.     fflush(stdout);
  331. }
  332.  
  333. void
  334. arcprecision(i)
  335.     int    i;
  336. {
  337.     printf("\nC-arcprecision: %d\n", i);
  338.     fflush(stdout);
  339. }
  340.  
  341. void
  342. circleprecision(i)
  343.     int    i;
  344. {
  345.     printf("\nC-circleprecision: %d\n", i);
  346.     fflush(stdout);
  347. }
  348.  
  349. void
  350. arc(a, b, c, d, e)
  351.     float    a, b, c, d, e;
  352. {
  353.     printf("\nC-arc: %f %f %f %f %f\n", a, b, c, d, e);
  354.     fflush(stdout);
  355. }
  356.  
  357. void
  358. sector(a, b, c, d, e)
  359.     float    a, b, c, d, e;
  360. {
  361.     printf("\nC-sector: %f %f %f %f %f\n", a, b, c, d, e);
  362.     fflush(stdout);
  363. }
  364.  
  365. void
  366. circle(a, b, c)
  367.     float    a, b, c;
  368. {
  369.     printf("\nC-circle: %f %f %f\n", a, b, c);
  370.     fflush(stdout);
  371. }
  372.  
  373. void
  374. curvebasis(b)
  375.     float b[4][4];
  376. {
  377.     printf("\nC-curvebasis:\n");
  378.     printf("%f %f %f %f\n", b[0][0], b[0][1], b[0][2], b[0][3]);
  379.     printf("%f %f %f %f\n", b[1][0], b[1][1], b[1][2], b[1][3]);
  380.     printf("%f %f %f %f\n", b[2][0], b[2][1], b[2][2], b[2][3]);
  381.     printf("%f %f %f %f\n\n", b[3][0], b[3][1], b[3][2], b[3][3]);
  382.     fflush(stdout);
  383. }
  384.  
  385. void
  386. curveprecision(i)
  387.     int    i;
  388. {
  389.     printf("\nC-curveprecision: %d\n", i);
  390.     fflush(stdout);
  391. }
  392.  
  393. void
  394. rcurve(b)
  395.     float b[4][4];
  396. {
  397.     printf("\nC-rcurve:\n");
  398.     printf("%f %f %f %f\n", b[0][0], b[0][1], b[0][2], b[0][3]);
  399.     printf("%f %f %f %f\n", b[1][0], b[1][1], b[1][2], b[1][3]);
  400.     printf("%f %f %f %f\n", b[2][0], b[2][1], b[2][2], b[2][3]);
  401.     printf("%f %f %f %f\n\n", b[3][0], b[3][1], b[3][2], b[3][3]);
  402.     fflush(stdout);
  403. }
  404.  
  405. void
  406. curve(b)
  407.     float b[4][3];
  408. {
  409.     printf("\nC-curve:\n");
  410.     printf("%f %f %f\n", b[0][0], b[0][1], b[0][2]);
  411.     printf("%f %f %f\n", b[1][0], b[1][1], b[1][2]);
  412.     printf("%f %f %f\n", b[2][0], b[2][1], b[2][2]);
  413.     printf("%f %f %f\n\n", b[3][0], b[3][1], b[3][2]);
  414.     fflush(stdout);
  415. }
  416.  
  417. void
  418. curven(n, b)
  419.     float b[][3];
  420. {
  421.     int    i;
  422.     
  423.     printf("\nC-curven: %d\n", n);
  424.     fflush(stdout);
  425.     if (n > 6) 
  426.         n = 6;
  427.  
  428.     for (i = 0; i < n; i++) 
  429.         printf("%f %f %f\n", b[i][0], b[i][1], b[i][2]);
  430.  
  431.     printf("\n");
  432.     fflush(stdout);
  433. }
  434.  
  435. void
  436. rect(a, b, c, d)
  437.     float    a, b, c, d;
  438. {
  439.     printf("\nC-rect: %f %f %f %f\n", a, b, c, d);
  440.     fflush(stdout);
  441. }
  442.  
  443. void
  444. polyfill(i)
  445.     int    i;
  446. {
  447.     printf("\nC-polyfill: %d\n", i);
  448.     fflush(stdout);
  449. }
  450.  
  451. void
  452. polyhatch(i)
  453.     int    i;
  454. {
  455.     printf("\nC-polyhatch: %d\n", i);
  456.     fflush(stdout);
  457. }
  458.  
  459. void
  460. hatchang(i)
  461.     float    i;
  462. {
  463.     printf("\nC-hatchang: %f\n", i);
  464.     fflush(stdout);
  465. }
  466.  
  467. void
  468. hatchpitch(i)
  469.     float    i;
  470. {
  471.     printf("\nC-hatchpitch: %f\n", i);
  472.     fflush(stdout);
  473. }
  474.  
  475. void
  476. poly2(n , p)
  477.     int    n;
  478.     float    p[][2];
  479. {
  480.     int    i;
  481.  
  482.     printf("\nC-poly2: %d\n", n);
  483.     fflush(stdout);
  484.     if (n > 6) 
  485.         n = 6;
  486.     
  487.     for (i = 0; i < n; i++)
  488.         printf("%f %f\n", p[i][0], p[i][1]);
  489.     fflush(stdout);
  490.  
  491.     printf("\n");
  492.     fflush(stdout);
  493. }
  494.     
  495. void
  496. poly(n , p)
  497.     int    n;
  498.     float    p[][3];
  499. {
  500.     int    i;
  501.  
  502.     printf("\nC-poly: %d\n", n);
  503.     fflush(stdout);
  504.     if (n > 6) 
  505.         n = 6;
  506.     
  507.     for (i = 0; i < n; i++)
  508.         printf("%f %f %f\n", p[i][0], p[i][1], p[i][2]);
  509.     fflush(stdout);
  510.  
  511.     printf("\n");
  512.     fflush(stdout);
  513. }
  514.  
  515. void
  516. makepoly()
  517. {
  518.     printf("\nC-makepoly\n");
  519.     fflush(stdout);
  520. }
  521.  
  522. void
  523. closepoly()
  524. {
  525.     printf("\nC-closepoly\n");
  526.     fflush(stdout);
  527. }
  528.  
  529. void
  530. font(s)
  531.     char *s;
  532. {
  533.     printf("\nC-font: %s\n", s);
  534.     fflush(stdout);
  535. }
  536.  
  537. int
  538. numchars()
  539. {
  540.     printf("\nC-numchars: returning 15\n");
  541.     fflush(stdout);
  542.     return(15);
  543. }
  544.  
  545. void
  546. textsize(a, b)
  547.     float    a, b;
  548. {
  549.     printf("\nC-textsize: %f %f\n", a, b);
  550.     fflush(stdout);
  551. }
  552.  
  553. void
  554. textang(a)
  555.     float    a;
  556. {
  557.     printf("\nC-textang: %f\n", a);
  558.     fflush(stdout);
  559. }
  560.  
  561. void
  562. fixedwidth(i)
  563.     int    i;
  564. {
  565.     printf("\nC-fixedwidth: %d\n", i);
  566.     fflush(stdout);
  567. }
  568.  
  569. void
  570. centertext(i)
  571.     int    i;
  572. {
  573.     printf("\nC-centertext: %d\n", i);
  574.     fflush(stdout);
  575. }
  576.  
  577. void
  578. getcharsize(c, a, b)
  579.     char    c;
  580.     float *a, *b;
  581. {
  582.     printf("\nC-getcharsize: %c, returning w = 11.3, h = 555.4\n", c);
  583.     fflush(stdout);
  584.     *a = 11.3;
  585.     *b = 555.4;
  586. }
  587.  
  588. void
  589. getfontsize(a, b)
  590.     float *a, *b;
  591. {
  592.     printf("\nC-getfontsize: returning w = 11.3, h = 555.4\n");
  593.     fflush(stdout);
  594.     *a = 11.3;
  595.     *b = 555.4;
  596. }
  597.  
  598. void
  599. drawchar(c)
  600.     char    c;
  601. {
  602.     printf("\nC-drawchar: %c\n", c);
  603.     fflush(stdout);
  604. }
  605.  
  606. void
  607. drawstr(c)
  608.     char    *c;
  609. {
  610.     printf("\nC-drawstr: %s\n", c);
  611.     fflush(stdout);
  612. }
  613.  
  614. float
  615. strlength(s)
  616.     char    *s;
  617. {
  618.     printf("\nC-strlength: returning (float)strlen(%s)\n", s);
  619.     fflush(stdout);
  620.     return ((float)strlen(s));
  621. }
  622.  
  623. void
  624. boxtext(x, y, l, h, s)
  625.     float    x, y, l, h;
  626.     char    *s;
  627. {
  628.     printf("\nC-boxtext: %f %f %f %f %s\n", x, y, l, h, s);
  629.     fflush(stdout);
  630. }
  631.  
  632. void
  633. boxfit(l, h, n)
  634.     float    l, h;
  635.     int    n;
  636. {
  637.     printf("\nC-boxfit: %f %f %d\n",l, h, n);
  638.     fflush(stdout);
  639. }
  640.  
  641. void
  642. translate(x, y, z)
  643.     float    x, y, z;
  644. {
  645.     printf("\nC-translate: %f %f %f\n", x, y, z);
  646.     fflush(stdout);
  647. }
  648.  
  649. void
  650. scale(x, y, z)
  651.     float    x, y, z;
  652. {
  653.     printf("\nC-scale: %f %f %f\n", x, y, z);
  654.     fflush(stdout);
  655. }
  656.  
  657. void
  658. rotate(x, a)
  659.     float    x;
  660.     char    a;
  661. {
  662.     printf("\nC-rotate: %f %c\n", x, a);
  663.     fflush(stdout);
  664. }
  665.  
  666. void
  667. patchbasis(a, b)
  668.     float    a[4][4], b[4][4];
  669. {
  670.     printf("\nC-patchbasis:\n");
  671.     printf("%f %f %f %f\n", a[0][0], a[0][1], a[0][2], a[0][3]);
  672.     printf("%f %f %f %f\n", a[1][0], a[1][1], a[1][2], a[1][3]);
  673.     printf("%f %f %f %f\n", a[2][0], a[2][1], a[2][2], a[2][3]);
  674.     printf("%f %f %f %f\n\n", a[3][0], a[3][1], a[3][2], a[3][3]);
  675.  
  676.     printf("%f %f %f %f\n", b[0][0], b[0][1], b[0][2], b[0][3]);
  677.     printf("%f %f %f %f\n", b[1][0], b[1][1], b[1][2], b[1][3]);
  678.     printf("%f %f %f %f\n", b[2][0], b[2][1], b[2][2], b[2][3]);
  679.     printf("%f %f %f %f\n\n", b[3][0], b[3][1], b[3][2], b[3][3]);
  680.     fflush(stdout);
  681. }
  682.  
  683. void
  684. patchprecision(a, b)
  685.     int    a, b;
  686. {
  687.     printf("\nC-patchprecision: %d %d\n", a, b);
  688.     fflush(stdout);
  689. }
  690.  
  691. void
  692. patchcurves(a, b)
  693.     int    a, b;
  694. {
  695.     printf("\nC-patchcurves: %d %d\n", a, b);
  696.     fflush(stdout);
  697. }
  698.  
  699. void
  700. rpatch(a, b, c, d)
  701.     float    a[4][4], b[4][4], c[4][4], d[4][4];
  702. {
  703.     printf("\nC-rpatch:\n");
  704.     printf("%f %f %f %f\n", a[0][0], a[0][1], a[0][2], a[0][3]);
  705.     printf("%f %f %f %f\n", a[1][0], a[1][1], a[1][2], a[1][3]);
  706.     printf("%f %f %f %f\n", a[2][0], a[2][1], a[2][2], a[2][3]);
  707.     printf("%f %f %f %f\n\n", a[3][0], a[3][1], a[3][2], a[3][3]);
  708.  
  709.     printf("%f %f %f %f\n", b[0][0], b[0][1], b[0][2], b[0][3]);
  710.     printf("%f %f %f %f\n", b[1][0], b[1][1], b[1][2], b[1][3]);
  711.     printf("%f %f %f %f\n", b[2][0], b[2][1], b[2][2], b[2][3]);
  712.     printf("%f %f %f %f\n\n", b[3][0], b[3][1], b[3][2], b[3][3]);
  713.  
  714.     printf("%f %f %f %f\n", c[0][0], c[0][1], c[0][2], c[0][3]);
  715.     printf("%f %f %f %f\n", c[1][0], c[1][1], c[1][2], c[1][3]);
  716.     printf("%f %f %f %f\n", c[2][0], c[2][1], c[2][2], c[2][3]);
  717.     printf("%f %f %f %f\n\n", c[3][0], c[3][1], c[3][2], c[3][3]);
  718.  
  719.     printf("%f %f %f %f\n", d[0][0], d[0][1], d[0][2], d[0][3]);
  720.     printf("%f %f %f %f\n", d[1][0], d[1][1], d[1][2], d[1][3]);
  721.     printf("%f %f %f %f\n", d[2][0], d[2][1], d[2][2], d[2][3]);
  722.     printf("%f %f %f %f\n\n", d[3][0], d[3][1], d[3][2], d[3][3]);
  723.     fflush(stdout);
  724. }
  725.  
  726. void
  727. patch(a, b, c)
  728.     float    a[4][4], b[4][4], c[4][4];
  729. {
  730.     printf("\nC-patch:\n");
  731.     printf("%f %f %f %f\n", a[0][0], a[0][1], a[0][2], a[0][3]);
  732.     printf("%f %f %f %f\n", a[1][0], a[1][1], a[1][2], a[1][3]);
  733.     printf("%f %f %f %f\n", a[2][0], a[2][1], a[2][2], a[2][3]);
  734.     printf("%f %f %f %f\n\n", a[3][0], a[3][1], a[3][2], a[3][3]);
  735.  
  736.     printf("%f %f %f %f\n", b[0][0], b[0][1], b[0][2], b[0][3]);
  737.     printf("%f %f %f %f\n", b[1][0], b[1][1], b[1][2], b[1][3]);
  738.     printf("%f %f %f %f\n", b[2][0], b[2][1], b[2][2], b[2][3]);
  739.     printf("%f %f %f %f\n\n", b[3][0], b[3][1], b[3][2], b[3][3]);
  740.  
  741.     printf("%f %f %f %f\n", c[0][0], c[0][1], c[0][2], c[0][3]);
  742.     printf("%f %f %f %f\n", c[1][0], c[1][1], c[1][2], c[1][3]);
  743.     printf("%f %f %f %f\n", c[2][0], c[2][1], c[2][2], c[2][3]);
  744.     printf("%f %f %f %f\n\n", c[3][0], c[3][1], c[3][2], c[3][3]);
  745.     fflush(stdout);
  746. }
  747.  
  748. void
  749. point(x, y, z)
  750.     float    x, y, z;
  751. {
  752.     printf("\nC-point: %f %f %f\n", x, y, z);
  753.     fflush(stdout);
  754. }
  755.  
  756. void
  757. point2(x, y)
  758.     float    x, y;
  759. {
  760.     printf("\nC-point2: %f %f\n", x, y);
  761.     fflush(stdout);
  762. }
  763.  
  764. void
  765. makeobj(n)
  766.     int    n;
  767. {
  768.     printf("\nC-makeobj: %d\n", n);
  769.     fflush(stdout);
  770. }
  771.  
  772. void
  773. delobj(n)
  774.     int    n;
  775. {
  776.     printf("\nC-delobj: %d\n", n);
  777.     fflush(stdout);
  778. }
  779.  
  780. void
  781. closeobj()
  782. {
  783.     printf("\nC-closeobj");
  784.     fflush(stdout);
  785. }
  786.  
  787. int
  788. genobj()
  789. {
  790.     printf("\nC-genobj: returning 77");
  791.     fflush(stdout);
  792.     return (77);
  793. }
  794.  
  795. int
  796. getopenobj()
  797. {
  798.     printf("\nC-getopenobj: returning 88");
  799.     fflush(stdout);
  800.     return (88);
  801. }
  802.  
  803. void
  804. callobj(n)
  805.     int    n;
  806. {
  807.     printf("\nC-callobj: %d\n", n);
  808.     fflush(stdout);
  809. }
  810.  
  811. int
  812. isobj(n)
  813.     int    n;
  814. {
  815.     printf("\nC-isobj: %d, returning 1\n", n);
  816.     fflush(stdout);
  817.     return(1);
  818. }
  819.  
  820. void
  821. loadobj(n, s)
  822.     int    n;
  823.     char    *s;
  824. {
  825.     printf("\nC-loadobj: %d %s\n", n, s);
  826.     fflush(stdout);
  827. }
  828.  
  829. void
  830. saveobj(n, s)
  831.     int    n;
  832.     char    *s;
  833. {
  834.     printf("\nC-saveobj: %d %s\n", n, s);
  835.     fflush(stdout);
  836. }
  837.  
  838. void
  839. getgp(x, y, z)
  840.     float    *x, *y, *z;
  841. {
  842.     printf("\nC-getgp: returning x = 1.0, y = 2.0, z = 3.0\n");
  843.     fflush(stdout);
  844.     *x = 1.0;
  845.     *y = 2.0;
  846.     *z = 3.0;
  847. }
  848.  
  849. void
  850. sgetgp2(x, y)
  851.     float    *x, *y;
  852. {
  853.     printf("\nC-sgetgp2: returning x = 1.0, y = 2.0\n");
  854.     fflush(stdout);
  855.     *x = 1.0;
  856.     *y = 2.0;
  857. }
  858.  
  859. void
  860. getgp2(x, y)
  861.     float    *x, *y;
  862. {
  863.     printf("\nC-getgp2: returning x = 1.0, y = 2.0\n");
  864.     fflush(stdout);
  865.     *x = 1.0;
  866.     *y = 2.0;
  867. }
  868.  
  869. void
  870. loadmatrix(c)
  871.     float    c[4][4];
  872. {
  873.     printf("\nC-loadmatrix:\n");
  874.     printf("%f %f %f %f\n", c[0][0], c[0][1], c[0][2], c[0][3]);
  875.     printf("%f %f %f %f\n", c[1][0], c[1][1], c[1][2], c[1][3]);
  876.     printf("%f %f %f %f\n", c[2][0], c[2][1], c[2][2], c[2][3]);
  877.     printf("%f %f %f %f\n\n", c[3][0], c[3][1], c[3][2], c[3][3]);
  878.     fflush(stdout);
  879. }
  880.  
  881. void
  882. multmatrix(c)
  883.     float    c[4][4];
  884. {
  885.     printf("\nC-multmatrix:\n");
  886.     printf("%f %f %f %f\n", c[0][0], c[0][1], c[0][2], c[0][3]);
  887.     printf("%f %f %f %f\n", c[1][0], c[1][1], c[1][2], c[1][3]);
  888.     printf("%f %f %f %f\n", c[2][0], c[2][1], c[2][2], c[2][3]);
  889.     printf("%f %f %f %f\n\n", c[3][0], c[3][1], c[3][2], c[3][3]);
  890.     fflush(stdout);
  891. }
  892.  
  893. void
  894. getmatrix(c)
  895.     float    c[4][4];
  896. {
  897.     printf("\nC-getmatrix:\n");
  898.     fflush(stdout);
  899.     c[0][0] = c[0][1] = c[0][2] = c[0][3] = 1.0;
  900.     c[1][0] = c[1][1] = c[1][2] = c[1][3] = 2.0;
  901.     c[2][0] = c[2][1] = c[2][2] = c[2][3] = 3.0;
  902.     c[3][0] = c[3][1] = c[3][2] = c[3][3] = 4.0;
  903. }
  904.  
  905. void
  906. yobbarays(n)
  907.     int    n;
  908. {
  909.     printf("\nC-yobbarays: %d\n", n);
  910.     fflush(stdout);
  911. }
  912.  
  913. int
  914. getstring(bcol, s)
  915.     int    bcol;
  916.     char    *s;
  917. {
  918.     printf("\nC-getstring: bcol = %d setting s to 'Hello there - bonk'\n", bcol);
  919.     fflush(stdout);
  920.     strcpy(s, "Hello there - bonk");
  921.     return (strlen(s));
  922. }
  923.  
  924. float
  925. getaspect()
  926. {
  927.     printf("\nC-getaspct: returning 0.75\n");
  928.     fflush(stdout);
  929.     return(0.75);
  930. }
  931.  
  932. void
  933. getfactors(x, y)
  934.     float    *x, *y;
  935. {
  936.     printf("\nC-getfactors: returning 1.2, 1.3\n");
  937.     fflush(stdout);
  938.     *x = 1.2;
  939.     *y = 1.3;
  940. }
  941.  
  942. void
  943. getdisplaysize(x, y)
  944.     float    *x, *y;
  945. {
  946.     printf("\nC-getdisplaysize: returning 1024, 768\n");
  947.     fflush(stdout);
  948.     *x = 1024;
  949.     *y = 768;
  950. }
  951.  
  952. int
  953. backbuffer()
  954. {
  955.     printf("\nC-backbuffer: returning 110\n");
  956.     fflush(stdout);
  957.     return (110);
  958. }
  959.  
  960. void
  961. frontbuffer()
  962. {
  963.     printf("\nC-frontbuffer:\n");
  964.     fflush(stdout);
  965. }
  966.  
  967. void
  968. swapbuffers()
  969. {
  970.     printf("\nC-swapbuffers:\n");
  971.     fflush(stdout);
  972. }
  973.  
  974. void
  975. up(a, b, c)
  976.     float    a, b, c;
  977. {
  978.     printf("\nC-up: %f, %f, %f\n", a, b, c);
  979.     fflush(stdout);
  980. }
  981.  
  982. void
  983. prefsize(a, b)
  984.     int    a, b;
  985. {
  986.     printf("\nC-prefsize: %d, %d\n", a, b);
  987.     fflush(stdout);
  988. }
  989.  
  990. void
  991. prefposition(a, b)
  992.     int    a, b;
  993. {
  994.     printf("\nC-prefposition: %d, %d\n", a, b);
  995.     fflush(stdout);
  996. }
  997.  
  998. void
  999. backface(i)
  1000.     int    i;
  1001. {
  1002.     printf("\nC-backface: %d\n", i);
  1003.     fflush(stdout);
  1004. }
  1005.  
  1006. void
  1007. backfacedir(i)
  1008.     int    i;
  1009. {
  1010.     printf("\nC-backfacedir: %d\n", i);
  1011.     fflush(stdout);
  1012. }
  1013.