DizzyBot: beep boop

2018-05-18T00:26:09Z

beep boop

DizzyBot: beep boop

2018-05-12T10:02:34Z

beep boop

New page

__MIXEDSYNTAXHIGHLIGHT__
Below is the full text to '''pline.c''' from the [[NetHack 3.6.1 source code|source code]] of [[NetHack 3.6.1]]. To link to a particular line, write [[Source:NetHack 3.6.1/src/pline.c#line123|<nowiki>[[Source:NetHack 3.6.1/src/pline.c#line123]]</nowiki>]], for example.

{{NGPL}}
1. /* NetHack 3.6 pline.c $NHDT-Date: 1520964541 2018/03/13 18:09:01 $ $NHDT-Branch: NetHack-3.6.0 $:$NHDT-Revision: 1.66 $ */
2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3. /*-Copyright (c) Robert Patrick Rankin, 2018. */
4. /* NetHack may be freely redistributed. See license for details. */
5. 
6. #define NEED_VARARGS /* Uses ... */ /* comment line for pre-compiled headers \
7. */
8. #include "hack.h"
9. 
10. static unsigned pline_flags = 0;
11. static char prevmsg[BUFSZ];
12. 
13. static char *FDECL(You_buf, (int));
14. #if defined(MSGHANDLER) && (defined(POSIX_TYPES) || defined(__GNUC__))
15. static void FDECL(execplinehandler, (const char *));
16. #endif
17. 
18. #ifdef DUMPLOG
19. /* also used in end.c */
20. unsigned saved_pline_index = 0; /* slot in saved_plines[] to use next */
21. char *saved_plines[DUMPLOG_MSG_COUNT] = { (char *) 0 };
22. 
23. /* keep the most recent DUMPLOG_MSG_COUNT messages */
24. void
25. dumplogmsg(line)
26. const char *line;
27. {
28. /*
29. * TODO:
30. * This essentially duplicates message history, which is
31. * currently implemented in an interface-specific manner.
32. * The core should take responsibility for that and have
33. * this share it.
34. */
35. unsigned indx = saved_pline_index; /* next slot to use */
36. char *oldest = saved_plines[indx]; /* current content of that slot */
37. 
38. if (oldest && strlen(oldest) >= strlen(line)) {
39. /* this buffer will gradually shrink until the 'else' is needed;
40. there's no pressing need to track allocation size instead */
41. Strcpy(oldest, line);
42. } else {
43. if (oldest)
44. free((genericptr_t) oldest);
45. saved_plines[indx] = dupstr(line);
46. }
47. saved_pline_index = (indx + 1) % DUMPLOG_MSG_COUNT;
48. }
49. 
50. /* called during save (unlike the interface-specific message history,
51. this data isn't saved and restored); end-of-game releases saved_pline[]
52. while writing its contents to the final dump log */
53. void
54. dumplogfreemessages()
55. {
56. unsigned indx;
57. 
58. for (indx = 0; indx < DUMPLOG_MSG_COUNT; ++indx)
59. if (saved_plines[indx])
60. free((genericptr_t) saved_plines[indx]), saved_plines[indx] = 0;
61. saved_pline_index = 0;
62. }
63. #endif
64. 
65. /*VARARGS1*/
66. /* Note that these declarations rely on knowledge of the internals
67. * of the variable argument handling stuff in "tradstdc.h"
68. */
69. 
70. #if defined(USE_STDARG) || defined(USE_VARARGS)
71. static void FDECL(vpline, (const char *, va_list));
72. 
73. void pline
74. VA_DECL(const char *, line)
75. {
76. VA_START(line);
77. VA_INIT(line, char *);
78. vpline(line, VA_ARGS);
79. VA_END();
80. }
81. 
82. # ifdef USE_STDARG
83. static void
84. vpline(const char *line, va_list the_args)
85. # else
86. static void
87. vpline(line, the_args)
88. const char *line;
89. va_list the_args;
90. # endif
91. 
92. #else /* USE_STDARG | USE_VARARG */
93. 
94. # define vpline pline
95. 
96. void pline
97. VA_DECL(const char *, line)
98. #endif /* USE_STDARG | USE_VARARG */
99. { /* start of vpline() or of nested block in USE_OLDARG's pline() */
100. static int in_pline = 0;
101. char pbuf[3 * BUFSZ];
102. int ln;
103. int msgtyp;
104. boolean no_repeat;
105. /* Do NOT use VA_START and VA_END in here... see above */
106. 
107. if (!line || !*line)
108. return;
109. #ifdef HANGUPHANDLING
110. if (program_state.done_hup)
111. return;
112. #endif
113. if (program_state.wizkit_wishing)
114. return;
115. 
116. if (index(line, '%')) {
117. Vsprintf(pbuf, line, VA_ARGS);
118. line = pbuf;
119. }
120. if ((ln = (int) strlen(line)) > BUFSZ - 1) {
121. if (line != pbuf) /* no '%' was present */
122. (void) strncpy(pbuf, line, BUFSZ - 1); /* caveat: unterminated */
123. /* truncate, preserving the final 3 characters:
124. "___ extremely long text" -> "___ extremely l...ext"
125. (this may be suboptimal if overflow is less than 3) */
126. (void) strncpy(pbuf + BUFSZ - 1 - 6, "...", 3);
127. /* avoid strncpy; buffers could overlap if excess is small */
128. pbuf[BUFSZ - 1 - 3] = line[ln - 3];
129. pbuf[BUFSZ - 1 - 2] = line[ln - 2];
130. pbuf[BUFSZ - 1 - 1] = line[ln - 1];
131. pbuf[BUFSZ - 1] = '\0';
132. line = pbuf;
133. }
134. 
135. #ifdef DUMPLOG
136. /* We hook here early to have options-agnostic output.
137. * Unfortunately, that means Norep() isn't honored (general issue) and
138. * that short lines aren't combined into one longer one (tty behavior).
139. */
140. if ((pline_flags & SUPPRESS_HISTORY) == 0)
141. dumplogmsg(line);
142. #endif
143. /* use raw_print() if we're called too early (or perhaps too late
144. during shutdown) or if we're being called recursively (probably
145. via debugpline() in the interface code) */
146. if (in_pline++ || !iflags.window_inited) {
147. /* [we should probably be using raw_printf("\n%s", line) here] */
148. raw_print(line);
149. iflags.last_msg = PLNMSG_UNKNOWN;
150. goto pline_done;
151. }
152. 
153. msgtyp = MSGTYP_NORMAL;
154. no_repeat = (pline_flags & PLINE_NOREPEAT) ? TRUE : FALSE;
155. if ((pline_flags & OVERRIDE_MSGTYPE) == 0) {
156. msgtyp = msgtype_type(line, no_repeat);
157. if (msgtyp == MSGTYP_NOSHOW
158. || (msgtyp == MSGTYP_NOREP && !strcmp(line, prevmsg)))
159. /* FIXME: we need a way to tell our caller that this message
160. * was suppressed so that caller doesn't set iflags.last_msg
161. * for something that hasn't been shown, otherwise a subsequent
162. * message which uses alternate wording based on that would be
163. * doing so out of context and probably end up seeming silly.
164. * (Not an issue for no-repeat but matters for no-show.)
165. */
166. goto pline_done;
167. }
168. 
169. if (vision_full_recalc)
170. vision_recalc(0);
171. if (u.ux)
172. flush_screen(1); /* %% */
173. 
174. putstr(WIN_MESSAGE, 0, line);
175. 
176. #if defined(MSGHANDLER) && (defined(POSIX_TYPES) || defined(__GNUC__))
177. execplinehandler(line);
178. #endif
179. 
180. /* this gets cleared after every pline message */
181. iflags.last_msg = PLNMSG_UNKNOWN;
182. (void) strncpy(prevmsg, line, BUFSZ), prevmsg[BUFSZ - 1] = '\0';
183. if (msgtyp == MSGTYP_STOP)
184. display_nhwindow(WIN_MESSAGE, TRUE); /* --more-- */
185. 
186. pline_done:
187. --in_pline;
188. return;
189. 
190. #if !(defined(USE_STDARG) || defined(USE_VARARGS))
191. /* provide closing brace for the nested block
192. which immediately follows USE_OLDARGS's VA_DECL() */
193. VA_END();
194. #endif
195. }
196. 
197. /* pline() variant which can override MSGTYPE handling or suppress
198. message history (tty interface uses pline() to issue prompts and
199. they shouldn't be blockable via MSGTYPE=hide) */
200. /*VARARGS2*/
201. void custompline
202. VA_DECL2(unsigned, pflags, const char *, line)
203. {
204. VA_START(line);
205. VA_INIT(line, const char *);
206. pline_flags = pflags;
207. vpline(line, VA_ARGS);
208. pline_flags = 0;
209. VA_END();
210. return;
211. }
212. 
213. /*VARARGS1*/
214. void Norep
215. VA_DECL(const char *, line)
216. {
217. VA_START(line);
218. VA_INIT(line, const char *);
219. pline_flags = PLINE_NOREPEAT;
220. vpline(line, VA_ARGS);
221. pline_flags = 0;
222. VA_END();
223. return;
224. }
225. 
226. /* work buffer for You(), &c and verbalize() */
227. static char *you_buf = 0;
228. static int you_buf_siz = 0;
229. 
230. static char *
231. You_buf(siz)
232. int siz;
233. {
234. if (siz > you_buf_siz) {
235. if (you_buf)
236. free((genericptr_t) you_buf);
237. you_buf_siz = siz + 10;
238. you_buf = (char *) alloc((unsigned) you_buf_siz);
239. }
240. return you_buf;
241. }
242. 
243. void
244. free_youbuf()
245. {
246. if (you_buf)
247. free((genericptr_t) you_buf), you_buf = (char *) 0;
248. you_buf_siz = 0;
249. }
250. 
251. /* `prefix' must be a string literal, not a pointer */
252. #define YouPrefix(pointer, prefix, text) \
253. Strcpy((pointer = You_buf((int) (strlen(text) + sizeof prefix))), prefix)
254. 
255. #define YouMessage(pointer, prefix, text) \
256. strcat((YouPrefix(pointer, prefix, text), pointer), text)
257. 
258. /*VARARGS1*/
259. void You
260. VA_DECL(const char *, line)
261. {
262. char *tmp;
263. VA_START(line);
264. VA_INIT(line, const char *);
265. vpline(YouMessage(tmp, "You ", line), VA_ARGS);
266. VA_END();
267. }
268. 
269. /*VARARGS1*/
270. void Your
271. VA_DECL(const char *, line)
272. {
273. char *tmp;
274. VA_START(line);
275. VA_INIT(line, const char *);
276. vpline(YouMessage(tmp, "Your ", line), VA_ARGS);
277. VA_END();
278. }
279. 
280. /*VARARGS1*/
281. void You_feel
282. VA_DECL(const char *, line)
283. {
284. char *tmp;
285. VA_START(line);
286. VA_INIT(line, const char *);
287. if (Unaware)
288. YouPrefix(tmp, "You dream that you feel ", line);
289. else
290. YouPrefix(tmp, "You feel ", line);
291. vpline(strcat(tmp, line), VA_ARGS);
292. VA_END();
293. }
294. 
295. /*VARARGS1*/
296. void You_cant
297. VA_DECL(const char *, line)
298. {
299. char *tmp;
300. VA_START(line);
301. VA_INIT(line, const char *);
302. vpline(YouMessage(tmp, "You can't ", line), VA_ARGS);
303. VA_END();
304. }
305. 
306. /*VARARGS1*/
307. void pline_The
308. VA_DECL(const char *, line)
309. {
310. char *tmp;
311. VA_START(line);
312. VA_INIT(line, const char *);
313. vpline(YouMessage(tmp, "The ", line), VA_ARGS);
314. VA_END();
315. }
316. 
317. /*VARARGS1*/
318. void There
319. VA_DECL(const char *, line)
320. {
321. char *tmp;
322. VA_START(line);
323. VA_INIT(line, const char *);
324. vpline(YouMessage(tmp, "There ", line), VA_ARGS);
325. VA_END();
326. }
327. 
328. /*VARARGS1*/
329. void You_hear
330. VA_DECL(const char *, line)
331. {
332. char *tmp;
333. 
334. if (Deaf || !flags.acoustics)
335. return;
336. VA_START(line);
337. VA_INIT(line, const char *);
338. if (Underwater)
339. YouPrefix(tmp, "You barely hear ", line);
340. else if (Unaware)
341. YouPrefix(tmp, "You dream that you hear ", line);
342. else
343. YouPrefix(tmp, "You hear ", line);
344. vpline(strcat(tmp, line), VA_ARGS);
345. VA_END();
346. }
347. 
348. /*VARARGS1*/
349. void You_see
350. VA_DECL(const char *, line)
351. {
352. char *tmp;
353. 
354. VA_START(line);
355. VA_INIT(line, const char *);
356. if (Unaware)
357. YouPrefix(tmp, "You dream that you see ", line);
358. else if (Blind) /* caller should have caught this... */
359. YouPrefix(tmp, "You sense ", line);
360. else
361. YouPrefix(tmp, "You see ", line);
362. vpline(strcat(tmp, line), VA_ARGS);
363. VA_END();
364. }
365. 
366. /* Print a message inside double-quotes.
367. * The caller is responsible for checking deafness.
368. * Gods can speak directly to you in spite of deafness.
369. */
370. /*VARARGS1*/
371. void verbalize
372. VA_DECL(const char *, line)
373. {
374. char *tmp;
375. 
376. VA_START(line);
377. VA_INIT(line, const char *);
378. tmp = You_buf((int) strlen(line) + sizeof "\"\"");
379. Strcpy(tmp, "\"");
380. Strcat(tmp, line);
381. Strcat(tmp, "\"");
382. vpline(tmp, VA_ARGS);
383. VA_END();
384. }
385. 
386. /*VARARGS1*/
387. /* Note that these declarations rely on knowledge of the internals
388. * of the variable argument handling stuff in "tradstdc.h"
389. */
390. 
391. #if defined(USE_STDARG) || defined(USE_VARARGS)
392. static void FDECL(vraw_printf, (const char *, va_list));
393. 
394. void raw_printf
395. VA_DECL(const char *, line)
396. {
397. VA_START(line);
398. VA_INIT(line, char *);
399. vraw_printf(line, VA_ARGS);
400. VA_END();
401. }
402. 
403. # ifdef USE_STDARG
404. static void
405. vraw_printf(const char *line, va_list the_args)
406. # else
407. static void
408. vraw_printf(line, the_args)
409. const char *line;
410. va_list the_args;
411. # endif
412. 
413. #else /* USE_STDARG | USE_VARARG */
414. 
415. void raw_printf
416. VA_DECL(const char *, line)
417. #endif
418. {
419. char pbuf[3 * BUFSZ];
420. int ln;
421. /* Do NOT use VA_START and VA_END in here... see above */
422. 
423. if (index(line, '%')) {
424. Vsprintf(pbuf, line, VA_ARGS);
425. line = pbuf;
426. }
427. if ((ln = (int) strlen(line)) > BUFSZ - 1) {
428. if (line != pbuf)
429. line = strncpy(pbuf, line, BUFSZ - 1);
430. /* unlike pline, we don't futz around to keep last few chars */
431. pbuf[BUFSZ - 1] = '\0'; /* terminate strncpy or truncate vsprintf */
432. }
433. raw_print(line);
434. #if defined(MSGHANDLER) && (defined(POSIX_TYPES) || defined(__GNUC__))
435. execplinehandler(line);
436. #endif
437. #if !(defined(USE_STDARG) || defined(USE_VARARGS))
438. VA_END(); /* (see vpline) */
439. #endif
440. }
441. 
442. /*VARARGS1*/
443. void impossible
444. VA_DECL(const char *, s)
445. {
446. char pbuf[2 * BUFSZ];
447. VA_START(s);
448. VA_INIT(s, const char *);
449. if (program_state.in_impossible)
450. panic("impossible called impossible");
451. 
452. program_state.in_impossible = 1;
453. Vsprintf(pbuf, s, VA_ARGS);
454. pbuf[BUFSZ - 1] = '\0'; /* sanity */
455. paniclog("impossible", pbuf);
456. pline("%s", VA_PASS1(pbuf));
457. pline(VA_PASS1(
458. "Program in disorder! (Saving and reloading may fix this problem.)"));
459. program_state.in_impossible = 0;
460. VA_END();
461. }
462. 
463. #if defined(MSGHANDLER) && (defined(POSIX_TYPES) || defined(__GNUC__))
464. static boolean use_pline_handler = TRUE;
465. static void
466. execplinehandler(line)
467. const char *line;
468. {
469. int f;
470. const char *args[3];
471. char *env;
472. 
473. if (!use_pline_handler)
474. return;
475. 
476. if (!(env = nh_getenv("NETHACK_MSGHANDLER"))) {
477. use_pline_handler = FALSE;
478. return;
479. }
480. 
481. f = fork();
482. if (f == 0) { /* child */
483. args[0] = env;
484. args[1] = line;
485. args[2] = NULL;
486. (void) setgid(getgid());
487. (void) setuid(getuid());
488. (void) execv(args[0], (char *const *) args);
489. perror((char *) 0);
490. (void) fprintf(stderr, "Exec to message handler %s failed.\n", env);
491. nh_terminate(EXIT_FAILURE);
492. } else if (f > 0) {
493. int status;
494. 
495. waitpid(f, &status, 0);
496. } else if (f == -1) {
497. perror((char *) 0);
498. use_pline_handler = FALSE;
499. pline("%s", VA_PASS1("Fork to message handler failed."));
500. }
501. }
502. #endif /* defined(POSIX_TYPES) || defined(__GNUC__) */
503. 
504. /*pline.c*/
[[Category:NetHack 3.6.1 source code|src/pline.c]]

@@ Line 2: / Line 2: @@
 Below is the full text to '''pline.c''' from the [[NetHack 3.6.1 source code|source code]] of [[NetHack 3.6.1]]. To link to a particular line, write [[Source:NetHack 3.6.1/src/pline.c#line123|<nowiki>[[Source:NetHack 3.6.1/src/pline.c#line123]]</nowiki>]], for example.
-{{NGPL}}
+== Top of file ==
   <span id="line1">1. /* NetHack 3.6	pline.c	$NHDT-Date: 1520964541 2018/03/13 18:09:01 $  $NHDT-Branch: NetHack-3.6.0 $:$NHDT-Revision: 1.66 $ */</span>
   <span id="line2">2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */</span>
   <span id="line3">3. /*-Copyright (c) Robert Patrick Rankin, 2018. */</span>
   <span id="line4">4. /* NetHack may be freely redistributed.  See license for details. */</span>
   <span id="line5">5. </span>
   <span id="line6">6. #define NEED_VARARGS /* Uses ... */ /* comment line for pre-compiled headers \</span>

Source:NetHack 3.6.1/src/pline.c - Revision history

DizzyBot: beep boop

DizzyBot: beep boop

DizzyBot: beep boop