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