home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume33 / pdcurses / part02 < prev    next >
Encoding:
Text File  |  1992-11-19  |  54.9 KB  |  1,926 lines
  1. Newsgroups: comp.sources.misc
  2. From: M.Hessling@gu.edu.au (Mark Hessling)
  3. Subject:  v33i082:  pdcurses - Public Domain curses library for DOS and OS/2 v2.0, Part02/11
  4. Message-ID: <1992Nov19.035949.6482@sparky.imd.sterling.com>
  5. X-Md4-Signature: c60892a2b557896b3a5bf8736debbddf
  6. Date: Thu, 19 Nov 1992 03:59:49 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: M.Hessling@gu.edu.au (Mark Hessling)
  10. Posting-number: Volume 33, Issue 82
  11. Archive-name: pdcurses/part02
  12. Environment: DOS,OS/2,ANSI-C
  13.  
  14. #! /bin/sh
  15. # This is a shell archive.  Remove anything before this line, then feed it
  16. # into a shell via "sh file" or similar.  To overwrite existing files,
  17. # type "sh file -c".
  18. # Contents:  demos/xmas.c nonport/wbox.c private/_vsscanf.c
  19. #   tools/buildlrf.def
  20. # Wrapped by kent@sparky on Wed Nov 18 21:44:06 1992
  21. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  22. echo If this archive is complete, you will see the following message:
  23. echo '          "shar: End of archive 2 (of 11)."'
  24. if test -f 'demos/xmas.c' -a "${1}" != "-c" ; then 
  25.   echo shar: Will not clobber existing file \"'demos/xmas.c'\"
  26. else
  27.   echo shar: Extracting \"'demos/xmas.c'\" \(33528 characters\)
  28.   sed "s/^X//" >'demos/xmas.c' <<'END_OF_FILE'
  29. X/******************************************************************************/
  30. X/* asciixmas                                                                  */
  31. X/* December 1989             Larry Bartz           Indianapolis, IN           */
  32. X/*                                                                            */
  33. X/*                                                                            */
  34. X/* I'm dreaming of an ascii character-based monochrome Christmas,             */
  35. X/* Just like the one's I used to know!                                        */
  36. X/* Via a full duplex communications channel,                                  */
  37. X/* At 9600 bits per second,                                                   */
  38. X/* Even though it's kinda slow.                                               */
  39. X/*                                                                            */
  40. X/* I'm dreaming of an ascii character-based monochrome Christmas,             */
  41. X/* With ev'ry C program I write!                                              */
  42. X/* May your screen be merry and bright!                                       */
  43. X/* And may all your Christmases be amber or green,                            */
  44. X/* (for reduced eyestrain and improved visibility)!                           */
  45. X/*                                                                            */
  46. X/*                                                                            */
  47. X/*                                                                            */
  48. X/*                                                                            */
  49. X/*                                                                            */
  50. X/* IMPLEMENTATION                                                             */
  51. X/*                                                                            */
  52. X/* Feel free to modify the defined string FROMWHO to reflect you, your        */
  53. X/* organization, your site, whatever.                                         */
  54. X/*                                                                            */
  55. X/* This really looks a lot better if you can turn off your cursor before      */
  56. X/* execution. I wanted to do that here but very few termcap entries or        */
  57. X/* terminfo definitions have the appropriate string defined. If you know      */
  58. X/* the string(s) for the terminal(s) you use or which your site supports,     */
  59. X/* you could call asciixmas from within a shell in which you issue the        */
  60. X/* string to the terminal. The cursor is distracting but it doesn't really    */
  61. X/* ruin the show.                                                             */
  62. X/*                                                                            */
  63. X/* At our site, we invoke this for our users just after login and the         */
  64. X/* determination of terminal type.                                            */
  65. X/*                                                                            */
  66. X/*                                                                            */
  67. X/* PORTABILITY                                                                */
  68. X/*                                                                            */
  69. X/* I wrote this using only the very simplest curses functions so that it      */
  70. X/* might be the most portable. I was personally able to test on five          */
  71. X/* different cpu/UNIX combinations.                                           */
  72. X/*                                                                            */
  73. X/*                                                                            */
  74. X/* COMPILE                                                                    */
  75. X/*                                                                            */
  76. X/* usually this:                                                              */
  77. X/*                                                                            */
  78. X/* cc -O asciixmas.c -lcurses -o asciixmas -s                                 */
  79. X/*                                                                            */
  80. X/*                                                                            */
  81. X/* Zilog S8000 models 11, 21, 31, etc with ZEUS variant of SYSTEM III         */
  82. X/* maybe other SYSTEM III also:                                               */
  83. X/*                                                                            */
  84. X/* cc asciixmas.c -lcurses -ltermlib -o asciixmas -s                          */
  85. X/*                                                                            */
  86. X/* as above with optional "peephole optimizer" installed:                     */
  87. X/*                                                                            */
  88. X/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
  89. X/*                                                                            */
  90. X/*                                                                            */
  91. X/* Zilog S8000 models 32, 130 with WE32100 chip and SYS V, REL2               */
  92. X/* maybe 3B2 also?                                                            */
  93. X/*                                                                            */
  94. X/* cc -f -O -K sd asciixmas.c -lcurses -o asciixmas -s                        */
  95. X/*                                                                            */
  96. X/*                                                                            */
  97. X/* Pyramid, Sequent, any other "dual universe" types compile and execute      */
  98. X/* under either universe. The compile line for the ucb universe (as you       */
  99. X/* might expect) is the same as for SYS III UNIX:                             */
  100. X/*                                                                            */
  101. X/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
  102. X/*                                                                            */
  103. X/* The above compile will also hold true for other BSD systems. (I hope)      */
  104. X/*                                                                            */
  105. X/*                                                                            */
  106. X/*                                                                            */
  107. X/*                                                                            */
  108. X/* For the Scrooges out there among you who don't want this thing to loop     */
  109. X/* forever (or until the user hits DEL), insert this into your compile        */
  110. X/* line just after "cc" :                                                     */
  111. X/*                                                                            */
  112. X/* -DNOLOOP                                                                   */
  113. X/*                                                                            */
  114. X/* like so:                                                                   */
  115. X/*                                                                            */
  116. X/* cc -DNOLOOP -O asciixmas.c -lcurses -o asciixmas -s                        */
  117. X/*                                                                            */
  118. X/*                                                                            */
  119. X/*                                                                            */
  120. X/******************************************************************************/
  121. X
  122. X#include <curses.h>
  123. X#include <signal.h>
  124. X
  125. X#define FROMWHO "Mark Hessling - (M.Hessling@itc.gu.edu.au)"
  126. X
  127. Xint y_pos, x_pos;
  128. X
  129. XWINDOW
  130. X       *treescrn, *treescrn2,*treescrn3, *treescrn4,*treescrn5, *treescrn6,
  131. X       *treescrn7, *treescrn8,
  132. X       *dotdeer0,
  133. X       *stardeer0,
  134. X       *lildeer0, *lildeer1, *lildeer2, *lildeer3,
  135. X       *middeer0, *middeer1, *middeer2, *middeer3,
  136. X       *bigdeer0, *bigdeer1, *bigdeer2, *bigdeer3, *bigdeer4,
  137. X       *lookdeer0, *lookdeer1, *lookdeer2, *lookdeer3, *lookdeer4,
  138. X       *w_holiday,
  139. X       *w_del_msg;
  140. X
  141. Xvoid main()
  142. X{
  143. X void done();
  144. X int loopy;
  145. X
  146. X  initscr();
  147. X  noecho();
  148. X  nonl();
  149. X  refresh();
  150. X  signal(SIGINT,done);
  151. X  signal(SIGTERM,done);
  152. X#if !defined    DOS && !defined OS2
  153. X  signal(SIGHUP,done);
  154. X  signal(SIGQUIT,done);
  155. X#endif
  156. X
  157. X
  158. X
  159. X  treescrn = newwin(16,27,3,53);
  160. X  treescrn2 = newwin(16,27,3,53);
  161. X  treescrn3 = newwin(16,27,3,53);
  162. X  treescrn4 = newwin(16,27,3,53);
  163. X  treescrn5 = newwin(16,27,3,53);
  164. X  treescrn6 = newwin(16,27,3,53);
  165. X  treescrn7 = newwin(16,27,3,53);
  166. X  treescrn8 = newwin(16,27,3,53);
  167. X
  168. X  dotdeer0 = newwin(3,71,0,8);
  169. X
  170. X  stardeer0 = newwin(4,56,0,8);
  171. X
  172. X  lildeer0 = newwin(7,53,0,8);
  173. X  lildeer1 = newwin(2,4,0,0);
  174. X  lildeer2 = newwin(2,4,0,0);
  175. X  lildeer3 = newwin(2,4,0,0);
  176. X
  177. X  middeer0 = newwin(15,42,0,8);
  178. X  middeer1 = newwin(3,7,0,0);
  179. X  middeer2 = newwin(3,7,0,0);
  180. X  middeer3 = newwin(3,7,0,0);
  181. X
  182. X  bigdeer0 = newwin(10,23,0,0);
  183. X  bigdeer1 = newwin(10,23,0,0);
  184. X  bigdeer2 = newwin(10,23,0,0);
  185. X  bigdeer3 = newwin(10,23,0,0);
  186. X  bigdeer4 = newwin(10,23,0,0);
  187. X
  188. X  lookdeer0 = newwin(10,25,0,0);
  189. X  lookdeer1 = newwin(10,25,0,0);
  190. X  lookdeer2 = newwin(10,25,0,0);
  191. X  lookdeer3 = newwin(10,25,0,0);
  192. X  lookdeer4 = newwin(10,25,0,0);
  193. X
  194. X  w_holiday = newwin(1,26,3,27);
  195. X
  196. X  w_del_msg = newwin(1,12,23,68);
  197. X
  198. X  mvwaddstr(w_del_msg,0,0,"DEL to quit");
  199. X
  200. X  mvwaddstr(w_holiday,0,0,"H A P P Y  H O L I D A Y S");
  201. X
  202. X  /* set up the windows for our various reindeer */
  203. X
  204. X  /* lildeer1 */
  205. X  mvwaddch(lildeer1,0,0,(chtype)'V');
  206. X  mvwaddch(lildeer1,1,0,(chtype)'@');
  207. X  mvwaddch(lildeer1,1,1,(chtype)'<');
  208. X  mvwaddch(lildeer1,1,2,(chtype)'>');
  209. X  mvwaddch(lildeer1,1,3,(chtype)'~');
  210. X
  211. X  /* lildeer2 */
  212. X  mvwaddch(lildeer2,0,0,(chtype)'V');
  213. X  mvwaddch(lildeer2,1,0,(chtype)'@');
  214. X  mvwaddch(lildeer2,1,1,(chtype)'|');
  215. X  mvwaddch(lildeer2,1,2,(chtype)'|');
  216. X  mvwaddch(lildeer2,1,3,(chtype)'~');
  217. X
  218. X  /* lildeer3 */
  219. X  mvwaddch(lildeer3,0,0,(chtype)'V');
  220. X  mvwaddch(lildeer3,1,0,(chtype)'@');
  221. X  mvwaddch(lildeer3,1,1,(chtype)'>');
  222. X  mvwaddch(lildeer3,1,2,(chtype)'<');
  223. X  mvwaddch(lildeer2,1,3,(chtype)'~');
  224. X
  225. X
  226. X  /* middeer1 */
  227. X  mvwaddch(middeer1,0,2,(chtype)'y');
  228. X  mvwaddch(middeer1,0,3,(chtype)'y');
  229. X  mvwaddch(middeer1,1,2,(chtype)'0');
  230. X  mvwaddch(middeer1,1,3,(chtype)'(');
  231. X  mvwaddch(middeer1,1,4,(chtype)'=');
  232. X  mvwaddch(middeer1,1,5,(chtype)')');
  233. X  mvwaddch(middeer1,1,6,(chtype)'~');
  234. X  mvwaddch(middeer1,2,3,(chtype)'\\');
  235. X  mvwaddch(middeer1,2,4,(chtype)'/');
  236. X
  237. X  /* middeer2 */
  238. X  mvwaddch(middeer2,0,2,(chtype)'y');
  239. X  mvwaddch(middeer2,0,3,(chtype)'y');
  240. X  mvwaddch(middeer2,1,2,(chtype)'0');
  241. X  mvwaddch(middeer2,1,3,(chtype)'(');
  242. X  mvwaddch(middeer2,1,4,(chtype)'=');
  243. X  mvwaddch(middeer2,1,5,(chtype)')');
  244. X  mvwaddch(middeer2,1,6,(chtype)'~');
  245. X  mvwaddch(middeer2,2,3,(chtype)'|');
  246. X  mvwaddch(middeer2,2,5,(chtype)'|');
  247. X
  248. X  /* middeer3 */
  249. X  mvwaddch(middeer3,0,2,(chtype)'y');
  250. X  mvwaddch(middeer3,0,3,(chtype)'y');
  251. X  mvwaddch(middeer3,1,2,(chtype)'0');
  252. X  mvwaddch(middeer3,1,3,(chtype)'(');
  253. X  mvwaddch(middeer3,1,4,(chtype)'=');
  254. X  mvwaddch(middeer3,1,5,(chtype)')');
  255. X  mvwaddch(middeer3,1,6,(chtype)'~');
  256. X  mvwaddch(middeer3,2,2,(chtype)'/');
  257. X  mvwaddch(middeer3,2,6,(chtype)'\\');
  258. X
  259. X
  260. X  /* bigdeer1 */
  261. X  mvwaddch(bigdeer1,0,17,(chtype)'\\');
  262. X  mvwaddch(bigdeer1,0,18,(chtype)'/');
  263. X  mvwaddch(bigdeer1,0,20,(chtype)'\\');
  264. X  mvwaddch(bigdeer1,0,21,(chtype)'/');
  265. X  mvwaddch(bigdeer1,1,18,(chtype)'\\');
  266. X  mvwaddch(bigdeer1,1,20,(chtype)'/');
  267. X  mvwaddch(bigdeer1,2,19,(chtype)'|');
  268. X  mvwaddch(bigdeer1,2,20,(chtype)'_');
  269. X  mvwaddch(bigdeer1,3,18,(chtype)'/');
  270. X  mvwaddch(bigdeer1,3,19,(chtype)'^');
  271. X  mvwaddch(bigdeer1,3,20,(chtype)'0');
  272. X  mvwaddch(bigdeer1,3,21,(chtype)'\\');
  273. X  mvwaddch(bigdeer1,4,17,(chtype)'/');
  274. X  mvwaddch(bigdeer1,4,18,(chtype)'/');
  275. X  mvwaddch(bigdeer1,4,19,(chtype)'\\');
  276. X  mvwaddch(bigdeer1,4,22,(chtype)'\\');
  277. X  mvwaddstr(bigdeer1,5,7,"^~~~~~~~~//  ~~U");
  278. X  mvwaddstr(bigdeer1,6,7,"( \\_____( /");
  279. X  mvwaddstr(bigdeer1,7,8,"( )    /");
  280. X  mvwaddstr(bigdeer1,8,9,"\\\\   /");
  281. X  mvwaddstr(bigdeer1,9,11,"\\>/>");
  282. X
  283. X  /* bigdeer2 */
  284. X  mvwaddch(bigdeer2,0,17,(chtype)'\\');
  285. X  mvwaddch(bigdeer2,0,18,(chtype)'/');
  286. X  mvwaddch(bigdeer2,0,20,(chtype)'\\');
  287. X  mvwaddch(bigdeer2,0,21,(chtype)'/');
  288. X  mvwaddch(bigdeer2,1,18,(chtype)'\\');
  289. X  mvwaddch(bigdeer2,1,20,(chtype)'/');
  290. X  mvwaddch(bigdeer2,2,19,(chtype)'|');
  291. X  mvwaddch(bigdeer2,2,20,(chtype)'_');
  292. X  mvwaddch(bigdeer2,3,18,(chtype)'/');
  293. X  mvwaddch(bigdeer2,3,19,(chtype)'^');
  294. X  mvwaddch(bigdeer2,3,20,(chtype)'0');
  295. X  mvwaddch(bigdeer2,3,21,(chtype)'\\');
  296. X  mvwaddch(bigdeer2,4,17,(chtype)'/');
  297. X  mvwaddch(bigdeer2,4,18,(chtype)'/');
  298. X  mvwaddch(bigdeer2,4,19,(chtype)'\\');
  299. X  mvwaddch(bigdeer2,4,22,(chtype)'\\');
  300. X  mvwaddstr(bigdeer2,5,7,"^~~~~~~~~//  ~~U");
  301. X  mvwaddstr(bigdeer2,6,7,"(( )____( /");
  302. X  mvwaddstr(bigdeer2,7,7,"( /      |");
  303. X  mvwaddstr(bigdeer2,8,8,"\\/      |");
  304. X  mvwaddstr(bigdeer2,9,9,"|>     |>");
  305. X
  306. X  /* bigdeer3 */
  307. X  mvwaddch(bigdeer3,0,17,(chtype)'\\');
  308. X  mvwaddch(bigdeer3,0,18,(chtype)'/');
  309. X  mvwaddch(bigdeer3,0,20,(chtype)'\\');
  310. X  mvwaddch(bigdeer3,0,21,(chtype)'/');
  311. X  mvwaddch(bigdeer3,1,18,(chtype)'\\');
  312. X  mvwaddch(bigdeer3,1,20,(chtype)'/');
  313. X  mvwaddch(bigdeer3,2,19,(chtype)'|');
  314. X  mvwaddch(bigdeer3,2,20,(chtype)'_');
  315. X  mvwaddch(bigdeer3,3,18,(chtype)'/');
  316. X  mvwaddch(bigdeer3,3,19,(chtype)'^');
  317. X  mvwaddch(bigdeer3,3,20,(chtype)'0');
  318. X  mvwaddch(bigdeer3,3,21,(chtype)'\\');
  319. X  mvwaddch(bigdeer3,4,17,(chtype)'/');
  320. X  mvwaddch(bigdeer3,4,18,(chtype)'/');
  321. X  mvwaddch(bigdeer3,4,19,(chtype)'\\');
  322. X  mvwaddch(bigdeer3,4,22,(chtype)'\\');
  323. X  mvwaddstr(bigdeer3,5,7,"^~~~~~~~~//  ~~U");
  324. X  mvwaddstr(bigdeer3,6,6,"( ()_____( /");
  325. X  mvwaddstr(bigdeer3,7,6,"/ /       /");
  326. X  mvwaddstr(bigdeer3,8,5,"|/          \\");
  327. X  mvwaddstr(bigdeer3,9,5,"/>           \\>");
  328. X
  329. X  /* bigdeer4 */
  330. X  mvwaddch(bigdeer4,0,17,(chtype)'\\');
  331. X  mvwaddch(bigdeer4,0,18,(chtype)'/');
  332. X  mvwaddch(bigdeer4,0,20,(chtype)'\\');
  333. X  mvwaddch(bigdeer4,0,21,(chtype)'/');
  334. X  mvwaddch(bigdeer4,1,18,(chtype)'\\');
  335. X  mvwaddch(bigdeer4,1,20,(chtype)'/');
  336. X  mvwaddch(bigdeer4,2,19,(chtype)'|');
  337. X  mvwaddch(bigdeer4,2,20,(chtype)'_');
  338. X  mvwaddch(bigdeer4,3,18,(chtype)'/');
  339. X  mvwaddch(bigdeer4,3,19,(chtype)'^');
  340. X  mvwaddch(bigdeer4,3,20,(chtype)'0');
  341. X  mvwaddch(bigdeer4,3,21,(chtype)'\\');
  342. X  mvwaddch(bigdeer4,4,17,(chtype)'/');
  343. X  mvwaddch(bigdeer4,4,18,(chtype)'/');
  344. X  mvwaddch(bigdeer4,4,19,(chtype)'\\');
  345. X  mvwaddch(bigdeer4,4,22,(chtype)'\\');
  346. X  mvwaddstr(bigdeer4,5,7,"^~~~~~~~~//  ~~U");
  347. X  mvwaddstr(bigdeer4,6,6,"( )______( /");
  348. X  mvwaddstr(bigdeer4,7,5,"(/          \\");
  349. X  mvwaddstr(bigdeer4,8,0,"v___=             ----^");
  350. X
  351. X
  352. X  /* lookdeer1 */
  353. X  mvwaddstr(lookdeer1,0,16,"\\/     \\/");
  354. X  mvwaddstr(lookdeer1,1,17,"\\Y/ \\Y/");
  355. X  mvwaddstr(lookdeer1,2,19,"\\=/");
  356. X  mvwaddstr(lookdeer1,3,17,"^\\o o/^");
  357. X  mvwaddstr(lookdeer1,4,17,"//( )");
  358. X  mvwaddstr(lookdeer1,5,7,"^~~~~~~~~// \\O/");
  359. X  mvwaddstr(lookdeer1,6,7,"( \\_____( /");
  360. X  mvwaddstr(lookdeer1,7,8,"( )    /");
  361. X  mvwaddstr(lookdeer1,8,9,"\\\\   /");
  362. X  mvwaddstr(lookdeer1,9,11,"\\>/>");
  363. X
  364. X  /* lookdeer2 */
  365. X  mvwaddstr(lookdeer2,0,16,"\\/     \\/");
  366. X  mvwaddstr(lookdeer2,1,17,"\\Y/ \\Y/");
  367. X  mvwaddstr(lookdeer2,2,19,"\\=/");
  368. X  mvwaddstr(lookdeer2,3,17,"^\\o o/^");
  369. X  mvwaddstr(lookdeer2,4,17,"//( )");
  370. X  mvwaddstr(lookdeer2,5,7,"^~~~~~~~~// \\O/");
  371. X  mvwaddstr(lookdeer2,6,7,"(( )____( /");
  372. X  mvwaddstr(lookdeer2,7,7,"( /      |");
  373. X  mvwaddstr(lookdeer2,8,8,"\\/      |");
  374. X  mvwaddstr(lookdeer2,9,9,"|>     |>");
  375. X
  376. X  /* lookdeer3 */
  377. X  mvwaddstr(lookdeer3,0,16,"\\/     \\/");
  378. X  mvwaddstr(lookdeer3,1,17,"\\Y/ \\Y/");
  379. X  mvwaddstr(lookdeer3,2,19,"\\=/");
  380. X  mvwaddstr(lookdeer3,3,17,"^\\o o/^");
  381. X  mvwaddstr(lookdeer3,4,17,"//( )");
  382. X  mvwaddstr(lookdeer3,5,7,"^~~~~~~~~// \\O/");
  383. X  mvwaddstr(lookdeer3,6,6,"( ()_____( /");
  384. X  mvwaddstr(lookdeer3,7,6,"/ /       /");
  385. X  mvwaddstr(lookdeer3,8,5,"|/          \\");
  386. X  mvwaddstr(lookdeer3,9,5,"/>           \\>");
  387. X
  388. X  /* lookdeer4 */
  389. X  mvwaddstr(lookdeer4,0,16,"\\/     \\/");
  390. X  mvwaddstr(lookdeer4,1,17,"\\Y/ \\Y/");
  391. X  mvwaddstr(lookdeer4,2,19,"\\=/");
  392. X  mvwaddstr(lookdeer4,3,17,"^\\o o/^");
  393. X  mvwaddstr(lookdeer4,4,17,"//( )");
  394. X  mvwaddstr(lookdeer4,5,7,"^~~~~~~~~// \\O/");
  395. X  mvwaddstr(lookdeer4,6,6,"( )______( /");
  396. X  mvwaddstr(lookdeer4,7,5,"(/          \\");
  397. X  mvwaddstr(lookdeer4,8,0,"v___=             ----^");
  398. X
  399. X
  400. X
  401. X  /***********************************************/
  402. X
  403. X  do
  404. X  {
  405. X    clear();
  406. X    werase(treescrn);
  407. X    touchwin(treescrn);
  408. X    werase(treescrn2);
  409. X    touchwin(treescrn2);
  410. X    werase(treescrn8);
  411. X    touchwin(treescrn8);
  412. X    refresh();
  413. X    delay_output(1000);
  414. X    boxit();
  415. X    del_msg();
  416. X    delay_output(1000);
  417. X    seas();
  418. X    del_msg();
  419. X    delay_output(1000);
  420. X    greet();
  421. X    del_msg();
  422. X    delay_output(1000);
  423. X    fromwho();
  424. X    del_msg();
  425. X    delay_output(1000);
  426. X    tree();
  427. X    delay_output(1000);
  428. X    balls();
  429. X    delay_output(1000);
  430. X    star();
  431. X    delay_output(1000);
  432. X    strng1();
  433. X    strng2();
  434. X    strng3();
  435. X    strng4();
  436. X    strng5();
  437. X
  438. X
  439. X  /* set up the windows for our blinking trees */
  440. X  /* **************************************** */
  441. X  /* treescrn3 */
  442. X
  443. X               overlay(treescrn, treescrn3);
  444. X
  445. X             /*balls*/
  446. X               mvwaddch(treescrn3, 4, 18, ' ');
  447. X               mvwaddch(treescrn3, 7, 6, ' ');
  448. X               mvwaddch(treescrn3, 8, 19, ' ');
  449. X               mvwaddch(treescrn3, 11, 22, ' ');
  450. X
  451. X             /*star*/
  452. X               mvwaddch(treescrn3, 0, 12, '*');
  453. X
  454. X             /*strng1*/
  455. X               mvwaddch(treescrn3, 3, 11, ' ');
  456. X
  457. X             /*strng2*/
  458. X               mvwaddch(treescrn3, 5, 13, ' ');
  459. X               mvwaddch(treescrn3, 6, 10, ' ');
  460. X
  461. X             /*strng3*/
  462. X               mvwaddch(treescrn3, 7, 16, ' ');
  463. X               mvwaddch(treescrn3, 7, 14, ' ');
  464. X
  465. X             /*strng4*/
  466. X               mvwaddch(treescrn3, 10, 13, ' ');
  467. X               mvwaddch(treescrn3, 10, 10, ' ');
  468. X               mvwaddch(treescrn3, 11, 8, ' ');
  469. X
  470. X             /*strng5*/
  471. X               mvwaddch(treescrn3, 11, 18, ' ');
  472. X               mvwaddch(treescrn3, 12, 13, ' ');
  473. X
  474. X
  475. X  /* treescrn4 */
  476. X
  477. X               overlay(treescrn, treescrn4);
  478. X
  479. X             /*balls*/
  480. X               mvwaddch(treescrn4, 3, 9, ' ');
  481. X               mvwaddch(treescrn4, 4, 16, ' ');
  482. X               mvwaddch(treescrn4, 7, 6, ' ');
  483. X               mvwaddch(treescrn4, 8, 19, ' ');
  484. X               mvwaddch(treescrn4, 11, 2, ' ');
  485. X               mvwaddch(treescrn4, 12, 23, ' ');
  486. X
  487. X             /*star*/
  488. X               wstandout(treescrn4);
  489. X               mvwaddch(treescrn4, 0, 12, '*');
  490. X               wstandend(treescrn4);
  491. X
  492. X             /*strng1*/
  493. X               mvwaddch(treescrn4, 3, 13, ' ');
  494. X
  495. X             /*strng2*/
  496. X
  497. X         /*strng3*/
  498. X               mvwaddch(treescrn4, 7, 15, ' ');
  499. X               mvwaddch(treescrn4, 8, 11, ' ');
  500. X
  501. X             /*strng4*/
  502. X               mvwaddch(treescrn4, 9, 16, ' ');
  503. X               mvwaddch(treescrn4, 10, 12, ' ');
  504. X               mvwaddch(treescrn4, 11, 8, ' ');
  505. X
  506. X             /*strng5*/
  507. X               mvwaddch(treescrn4, 11, 18, ' ');
  508. X           mvwaddch(treescrn4, 12, 14, ' ');
  509. X
  510. X
  511. X  /* treescrn5 */
  512. X
  513. X               overlay(treescrn, treescrn5);
  514. X
  515. X             /*balls*/
  516. X               mvwaddch(treescrn5, 3, 15, ' ');
  517. X               mvwaddch(treescrn5, 10, 20, ' ');
  518. X               mvwaddch(treescrn5, 12, 1, ' ');
  519. X
  520. X             /*star*/
  521. X               mvwaddch(treescrn5, 0, 12, '*');
  522. X
  523. X             /*strng1*/
  524. X               mvwaddch(treescrn5, 3, 11, ' ');
  525. X
  526. X             /*strng2*/
  527. X               mvwaddch(treescrn5, 5, 12, ' ');
  528. X
  529. X             /*strng3*/
  530. X           mvwaddch(treescrn5, 7, 14, ' ');
  531. X               mvwaddch(treescrn5, 8, 10, ' ');
  532. X
  533. X             /*strng4*/
  534. X               mvwaddch(treescrn5, 9, 15, ' ');
  535. X               mvwaddch(treescrn5, 10, 11, ' ');
  536. X               mvwaddch(treescrn5, 11, 7, ' ');
  537. X
  538. X             /*strng5*/
  539. X               mvwaddch(treescrn5, 11, 17, ' ');
  540. X               mvwaddch(treescrn5, 12, 13, ' ');
  541. X
  542. X  /* treescrn6 */
  543. X
  544. X               overlay(treescrn, treescrn6);
  545. X
  546. X             /*balls*/
  547. X               mvwaddch(treescrn6, 6, 7, ' ');
  548. X               mvwaddch(treescrn6, 7, 18, ' ');
  549. X               mvwaddch(treescrn6, 10, 4, ' ');
  550. X               mvwaddch(treescrn6, 11, 23, ' ');
  551. X
  552. X         /*star*/
  553. X               wstandout(treescrn6);
  554. X               mvwaddch(treescrn6, 0, 12, '*');
  555. X               wstandend(treescrn6);
  556. X
  557. X             /*strng1*/
  558. X
  559. X             /*strng2*/
  560. X               mvwaddch(treescrn6, 5, 11, ' ');
  561. X
  562. X             /*strng3*/
  563. X           mvwaddch(treescrn6, 7, 13, ' ');
  564. X               mvwaddch(treescrn6, 8, 9, ' ');
  565. X
  566. X             /*strng4*/
  567. X               mvwaddch(treescrn6, 9, 14, ' ');
  568. X               mvwaddch(treescrn6, 10, 10, ' ');
  569. X               mvwaddch(treescrn6, 11, 6, ' ');
  570. X
  571. X             /*strng5*/
  572. X               mvwaddch(treescrn6, 11, 16, ' ');
  573. X               mvwaddch(treescrn6, 12, 12, ' ');
  574. X
  575. X  /* treescrn7 */
  576. X
  577. X               overlay(treescrn, treescrn7);
  578. X
  579. X             /*balls*/
  580. X               mvwaddch(treescrn7, 3, 15, ' ');
  581. X               mvwaddch(treescrn7, 6, 7, ' ');
  582. X               mvwaddch(treescrn7, 7, 18, ' ');
  583. X               mvwaddch(treescrn7, 10, 4, ' ');
  584. X               mvwaddch(treescrn7, 11, 22, ' ');
  585. X
  586. X             /*star*/
  587. X               mvwaddch(treescrn7, 0, 12, '*');
  588. X
  589. X             /*strng1*/
  590. X               mvwaddch(treescrn7, 3, 12, ' ');
  591. X
  592. X             /*strng2*/
  593. X               mvwaddch(treescrn7, 5, 13, ' ');
  594. X               mvwaddch(treescrn7, 6, 9, ' ');
  595. X
  596. X         /*strng3*/
  597. X               mvwaddch(treescrn7, 7, 15, ' ');
  598. X               mvwaddch(treescrn7, 8, 11, ' ');
  599. X
  600. X             /*strng4*/
  601. X               mvwaddch(treescrn7, 9, 16, ' ');
  602. X               mvwaddch(treescrn7, 10, 12, ' ');
  603. X               mvwaddch(treescrn7, 11, 8, ' ');
  604. X
  605. X             /*strng5*/
  606. X               mvwaddch(treescrn7, 11, 18, ' ');
  607. X           mvwaddch(treescrn7, 12, 14, ' ');
  608. X
  609. X
  610. X    delay_output(1000);
  611. X    reindeer();
  612. X
  613. X    touchwin(w_holiday);
  614. X    wrefresh(w_holiday);
  615. X    wrefresh(w_del_msg);
  616. X
  617. X    delay_output(1000);
  618. X    for(loopy = 0;loopy < 100;loopy++)
  619. X    {
  620. X      blinkit();
  621. X    }
  622. X
  623. X#ifdef NOLOOP
  624. X    done();
  625. X#endif
  626. X
  627. X  }
  628. X  while(!typeahead(stdin));
  629. X}
  630. X
  631. Xboxit()
  632. X{
  633. X int x = 0;
  634. X
  635. X  while(x < 20)
  636. X  {
  637. X    mvaddch(x, 7, '|');
  638. X    ++x;
  639. X  }
  640. X
  641. X  x = 8;
  642. X
  643. X  while(x < 80)
  644. X  {
  645. X    mvaddch(19, x, '_');
  646. X    ++x;
  647. X  }
  648. X
  649. X  x = 0;
  650. X
  651. X  while(x < 80)
  652. X  {
  653. X    mvaddch(22, x, '_');
  654. X    ++x;
  655. X  }
  656. X
  657. X  return( 0 );
  658. X}
  659. X
  660. Xseas()
  661. X{
  662. X  mvaddch(4, 1, 'S');
  663. X  mvaddch(6, 1, 'E');
  664. X  mvaddch(8, 1, 'A');
  665. X  mvaddch(10, 1, 'S');
  666. X  mvaddch(12, 1, 'O');
  667. X  mvaddch(14, 1, 'N');
  668. X  mvaddch(16, 1, '`');
  669. X  mvaddch(18, 1, 'S');
  670. X
  671. X  return( 0 );
  672. X}
  673. X
  674. X
  675. Xgreet()
  676. X{
  677. X  mvaddch(3, 5, 'G');
  678. X  mvaddch(5, 5, 'R');
  679. X  mvaddch(7, 5, 'E');
  680. X  mvaddch(9, 5, 'E');
  681. X  mvaddch(11, 5, 'T');
  682. X  mvaddch(13, 5, 'I');
  683. X  mvaddch(15, 5, 'N');
  684. X  mvaddch(17, 5, 'G');
  685. X  mvaddch(19, 5, 'S');
  686. X
  687. X  return( 0 );
  688. X}
  689. X
  690. X
  691. Xfromwho()
  692. X{
  693. X  mvaddstr(21, 13, FROMWHO);
  694. X  return( 0 );
  695. X}
  696. X
  697. X
  698. Xdel_msg()
  699. X{
  700. X  mvaddstr(23, 68, "DEL to quit");
  701. X
  702. X  refresh();
  703. X
  704. X  return( 0 );
  705. X}
  706. X
  707. X
  708. Xtree()
  709. X{
  710. X  mvwaddch(treescrn, 1, 11, (chtype)'/');
  711. X  mvwaddch(treescrn, 2, 11, (chtype)'/');
  712. X  mvwaddch(treescrn, 3, 10, (chtype)'/');
  713. X  mvwaddch(treescrn, 4, 9, (chtype)'/');
  714. X  mvwaddch(treescrn, 5, 9, (chtype)'/');
  715. X  mvwaddch(treescrn, 6, 8, (chtype)'/');
  716. X  mvwaddch(treescrn, 7, 7, (chtype)'/');
  717. X  mvwaddch(treescrn, 8, 6, (chtype)'/');
  718. X  mvwaddch(treescrn, 9, 6, (chtype)'/');
  719. X  mvwaddch(treescrn, 10, 5, (chtype)'/');
  720. X  mvwaddch(treescrn, 11, 3, (chtype)'/');
  721. X  mvwaddch(treescrn, 12, 2, (chtype)'/');
  722. X
  723. X  mvwaddch(treescrn, 1, 13, (chtype)'\\');
  724. X  mvwaddch(treescrn, 2, 13, (chtype)'\\');
  725. X  mvwaddch(treescrn, 3, 14, (chtype)'\\');
  726. X  mvwaddch(treescrn, 4, 15, (chtype)'\\');
  727. X  mvwaddch(treescrn, 5, 15, (chtype)'\\');
  728. X  mvwaddch(treescrn, 6, 16, (chtype)'\\');
  729. X  mvwaddch(treescrn, 7, 17, (chtype)'\\');
  730. X  mvwaddch(treescrn, 8, 18, (chtype)'\\');
  731. X  mvwaddch(treescrn, 9, 18, (chtype)'\\');
  732. X  mvwaddch(treescrn, 10, 19, (chtype)'\\');
  733. X  mvwaddch(treescrn, 11, 21, (chtype)'\\');
  734. X  mvwaddch(treescrn, 12, 22, (chtype)'\\');
  735. X
  736. X  mvwaddch(treescrn, 4, 10, (chtype)'_');
  737. X  mvwaddch(treescrn, 4, 14, (chtype)'_');
  738. X  mvwaddch(treescrn, 8, 7, (chtype)'_');
  739. X  mvwaddch(treescrn, 8, 17, (chtype)'_');
  740. X
  741. X  mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");
  742. X
  743. X  mvwaddstr(treescrn, 14, 11, "| |");
  744. X  mvwaddstr(treescrn, 15, 11, "|_|");
  745. X
  746. X  wrefresh(treescrn);
  747. X  wrefresh(w_del_msg);
  748. X
  749. X  return( 0 );
  750. X}
  751. X
  752. X
  753. Xballs()
  754. X{
  755. X
  756. X  overlay(treescrn, treescrn2);
  757. X
  758. X  mvwaddch(treescrn2, 3, 9, (chtype)'@');
  759. X  mvwaddch(treescrn2, 3, 15, (chtype)'@');
  760. X  mvwaddch(treescrn2, 4, 8, (chtype)'@');
  761. X  mvwaddch(treescrn2, 4, 16, (chtype)'@');
  762. X  mvwaddch(treescrn2, 5, 7, (chtype)'@');
  763. X  mvwaddch(treescrn2, 5, 17, (chtype)'@');
  764. X  mvwaddch(treescrn2, 7, 6, (chtype)'@');
  765. X  mvwaddch(treescrn2, 7, 18, (chtype)'@');
  766. X  mvwaddch(treescrn2, 8, 5, (chtype)'@');
  767. X  mvwaddch(treescrn2, 8, 19, (chtype)'@');
  768. X  mvwaddch(treescrn2, 10, 4, (chtype)'@');
  769. X  mvwaddch(treescrn2, 10, 20, (chtype)'@');
  770. X  mvwaddch(treescrn2, 11, 2, (chtype)'@');
  771. X  mvwaddch(treescrn2, 11, 22, (chtype)'@');
  772. X  mvwaddch(treescrn2, 12, 1, (chtype)'@');
  773. X  mvwaddch(treescrn2, 12, 23, (chtype)'@');
  774. X
  775. X  wrefresh(treescrn2);
  776. X  wrefresh(w_del_msg);
  777. X  return( 0 );
  778. X}
  779. X
  780. X
  781. Xstar()
  782. X{
  783. X  wstandout(treescrn2);
  784. X  mvwaddch(treescrn2, 0, 12, (chtype)'*');
  785. X  wstandend(treescrn2);
  786. X
  787. X  wrefresh(treescrn2);
  788. X  wrefresh(w_del_msg);
  789. X  return( 0 );
  790. X}
  791. X
  792. X
  793. Xstrng1()
  794. X{
  795. X  mvwaddch(treescrn2, 3, 13, (chtype)'\'');
  796. X  mvwaddch(treescrn2, 3, 12, (chtype)':');
  797. X  mvwaddch(treescrn2, 3, 11, (chtype)'.');
  798. X
  799. X  wrefresh(treescrn2);
  800. X  wrefresh(w_del_msg);
  801. X  return( 0 );
  802. X}
  803. X
  804. X
  805. Xstrng2()
  806. X{
  807. X  mvwaddch(treescrn2, 5, 14, (chtype)'\'');
  808. X  mvwaddch(treescrn2, 5, 13, (chtype)':');
  809. X  mvwaddch(treescrn2, 5, 12, (chtype)'.');
  810. X  mvwaddch(treescrn2, 5, 11, (chtype)',');
  811. X  mvwaddch(treescrn2, 6, 10, (chtype)'\'');
  812. X  mvwaddch(treescrn2, 6, 9, (chtype)':');
  813. X
  814. X  wrefresh(treescrn2);
  815. X  wrefresh(w_del_msg);
  816. X  return( 0 );
  817. X}
  818. X
  819. X
  820. Xstrng3()
  821. X{
  822. X  mvwaddch(treescrn2, 7, 16, (chtype)'\'');
  823. X  mvwaddch(treescrn2, 7, 15, (chtype)':');
  824. X  mvwaddch(treescrn2, 7, 14, (chtype)'.');
  825. X  mvwaddch(treescrn2, 7, 13, (chtype)',');
  826. X  mvwaddch(treescrn2, 8, 12, (chtype)'\'');
  827. X  mvwaddch(treescrn2, 8, 11, (chtype)':');
  828. X  mvwaddch(treescrn2, 8, 10, (chtype)'.');
  829. X  mvwaddch(treescrn2, 8, 9, (chtype)',');
  830. X
  831. X  wrefresh(treescrn2);
  832. X  wrefresh(w_del_msg);
  833. X  return( 0 );
  834. X}
  835. X
  836. X
  837. Xstrng4()
  838. X{
  839. X  mvwaddch(treescrn2, 9, 17, (chtype)'\'');
  840. X  mvwaddch(treescrn2, 9, 16, (chtype)':');
  841. X  mvwaddch(treescrn2, 9, 15, (chtype)'.');
  842. X  mvwaddch(treescrn2, 9, 14, (chtype)',');
  843. X  mvwaddch(treescrn2, 10, 13, (chtype)'\'');
  844. X  mvwaddch(treescrn2, 10, 12, (chtype)':');
  845. X  mvwaddch(treescrn2, 10, 11, (chtype)'.');
  846. X  mvwaddch(treescrn2, 10, 10, (chtype)',');
  847. X  mvwaddch(treescrn2, 11, 9, (chtype)'\'');
  848. X  mvwaddch(treescrn2, 11, 8, (chtype)':');
  849. X  mvwaddch(treescrn2, 11, 7, (chtype)'.');
  850. X  mvwaddch(treescrn2, 11, 6, (chtype)',');
  851. X  mvwaddch(treescrn2, 12, 5, (chtype)'\'');
  852. X
  853. X  wrefresh(treescrn2);
  854. X  wrefresh(w_del_msg);
  855. X  return( 0 );
  856. X}
  857. X
  858. X
  859. Xstrng5()
  860. X{
  861. X  mvwaddch(treescrn2, 11, 19, (chtype)'\'');
  862. X  mvwaddch(treescrn2, 11, 18, (chtype)':');
  863. X  mvwaddch(treescrn2, 11, 17, (chtype)'.');
  864. X  mvwaddch(treescrn2, 11, 16, (chtype)',');
  865. X  mvwaddch(treescrn2, 12, 15, (chtype)'\'');
  866. X  mvwaddch(treescrn2, 12, 14, (chtype)':');
  867. X  mvwaddch(treescrn2, 12, 13, (chtype)'.');
  868. X  mvwaddch(treescrn2, 12, 12, (chtype)',');
  869. X
  870. X  /* save a fully lit tree */
  871. X  overlay(treescrn2, treescrn);
  872. X
  873. X  wrefresh(treescrn2);
  874. X  wrefresh(w_del_msg);
  875. X  return( 0 );
  876. X}
  877. X
  878. X
  879. X
  880. Xblinkit()
  881. X{
  882. X static int cycle;
  883. X
  884. X  if(cycle > 4)
  885. X  {
  886. X    cycle = 0;
  887. X  }
  888. X
  889. X
  890. X  touchwin(treescrn8);
  891. X
  892. X  switch(cycle)
  893. X  {
  894. X
  895. X    case 0:
  896. X               overlay(treescrn3, treescrn8);
  897. X               wrefresh(treescrn8);
  898. X               wrefresh(w_del_msg);
  899. X
  900. X               break;
  901. X    case 1:
  902. X               overlay(treescrn4, treescrn8);
  903. X               wrefresh(treescrn8);
  904. X               wrefresh(w_del_msg);
  905. X
  906. X               break;
  907. X    case 2:
  908. X               overlay(treescrn5, treescrn8);
  909. X               wrefresh(treescrn8);
  910. X               wrefresh(w_del_msg);
  911. X
  912. X               break;
  913. X    case 3:
  914. X               overlay(treescrn6, treescrn8);
  915. X               wrefresh(treescrn8);
  916. X               wrefresh(w_del_msg);
  917. X
  918. X               break;
  919. X    case 4:
  920. X               overlay(treescrn7, treescrn8);
  921. X               wrefresh(treescrn8);
  922. X               wrefresh(w_del_msg);
  923. X
  924. X               break;
  925. X  }
  926. X
  927. X   touchwin(treescrn8);
  928. X
  929. X
  930. X
  931. X   /*ALL ON***************************************************/
  932. X
  933. X
  934. X   overlay(treescrn, treescrn8);
  935. X   wrefresh(treescrn8);
  936. X   wrefresh(w_del_msg);
  937. X
  938. X
  939. X  ++cycle;
  940. X  return( 0 );
  941. X}
  942. X
  943. X
  944. Xreindeer()
  945. X{
  946. X int looper;
  947. X
  948. X  y_pos = 0;
  949. X
  950. X
  951. X  for(x_pos = 70; x_pos > 62; x_pos--)
  952. X  {
  953. X    if(x_pos < 62)
  954. X    {
  955. X      y_pos = 1;
  956. X    }
  957. X    for(looper = 0; looper < 4; looper++)
  958. X    {
  959. X      mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'.');
  960. X      wrefresh(dotdeer0);
  961. X      wrefresh(w_del_msg);
  962. X      werase(dotdeer0);
  963. X      wrefresh(dotdeer0);
  964. X      wrefresh(w_del_msg);
  965. X    }
  966. X  }
  967. X
  968. X  y_pos = 2;
  969. X
  970. X  for(; x_pos > 50; x_pos--)
  971. X  {
  972. X
  973. X    for(looper = 0; looper < 4; looper++)
  974. X    {
  975. X
  976. X      if(x_pos < 56)
  977. X      {
  978. X        y_pos = 3;
  979. X
  980. X        mvwaddch(stardeer0, y_pos, x_pos, (chtype)'*');
  981. X        wrefresh(stardeer0);
  982. X        wrefresh(w_del_msg);
  983. X        werase(stardeer0);
  984. X        wrefresh(stardeer0);
  985. X        wrefresh(w_del_msg);
  986. X      }
  987. X      else
  988. X      {
  989. X        mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'*');
  990. X        wrefresh(dotdeer0);
  991. X        wrefresh(w_del_msg);
  992. X        werase(dotdeer0);
  993. X        wrefresh(dotdeer0);
  994. X        wrefresh(w_del_msg);
  995. X      }
  996. X    }
  997. X  }
  998. X
  999. X  x_pos = 58;
  1000. X
  1001. X  for(y_pos = 2; y_pos < 5; y_pos++)
  1002. X  {
  1003. X
  1004. X    touchwin(lildeer0);
  1005. X    wrefresh(lildeer0);
  1006. X    wrefresh(w_del_msg);
  1007. X
  1008. X    for(looper = 0; looper < 4; looper++)
  1009. X    {
  1010. X      mvwin(lildeer3, y_pos, x_pos);
  1011. X      wrefresh(lildeer3);
  1012. X      wrefresh(w_del_msg);
  1013. X
  1014. X      mvwin(lildeer2, y_pos, x_pos);
  1015. X      wrefresh(lildeer2);
  1016. X      wrefresh(w_del_msg);
  1017. X
  1018. X      mvwin(lildeer1, y_pos, x_pos);
  1019. X      wrefresh(lildeer1);
  1020. X      wrefresh(w_del_msg);
  1021. X
  1022. X      mvwin(lildeer2, y_pos, x_pos);
  1023. X      wrefresh(lildeer2);
  1024. X      wrefresh(w_del_msg);
  1025. X
  1026. X      mvwin(lildeer3, y_pos, x_pos);
  1027. X      wrefresh(lildeer3);
  1028. X      wrefresh(w_del_msg);
  1029. X
  1030. X      touchwin(lildeer0);
  1031. X      wrefresh(lildeer0);
  1032. X      wrefresh(w_del_msg);
  1033. X
  1034. X      x_pos -= 2;
  1035. X    }
  1036. X  }
  1037. X
  1038. X
  1039. X  x_pos = 35;
  1040. X
  1041. X  for(y_pos = 5; y_pos < 10; y_pos++)
  1042. X  {
  1043. X
  1044. X    touchwin(middeer0);
  1045. X    wrefresh(middeer0);
  1046. X    wrefresh(w_del_msg);
  1047. X
  1048. X    for(looper = 0; looper < 2; looper++)
  1049. X    {
  1050. X      mvwin(middeer3, y_pos, x_pos);
  1051. X      wrefresh(middeer3);
  1052. X      wrefresh(w_del_msg);
  1053. X
  1054. X      mvwin(middeer2, y_pos, x_pos);
  1055. X      wrefresh(middeer2);
  1056. X      wrefresh(w_del_msg);
  1057. X
  1058. X      mvwin(middeer1, y_pos, x_pos);
  1059. X      wrefresh(middeer1);
  1060. X      wrefresh(w_del_msg);
  1061. X
  1062. X      mvwin(middeer2, y_pos, x_pos);
  1063. X      wrefresh(middeer2);
  1064. X      wrefresh(w_del_msg);
  1065. X
  1066. X      mvwin(middeer3, y_pos, x_pos);
  1067. X      wrefresh(middeer3);
  1068. X      wrefresh(w_del_msg);
  1069. X
  1070. X      touchwin(middeer0);
  1071. X      wrefresh(middeer0);
  1072. X      wrefresh(w_del_msg);
  1073. X
  1074. X      x_pos -= 3;
  1075. X    }
  1076. X  }
  1077. X
  1078. X  delay_output(2000);
  1079. X
  1080. X  y_pos = 1;
  1081. X
  1082. X  for(x_pos = 8; x_pos < 16; x_pos++)
  1083. X  {
  1084. X
  1085. X      mvwin(bigdeer4, y_pos, x_pos);
  1086. X      wrefresh(bigdeer4);
  1087. X      wrefresh(w_del_msg);
  1088. X
  1089. X      mvwin(bigdeer3, y_pos, x_pos);
  1090. X      wrefresh(bigdeer3);
  1091. X      wrefresh(w_del_msg);
  1092. X
  1093. X      mvwin(bigdeer2, y_pos, x_pos);
  1094. X      wrefresh(bigdeer2);
  1095. X      wrefresh(w_del_msg);
  1096. X
  1097. X      mvwin(bigdeer1, y_pos, x_pos);
  1098. X      wrefresh(bigdeer1);
  1099. X      wrefresh(w_del_msg);
  1100. X
  1101. X      mvwin(bigdeer2, y_pos, x_pos);
  1102. X      wrefresh(bigdeer2);
  1103. X      wrefresh(w_del_msg);
  1104. X
  1105. X      mvwin(bigdeer3, y_pos, x_pos);
  1106. X      wrefresh(bigdeer3);
  1107. X      wrefresh(w_del_msg);
  1108. X
  1109. X      mvwin(bigdeer4, y_pos, x_pos);
  1110. X      wrefresh(bigdeer4);
  1111. X      wrefresh(w_del_msg);
  1112. X
  1113. X      mvwin(bigdeer0, y_pos, x_pos);
  1114. X      wrefresh(bigdeer0);
  1115. X      wrefresh(w_del_msg);
  1116. X  }
  1117. X
  1118. X    --x_pos;
  1119. X
  1120. X    for(looper = 0; looper < 6; looper++)
  1121. X    {
  1122. X      mvwin(lookdeer4, y_pos, x_pos);
  1123. X      wrefresh(lookdeer4);
  1124. X      wrefresh(w_del_msg);
  1125. X
  1126. X      mvwin(lookdeer3, y_pos, x_pos);
  1127. X      wrefresh(lookdeer3);
  1128. X      wrefresh(w_del_msg);
  1129. X
  1130. X      mvwin(lookdeer2, y_pos, x_pos);
  1131. X      wrefresh(lookdeer2);
  1132. X      wrefresh(w_del_msg);
  1133. X
  1134. X      mvwin(lookdeer1, y_pos, x_pos);
  1135. X      wrefresh(lookdeer1);
  1136. X      wrefresh(w_del_msg);
  1137. X
  1138. X      mvwin(lookdeer2, y_pos, x_pos);
  1139. X      wrefresh(lookdeer2);
  1140. X      wrefresh(w_del_msg);
  1141. X
  1142. X      mvwin(lookdeer3, y_pos, x_pos);
  1143. X      wrefresh(lookdeer3);
  1144. X      wrefresh(w_del_msg);
  1145. X
  1146. X      mvwin(lookdeer4, y_pos, x_pos);
  1147. X      wrefresh(lookdeer4);
  1148. X      wrefresh(w_del_msg);
  1149. X
  1150. X    }
  1151. X
  1152. X    mvwin(lookdeer0, y_pos, x_pos);
  1153. X    wrefresh(lookdeer0);
  1154. X    wrefresh(w_del_msg);
  1155. X
  1156. X  for(; y_pos < 10; y_pos++)
  1157. X  {
  1158. X
  1159. X    for(looper = 0; looper < 2; looper++)
  1160. X    {
  1161. X      mvwin(bigdeer4, y_pos, x_pos);
  1162. X      wrefresh(bigdeer4);
  1163. X      wrefresh(w_del_msg);
  1164. X
  1165. X      mvwin(bigdeer3, y_pos, x_pos);
  1166. X      wrefresh(bigdeer3);
  1167. X      wrefresh(w_del_msg);
  1168. X
  1169. X      mvwin(bigdeer2, y_pos, x_pos);
  1170. X      wrefresh(bigdeer2);
  1171. X      wrefresh(w_del_msg);
  1172. X
  1173. X      mvwin(bigdeer1, y_pos, x_pos);
  1174. X      wrefresh(bigdeer1);
  1175. X      wrefresh(w_del_msg);
  1176. X
  1177. X      mvwin(bigdeer2, y_pos, x_pos);
  1178. X      wrefresh(bigdeer2);
  1179. X      wrefresh(w_del_msg);
  1180. X
  1181. X      mvwin(bigdeer3, y_pos, x_pos);
  1182. X      wrefresh(bigdeer3);
  1183. X      wrefresh(w_del_msg);
  1184. X
  1185. X      mvwin(bigdeer4, y_pos, x_pos);
  1186. X      wrefresh(bigdeer4);
  1187. X      wrefresh(w_del_msg);
  1188. X    }
  1189. X      mvwin(bigdeer0, y_pos, x_pos);
  1190. X      wrefresh(bigdeer0);
  1191. X      wrefresh(w_del_msg);
  1192. X  }
  1193. X
  1194. X  --y_pos;
  1195. X
  1196. X  mvwin(lookdeer3, y_pos, x_pos);
  1197. X  wrefresh(lookdeer3);
  1198. X  wrefresh(w_del_msg);
  1199. X  return( 0 );
  1200. X}
  1201. X
  1202. X
  1203. X
  1204. Xvoid done()
  1205. X{
  1206. X  signal(SIGINT,done);
  1207. X  signal(SIGTERM,done);
  1208. X#if !defined    DOS && !defined OS2
  1209. X  signal(SIGHUP,done);
  1210. X  signal(SIGQUIT,done);
  1211. X#endif
  1212. X  clear();
  1213. X  refresh();
  1214. X  endwin();
  1215. X  exit(0);
  1216. X}
  1217. END_OF_FILE
  1218.   if test 33528 -ne `wc -c <'demos/xmas.c'`; then
  1219.     echo shar: \"'demos/xmas.c'\" unpacked with wrong size!
  1220.   fi
  1221.   # end of 'demos/xmas.c'
  1222. fi
  1223. if test -f 'nonport/wbox.c' -a "${1}" != "-c" ; then 
  1224.   echo shar: Will not clobber existing file \"'nonport/wbox.c'\"
  1225. else
  1226.   echo shar: Extracting \"'nonport/wbox.c'\" \(5122 characters\)
  1227.   sed "s/^X//" >'nonport/wbox.c' <<'END_OF_FILE'
  1228. X#define    CURSES_LIBRARY    1
  1229. X#include <curses.h>
  1230. X#undef    wbox
  1231. X
  1232. X#ifndef    NDEBUG
  1233. Xchar *rcsid_wbox = "$Header: c:/curses/nonport/RCS/wbox.c%v 2.0 1992/11/15 03:18:30 MH Rel $";
  1234. X#endif
  1235. X
  1236. X/*man-start*********************************************************************
  1237. X
  1238. X  wbox()    - draw box
  1239. X
  1240. X  PDCurses Description:
  1241. X     Draws a box in window 'win', enclosing the area xmin-xmax and
  1242. X     ymin-xmax. If xmax and/or ymax is 0, the window max value is
  1243. X     used. 'v' and 'h' are the vertical and horizontal characters
  1244. X     to use.     If 'v' and 'h' are PC grapics lines, wbox will make
  1245. X     the corners in a pretty way.
  1246. X
  1247. X         Single Bar Box            Double Bar Box
  1248. X     ----------------------        ======================
  1249. X     (0xDA)    (0xC4)    (0xBF)        (0xC9)    (0xCD)    (0xBB)
  1250. X       +      -      +          +      =      +
  1251. X       | (0xB3)        |          || (0xBA)     ||
  1252. X       +      -      +          +      =      +
  1253. X     (0xC0)        (0xD9)        (0xC8)        (0xBC)
  1254. X
  1255. X     PC Graphic Graphic Character Solids:
  1256. X         # (quarter-tone)    (0xB0)
  1257. X         # (half-tone)        (0xB1)
  1258. X         # (three-quarter-tone)    (0xB2)
  1259. X         # (solid)        (0xDB)
  1260. X
  1261. X  PDCurses Return Value:
  1262. X     The wbox() function returns OK on success and ERR on error.
  1263. X
  1264. X  PDCurses Errors:
  1265. X     No errors are defined for this function.
  1266. X
  1267. X  Portability:
  1268. X     PDCurses    int wbox( WINDOW* win,  int ymin, int xmin,
  1269. X                         int ymax, int xmax,
  1270. X                         chtype v,   chtype h );
  1271. X     BSD Curses
  1272. X     SYS V Curses
  1273. X
  1274. X**man-end**********************************************************************/
  1275. X
  1276. Xint    wbox(WINDOW *win,int ymin,int xmin,int ymax,int xmax,chtype v,chtype h)
  1277. X{
  1278. X    chtype    l;        /* border chars */
  1279. X    chtype    r;
  1280. X    chtype    t;
  1281. X    chtype    b;
  1282. X    chtype    tl;
  1283. X    chtype    tr;
  1284. X    chtype    bl;
  1285. X    chtype    br;
  1286. X    chtype    vattr;
  1287. X    chtype    hattr;
  1288. X    int    i;
  1289. X
  1290. X    if (win == (WINDOW *)NULL)
  1291. X        return( ERR );
  1292. X    if (ymax == 0)
  1293. X        ymax = win->_maxy - 1;
  1294. X    if (xmax == 0)
  1295. X        xmax = win->_maxx - 1;
  1296. X
  1297. X    if ((ymin >= win->_maxy) ||
  1298. X        (ymax > win->_maxy) ||
  1299. X        (xmin >= win->_maxx) ||
  1300. X        (xmax > win->_maxx) ||
  1301. X        (ymin >= ymax) ||
  1302. X        (xmin >= xmax))
  1303. X    {
  1304. X        return (ERR);
  1305. X    }
  1306. X
  1307. X    l = r    = v & A_CHARTEXT;
  1308. X    t = b    = h & A_CHARTEXT;
  1309. X
  1310. X/* if the incoming character doesn't have its own attribute
  1311. X   then    use the    current    attributes for the window.
  1312. X   if the incoming character has attributes but    not a colour
  1313. X   component, or the attributes    to the current attributes
  1314. X   for the window.
  1315. X   if the incoming character has a colour component use    the
  1316. X   attributes solely from the incoming character */
  1317. X
  1318. X    if ((h    & A_ATTRIBUTES)    == 0)
  1319. X       hattr    = win->_attrs;
  1320. X    else
  1321. X       if ((h & A_COLOR) == 0)
  1322. X          hattr = (h & A_ATTRIBUTES) | win->_attrs;
  1323. X       else
  1324. X          hattr = (h & A_ATTRIBUTES);
  1325. X
  1326. X    if ((v    & A_ATTRIBUTES)    == 0)
  1327. X       vattr    = win->_attrs;
  1328. X    else
  1329. X       if ((v & A_COLOR) == 0)
  1330. X          vattr = (v | win->_attrs);
  1331. X       else
  1332. X          vattr = v;
  1333. X
  1334. X    tl = tr = bl = br = l;        /* default same as vertical         */
  1335. X
  1336. X    if (l == 0xba)            /* vertical double bars             */
  1337. X    {
  1338. X        if (t == 0xcd)        /* horizontal too?             */
  1339. X        {
  1340. X            tl = 0xc9;    /* use double bar corners         */
  1341. X            tr = 0xbb;
  1342. X            bl = 0xc8;
  1343. X            br = 0xbc;
  1344. X        }
  1345. X        else
  1346. X        {
  1347. X            tl = 0xd6;       /* use horz-s vert-d corners         */
  1348. X            tr = 0xb7;
  1349. X            bl = 0xd3;
  1350. X            br = 0xbd;
  1351. X        }
  1352. X    }
  1353. X
  1354. X    if (l == 0xb3)               /* vertical single bars         */
  1355. X    {
  1356. X        if (t == 0xcd)
  1357. X        {
  1358. X            tl = 0xd5;       /* horizontal double bars         */
  1359. X            tr = 0xb8;
  1360. X            bl = 0xd4;
  1361. X            br = 0xbe;
  1362. X        }
  1363. X        else
  1364. X        {
  1365. X            tl = 0xda;       /* use horz-s vert-s bars         */
  1366. X            tr = 0xbf;
  1367. X            bl = 0xc0;
  1368. X            br = 0xd9;
  1369. X        }
  1370. X    }
  1371. X
  1372. X    /*
  1373. X     * wborder() settings override parms
  1374. X     */
  1375. X    if (win->_borderchars[0]) l  = win->_borderchars[0];
  1376. X    if (win->_borderchars[1]) r  = win->_borderchars[1];
  1377. X    if (win->_borderchars[2]) t  = win->_borderchars[2];
  1378. X    if (win->_borderchars[3]) b  = win->_borderchars[3];
  1379. X    if (win->_borderchars[4]) tl = win->_borderchars[4];
  1380. X    if (win->_borderchars[5]) tr = win->_borderchars[5];
  1381. X    if (win->_borderchars[6]) bl = win->_borderchars[6];
  1382. X    if (win->_borderchars[7]) br = win->_borderchars[7];
  1383. X
  1384. X    if  (!(v|h) && !(l|r|t|b|tl|tr|bl|br))
  1385. X    {
  1386. X        /*
  1387. X         *    Appropriate default:
  1388. X         *
  1389. X         *    Single box with parent window's title attribute
  1390. X         */
  1391. X        l  = r = 0xb3 | win->_title_attr;
  1392. X        t  = b = 0xc4 | win->_title_attr;
  1393. X        tl = 0xda | win->_attrs;
  1394. X        tr = 0xbf | win->_attrs;
  1395. X        bl = 0xc0 | win->_attrs;
  1396. X        br = 0xd9 | win->_attrs;
  1397. X    }
  1398. X
  1399. X    for (i = xmin + 1; i <= xmax - 1; i++)
  1400. X    {
  1401. X        win->_y[ymin][i] = (t | hattr);
  1402. X        win->_y[ymax][i] = (b | hattr);
  1403. X    }
  1404. X
  1405. X    for (i = ymin + 1; i <= ymax - 1; i++)
  1406. X    {
  1407. X        win->_y[i][xmin] = (l | vattr);
  1408. X        win->_y[i][xmax] = (r | vattr);
  1409. X    }
  1410. X
  1411. X    win->_y[ymin][xmin] = (tl | vattr);
  1412. X    win->_y[ymin][xmax] = (tr | vattr);
  1413. X    win->_y[ymax][xmin] = (bl | vattr);
  1414. X    win->_y[ymax][xmax] = (br | vattr);
  1415. X
  1416. X    for (i = ymin; i <= ymax; i++)
  1417. X    {
  1418. X        if (win->_firstch[i] == _NO_CHANGE)
  1419. X        {
  1420. X            win->_firstch[i] = xmin;
  1421. X            win->_lastch[i] = xmax;
  1422. X        }
  1423. X        else
  1424. X        {
  1425. X            win->_firstch[i] = min(win->_firstch[i], xmin);
  1426. X            win->_lastch[i] = max(win->_lastch[i], xmax);
  1427. X        }
  1428. X    }
  1429. X    /*
  1430. X     * set wborder() settings to current values
  1431. X     */
  1432. X    win->_borderchars[0] = l  | vattr;
  1433. X    win->_borderchars[1] = r  | vattr;
  1434. X    win->_borderchars[2] = t  | hattr;
  1435. X    win->_borderchars[3] = b  | hattr;
  1436. X    win->_borderchars[4] = tl | vattr;
  1437. X    win->_borderchars[5] = tr | vattr;
  1438. X    win->_borderchars[6] = bl | vattr;
  1439. X    win->_borderchars[7] = br | vattr;
  1440. X    return (OK);
  1441. X}
  1442. END_OF_FILE
  1443.   if test 5122 -ne `wc -c <'nonport/wbox.c'`; then
  1444.     echo shar: \"'nonport/wbox.c'\" unpacked with wrong size!
  1445.   fi
  1446.   # end of 'nonport/wbox.c'
  1447. fi
  1448. if test -f 'private/_vsscanf.c' -a "${1}" != "-c" ; then 
  1449.   echo shar: Will not clobber existing file \"'private/_vsscanf.c'\"
  1450. else
  1451.   echo shar: Extracting \"'private/_vsscanf.c'\" \(12556 characters\)
  1452.   sed "s/^X//" >'private/_vsscanf.c' <<'END_OF_FILE'
  1453. X/*
  1454. X * This module is based on vsscanf.c and input.c from emx 0.8f library
  1455. X * source which is Copyright (c) 1990-1992 by Eberhard Mattes.
  1456. X * Eberhard Mattes has kindly agreed to allow this module to be incorporated
  1457. X * into PDCurses.
  1458. X */
  1459. X#ifndef    NDEBUG
  1460. Xchar *rcsid__vsscanf = "$Header: c:/curses/private/RCS/_vsscanf.c%v 2.0 1992/11/15 03:24:18 MH Rel $";
  1461. X#endif
  1462. X
  1463. X#include <stdio.h>
  1464. X#include <stdlib.h>
  1465. X#include <stdarg.h>
  1466. X#include <string.h>
  1467. X#include <limits.h>
  1468. X#include <ctype.h>
  1469. X
  1470. X#define TRUE 1
  1471. X#define FALSE 0
  1472. X
  1473. X#define WHITE(x) ((x) == ' ' || (x) == '\t' || (x) == '\n')
  1474. X
  1475. X#define NEXT(x) \
  1476. X        do { \
  1477. X            x = *buf++; \
  1478. X            if (x == '\0') \
  1479. X               return (count == 0 ? EOF : count); \
  1480. X            ++chars; \
  1481. X           } while (0)
  1482. X#define UNGETC(x) \
  1483. X        do { \
  1484. X            --buf; *buf = x; --chars; \
  1485. X           } while (0)
  1486. X
  1487. X/*man-start*********************************************************************
  1488. X
  1489. X  PDC_vsscanf()    - Internal routine to parse and format an input buffer.
  1490. X
  1491. X  PDCurses Description:
  1492. X     This is a private PDCurses routine.
  1493. X
  1494. X     Scan a series of input fields. Each field is formatted according to
  1495. X     a supplied format string and the formatted input is stored in the
  1496. X     variable number of addresses passed.
  1497. X
  1498. X  PDCurses Return Value:
  1499. X     This function returns the number of input fields or EOF on error.
  1500. X
  1501. X  PDCurses Errors:
  1502. X     If the supplied data is invalid or an incorrect number of arguments
  1503. X     are passed, EOF is returned as an error.
  1504. X
  1505. X  Portability:
  1506. X     PDCurses    int PDC_vsscanf(char *buf,const char *fmt,va_list arg_ptr);
  1507. X
  1508. X**man-end**********************************************************************/
  1509. X
  1510. Xint PDC_vsscanf ( char *buf, const char *fmt, char *arg_ptr)
  1511. X{
  1512. X  int count, chars, c, width, radix, d, i;
  1513. X  int *int_ptr;
  1514. X  long *long_ptr;
  1515. X  short *short_ptr;
  1516. X  char *char_ptr;
  1517. X  unsigned char f;
  1518. X  char neg, assign, ok, size;
  1519. X  unsigned long n;
  1520. X  char map[256], end;
  1521. X  double dx, dd, *dbl_ptr;
  1522. X  float *flt_ptr;
  1523. X  int exp;
  1524. X  char eneg;
  1525. X
  1526. X  count = 0; chars = 0; c = 0;
  1527. X  while ((f = *fmt) != 0)
  1528. X    {
  1529. X      if (WHITE (f))
  1530. X        {
  1531. X          do
  1532. X            {
  1533. X              ++fmt; f = *fmt;
  1534. X            } while (WHITE (f));
  1535. X          do
  1536. X            {
  1537. X              c = *buf++;
  1538. X              if (c == '\0')
  1539. X                {
  1540. X                  if (f == 0 || count != 0)
  1541. X                    return (count);
  1542. X                  else
  1543. X                    return (EOF);
  1544. X                }
  1545. X              else
  1546. X                ++chars;
  1547. X            } while (WHITE (c));
  1548. X          UNGETC (c);
  1549. X        }
  1550. X      else if (f != '%')
  1551. X        {
  1552. X          NEXT (c);
  1553. X          if (c != f)
  1554. X            return (count);
  1555. X          ++fmt;
  1556. X        }
  1557. X      else
  1558. X        {
  1559. X          assign = TRUE; width = INT_MAX;
  1560. X          char_ptr = NULL;
  1561. X          ++fmt;
  1562. X          if (*fmt == '*')
  1563. X            {
  1564. X              assign = FALSE;
  1565. X              ++fmt;
  1566. X            }
  1567. X          if (isdigit (*fmt))
  1568. X            {
  1569. X              width = 0;
  1570. X              while (isdigit (*fmt))
  1571. X                width = width * 10 + (*fmt++ - '0');
  1572. X              if (width == 0) width = INT_MAX;
  1573. X            }
  1574. X          size = 0;
  1575. X          if (*fmt == 'h' || *fmt == 'l')
  1576. X            size = *fmt++;
  1577. X          f = *fmt;
  1578. X          switch (f)
  1579. X            {
  1580. X            case 'c':
  1581. X              if (width == INT_MAX)
  1582. X                width = 1;
  1583. X              if (assign)
  1584. X                char_ptr = va_arg (arg_ptr, char *);
  1585. X              while (width > 0)
  1586. X                {
  1587. X                  --width;
  1588. X                  NEXT (c);
  1589. X                  if (assign)
  1590. X                    {
  1591. X                      *char_ptr++ = (char)c;
  1592. X                      ++count;
  1593. X                    }
  1594. X                }
  1595. X              break;
  1596. X            case '[':
  1597. X              (void)memset (map, 0, 256);
  1598. X              end = 0;
  1599. X              ++fmt;
  1600. X              if (*fmt == '^')
  1601. X                {
  1602. X                  ++fmt; end = 1;
  1603. X                }
  1604. X              i = 0;
  1605. X              for (;;)
  1606. X                {
  1607. X                  f = (unsigned char)*fmt;
  1608. X                  switch (f)
  1609. X                    {
  1610. X                    case 0:
  1611. X                      --fmt;       /* avoid skipping past 0 */
  1612. X                      NEXT (c);
  1613. X                      goto string;
  1614. X                    case ']':
  1615. X                      if (i > 0)
  1616. X                        {
  1617. X                          NEXT (c);
  1618. X                          goto string;
  1619. X                        }
  1620. X                      /* no break */
  1621. X                    default:
  1622. X                      if (fmt[1] == '-' && fmt[2] != 0 &&
  1623. X                          f < (unsigned char)fmt[2])
  1624. X                        {
  1625. X                          (void)memset (map+f, 1, (unsigned char)fmt[2]-f);
  1626. X                          fmt += 2;
  1627. X                        }
  1628. X                      else
  1629. X                        map[f] = 1;
  1630. X                      break;
  1631. X                    }
  1632. X                  ++fmt; ++i;
  1633. X                }
  1634. X            case 's':
  1635. X              (void)memset (map, 0, 256);
  1636. X              map[' '] = 1;
  1637. X              map['\n'] = 1;
  1638. X              map['\t'] = 1;
  1639. X              end = 1;
  1640. X              do
  1641. X                {
  1642. X                  NEXT (c);
  1643. X                } while (WHITE (c));
  1644. Xstring:
  1645. X              if (assign)
  1646. X                char_ptr = va_arg (arg_ptr, char *);
  1647. X              while (width > 0 && map[(unsigned char)c] != end)
  1648. X                {
  1649. X                  --width;
  1650. X                  if (assign)
  1651. X                    *char_ptr++ = (char)c;
  1652. X                  c = *buf++;
  1653. X                  if (c == '\0')
  1654. X                    break;
  1655. X                  else
  1656. X                    ++chars;
  1657. X                }
  1658. X              if (assign)
  1659. X                {
  1660. X                  *char_ptr = 0;
  1661. X                  ++count;
  1662. X                }
  1663. X              if (c == '\0')
  1664. X                return (count);
  1665. X              else
  1666. X                UNGETC (c);
  1667. X              break;
  1668. X            case 'f':
  1669. X            case 'e':
  1670. X            case 'E':
  1671. X            case 'g':
  1672. X            case 'G':
  1673. X              neg = ok = FALSE; dx = 0.0;
  1674. X              do
  1675. X                {
  1676. X                  NEXT (c);
  1677. X                } while (WHITE (c));
  1678. X              if (c == '+')
  1679. X                {
  1680. X                  NEXT (c); --width;
  1681. X                }
  1682. X              else if (c == '-')
  1683. X                {
  1684. X                  neg = TRUE; NEXT (c); --width;
  1685. X                }
  1686. X              while (width > 0 && isdigit (c))
  1687. X                {
  1688. X                  --width;
  1689. X                  dx = dx * 10.0 + (double)(c - '0');
  1690. X                  ok = TRUE;
  1691. X                  c = *buf++;
  1692. X                  if (c == '\0')
  1693. X                    break;
  1694. X                  else
  1695. X                    ++chars;
  1696. X                }
  1697. X              if (width > 0 && c == '.')
  1698. X                {
  1699. X                  --width;
  1700. X                  dd = 10.0; NEXT (c);
  1701. X                  while (width > 0 && isdigit (c))
  1702. X                    {
  1703. X                      --width;
  1704. X                      dx += (double)(c - '0') / dd;
  1705. X                      dd *= 10.0;
  1706. X                      ok = TRUE;
  1707. X                      c = *buf++;
  1708. X                      if (c == '\0')
  1709. X                        break;
  1710. X                      else
  1711. X                        ++chars;
  1712. X                    }
  1713. X                }
  1714. X              if (!ok)
  1715. X                return (count);
  1716. X              if (width > 0 && (c == 'e' || c == 'E'))
  1717. X                {
  1718. X                  eneg = FALSE; exp = 0; NEXT (c); --width;
  1719. X                  if (width > 0 && c == '+')
  1720. X                    {
  1721. X                      NEXT (c); --width;
  1722. X                    }
  1723. X                  else if (width > 0 && c == '-')
  1724. X                    {
  1725. X                      eneg = TRUE; NEXT (c); --width;
  1726. X                    }
  1727. X                  if (!(width > 0 && isdigit (c)))
  1728. X                    {
  1729. X                      UNGETC (c);
  1730. X                      return (count);
  1731. X                    }
  1732. X                  while (width > 0 && isdigit (c))
  1733. X                    {
  1734. X                      --width;
  1735. X                      exp = exp * 10 + (c - '0');
  1736. X                      c = *buf++;
  1737. X                      if (c == '\0')
  1738. X                        break;
  1739. X                      else
  1740. X                        ++chars;
  1741. X                    }
  1742. X                  if (eneg) exp = -exp;
  1743. X                  while (exp > 0)
  1744. X                    {
  1745. X                      dx *= 10.0;
  1746. X                      --exp;
  1747. X                    }
  1748. X                  while (exp < 0)
  1749. X                    {
  1750. X                      dx /= 10.0;
  1751. X                      ++exp;
  1752. X                    }
  1753. X                }
  1754. X              if (assign)
  1755. X                {
  1756. X                  if (neg) dx = -dx;
  1757. X                  if (size == 'l')
  1758. X                    {
  1759. X                      dbl_ptr = va_arg (arg_ptr, double *);
  1760. X                      *dbl_ptr = dx;
  1761. X                    }
  1762. X                  else
  1763. X                    {
  1764. X                      flt_ptr = va_arg (arg_ptr, float *);
  1765. X                      *flt_ptr = (float)dx;
  1766. X                    }
  1767. X                  ++count;
  1768. X                }
  1769. X              if (c == '\0')
  1770. X                return (count);
  1771. X              else
  1772. X                UNGETC (c);
  1773. X              break;
  1774. X            case 'i':
  1775. X              neg = FALSE; radix = 10;
  1776. X              do
  1777. X                {
  1778. X                  NEXT (c);
  1779. X                } while (WHITE (c));
  1780. X              if (!(width > 0 && c == '0'))
  1781. X                goto scan_complete_number;
  1782. X              NEXT (c); --width;
  1783. X              if (width > 0 && (c == 'x' || c == 'X'))
  1784. X                {
  1785. X                  NEXT (c); radix = 16; --width;
  1786. X                }
  1787. X              else if (width > 0 && (c >= '0' && c <= '7'))
  1788. X                radix = 8;
  1789. X              goto scan_unsigned_number;
  1790. X            case 'd':
  1791. X            case 'u':
  1792. X            case 'o':
  1793. X            case 'x':
  1794. X            case 'X':
  1795. X              do
  1796. X                {
  1797. X                  NEXT (c);
  1798. X                } while (WHITE (c));
  1799. X              switch (f)
  1800. X                {
  1801. X                case 'o':           radix = 8; break;
  1802. X                case 'x': case 'X': radix = 16; break;
  1803. X                default:            radix = 10; break;
  1804. X                }
  1805. Xscan_complete_number:
  1806. X              neg = FALSE;
  1807. X              if (width > 0 && c == '+')
  1808. X                {
  1809. X                  NEXT (c); --width;
  1810. X                }
  1811. X              else if (width > 0 && c == '-' && radix == 10)
  1812. X                {
  1813. X                  neg = TRUE; NEXT (c); --width;
  1814. X                }
  1815. Xscan_unsigned_number:
  1816. X              n = 0; ok = FALSE;
  1817. X              while (width > 0)
  1818. X                {
  1819. X                  --width;
  1820. X                  if (isdigit (c))
  1821. X                    d = c - '0';
  1822. X                  else if (isupper (c))
  1823. X                    d = c - 'A' + 10;
  1824. X                  else if (islower (c))
  1825. X                    d = c - 'a' + 10;
  1826. X                  else
  1827. X                    break;
  1828. X                  if (d < 0 || d >= radix)
  1829. X                    break;
  1830. X                  ok = TRUE;
  1831. X                  n = n * radix + d;
  1832. X                  c = *buf++;
  1833. X                  if (c == '\0')
  1834. X                    break;
  1835. X                  else
  1836. X                    ++chars;
  1837. X                }
  1838. X              if (!ok)
  1839. X                return (count);
  1840. X              if (assign)
  1841. X                {
  1842. X                  if (neg) n = -n;
  1843. X                  switch(size)
  1844. X                     {
  1845. X                      case 'h':
  1846. X                              short_ptr = va_arg (arg_ptr, short *);
  1847. X                              *short_ptr = (short)n;
  1848. X                              break;
  1849. X                      case 'l':
  1850. X                              long_ptr = va_arg (arg_ptr, long *);
  1851. X                              *long_ptr = (long)n;
  1852. X                              break;
  1853. X                      default:
  1854. X                              int_ptr = va_arg (arg_ptr, int *);
  1855. X                              *int_ptr = (int)n;
  1856. X                     }
  1857. X                  ++count;
  1858. X                }
  1859. X              if (c == '\0')
  1860. X                return (count);
  1861. X              else
  1862. X                UNGETC (c);
  1863. X              break;
  1864. X            case 'n':
  1865. X              if (assign)
  1866. X                {
  1867. X                  int_ptr = va_arg (arg_ptr, int *);
  1868. X                  *int_ptr = chars;
  1869. X                  ++count;
  1870. X                }
  1871. X              break;
  1872. X            default:
  1873. X              if (f == 0)                 /* % at end of string */
  1874. X                return (count);
  1875. X              NEXT (c);
  1876. X              if (c != f)
  1877. X                return (count);
  1878. X              break;
  1879. X            }
  1880. X          ++fmt;
  1881. X        }
  1882. X    }
  1883. X  return (count);
  1884. X}
  1885. END_OF_FILE
  1886.   if test 12556 -ne `wc -c <'private/_vsscanf.c'`; then
  1887.     echo shar: \"'private/_vsscanf.c'\" unpacked with wrong size!
  1888.   fi
  1889.   # end of 'private/_vsscanf.c'
  1890. fi
  1891. if test -f 'tools/buildlrf.def' -a "${1}" != "-c" ; then 
  1892.   echo shar: Will not clobber existing file \"'tools/buildlrf.def'\"
  1893. else
  1894.   echo shar: Extracting \"'tools/buildlrf.def'\" \(74 characters\)
  1895.   sed "s/^X//" >'tools/buildlrf.def' <<'END_OF_FILE'
  1896. XNAME buildlrf windowcompat
  1897. X
  1898. XDESCRIPTION 'test'
  1899. X
  1900. XPROTMODE
  1901. X
  1902. XSTACKSIZE 32767
  1903. END_OF_FILE
  1904.   if test 74 -ne `wc -c <'tools/buildlrf.def'`; then
  1905.     echo shar: \"'tools/buildlrf.def'\" unpacked with wrong size!
  1906.   fi
  1907.   # end of 'tools/buildlrf.def'
  1908. fi
  1909. echo shar: End of archive 2 \(of 11\).
  1910. cp /dev/null ark2isdone
  1911. MISSING=""
  1912. for I in 1 2 3 4 5 6 7 8 9 10 11 ; do
  1913.     if test ! -f ark${I}isdone ; then
  1914.     MISSING="${MISSING} ${I}"
  1915.     fi
  1916. done
  1917. if test "${MISSING}" = "" ; then
  1918.     echo You have unpacked all 11 archives.
  1919.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1920. else
  1921.     echo You still must unpack the following archives:
  1922.     echo "        " ${MISSING}
  1923. fi
  1924. exit 0
  1925. exit 0 # Just in case...
  1926.