ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/cfperl.xs

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.180 by root, Mon Apr 2 18:04:47 2007 UTC vs.
Revision 1.391 by root, Sat Jul 3 01:49:18 2010 UTC

1	/*****************************************************************************/
2	/* CrossFire, A Multiplayer game for the X Window System */
3	/*****************************************************************************/
4
5	/*	1	/*
6	* This code is placed under the GNU General Public Licence (GPL)	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
7	*	3	*
8	* Copyright (C) 2001-2005 by Chachkoff Yann	4	* Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
9	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>	5	*
10	*
11	* This program is free software; you can redistribute it and/or modify	6	* Deliantra is free software: you can redistribute it and/or modify it under
12	* it under the terms of the GNU General Public License as published by	7	* the terms of the Affero GNU General Public License as published by the
13	* the Free Software Foundation; either version 2 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
14	* (at your option) any later version.	9	* option) any later version.
15	*	10	*
16	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	14	* GNU General Public License for more details.
20	*	15	*
21	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the Affero GNU General Public License
22	* along with this program; if not, write to the Free Software	17	* and the GNU General Public License along with this program. If not, see
23	* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	18	* <http://www.gnu.org/licenses/>.
		19	*
		20	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	21	*/
25		22
26	#define PLUGIN_NAME "perl"	23	#include "autoconf.h"
27	#define PLUGIN_VERSION "cfperl 0.5"
28		24
29	#include <plugin_common.h>	25	#if HAVE_EXECINFO_H
30	#include <sounds.h>	26	# include <execinfo.h>
		27	#endif
		28
31	#include <cstdarg>	29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "../random_maps/random_map.h"
		34	#include "evthread.h"
32	#include <sproto.h>	35	#include "sproto.h"
33
34	#include "loader.h"
35	#include "cfperl.h"
36	#include "shstr.h"
37		36
38	#include <unistd.h>	37	#include <unistd.h>
39	#if _POSIX_MEMLOCK	38	#if _POSIX_MEMLOCK
40	# include <sys/mman.h>	39	# include <sys/mman.h>
41	#endif	40	#endif
42		41
		42	#if HAVE_MALLOC_H
		43	# include <malloc.h>
		44	#endif
		45
		46	#if !__GLIBC__
		47	# define malloc_trim(pad) -1
		48	#endif
		49
43	#include <EXTERN.h>	50	#include <EXTERN.h>
44	#include <perl.h>	51	#include <perl.h>
45	#include <XSUB.h>	52	#include <XSUB.h>
46		53
47	#include "CoroAPI.h"	54	#include "CoroAPI.h"
48	#include "perlxsi.c"	55	#include "perlxsi.c"
49		56
50	extern sint64 *levels; // the experience table	57	typedef object_thawer &object_thawer_ref;
		58	typedef object_freezer &object_freezer_ref;
51		59
52	typedef object object_ornull;	60	typedef std::string std__string;
53	typedef maptile maptile_ornull;
54
55	#if IVSIZE >= 8
56	typedef IV val64;
57	# define newSVval64 newSViv
58	# define SvVAL64 SvIV
59	#else
60	typedef double val64;
61	# define newSVval64 newSVnv
62	# define SvVAL64 SvNV
63	#endif
64
65	static f_plug_api gethook = cfapi_get_hooks;
66	static f_plug_api object_set_property = cfapi_object_set_property;
67	static f_plug_api object_insert = cfapi_object_insert;
68		61
69	static PerlInterpreter *perl;	62	static PerlInterpreter *perl;
70		63
71	double runtime;	64	tstamp NOW, runtime;
		65
		66	static int tick_inhibit;
		67	static int tick_pending;
72		68
73	global gbl_ev;	69	global gbl_ev;
74	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	70	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
75	static SV *sv_runtime;	71	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
		72	static AV *av_reflect;
		73
		74	bitset<NUM_EVENT_TYPES> ev_want_event;
		75	bitset<NUM_TYPES> ev_want_type;
76		76
77	static HV	77	static HV
78	*stash_cf,	78	*stash_cf,
79	*stash_cf_object_wrap,	79	*stash_cf_object_wrap,
80	*stash_cf_object_player_wrap,	80	*stash_cf_object_player_wrap,
81	*stash_cf_player_wrap,	81	*stash_cf_player_wrap,
82	*stash_cf_map_wrap,	82	*stash_cf_map_wrap,
		83	*stash_cf_mapspace_wrap,
83	*stash_cf_client_wrap,	84	*stash_cf_client_wrap,
84	*stash_cf_arch_wrap,	85	*stash_cf_arch_wrap,
85	*stash_cf_party_wrap,	86	*stash_cf_party_wrap,
86	*stash_cf_region_wrap,	87	*stash_cf_region_wrap,
87	*stash_cf_living_wrap;	88	*stash_cf_living_wrap,
		89	*stash_cf_layout_wrap,
		90	*stash_ext_map_world;
		91
		92	static SV
		93	*cv_cf_do_invoke,
		94	*cv_cf__can_merge,
		95	*cv_cf_client_send_msg,
		96	*cv_cf_tick,
		97	*cv_cf_match_match;
		98
		99	#ifndef newSVpv_utf8
		100	static SV *
		101	newSVpv_utf8 (const char *s)
		102	{
		103	if (!s)
		104	return newSV (0);
		105
		106	SV *sv = newSVpv (s, 0);
		107	SvUTF8_on (sv);
		108	return sv;
		109	}
		110	#endif
		111
		112	#ifndef newSVpvn_utf8
		113	static SV *
		114	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		115	{
		116	if (!s)
		117	return newSV (0);
		118
		119	SV *sv = newSVpvn (s, l);
		120
		121	if (utf8)
		122	SvUTF8_on (sv);
		123
		124	return sv;
		125	}
		126	#endif
		127
		128	noinline utf8_string
		129	cfSvPVutf8_nolen (SV *sv)
		130	{
		131	SvGETMAGIC (sv);
		132
		133	if (SvPOK (sv))
		134	{
		135	if (!SvUTF8 (sv))
		136	sv_utf8_upgrade_nomg (sv);
		137
		138	return SvPVX (sv);
		139	}
		140
		141	return SvPV_nolen (sv);
		142	}
88		143
89	// helper cast function, returns super class * or 0	144	// helper cast function, returns super class * or 0
90	template<class super>	145	template<class super>
91	static super *	146	static super *
92	is_a (attachable *at)	147	is_a (attachable *at)
…		…
102		157
103	unordered_vector<attachable *> attachable::mortals;	158	unordered_vector<attachable *> attachable::mortals;
104		159
105	attachable::~attachable ()	160	attachable::~attachable ()
106	{	161	{
107	flags |=0x3300;//D
108	assert (!self);	162	assert (!self);
109	assert (!cb);	163	assert (!cb);
110	}	164	}
111		165
112	int	166	int
…		…
126	SvREFCNT_inc (self);	180	SvREFCNT_inc (self);
127	hv_clear (self);	181	hv_clear (self);
128	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	182	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
129	SvREFCNT_dec (self);	183	SvREFCNT_dec (self);
130		184
131	// self *must* be null now because thats sv_unmagic's job.	185	// self *must* be null now because that's sv_unmagic's job.
132	assert (!this->self);	186	assert (!this->self);
133	flags |= 0x80; // severed //D
134	}	187	}
135	}	188	}
136		189
137	void	190	void
138	attachable::optimise ()	191	attachable::optimise ()
139	{	192	{
140	if (self	193	if (self
141	&& SvREFCNT (self) == 1	194	&& SvREFCNT (self) == 1
142	&& !HvTOTALKEYS (self))	195	&& !HvTOTALKEYS (self))
143	flags |= 0x40,//D
144	sever_self ();	196	sever_self ();
145	}	197	}
146		198
147	// check wether the object really is dead	199	// check wether the object really is dead
148	void	200	void
…		…
155	}	207	}
156		208
157	void	209	void
158	attachable::do_destroy ()	210	attachable::do_destroy ()
159	{	211	{
160	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	212	INVOKE_ATTACHABLE (DESTROY, this);
161		213
162	if (cb)	214	if (cb)
163	{	215	{
164	SvREFCNT_dec (cb);	216	SvREFCNT_dec (cb);
165	cb = 0;	217	cb = 0;
166	}	218	}
167		219
168	if (self)
169	sever_self ();
170
171	flags |= 0x20; //D
172	mortals.push_back (this);	220	mortals.push_back (this);
173	}	221	}
174		222
175	void	223	void
176	attachable::destroy ()	224	attachable::destroy ()
177	{	225	{
178	if (destroyed ())	226	if (destroyed ())
179	return;	227	return;
180		228
181	flags |= F_DESTROYED;	229	attachable_flags |= F_DESTROYED;
182	do_destroy ();	230	do_destroy ();
		231	sever_self ();
		232	}
		233
		234	void
		235	attachable::do_delete ()
		236	{
		237	delete this;
183	}	238	}
184		239
185	void	240	void
186	attachable::check_mortals ()	241	attachable::check_mortals ()
187	{	242	{
…		…
191	{	246	{
192	if (i >= mortals.size ())	247	if (i >= mortals.size ())
193	{	248	{
194	i = 0;	249	i = 0;
195		250
196	if (mortals.size () > 1000)	251	if (mortals.size () >= 512)
197	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());	252	{
		253	static int last_mortalcount;
		254	if (mortals.size () != last_mortalcount)
		255	{
		256	last_mortalcount = mortals.size ();
		257	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		258
		259	if (0)
		260	{
		261	for (int j = 0; j < mortals.size (); ++j)//D
		262	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		263
		264	fprintf (stderr, "\n");//D
		265	}
		266	}
		267	}
198		268
199	break;	269	break;
200	}	270	}
201		271
202	attachable *obj = mortals [i];	272	attachable *obj = mortals [i];
203		273
204	obj->refcnt_chk (); // unborrow from perl, if necessary	274	#if 0
205		275	if (obj->self)//D make this an assert later
206	//if (obj->refcnt > 0 || obj->self)
207	if (obj->refcnt || obj->self)
208	{	276	{
209	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D	277	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
		278	obj->sever_self ();
		279	}
		280	#endif
		281
		282	if (obj->refcnt)
		283	{
210	++i; // further delay freeing	284	++i; // further delay freeing
211		285
212	if (!(i & 0x3ff))	286	if (!(i & 0x3ff))
213	break;	287	break;
214	}	288	}
215	else	289	else
216	{	290	{
217	mortals.erase (i);	291	mortals.erase (i);
218	delete obj;	292	obj->sever_self ();
		293	obj->do_delete ();
219	}	294	}
220	}	295	}
221	}	296	}
222		297
		298	void
		299	attachable::set_key (const char *key, const char *value, bool is_utf8)
		300	{
		301	if (!self)
		302	self = newHV ();
		303
		304	if (value)
		305	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		306	else
		307	hv_delete (self, key, strlen (key), G_DISCARD);
		308	}
		309
223	attachable &	310	attachable &
224	attachable::operator =(const attachable &src)	311	attachable::operator =(const attachable &src)
225	{	312	{
226	//if (self || cb)	313	//if (self || cb)
227	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	314	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
228		315
229	attach = src.attach;	316	attach = src.attach;
230	return *this;	317	return *this;
231	}	318	}
232		319
		320	#if 0
		321	template<typename T>
		322	static bool
		323	find_backref (void *ptr, T *obj)
		324	{
		325	char *s = (char *)obj;
		326	while (s < (char *)obj + sizeof (T))
		327	{
		328	if (ptr == *(void **)s)
		329	return true;
		330
		331	s += sizeof (void *); // assume natural alignment
		332	}
		333
		334	return false;
		335	}
		336
		337	// for debugging, find "live" objects containing this ptr
		338	static void
		339	find_backref (void *ptr)
		340	{
		341	for_all_objects (op)
		342	if (find_backref (ptr, op))
		343	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		344
		345	for_all_players (pl)
		346	if (find_backref (ptr, pl))
		347	fprintf (stderr, "P %p\n", pl);
		348
		349	for_all_clients (ns)
		350	if (find_backref (ptr, ns))
		351	fprintf (stderr, "C %p\n", ns);
		352	}
		353	#endif
		354
233	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	355	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
234		356
235	static SV *	357	static SV *
236	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	358	newSVptr (void *ptr, HV *stash, HV *hv)
237	{	359	{
238	SV *sv;
239
240	if (!ptr)	360	if (!ptr)
241	return &PL_sv_undef;	361	return newSV (0);
242		362
243	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	363	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
244	return sv_bless (newRV_noinc ((SV *)hv), stash);	364	return sv_bless (newRV_noinc ((SV *)hv), stash);
		365	}
		366
		367	static SV * noinline
		368	newSVptr (void *ptr, HV *stash)
		369	{
		370	return newSVptr (ptr, stash, newHV ());
245	}	371	}
246		372
247	static int	373	static int
248	attachable_free (pTHX_ SV *sv, MAGIC *mg)	374	attachable_free (pTHX_ SV *sv, MAGIC *mg)
249	{	375	{
…		…
261	return 0;	387	return 0;
262	}	388	}
263		389
264	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};	390	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
265		391
266	static SV *	392	static SV * noinline
267	newSVattachable (attachable *obj, HV *stash)	393	newSVattachable (attachable *obj, HV *stash)
268	{	394	{
269	if (!obj)	395	if (!obj)
270	return &PL_sv_undef;	396	return newSV (0);
271		397
272	if (!obj->self)	398	if (!obj->self)
		399	obj->self = newHV ();
		400
		401	if (!SvOBJECT (obj->self))
273	{	402	{
274	obj->self = newHV ();
275	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);	403	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
276	obj->flags |= (obj->flags & 0xc0) << 8;
277	obj->flags &= ~0xc0;//D
278	obj->flags |= 0x10;//D
279		404
280	// now bless the object _once_	405	// now bless the object _once_
		406	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
281	return sv_bless (newRV_inc ((SV *)obj->self), stash);	407	return sv_bless (newRV_inc ((SV *)obj->self), stash);
282	}	408	}
283	else	409	else
284	{	410	{
285	SV *sv = newRV_inc ((SV *)obj->self);	411	SV *sv = newRV_inc ((SV *)obj->self);
…		…
289		415
290	return sv;	416	return sv;
291	}	417	}
292	}	418	}
293		419
		420	#if 0 // unused
294	static void	421	static void
295	clearSVptr (SV *sv)	422	clearSVptr (SV *sv)
296	{	423	{
297	if (SvROK (sv))	424	if (SvROK (sv))
298	sv = SvRV (sv);	425	sv = SvRV (sv);
299		426
300	hv_clear ((HV *)sv);	427	hv_clear ((HV *)sv);
301	sv_unmagic (sv, PERL_MAGIC_ext);	428	sv_unmagic (sv, PERL_MAGIC_ext);
302	}	429	}
		430	#endif
		431
		432	static long
		433	SvPTR_nc (SV *sv)
		434	{
		435	sv = SvRV (sv);
		436
		437	// very important shortcut
		438	if (expect_true (SvMAGIC (sv) && SvMAGIC (sv)->mg_type == PERL_MAGIC_ext))
		439	return (long)SvMAGIC (sv)->mg_ptr;
		440
		441	if (MAGIC *mg = mg_find (sv, PERL_MAGIC_ext))
		442	return (long)mg->mg_ptr;
		443
		444	croak ("perl code used object, but C object is already destroyed, caught");
		445	}
303		446
304	static long	447	static long
305	SvPTR (SV *sv, const char *klass)	448	SvPTR (SV *sv, const char *klass)
306	{	449	{
307	if (!sv_derived_from (sv, klass))	450	if (!sv_derived_from (sv, klass))
308	croak ("object of type %s expected", klass);	451	croak ("object of type %s expected", klass);
309		452
310	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	453	return SvPTR_nc (sv);
311
312	if (!mg)
313	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
314
315	return (long)mg->mg_ptr;
316	}	454	}
317		455
318	static long	456	static long noinline
319	SvPTR_ornull (SV *sv, const char *klass)	457	SvPTR_ornull (SV *sv, const char *klass)
320	{	458	{
321	if (SvOK (sv))	459	if (expect_false (!SvOK (sv))) return 0;
		460
322	return SvPTR (sv, klass);	461	return SvPTR (sv, klass);
323	else
324	return 0;
325	}	462	}
326		463
		464	static long noinline
		465	SvPTR_ornull_client (SV *sv)
		466	{
		467	if (expect_false (!SvOK (sv))) return 0;
		468
		469	if (!SvROK (sv)
		470	|| (SvSTASH (SvRV (sv)) != stash_cf_client_wrap
		471	&& !sv_derived_from (sv, "cf::client")))
		472	croak ("object of type cf::client expected");
		473
		474	return SvPTR_nc (sv);
		475	}
		476
		477	static long noinline
		478	SvPTR_ornull_object (SV *sv)
		479	{
		480	if (expect_false (!SvOK (sv))) return 0;
		481
		482	if (!SvROK (sv)
		483	|| (SvSTASH (SvRV (sv)) != stash_cf_object_wrap
		484	&& SvSTASH (SvRV (sv)) != stash_cf_object_player_wrap
		485	&& SvSTASH (SvRV (sv)) != stash_cf_arch_wrap
		486	&& !sv_derived_from (sv, "cf::object")))
		487	croak ("object of type cf::object expected");
		488
		489	return SvPTR_nc (sv);
		490	}
		491
		492	static long noinline
		493	SvPTR_ornull_maptile (SV *sv)
		494	{
		495	if (expect_false (!SvOK (sv))) return 0;
		496
		497	if (!SvROK (sv)
		498	|| (SvSTASH (SvRV (sv)) != stash_cf_map_wrap
		499	&& SvSTASH (SvRV (sv)) != stash_ext_map_world
		500	&& !sv_derived_from (sv, "cf::map")))
		501	croak ("object of type cf::map expected");
		502
		503	return SvPTR_nc (sv);
		504	}
		505
		506	static long noinline
		507	SvPTR_ornull_player (SV *sv)
		508	{
		509	if (expect_false (!SvOK (sv))) return 0;
		510
		511	if (!SvROK (sv)
		512	|| (SvSTASH (SvRV (sv)) != stash_cf_player_wrap
		513	&& !sv_derived_from (sv, "cf::player")))
		514	croak ("object of type cf::player expected");
		515
		516	return SvPTR_nc (sv);
		517	}
		518
327	inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }	519	static inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
328	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }	520	static inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
329	inline SV *to_sv (bool v) { return newSViv (v); }	521	static inline SV *to_sv (bool v) { return newSViv (v); }
330	inline SV *to_sv ( signed char v) { return newSViv (v); }	522	static inline SV *to_sv ( signed char v) { return newSViv (v); }
331	inline SV *to_sv (unsigned char v) { return newSViv (v); }	523	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
332	inline SV *to_sv ( signed short v) { return newSViv (v); }	524	static inline SV *to_sv ( signed short v) { return newSViv (v); }
333	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	525	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
334	inline SV *to_sv ( signed int v) { return newSViv (v); }	526	static inline SV *to_sv ( signed int v) { return newSViv (v); }
335	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	527	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
336	inline SV *to_sv ( signed long v) { return newSViv (v); }	528	static inline SV *to_sv ( signed long v) { return newSViv (v); }
337	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	529	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
338	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	530	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
339	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	531	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
340	inline SV *to_sv (float v) { return newSVnv (v); }	532	static inline SV *to_sv (float v) { return newSVnv (v); }
341	inline SV *to_sv (double v) { return newSVnv (v); }	533	static inline SV *to_sv (double v) { return newSVnv (v); }
342	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }	534	static inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
343	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }	535	static inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
		536	// gcc dislikes noilnine on to_sv
344	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }	537	static noinline SV *to_sv_ni (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
		538	static inline SV *to_sv (object * v) { return to_sv_ni (v); }
345	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }	539	static inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
346	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }	540	static inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		541	static inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
347	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }	542	static inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
348	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
349	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	543	static inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		544	static inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
		545	static inline SV *to_sv (layout * v) { return newSVptr (v, stash_cf_layout_wrap); }
350		546
351	inline SV *to_sv (object & v) { return to_sv (&v); }	547	static inline SV *to_sv (object & v) { return to_sv (&v); }
352	inline SV *to_sv (living & v) { return to_sv (&v); }	548	static inline SV *to_sv (living & v) { return to_sv (&v); }
353		549
354	//inline SV *to_sv (faceinfo * v) { return to_sv (v->name); }
355	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
356	inline SV *to_sv (std::string & v) { return newSVpvn (v.data (), v.size ()); }	550	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
		551	static inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
357		552
358	inline SV *to_sv (UUID v)	553	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
359	{
360	char buf[128];
361	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
362	return newSVpv (buf, 0);
363	}
364		554
		555	static inline SV *to_sv (dynbuf * v)
		556	{
		557	SV *sv = newSV (0);
		558
		559	sv_upgrade (sv, SVt_PV);
		560	SvGROW (sv, v->size () + 1);
		561	SvPOK_only (sv);
		562	v->linearise (SvPVX (sv));
		563	SvCUR_set (sv, v->size ());
		564	*SvEND (sv) = 0;
		565
		566	return sv;
		567	}
		568
		569	static inline SV *to_sv (dynbuf_text * v)
		570	{
		571	SV *sv = to_sv (static_cast<dynbuf *> (v));
		572	SvUTF8_on (sv);
		573	return sv;
		574	}
		575
365	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	576	static inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? cfSvPVutf8_nolen (sv) : 0; }
366	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	577	static inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
367	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	578	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
368	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	579	static inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
369	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	580	static inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
370	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	581	static inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
371	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	582	static inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
372	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	583	static inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
373	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	584	static inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
374	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	585	static inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
375	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	586	static inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
376	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	587	static inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
377	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	588	static inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
378	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	589	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
379	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	590	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
380	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }	591	static inline void sv_to (SV *sv, client * &v) { v = (client *) (attachable *)SvPTR_ornull_client (sv); }
381	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	592	static inline void sv_to (SV *sv, player * &v) { v = (player *) (attachable *)SvPTR_ornull_player (sv); }
382	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	593	static inline void sv_to (SV *sv, object * &v) { v = (object *) (attachable *)SvPTR_ornull_object (sv); }
		594	static inline void sv_to (SV *sv, maptile * &v) { v = (maptile *) (attachable *)SvPTR_ornull_maptile (sv); }
383	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	595	static inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
384	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }	596	static inline void sv_to (SV *sv, region * &v) { v = (region *) (attachable *)SvPTR_ornull (sv, "cf::region"); }
385	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	597	static inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
386	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	598	static inline void sv_to (SV *sv, partylist * &v) { v = (partylist *) SvPTR_ornull (sv, "cf::party"); }
387	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
388	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	599	static inline void sv_to (SV *sv, living * &v) { v = (living *) SvPTR_ornull (sv, "cf::living"); }
		600	static inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *) SvPTR_ornull (sv, "cf::mapspace"); }
		601	static inline void sv_to (SV *sv, layout * &v) { v = (layout *) SvPTR_ornull (sv, "cf::layout"); }
		602	static inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *) SvPTR_ornull (sv, "cf::object::freezer"); }
		603	static inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *) SvPTR_ornull (sv, "cf::object::thawer" ); }
389		604
390	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	605	//static inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
391	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); }	606	static inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
392		607
393	template<class T>	608	template<class T>
394	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	609	static inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
395		610
396	template<int N>	611	template<int N>
397	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	612	static inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
398		613
399	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
400	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	614	static inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
401	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	615	static inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
402	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	616	static inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
403	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	617	static inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
404		618
405	inline void sv_to (SV *sv, std::string &v)	619	static inline void sv_to (SV *sv, std::string &v)
406	{	620	{
407	STRLEN len;	621	STRLEN len;
408	char *data = SvPVbyte (sv, len);	622	char *data = SvPVbyte (sv, len);
409	v.assign (data, len);	623	v.assign (data, len);
410	}	624	}
411		625
412	inline void sv_to (SV *sv, UUID &v)	626	static inline void sv_to (SV *sv, UUID &v)
413	{	627	{
414	unsigned int version;	628	if (!v.parse (SvPV_nolen (sv)))
415
416	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
417	croak ("unparsable uuid: %s", SvPV_nolen (sv));	629	croak ("unparsable uuid: %s", SvPV_nolen (sv));
418	}	630	}
419		631
420	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	632	static inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
421		633
422	static SV *	634	static SV *
423	newSVdt_va (va_list &ap, data_type type)	635	newSVdt_va (va_list &ap, data_type type)
424	{	636	{
425	SV *sv;	637	SV *sv;
…		…
439	break;	651	break;
440		652
441	case DT_STRING:	653	case DT_STRING:
442	{	654	{
443	char *str = (char *)va_arg (ap, const char *);	655	char *str = (char *)va_arg (ap, const char *);
444	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	656	sv = str ? newSVpv (str, 0) : newSV (0);
445	}	657	}
446	break;	658	break;
447		659
448	case DT_DATA:	660	case DT_DATA:
449	{	661	{
450	char *str = (char *)va_arg (ap, const void *);	662	char *str = (char *)va_arg (ap, const void *);
451	int len = va_arg (ap, int);	663	int len = va_arg (ap, int);
452	sv = str ? newSVpv (str, len) : &PL_sv_undef;	664	sv = str ? newSVpv (str, len) : newSV (0);
453	}	665	}
454	break;	666	break;
455		667
456	case DT_OBJECT:	668	case DT_OBJECT:
457	sv = to_sv (va_arg (ap, object *));	669	sv = to_sv (va_arg (ap, object *));
…		…
499	va_end (ap);	711	va_end (ap);
500		712
501	return sv;	713	return sv;
502	}	714	}
503		715
		716	// typemap support, mostly to avoid excessive inlining
		717	template<class type>
		718	static void noinline
		719	cf_obj_to (SV *arg, type &var)
		720	{
		721	sv_to (arg, var);
		722	if (expect_false (!var))
		723	croak ("must not pass invalid/null cf_obj here");
		724	}
		725
		726	template<class object>
		727	static void noinline
		728	cf_obj_ornull_to (SV *arg, object *&var)
		729	{
		730	if (SvOK (arg))
		731	{
		732	sv_to (arg, var);
		733	if (expect_false (!var))
		734	croak ("unable to convert perl object to C++ object");
		735	}
		736	else
		737	var = 0;
		738	}
		739
		740	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		741
504	static SV *	742	static SV *
505	newSVcfapi (int type, ...)
506	{
507	SV *sv;
508
509	va_list ap;
510	va_start (ap, type);
511
512	switch (type)
513	{
514	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
515	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
516	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
517	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
518	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
519	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
520	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
521	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
522	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
523	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
524
525	default:
526	assert (("unhandled type in newSVcfapi", 0));
527	}
528
529	va_end (ap);
530
531	return sv;
532	}
533
534	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
535
536	SV *
537	registry (attachable *ext)	743	registry (attachable *ext)
538	{	744	{
539	if (!ext->cb)	745	if (!ext->cb)
540	ext->cb = newAV ();	746	ext->cb = newAV ();
541		747
542	return newRV_inc ((SV *)ext->cb);	748	return newRV_inc ((SV *)ext->cb);
543	}	749	}
544		750
545	/////////////////////////////////////////////////////////////////////////////	751	/////////////////////////////////////////////////////////////////////////////
546		752
547	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
548	{
549	return 0;
550	}
551
552	static CommArray_s rtn_cmd;
553
554	static int
555	runPluginCommand (object *obj, char *params)
556	{
557	return -1;
558	}
559
560	extern "C" void *cfperl_getPluginProperty (int *type, ...)
561	{
562	va_list args;
563	char *propname;
564	int i;
565	va_start (args, type);
566	propname = va_arg (args, char *);
567	//printf ("Property name: %s\n", propname);
568
569	if (!strcmp (propname, "command?"))
570	return NULL;
571	else if (!strcmp (propname, "Identification"))
572	{
573	va_end (args);
574	return (void *)PLUGIN_NAME;
575	}
576	else if (!strcmp (propname, "FullName"))
577	{
578	va_end (args);
579	return (void *)PLUGIN_VERSION;
580	}
581	else
582	va_end (args);
583
584	return NULL;
585	}
586
587	extern "C" int cfperl_postInitPlugin ()
588	{
589	int hooktype = 1;
590	int rtype = 0;
591
592	cf_init_plugin (gethook);
593
594	return 0;
595	}
596
597	extern "C" int cfperl_closePlugin ()
598	{
599	return 0;
600	}
601
602	void	753	void
603	cfperl_init ()	754	cfperl_init ()
604	{	755	{
		756	extern char **environ;
		757
605	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	758	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
606	perl = perl_alloc ();	759	perl = perl_alloc ();
607	perl_construct (perl);	760	perl_construct (perl);
608		761
609	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	762	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
610		763
611	const char *argv[] = {	764	const char *argv[] = {
612	"",	765	settings.argv [0],
613	"-e"	766	"-e0"
614	"use Event; use Coro;" // required for bootstrap
615	"cf->bootstrap;" // required for datadir :*>
616	"unshift @INC, cf::datadir ();"
617	"require cf;"
618	};	767	};
619		768
620	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	769	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
621	|| perl_run (perl))	770	|| perl_run (perl))
622	{	771	{
623	printf ("unable to initialize perl-interpreter, aborting.\n");	772	printf ("unable to initialize perl-interpreter, aborting.\n");
624	exit (EXIT_FAILURE);	773	exit (EXIT_FAILURE);
625	}	774	}
626		775
		776	eval_pv (
		777	"#line 1 'cfperl init'\n"
		778	"use EV ();\n" // required by bootstrap
		779	"use Coro ();\n" // required by bootstrap
		780	"cf->bootstrap;\n" // required for cf::datadir
		781	"unshift @INC, cf::datadir ();\n" // required for 'require' :)
		782	"require cf;\n",
		783	0
		784	);
		785
		786	if (SvTRUE (ERRSV))
627	{	787	{
628	dSP;	788	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
629		789	exit (EXIT_FAILURE);
630	PUSHMARK (SP);
631	PUTBACK;
632	call_pv ("cf::init", G_DISCARD | G_VOID);
633	}	790	}
634	}	791	}
635		792
		793	void
636	void cfperl_main ()	794	cfperl_main ()
637	{	795	{
638	dSP;	796	dSP;
639		797
640	PUSHMARK (SP);	798	PUSHMARK (SP);
641	PUTBACK;	799	PUTBACK;
…		…
645	void	803	void
646	attachable::instantiate ()	804	attachable::instantiate ()
647	{	805	{
648	if (attach)	806	if (attach)
649	{	807	{
650	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	808	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
651	attach = 0;	809	attach = 0;
652	}	810	}
653	}	811	}
654		812
655	void	813	void
656	attachable::reattach ()	814	attachable::reattach ()
657	{	815	{
658	optimise ();	816	optimise ();
659	//TODO: check for _attachment's, very important for restarts	817	//TODO: check for _attachment's, very important for restarts
660	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	818	INVOKE_ATTACHABLE (REATTACH, this);
661	}	819	}
662		820
663	static event_klass klass_of[NUM_EVENT_TYPES] = {	821	static event_klass klass_of[NUM_EVENT_TYPES] = {
664	# define def(type,name) KLASS_ ## type,	822	# define def(type,name) KLASS_ ## type,
665	# include "eventinc.h"	823	# include "eventinc.h"
666	# undef def	824	# undef def
667	};	825	};
668		826
669	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	827	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
670		828
671	static void	829	static void noinline
672	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	830	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
673	{	831	{
674	// event must be in array	832	// event must be in array
675	if (event >= 0 && event <= AvFILLp (registry))	833	if (event >= 0 && event <= AvFILLp (registry))
676	{	834	{
…		…
708	}	866	}
709		867
710	void	868	void
711	global::gather_callbacks (AV *&callbacks, event_type event) const	869	global::gather_callbacks (AV *&callbacks, event_type event) const
712	{	870	{
713	::gather_callbacks (callbacks, cb_object, event);	871	::gather_callbacks (callbacks, cb_global, event);
714	}	872	}
715		873
716	void	874	void
717	object::gather_callbacks (AV *&callbacks, event_type event) const	875	object::gather_callbacks (AV *&callbacks, event_type event) const
718	{	876	{
719	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	877	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
720	{	878	{
721	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	879	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
722		880
723	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	881	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
724	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	882	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
725	}	883	}
726		884
…		…
762	{	920	{
763	attachable::gather_callbacks (callbacks, event);	921	attachable::gather_callbacks (callbacks, event);
764	::gather_callbacks (callbacks, cb_map, event);	922	::gather_callbacks (callbacks, cb_map, event);
765	}	923	}
766		924
		925	static void noinline
		926	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		927	{
		928	for (int event = 0; event <= AvFILLp (registry); ++event)
		929	{
		930	SV *cbs_ = AvARRAY (registry)[event];
		931
		932	// element must be list of callback entries
		933	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		934	{
		935	AV *cbs = (AV *)SvRV (cbs_);
		936
		937	// no callback entries, no callbacks to call
		938	if (AvFILLp (cbs) >= 0)
		939	set.set (event);
		940	}
		941	}
		942	}
		943
		944	// very slow and inefficient way to recalculate the global want bitsets
		945	static void
		946	_recalc_want ()
		947	{
		948	ev_want_event.reset ();
		949
		950	_recalc_want (ev_want_event, cb_global);
		951	_recalc_want (ev_want_event, cb_attachable);
		952	_recalc_want (ev_want_event, cb_object);
		953	_recalc_want (ev_want_event, cb_client);
		954	_recalc_want (ev_want_event, cb_player);
		955	_recalc_want (ev_want_event, cb_map);
		956
		957	ev_want_type.reset ();
		958
		959	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		960	{
		961	SV *cbs_ = AvARRAY (cb_type)[type];
		962
		963	// element must be list of callback entries
		964	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		965	{
		966	AV *cbs = (AV *)SvRV (cbs_);
		967
		968	// no callback entries, no callbacks to call
		969	if (AvFILLp (cbs) >= 0)
		970	ev_want_type.set (type % NUM_TYPES);
		971	}
		972	}
		973	}
		974
767	bool	975	bool
768	attachable::invoke (event_type event, ...)	976	attachable::invoke (event_type event, ...)
769	{	977	{
770	data_type dt;	978	data_type dt;
771	va_list ap;
772
773	va_start (ap, event);
774		979
775	// callback call ordering should be:	980	// callback call ordering should be:
776	// 1. per-object callback	981	// 1. per-object callback
777	// 2. per-class object	982	// 2. per-class object
778	// 3. per-type callback	983	// 3. per-type callback
…		…
782	gather_callbacks (callbacks, event);	987	gather_callbacks (callbacks, event);
783		988
784	// short-circuit processing if no callbacks found/defined	989	// short-circuit processing if no callbacks found/defined
785	if (!callbacks)	990	if (!callbacks)
786	return 0;	991	return 0;
		992
		993	va_list ap;
		994	va_start (ap, event);
787		995
788	CALL_BEGIN (3);	996	CALL_BEGIN (3);
789	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	997	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
790	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	998	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
791		999
…		…
815	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1023	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
816	}	1024	}
817		1025
818	va_end (ap);	1026	va_end (ap);
819		1027
820	CALL_CALL ("cf::do_invoke", G_SCALAR);	1028	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
821	count = count > 0 ? POPi : 0;	1029	count = count > 0 ? POPi : 0;
822		1030
823	CALL_END;	1031	CALL_END;
824		1032
825	return count;	1033	return count;
826	}	1034	}
827		1035
828	SV *	1036	static SV *
829	cfperl_result (int idx)	1037	cfperl_result (int idx)
830	{	1038	{
831	AV *av = get_av ("cfperl::invoke_results", 0);	1039	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
832	if (!av)	1040	if (!av)
833	return &PL_sv_undef;	1041	return &PL_sv_undef;
834		1042
835	SV **sv = av_fetch (av, idx, 0);	1043	SV **sv = av_fetch (av, idx, 0);
836	if (!sv)	1044	if (!sv)
…		…
850	{	1058	{
851	return SvNV (cfperl_result (idx));	1059	return SvNV (cfperl_result (idx));
852	}	1060	}
853		1061
854	/////////////////////////////////////////////////////////////////////////////	1062	/////////////////////////////////////////////////////////////////////////////
		1063	// various c++ => perl glue functions
		1064
		1065	void
		1066	cfperl_tick ()
		1067	{
		1068	tick_pending = 1;
		1069
		1070	if (tick_inhibit)
		1071	return;
		1072
		1073	tick_pending = 0;
		1074
		1075	dSP;
		1076
		1077	PUSHMARK (SP);
		1078	PUTBACK;
		1079	call_pvsv (cv_cf_tick, G_DISCARD | G_VOID);
		1080
		1081	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		1082	}
855		1083
856	void	1084	void
857	cfperl_emergency_save ()	1085	cfperl_emergency_save ()
858	{	1086	{
859	CALL_BEGIN (0);	1087	CALL_BEGIN (0);
…		…
868	CALL_ARG (make_core);	1096	CALL_ARG (make_core);
869	CALL_CALL ("cf::post_cleanup", G_VOID);	1097	CALL_CALL ("cf::post_cleanup", G_VOID);
870	CALL_END;	1098	CALL_END;
871	}	1099	}
872		1100
		1101	void
		1102	cfperl_make_book (object *book, int level)
		1103	{
		1104	CALL_BEGIN (2);
		1105	CALL_ARG (book);
		1106	CALL_ARG (level);
		1107	CALL_CALL ("ext::books::make_book", G_VOID);
		1108	CALL_END;
		1109	}
		1110
		1111	void
		1112	cfperl_send_msg (client *ns, int color, const_utf8_string type, const_utf8_string msg)
		1113	{
		1114	CALL_BEGIN (4);
		1115	CALL_ARG (ns);
		1116	CALL_ARG (type);
		1117	CALL_ARG_SV (newSVpv_utf8 (msg));
		1118	CALL_ARG (color);
		1119	CALL_CALL (cv_cf_client_send_msg, G_VOID);
		1120	CALL_END;
		1121	}
		1122
		1123	int
		1124	cfperl_can_merge (object *ob1, object *ob2)
		1125	{
		1126	int can;
		1127
		1128	CALL_BEGIN (2);
		1129	CALL_ARG (ob1);
		1130	CALL_ARG (ob2);
		1131	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1132	can = count && SvTRUE (TOPs);
		1133	CALL_END;
		1134
		1135	return can;
		1136	}
		1137
		1138	void
		1139	cfperl_mapscript_activate (object *ob, int state, object *activator, object *originator)
		1140	{
		1141	CALL_BEGIN (4);
		1142	CALL_ARG (ob);
		1143	CALL_ARG (state);
		1144	CALL_ARG (activator);
		1145	CALL_ARG (originator);
		1146	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1147	CALL_END;
		1148	}
		1149
		1150	player *
		1151	player::find (const_utf8_string name)
		1152	{
		1153	CALL_BEGIN (1);
		1154	CALL_ARG (name);
		1155	CALL_CALL ("cf::player::find", G_SCALAR);
		1156
		1157	player *retval = 0;
		1158	if (count) sv_to (POPs, retval);
		1159
		1160	CALL_END;
		1161
		1162	return retval;
		1163	}
		1164
873	maptile *	1165	maptile *
		1166	find_style (const_utf8_string dirname, const_utf8_string stylename, int difficulty, bool recurse)
		1167	{
		1168	CALL_BEGIN (4);
		1169	CALL_ARG (dirname);
		1170	CALL_ARG (stylename);
		1171	CALL_ARG (difficulty);
		1172	CALL_ARG (recurse);
		1173	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1174
		1175	maptile *retval = 0;
		1176	if (count) sv_to (POPs, retval);
		1177
		1178	CALL_END;
		1179
		1180	return retval;
		1181	}
		1182
		1183	maptile *
874	maptile::find_sync (const char *path, maptile *origin)	1184	maptile::find_sync (const_utf8_string path, maptile *origin)
875	{	1185	{
876	CALL_BEGIN (2);	1186	CALL_BEGIN (2);
877	CALL_ARG (path);	1187	CALL_ARG (path);
878	CALL_ARG (origin);	1188	CALL_ARG (origin);
879	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1189	CALL_CALL ("cf::map::find_sync", G_SCALAR);
880		1190
881	maptile *retval;	1191	maptile *retval = 0;
882
883	if (count)
884	sv_to (POPs, retval);	1192	if (count) sv_to (POPs, retval);
885	else
886	retval = 0;
887		1193
888	CALL_END;	1194	CALL_END;
889		1195
890	return retval;	1196	return retval;
891	}	1197	}
892		1198
893	maptile *	1199	maptile *
894	maptile::find_async (const char *path, maptile *origin)	1200	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
895	{	1201	{
896	CALL_BEGIN (2);	1202	CALL_BEGIN (3);
897	CALL_ARG (path);	1203	CALL_ARG (path);
898	CALL_ARG (origin);	1204	CALL_ARG (origin);
		1205	CALL_ARG (load);
899	CALL_CALL ("cf::map::find_async", G_SCALAR);	1206	CALL_CALL ("cf::map::find_async", G_SCALAR);
900		1207
901	maptile *retval;	1208	maptile *retval = 0;
902
903	if (count)
904	sv_to (POPs, retval);	1209	if (count) sv_to (POPs, retval);
905	else
906	retval = 0;
907		1210
908	CALL_END;	1211	CALL_END;
909		1212
910	return retval;	1213	return retval;
911	}	1214	}
…		…
914	maptile::do_load_sync ()	1217	maptile::do_load_sync ()
915	{	1218	{
916	CALL_BEGIN (1);	1219	CALL_BEGIN (1);
917	CALL_ARG (this);	1220	CALL_ARG (this);
918	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1221	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
919	CALL_END;
920	}
921
922	void
923	maptile::change_all_map_light (int change)
924	{
925	CALL_BEGIN (1);
926	CALL_ARG (change);
927	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
928	CALL_END;	1222	CALL_END;
929	}	1223	}
930		1224
931	void	1225	void
932	object::enter_exit (object *exit)	1226	object::enter_exit (object *exit)
…		…
939	CALL_ARG (exit);	1233	CALL_ARG (exit);
940	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1234	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
941	CALL_END;	1235	CALL_END;
942	}	1236	}
943		1237
		1238	void
		1239	object::player_goto (const_utf8_string path, int x, int y)
		1240	{
		1241	if (type != PLAYER)
		1242	return;
		1243
		1244	CALL_BEGIN (4);
		1245	CALL_ARG (this);
		1246	CALL_ARG (path);
		1247	CALL_ARG (x);
		1248	CALL_ARG (y);
		1249	CALL_CALL ("cf::object::player::goto", G_VOID);
		1250	CALL_END;
		1251	}
		1252
		1253	const_utf8_string
		1254	object::ref () const
		1255	{
		1256	if (type == PLAYER)
		1257	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1258	else
		1259	// TODO: should be able to save references within the same map, at least
		1260	return 0;
		1261	}
		1262
		1263	object *
		1264	object::deref (const_utf8_string ref)
		1265	{
		1266	object *retval = 0;
		1267
		1268	if (ref)
		1269	{
		1270	CALL_BEGIN (1);
		1271	CALL_ARG (ref);
		1272	CALL_CALL ("cf::object::deref", G_SCALAR);
		1273
		1274	if (count)
		1275	sv_to (POPs, retval);
		1276
		1277	CALL_END;
		1278	}
		1279
		1280	return retval;
		1281	}
		1282
		1283	void
		1284	log_backtrace (const_utf8_string msg)
		1285	{
		1286	#if HAVE_BACKTRACE
		1287	void *addr [20];
		1288	int size = backtrace (addr, 20);
		1289
		1290	CALL_BEGIN (size);
		1291	CALL_ARG (msg);
		1292	for (int i = 0; i < size; ++i)
		1293	CALL_ARG ((IV)addr [i]);
		1294	CALL_CALL ("cf::_log_backtrace", G_VOID);
		1295	CALL_END;
		1296	#endif
		1297	}
		1298
		1299	bool
		1300	is_match_expr (const_utf8_string expr)
		1301	{
		1302	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1303	}
		1304
		1305	bool
		1306	match (const_utf8_string expr, object *ob, object *self, object *source, object *originator)
		1307	{
		1308	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1309	expr += sizeof ("match ") - 1;
		1310
		1311	CALL_BEGIN (5);
		1312	CALL_ARG (expr);
		1313	CALL_ARG (ob);
		1314	CALL_ARG (self);
		1315	CALL_ARG (source);
		1316	CALL_ARG (originator);
		1317	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1318
		1319	bool matched = count && SvTRUE (TOPs);
		1320
		1321	CALL_END;
		1322
		1323	return matched;
		1324	}
		1325
		1326	object *
		1327	match_one (const_utf8_string expr, object *ob, object *self, object *source, object *originator)
		1328	{
		1329	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1330	expr += sizeof ("match ") - 1;
		1331
		1332	CALL_BEGIN (5);
		1333	CALL_ARG (expr);
		1334	CALL_ARG (ob);
		1335	CALL_ARG (self);
		1336	CALL_ARG (source);
		1337	CALL_ARG (originator);
		1338	CALL_CALL (cv_cf_match_match, G_ARRAY);
		1339
		1340	object *one = 0;
		1341
		1342	if (count)
		1343	sv_to (TOPs, one);
		1344
		1345	CALL_END;
		1346
		1347	return one;
		1348	}
		1349
944	/////////////////////////////////////////////////////////////////////////////	1350	/////////////////////////////////////////////////////////////////////////////
945		1351
946	struct EventAPI *watcher_base::GEventAPI;	1352	struct EVAPI *evapi::GEVAPI;
947	struct CoroAPI *coroapi::GCoroAPI;	1353	struct CoroAPI *coroapi::GCoroAPI;
948		1354
949	int coroapi::cede_counter;
950
951	static void iw_dispatch (pe_event *ev)
952	{
953	iw *w = (iw *)ev->ext_data;
954	w->call (*w);
955	}
956
957	void	1355	void
958	iw::alloc ()	1356	coroapi::do_cede_to_tick ()
959	{	1357	{
960	pe = GEventAPI->new_idle (0, 0);	1358	cede_pending = 0;
961		1359	cede ();
962	WaREENTRANT_off (pe);
963	pe->base.callback = (void *)iw_dispatch;
964	pe->base.ext_data = (void *)this;
965	}	1360	}
966		1361
967	static void iow_dispatch (pe_event *ev)
968	{
969	iow *w = (iow *)ev->ext_data;
970	w->call (*w, ((pe_ioevent *)ev)->got);
971	}
972
973	void	1362	void
974	iow::alloc ()	1363	coroapi::wait_for_tick ()
975	{	1364	{
976	pe = GEventAPI->new_io (0, 0);	1365	CALL_BEGIN (0);
977		1366	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
978	WaREENTRANT_off (pe);	1367	CALL_END;
979	pe->base.callback = (void *)iow_dispatch;
980	pe->base.ext_data = (void *)this;
981
982	pe->fd = -1;
983	pe->poll = 0;
984	}	1368	}
985		1369
986	void	1370	void
987	iow::fd (int fd)	1371	coroapi::wait_for_tick_begin ()
988	{	1372	{
989	pe->fd = fd;	1373	CALL_BEGIN (0);
990	}	1374	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
991		1375	CALL_END;
992	int
993	iow::poll ()
994	{
995	return pe->poll;
996	}	1376	}
997		1377
998	void	1378	void
999	iow::poll (int events)	1379	iow::poll (int events)
1000	{	1380	{
1001	if (pe->poll != events)	1381	if (events != this->events)
1002	{	1382	{
		1383	int active = ev_is_active ((ev_io *)this);
1003	if (pe->poll) stop ();	1384	if (active) stop ();
1004	pe->poll = events;	1385	ev_io_set ((ev_io *)this, fd, events);
1005	if (pe->poll) start ();	1386	if (active) start ();
1006	}	1387	}
1007	}	1388	}
1008		1389
1009	void	1390	static void
1010	_connect_to_perl ()	1391	_connect_to_perl_1 ()
1011	{	1392	{
1012	stash_cf = gv_stashpv ("cf" , 1);	1393	stash_cf = gv_stashpv ("cf", 1);
1013		1394
1014	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1395	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1015	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1396	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1016	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1397	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1017	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1398	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1399	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1018	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1400	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1019	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1401	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1020	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1402	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1021	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1403	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1022	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1404	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
		1405	stash_cf_layout_wrap = gv_stashpv ("cf::layout::wrap", 1);
		1406	stash_ext_map_world = gv_stashpv ("ext::map_world" , 1);
1023		1407
1024	sv_runtime = get_sv ("cf::RUNTIME", 1);	1408	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1025	sv_upgrade (sv_runtime, SVt_NV);	1409	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1410	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
		1411	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1026		1412
1027	cb_global = get_av ("cf::CB_GLOBAL", 1);	1413	cb_global = get_av ("cf::CB_GLOBAL", 1);
1028	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1414	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1029	cb_object = get_av ("cf::CB_OBJECT", 1);	1415	cb_object = get_av ("cf::CB_OBJECT", 1);
1030	cb_player = get_av ("cf::CB_PLAYER", 1);	1416	cb_player = get_av ("cf::CB_PLAYER", 1);
1031	cb_client = get_av ("cf::CB_CLIENT", 1);	1417	cb_client = get_av ("cf::CB_CLIENT", 1);
1032	cb_type = get_av ("cf::CB_TYPE" , 1);	1418	cb_type = get_av ("cf::CB_TYPE" , 1);
1033	cb_map = get_av ("cf::CB_MAP" , 1);	1419	cb_map = get_av ("cf::CB_MAP" , 1);
1034	}	1420	}
1035		1421
		1422	static void
		1423	_connect_to_perl_2 ()
		1424	{
		1425	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1426	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1427	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1428	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1429	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
		1430	}
		1431
1036	MODULE = cf PACKAGE = cf PREFIX = cf_	1432	MODULE = cf PACKAGE = cf PREFIX = cf_
1037		1433
1038	BOOT:	1434	BOOT:
1039	{	1435	{
		1436	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
		1437	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1438
1040	_connect_to_perl ();	1439	_connect_to_perl_1 ();
1041
1042	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1043	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1044		1440
1045	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1441	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
		1442
		1443	//{
		1444	// require_pv ("Time::HiRes");
		1445	//
		1446	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
		1447	// if (!svp) croak ("Time::HiRes is required");
		1448	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
		1449	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
		1450	//}
1046		1451
1047	static const struct {	1452	static const struct {
1048	const char *name;	1453	const char *name;
1049	IV iv;	1454	IV iv;
1050	} *civ, const_iv[] = {	1455	} *civ, const_iv[] = {
1051	# define const_iv(name) { # name, (IV)name },	1456	# define const_iv(name) { # name, (IV)name },
1052	const_iv (llevError)	1457	# include "const_iv.h"
1053	const_iv (llevInfo)	1458	# define def(uc, lc, name, plus, change) const_iv (AT_ ## uc) const_iv (ATNR_ ## uc)
1054	const_iv (llevDebug)	1459	# include "attackinc.h"
1055	const_iv (llevMonster)	1460	# undef def
		1461	# define def(uc, flags) const_iv (SK_ ## uc)
		1462	# include "skillinc.h"
		1463	# undef def
1056		1464
1057	const_iv (Map0Cmd)	1465	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1058	const_iv (Map1Cmd)
1059	const_iv (Map1aCmd)
1060		1466
1061	const_iv (MAP_CLIENT_X)	1467	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1062	const_iv (MAP_CLIENT_Y)
1063		1468
1064	const_iv (MAX_TIME)	1469	const_iv (MAX_TIME)
1065	const_iv (PLAYER)
1066	const_iv (TRANSPORT)
1067	const_iv (ROD)
1068	const_iv (TREASURE)
1069	const_iv (POTION)
1070	const_iv (FOOD)
1071	const_iv (POISON)
1072	const_iv (BOOK)
1073	const_iv (CLOCK)	1470	const_iv (MAXSOCKBUF)
1074	const_iv (ARROW)
1075	const_iv (BOW)
1076	const_iv (WEAPON)
1077	const_iv (ARMOUR)
1078	const_iv (PEDESTAL)
1079	const_iv (ALTAR)
1080	const_iv (LOCKED_DOOR)
1081	const_iv (SPECIAL_KEY)
1082	const_iv (MAP)
1083	const_iv (DOOR)
1084	const_iv (KEY)
1085	const_iv (TIMED_GATE)
1086	const_iv (TRIGGER)
1087	const_iv (GRIMREAPER)
1088	const_iv (MAGIC_EAR)
1089	const_iv (TRIGGER_BUTTON)
1090	const_iv (TRIGGER_ALTAR)
1091	const_iv (TRIGGER_PEDESTAL)
1092	const_iv (SHIELD)
1093	const_iv (HELMET)
1094	const_iv (HORN)
1095	const_iv (MONEY)
1096	const_iv (CLASS)
1097	const_iv (GRAVESTONE)
1098	const_iv (AMULET)
1099	const_iv (PLAYERMOVER)
1100	const_iv (TELEPORTER)
1101	const_iv (CREATOR)
1102	const_iv (SKILL)
1103	const_iv (EARTHWALL)
1104	const_iv (GOLEM)
1105	const_iv (THROWN_OBJ)
1106	const_iv (BLINDNESS)
1107	const_iv (GOD)
1108	const_iv (DETECTOR)
1109	const_iv (TRIGGER_MARKER)
1110	const_iv (DEAD_OBJECT)
1111	const_iv (DRINK)
1112	const_iv (MARKER)
1113	const_iv (HOLY_ALTAR)
1114	const_iv (PLAYER_CHANGER)
1115	const_iv (BATTLEGROUND)
1116	const_iv (PEACEMAKER)
1117	const_iv (GEM)
1118	const_iv (FIREWALL)
1119	const_iv (ANVIL)
1120	const_iv (CHECK_INV)
1121	const_iv (MOOD_FLOOR)
1122	const_iv (EXIT)
1123	const_iv (ENCOUNTER)
1124	const_iv (SHOP_FLOOR)
1125	const_iv (SHOP_MAT)
1126	const_iv (RING)
1127	const_iv (FLOOR)
1128	const_iv (FLESH)
1129	const_iv (INORGANIC)
1130	const_iv (SKILL_TOOL)
1131	const_iv (LIGHTER)
1132	const_iv (BUILDABLE_WALL)
1133	const_iv (MISC_OBJECT)
1134	const_iv (LAMP)
1135	const_iv (DUPLICATOR)
1136	const_iv (SPELLBOOK)
1137	const_iv (CLOAK)
1138	const_iv (SPINNER)
1139	const_iv (GATE)
1140	const_iv (BUTTON)
1141	const_iv (CF_HANDLE)
1142	const_iv (HOLE)
1143	const_iv (TRAPDOOR)
1144	const_iv (SIGN)
1145	const_iv (BOOTS)
1146	const_iv (GLOVES)
1147	const_iv (SPELL)
1148	const_iv (SPELL_EFFECT)
1149	const_iv (CONVERTER)
1150	const_iv (BRACERS)
1151	const_iv (POISONING)
1152	const_iv (SAVEBED)
1153	const_iv (WAND)
1154	const_iv (SCROLL)
1155	const_iv (DIRECTOR)
1156	const_iv (GIRDLE)
1157	const_iv (FORCE)
1158	const_iv (POTION_EFFECT)
1159	const_iv (EVENT_CONNECTOR)
1160	const_iv (CLOSE_CON)
1161	const_iv (CONTAINER)
1162	const_iv (ARMOUR_IMPROVER)
1163	const_iv (WEAPON_IMPROVER)
1164	const_iv (SKILLSCROLL)
1165	const_iv (DEEP_SWAMP)
1166	const_iv (IDENTIFY_ALTAR)
1167	const_iv (MENU)
1168	const_iv (RUNE)
1169	const_iv (TRAP)
1170	const_iv (POWER_CRYSTAL)
1171	const_iv (CORPSE)
1172	const_iv (DISEASE)
1173	const_iv (SYMPTOM)
1174	const_iv (BUILDER)
1175	const_iv (MATERIAL)
1176	const_iv (ITEM_TRANSFORMER)
1177		1471
1178	const_iv (NUM_SUBTYPES)	1472	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
		1473	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1179		1474
1180	const_iv (ST_BD_BUILD)	1475	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_LEVEL)
1181	const_iv (ST_BD_REMOVE)
1182		1476
1183	const_iv (ST_MAT_FLOOR)	1477	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1184	const_iv (ST_MAT_WALL)	1478	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1185	const_iv (ST_MAT_ITEM)
1186
1187	const_iv (AT_PHYSICAL)
1188	const_iv (AT_MAGIC)
1189	const_iv (AT_FIRE)
1190	const_iv (AT_ELECTRICITY)
1191	const_iv (AT_COLD)
1192	const_iv (AT_CONFUSION)
1193	const_iv (AT_ACID)
1194	const_iv (AT_DRAIN)
1195	const_iv (AT_WEAPONMAGIC)
1196	const_iv (AT_GHOSTHIT)
1197	const_iv (AT_POISON)
1198	const_iv (AT_SLOW)
1199	const_iv (AT_PARALYZE)
1200	const_iv (AT_TURN_UNDEAD)
1201	const_iv (AT_FEAR)
1202	const_iv (AT_CANCELLATION)
1203	const_iv (AT_DEPLETE)
1204	const_iv (AT_DEATH)
1205	const_iv (AT_CHAOS)
1206	const_iv (AT_COUNTERSPELL)
1207	const_iv (AT_GODPOWER)
1208	const_iv (AT_HOLYWORD)
1209	const_iv (AT_BLIND)
1210	const_iv (AT_INTERNAL)
1211	const_iv (AT_LIFE_STEALING)
1212	const_iv (AT_DISEASE)
1213
1214	const_iv (WEAP_HIT)
1215	const_iv (WEAP_SLASH)
1216	const_iv (WEAP_PIERCE)
1217	const_iv (WEAP_CLEAVE)
1218	const_iv (WEAP_SLICE)
1219	const_iv (WEAP_STAB)
1220	const_iv (WEAP_WHIP)
1221	const_iv (WEAP_CRUSH)
1222	const_iv (WEAP_BLUD)
1223
1224	const_iv (FLAG_ALIVE)
1225	const_iv (FLAG_WIZ)
1226	const_iv (FLAG_REMOVED)
1227	const_iv (FLAG_FREED)
1228	const_iv (FLAG_WAS_WIZ)
1229	const_iv (FLAG_APPLIED)
1230	const_iv (FLAG_UNPAID)
1231	const_iv (FLAG_USE_SHIELD)
1232	const_iv (FLAG_NO_PICK)
1233	const_iv (FLAG_ANIMATE)
1234	const_iv (FLAG_MONSTER)
1235	const_iv (FLAG_FRIENDLY)
1236	const_iv (FLAG_GENERATOR)
1237	const_iv (FLAG_IS_THROWN)
1238	const_iv (FLAG_AUTO_APPLY)
1239	const_iv (FLAG_PLAYER_SOLD)
1240	const_iv (FLAG_SEE_INVISIBLE)
1241	const_iv (FLAG_CAN_ROLL)
1242	const_iv (FLAG_OVERLAY_FLOOR)
1243	const_iv (FLAG_IS_TURNABLE)
1244	const_iv (FLAG_IS_USED_UP)
1245	const_iv (FLAG_IDENTIFIED)
1246	const_iv (FLAG_REFLECTING)
1247	const_iv (FLAG_CHANGING)
1248	const_iv (FLAG_SPLITTING)
1249	const_iv (FLAG_HITBACK)
1250	const_iv (FLAG_STARTEQUIP)
1251	const_iv (FLAG_BLOCKSVIEW)
1252	const_iv (FLAG_UNDEAD)
1253	const_iv (FLAG_SCARED)
1254	const_iv (FLAG_UNAGGRESSIVE)
1255	const_iv (FLAG_REFL_MISSILE)
1256	const_iv (FLAG_REFL_SPELL)
1257	const_iv (FLAG_NO_MAGIC)
1258	const_iv (FLAG_NO_FIX_PLAYER)
1259	const_iv (FLAG_IS_LIGHTABLE)
1260	const_iv (FLAG_TEAR_DOWN)
1261	const_iv (FLAG_RUN_AWAY)
1262	const_iv (FLAG_PICK_UP)
1263	const_iv (FLAG_UNIQUE)
1264	const_iv (FLAG_NO_DROP)
1265	const_iv (FLAG_WIZCAST)
1266	const_iv (FLAG_CAST_SPELL)
1267	const_iv (FLAG_USE_SCROLL)
1268	const_iv (FLAG_USE_RANGE)
1269	const_iv (FLAG_USE_BOW)
1270	const_iv (FLAG_USE_ARMOUR)
1271	const_iv (FLAG_USE_WEAPON)
1272	const_iv (FLAG_USE_RING)
1273	const_iv (FLAG_READY_RANGE)
1274	const_iv (FLAG_READY_BOW)
1275	const_iv (FLAG_XRAYS)
1276	const_iv (FLAG_NO_APPLY)
1277	const_iv (FLAG_IS_FLOOR)
1278	const_iv (FLAG_LIFESAVE)
1279	const_iv (FLAG_NO_STRENGTH)
1280	const_iv (FLAG_SLEEP)
1281	const_iv (FLAG_STAND_STILL)
1282	const_iv (FLAG_RANDOM_MOVE)
1283	const_iv (FLAG_ONLY_ATTACK)
1284	const_iv (FLAG_CONFUSED)
1285	const_iv (FLAG_STEALTH)
1286	const_iv (FLAG_WIZPASS)
1287	const_iv (FLAG_IS_LINKED)
1288	const_iv (FLAG_CURSED)
1289	const_iv (FLAG_DAMNED)
1290	const_iv (FLAG_SEE_ANYWHERE)
1291	const_iv (FLAG_KNOWN_MAGICAL)
1292	const_iv (FLAG_KNOWN_CURSED)
1293	const_iv (FLAG_CAN_USE_SKILL)
1294	const_iv (FLAG_BEEN_APPLIED)
1295	const_iv (FLAG_READY_SCROLL)
1296	const_iv (FLAG_USE_ROD)
1297	const_iv (FLAG_USE_HORN)
1298	const_iv (FLAG_MAKE_INVIS)
1299	const_iv (FLAG_INV_LOCKED)
1300	const_iv (FLAG_IS_WOODED)
1301	const_iv (FLAG_IS_HILLY)
1302	const_iv (FLAG_READY_SKILL)
1303	const_iv (FLAG_READY_WEAPON)
1304	const_iv (FLAG_NO_SKILL_IDENT)
1305	const_iv (FLAG_BLIND)
1306	const_iv (FLAG_SEE_IN_DARK)
1307	const_iv (FLAG_IS_CAULDRON)
1308	const_iv (FLAG_NO_STEAL)
1309	const_iv (FLAG_ONE_HIT)
1310	const_iv (FLAG_CLIENT_SENT)
1311	const_iv (FLAG_BERSERK)
1312	const_iv (FLAG_NEUTRAL)
1313	const_iv (FLAG_NO_ATTACK)
1314	const_iv (FLAG_NO_DAMAGE)
1315	const_iv (FLAG_OBJ_ORIGINAL)
1316	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1317	const_iv (FLAG_ACTIVATE_ON_PUSH)
1318	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1319	const_iv (FLAG_IS_WATER)
1320	const_iv (FLAG_CONTENT_ON_GEN)
1321	const_iv (FLAG_IS_A_TEMPLATE)
1322	const_iv (FLAG_IS_BUILDABLE)
1323	const_iv (FLAG_DESTROY_ON_DEATH)
1324	const_iv (FLAG_NO_MAP_SAVE)
1325
1326	const_iv (NDI_BLACK)
1327	const_iv (NDI_WHITE)
1328	const_iv (NDI_NAVY)
1329	const_iv (NDI_RED)
1330	const_iv (NDI_ORANGE)
1331	const_iv (NDI_BLUE)
1332	const_iv (NDI_DK_ORANGE)
1333	const_iv (NDI_GREEN)
1334	const_iv (NDI_LT_GREEN)
1335	const_iv (NDI_GREY)
1336	const_iv (NDI_BROWN)
1337	const_iv (NDI_GOLD)
1338	const_iv (NDI_TAN)
1339	const_iv (NDI_MAX_COLOR)
1340	const_iv (NDI_COLOR_MASK)
1341	const_iv (NDI_UNIQUE)
1342	const_iv (NDI_ALL)
1343
1344	const_iv (UPD_LOCATION)
1345	const_iv (UPD_FLAGS)
1346	const_iv (UPD_WEIGHT)
1347	const_iv (UPD_FACE)
1348	const_iv (UPD_NAME)
1349	const_iv (UPD_ANIM)
1350	const_iv (UPD_ANIMSPEED)
1351	const_iv (UPD_NROF)
1352
1353	const_iv (UPD_SP_MANA)
1354	const_iv (UPD_SP_GRACE)
1355	const_iv (UPD_SP_DAMAGE)
1356
1357	const_iv (F_APPLIED)
1358	const_iv (F_LOCATION)
1359	const_iv (F_UNPAID)
1360	const_iv (F_MAGIC)
1361	const_iv (F_CURSED)
1362	const_iv (F_DAMNED)
1363	const_iv (F_OPEN)
1364	const_iv (F_NOPICK)
1365	const_iv (F_LOCKED)	1479	const_iv (F_LOCKED)
1366		1480
1367	const_iv (F_BUY)	1481	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1368	const_iv (F_SHOP)	1482	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1369	const_iv (F_SELL)
1370		1483
1371	const_iv (P_BLOCKSVIEW)	1484	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1372	const_iv (P_PLAYER)
1373	const_iv (P_NO_MAGIC)
1374	const_iv (P_IS_ALIVE)
1375	const_iv (P_NO_CLERIC)
1376	const_iv (P_OUT_OF_MAP)
1377	const_iv (P_NEW_MAP)
1378	const_iv (P_UPTODATE)
1379		1485
1380	const_iv (UP_OBJ_INSERT)	1486	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1381	const_iv (UP_OBJ_REMOVE)	1487	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1382	const_iv (UP_OBJ_CHANGE)
1383	const_iv (UP_OBJ_FACE)
1384		1488
1385	const_iv (INS_NO_MERGE)	1489	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1386	const_iv (INS_ABOVE_FLOOR_ONLY)
1387	const_iv (INS_NO_WALK_ON)
1388	const_iv (INS_ON_TOP)
1389	const_iv (INS_BELOW_ORIGINATOR)
1390	const_iv (INS_MAP_LOAD)
1391
1392	const_iv (WILL_APPLY_HANDLE)
1393	const_iv (WILL_APPLY_TREASURE)
1394	const_iv (WILL_APPLY_EARTHWALL)
1395	const_iv (WILL_APPLY_DOOR)
1396	const_iv (WILL_APPLY_FOOD)
1397
1398	const_iv (SAVE_MODE)
1399	const_iv (SAVE_DIR_MODE)
1400
1401	const_iv (M_PAPER)
1402	const_iv (M_IRON)
1403	const_iv (M_GLASS)
1404	const_iv (M_LEATHER)
1405	const_iv (M_WOOD)
1406	const_iv (M_ORGANIC)
1407	const_iv (M_STONE)
1408	const_iv (M_CLOTH)
1409	const_iv (M_ADAMANT)
1410	const_iv (M_LIQUID)
1411	const_iv (M_SOFT_METAL)
1412	const_iv (M_BONE)
1413	const_iv (M_ICE)	1490	const_iv (MAP_INACTIVE)
1414	const_iv (M_SPECIAL)
1415		1491
1416	const_iv (SK_EXP_ADD_SKILL)	1492	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1417	const_iv (SK_EXP_TOTAL)	1493	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1418	const_iv (SK_EXP_NONE)
1419	const_iv (SK_SUBTRACT_SKILL_EXP)
1420	const_iv (SK_EXP_SKILL_ONLY)
1421		1494
1422	const_iv (SK_LOCKPICKING)	1495	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1423	const_iv (SK_HIDING)
1424	const_iv (SK_SMITHERY)
1425	const_iv (SK_BOWYER)
1426	const_iv (SK_JEWELER)
1427	const_iv (SK_ALCHEMY)
1428	const_iv (SK_STEALING)
1429	const_iv (SK_LITERACY)
1430	const_iv (SK_BARGAINING)
1431	const_iv (SK_JUMPING)
1432	const_iv (SK_DET_MAGIC)
1433	const_iv (SK_ORATORY)
1434	const_iv (SK_SINGING)
1435	const_iv (SK_DET_CURSE)
1436	const_iv (SK_FIND_TRAPS)
1437	const_iv (SK_MEDITATION)
1438	const_iv (SK_PUNCHING)
1439	const_iv (SK_FLAME_TOUCH)
1440	const_iv (SK_KARATE)
1441	const_iv (SK_CLIMBING)
1442	const_iv (SK_WOODSMAN)
1443	const_iv (SK_INSCRIPTION)
1444	const_iv (SK_ONE_HANDED_WEAPON)
1445	const_iv (SK_MISSILE_WEAPON)
1446	const_iv (SK_THROWING)
1447	const_iv (SK_USE_MAGIC_ITEM)
1448	const_iv (SK_DISARM_TRAPS)
1449	const_iv (SK_SET_TRAP)
1450	const_iv (SK_THAUMATURGY)
1451	const_iv (SK_PRAYING)
1452	const_iv (SK_CLAWING)
1453	const_iv (SK_LEVITATION)
1454	const_iv (SK_SUMMONING)
1455	const_iv (SK_PYROMANCY)
1456	const_iv (SK_EVOCATION)
1457	const_iv (SK_SORCERY)
1458	const_iv (SK_TWO_HANDED_WEAPON)
1459	const_iv (SK_SPARK_TOUCH)
1460	const_iv (SK_SHIVER)
1461	const_iv (SK_ACID_SPLASH)
1462	const_iv (SK_POISON_NAIL)
1463		1496
1464	const_iv (SOUND_NEW_PLAYER)	1497	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1465	const_iv (SOUND_FIRE_ARROW)
1466	const_iv (SOUND_LEARN_SPELL)
1467	const_iv (SOUND_FUMBLE_SPELL)
1468	const_iv (SOUND_WAND_POOF)
1469	const_iv (SOUND_OPEN_DOOR)
1470	const_iv (SOUND_PUSH_PLAYER)
1471	const_iv (SOUND_PLAYER_HITS1)
1472	const_iv (SOUND_PLAYER_HITS2)
1473	const_iv (SOUND_PLAYER_HITS3)
1474	const_iv (SOUND_PLAYER_HITS4)
1475	const_iv (SOUND_PLAYER_IS_HIT1)
1476	const_iv (SOUND_PLAYER_IS_HIT2)
1477	const_iv (SOUND_PLAYER_IS_HIT3)
1478	const_iv (SOUND_PLAYER_KILLS)
1479	const_iv (SOUND_PET_IS_KILLED)
1480	const_iv (SOUND_PLAYER_DIES)
1481	const_iv (SOUND_OB_EVAPORATE)
1482	const_iv (SOUND_OB_EXPLODE)
1483	const_iv (SOUND_CLOCK)
1484	const_iv (SOUND_TURN_HANDLE)
1485	const_iv (SOUND_FALL_HOLE)
1486	const_iv (SOUND_DRINK_POISON)
1487	const_iv (SOUND_CAST_SPELL_0)
1488
1489	const_iv (PREFER_LOW)
1490	const_iv (PREFER_HIGH)
1491
1492	const_iv (ATNR_PHYSICAL)
1493	const_iv (ATNR_MAGIC)
1494	const_iv (ATNR_FIRE)
1495	const_iv (ATNR_ELECTRICITY)
1496	const_iv (ATNR_COLD)
1497	const_iv (ATNR_CONFUSION)
1498	const_iv (ATNR_ACID)
1499	const_iv (ATNR_DRAIN)
1500	const_iv (ATNR_WEAPONMAGIC)
1501	const_iv (ATNR_GHOSTHIT)
1502	const_iv (ATNR_POISON)
1503	const_iv (ATNR_SLOW)
1504	const_iv (ATNR_PARALYZE)
1505	const_iv (ATNR_TURN_UNDEAD)
1506	const_iv (ATNR_FEAR)
1507	const_iv (ATNR_CANCELLATION)
1508	const_iv (ATNR_DEPLETE)
1509	const_iv (ATNR_DEATH)
1510	const_iv (ATNR_CHAOS)
1511	const_iv (ATNR_COUNTERSPELL)
1512	const_iv (ATNR_GODPOWER)
1513	const_iv (ATNR_HOLYWORD)
1514	const_iv (ATNR_BLIND)
1515	const_iv (ATNR_INTERNAL)
1516	const_iv (ATNR_LIFE_STEALING)
1517	const_iv (ATNR_DISEASE)
1518
1519	const_iv (MAP_IN_MEMORY)
1520	const_iv (MAP_SWAPPED)
1521	const_iv (MAP_LOADING)
1522	const_iv (MAP_SAVING)
1523
1524	const_iv (KLASS_ATTACHABLE)
1525	const_iv (KLASS_GLOBAL)
1526	const_iv (KLASS_OBJECT)
1527	const_iv (KLASS_CLIENT)
1528	const_iv (KLASS_PLAYER)
1529	const_iv (KLASS_MAP)
1530
1531	const_iv (CS_QUERY_YESNO)
1532	const_iv (CS_QUERY_SINGLECHAR)
1533	const_iv (CS_QUERY_HIDEINPUT)
1534
1535	const_iv (ST_DEAD)
1536	const_iv (ST_SETUP)
1537	const_iv (ST_PLAYING)
1538	const_iv (ST_CUSTOM)
1539
1540	const_iv (ST_CHANGE_CLASS)
1541
1542	const_iv (IO_HEADER)
1543	const_iv (IO_OBJECTS)
1544	const_iv (IO_UNIQUES)
1545
1546	// random map generator
1547	const_iv (LAYOUT_NONE)
1548	const_iv (LAYOUT_ONION)
1549	const_iv (LAYOUT_MAZE)
1550	const_iv (LAYOUT_SPIRAL)
1551	const_iv (LAYOUT_ROGUELIKE)
1552	const_iv (LAYOUT_SNAKE)
1553	const_iv (LAYOUT_SQUARE_SPIRAL)
1554
1555	const_iv (RMOPT_RANDOM)
1556	const_iv (RMOPT_CENTERED)
1557	const_iv (RMOPT_LINEAR)
1558	const_iv (RMOPT_BOTTOM_C)
1559	const_iv (RMOPT_BOTTOM_R)
1560	const_iv (RMOPT_IRR_SPACE)
1561	const_iv (RMOPT_WALL_OFF)
1562	const_iv (RMOPT_WALLS_ONLY)
1563	const_iv (RMOPT_NO_DOORS)
1564
1565	const_iv (SYMMETRY_RANDOM)
1566	const_iv (SYMMETRY_NONE)
1567	const_iv (SYMMETRY_X)
1568	const_iv (SYMMETRY_Y)
1569	const_iv (SYMMETRY_XY)
1570	};	1498	};
1571		1499
1572	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1500	for (civ = const_iv + array_length (const_iv); civ-- > const_iv; )
1573	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1501	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1574		1502
1575	static const struct {	1503	static const struct {
1576	const char *name;	1504	const char *name;
1577	int skip;	1505	int skip;
…		…
1583	# undef def	1511	# undef def
1584	};	1512	};
1585		1513
1586	AV *av = get_av ("cf::EVENT", 1);	1514	AV *av = get_av ("cf::EVENT", 1);
1587		1515
1588	for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; )	1516	for (eiv = event_iv + array_length (event_iv); eiv-- > event_iv; )
1589	{	1517	{
1590	AV *event = newAV ();	1518	AV *event = newAV ();
1591	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1519	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1592	av_push (event, newSViv (eiv->klass));	1520	av_push (event, newSViv (eiv->klass));
1593	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1521	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1594	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1522	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1595	}	1523	}
1596	}
1597		1524
		1525	// used by autogenerated BOOT sections from genacc
		1526	av_reflect = get_av ("cf::REFLECT", 1);
		1527	}
		1528
		1529	void _gv_clear (SV *gv)
		1530	CODE:
		1531	assert (SvTYPE (gv) == SVt_PVGV);
		1532	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1533	f (GvGP (gv)->gp_form);
		1534	f (GvGP (gv)->gp_io);
		1535	f (GvGP (gv)->gp_sv);
		1536	f (GvGP (gv)->gp_av);
		1537	f (GvGP (gv)->gp_hv);
		1538	f (GvGP (gv)->gp_cv);
		1539	GvCVGEN (gv) = 0;
		1540	GvMULTI_off (gv);
		1541	# undef f
		1542
1598	void _connect_to_perl ()	1543	void _connect_to_perl_1 ()
1599		1544
		1545	void _connect_to_perl_2 ()
		1546
		1547	void _recalc_want ()
		1548
		1549	# not used by default anymore
1600	void _global_reattach ()	1550	void _global_reattach ()
1601	CODE:	1551	CODE:
1602	{	1552	{
1603	// reattach to all attachable objects in the game.	1553	// reattach to all attachable objects in the game.
1604	for_all_clients (ns)	1554	for_all_clients (ns)
…		…
1606		1556
1607	for_all_objects (op)	1557	for_all_objects (op)
1608	op->reattach ();	1558	op->reattach ();
1609	}	1559	}
1610		1560
		1561	# support function for map-world.ext
		1562	void _quantise (SV *data_sv, SV *plt_sv)
		1563	CODE:
		1564	{
		1565	if (!SvROK (plt_sv) || SvTYPE (SvRV (plt_sv)) != SVt_PVAV)
		1566	croak ("_quantise called with invalid agruments");
		1567
		1568	plt_sv = SvRV (plt_sv);
		1569	SV **plt = AvARRAY (plt_sv);
		1570	int plt_count = AvFILL (plt_sv) + 1;
		1571
		1572	STRLEN len;
		1573	char *data = SvPVbyte (data_sv, len);
		1574	char *dst = data;
		1575
		1576	while (len >= 3)
		1577	{
		1578	for (SV **val_sv = plt + plt_count; val_sv-- > plt; )
		1579	{
		1580	char *val = SvPVX (*val_sv);
		1581
		1582	if (val [0] == data [0]
		1583	&& val [1] == data [1]
		1584	&& val [2] == data [2])
		1585	{
		1586	*dst++ = val [3];
		1587	goto next;
		1588	}
		1589	}
		1590
		1591	croak ("_quantise: color not found in palette: #%02x%02x%02x, at offset %d %d",
		1592	(uint8_t)data [0], (uint8_t)data [1], (uint8_t)data [2],
		1593	dst - SvPVX (data_sv), len);
		1594
		1595	next:
		1596	data += 3;
		1597	len -= 3;
		1598	}
		1599
		1600	SvCUR_set (data_sv, dst - SvPVX (data_sv));
		1601	}
		1602
		1603	void init_anim ()
		1604
		1605	void init_globals ()
		1606
		1607	void init_attackmess ()
		1608
		1609	void init_dynamic ()
		1610
		1611	void load_settings ()
		1612
		1613	void reload_exp_table ()
		1614
		1615	void reload_materials ()
		1616
		1617	void init_uuid ()
		1618	CODE:
		1619	UUID::init ();
		1620
		1621	void init_signals ()
		1622
		1623	void init_skills ()
		1624
		1625	void init_beforeplay ()
		1626
		1627	void evthread_start (int aiofd)
		1628
		1629	void cede_to_tick ()
		1630	CODE:
		1631	coroapi::cede_to_tick ();
		1632
		1633	NV till_tick ()
		1634	CODE:
		1635	RETVAL = SvNVX (sv_next_tick) - now ();
		1636	OUTPUT:
		1637	RETVAL
		1638
		1639	int tick_inhibit ()
		1640	CODE:
		1641	RETVAL = tick_inhibit;
		1642	OUTPUT:
		1643	RETVAL
		1644
		1645	void tick_inhibit_inc ()
		1646	CODE:
		1647	++tick_inhibit;
		1648
		1649	void tick_inhibit_dec ()
		1650	CODE:
		1651	if (!--tick_inhibit)
		1652	if (tick_pending)
		1653	{
		1654	ev_async_send (EV_DEFAULT, &tick_watcher);
		1655	coroapi::cede ();
		1656	}
		1657
		1658	void server_tick ()
		1659	CODE:
		1660	{
		1661	ev_now_update (EV_DEFAULT);
		1662	NOW = ev_now (EV_DEFAULT);
		1663	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1664	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1665	runtime = SvNVX (sv_runtime);
		1666
		1667	server_tick ();
		1668
		1669	ev_now_update (EV_DEFAULT);
		1670	NOW = ev_now (EV_DEFAULT);
		1671	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1672	runtime += TICK;
		1673	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1674	}
		1675
1611	NV floor (NV x)	1676	NV floor (NV x)
1612		1677
1613	NV ceil (NV x)	1678	NV ceil (NV x)
1614		1679
1615	NV rndm (...)	1680	NV rndm (...)
		1681	ALIAS:
		1682	rmg_rndm = 1
1616	CODE:	1683	CODE:
		1684	{
		1685	rand_gen &gen = ix ? rmg_rndm : rndm;
1617	switch (items)	1686	switch (items)
1618	{	1687	{
1619	case 0: RETVAL = rndm (); break;	1688	case 0: RETVAL = gen (); break;
1620	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1689	case 1: RETVAL = gen (SvUV (ST (0))); break;
1621	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1690	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1622	default: croak ("cf::rndm requires none, one or two parameters."); break;	1691	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1623	}	1692	}
		1693	}
1624	OUTPUT:	1694	OUTPUT:
1625	RETVAL	1695	RETVAL
1626		1696
1627	void server_tick ()	1697	NV clamp (NV value, NV min_value, NV max_value)
1628	CODE:	1698	CODE:
1629	runtime = SvNVx (sv_runtime);	1699	RETVAL = clamp (value, min_value, max_value);
1630	server_tick ();	1700	OUTPUT:
		1701	RETVAL
1631		1702
1632	void	1703	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
1633	LOG (int level, char *msg)	1704	CODE:
		1705	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
		1706	OUTPUT:
		1707	RETVAL
		1708
		1709	const char *ordinal (int i)
		1710
		1711	void weaken (...)
		1712	PROTOTYPE: @
		1713	CODE:
		1714	while (items > 0)
		1715	sv_rvweaken (ST (--items));
		1716
		1717	void log_suspend ()
		1718
		1719	void log_resume ()
		1720
		1721	void log_backtrace (utf8_string msg)
		1722
		1723	void LOG (int flags, utf8_string msg)
1634	PROTOTYPE: $$	1724	PROTOTYPE: $$
1635	C_ARGS: (LogLevel)level, "%s", msg	1725	C_ARGS: flags, "%s", msg
1636		1726
1637	char *path_combine (char *base, char *path)	1727	octet_string path_combine (octet_string base, octet_string path)
1638	PROTOTYPE: $$	1728	PROTOTYPE: $$
1639		1729
1640	char *path_combine_and_normalize (char *base, char *path)	1730	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1641	PROTOTYPE: $$	1731	PROTOTYPE: $$
1642		1732
1643	const char *
1644	get_maps_directory (char *path)
1645	PROTOTYPE: $
1646	ALIAS: maps_directory = 0
1647	CODE:
1648	RETVAL = create_pathname (path);
1649	OUTPUT: RETVAL
1650
1651	void	1733	void
1652	sub_generation_inc ()	1734	sub_generation_inc ()
1653	CODE:	1735	CODE:
1654	PL_sub_generation++;	1736	PL_sub_generation++;
1655		1737
1656	const char *	1738	const_octet_string
1657	mapdir ()	1739	mapdir ()
1658	PROTOTYPE:	1740	PROTOTYPE:
1659	ALIAS:	1741	ALIAS:
1660	mapdir = 0	1742	mapdir = 0
1661	uniquedir = 1	1743	uniquedir = 1
…		…
1677	}	1759	}
1678	OUTPUT: RETVAL	1760	OUTPUT: RETVAL
1679		1761
1680	void abort ()	1762	void abort ()
1681		1763
		1764	void reset_signals ()
		1765
1682	void fork_abort (char *cause = "cf::fork_abort")	1766	void fork_abort (const_octet_string cause = "cf::fork_abort")
1683		1767
1684	void cleanup (const char *cause, bool make_core = false)	1768	void cleanup (const_octet_string cause, bool make_core = false)
1685		1769
1686	void emergency_save ()	1770	void emergency_save ()
1687		1771
1688	void _exit (int status = EXIT_SUCCESS)	1772	void _exit (int status = EXIT_SUCCESS)
1689		1773
1690	UV sv_2watcher (SV *w)
1691	CODE:
1692	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1693	OUTPUT:
1694	RETVAL
1695
1696	#if _POSIX_MEMLOCK	1774	#if _POSIX_MEMLOCK
1697		1775
1698	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1776	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1777	INIT:
		1778	#if __GLIBC__
		1779	mallopt (M_TOP_PAD, 1024 * 1024);
		1780	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1781	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1782	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1783	#endif
1699		1784
1700	int munlockall ()	1785	int munlockall ()
1701		1786
1702	#endif	1787	#endif
1703		1788
		1789	int
		1790	malloc_trim (IV pad = 0)
		1791
		1792	void
		1793	mallinfo ()
		1794	PPCODE:
		1795	{
		1796	#if __GLIBC__
		1797	struct mallinfo mai = mallinfo ();
		1798	EXTEND (SP, 10*2);
		1799	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1800	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1801	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1802	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1803	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1804	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1805	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1806	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1807	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1808	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1809	#endif
		1810	EXTEND (SP, 5*2);
		1811	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1812	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1813	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1814	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1815	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1816	}
		1817
1704	int find_animation (char *text)	1818	int find_animation (utf8_string text)
1705	PROTOTYPE: $	1819	PROTOTYPE: $
1706		1820
1707	int random_roll (int min, int max, object *op, int goodbad);	1821	int random_roll (int min, int max, object *op, int goodbad);
1708		1822
1709	const char *cost_string_from_value(uint64 cost, int approx = 0)	1823	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1710		1824
1711	int
1712	exp_to_level (val64 exp)	1825	int exp_to_level (val64 exp)
1713	CODE:
1714	{
1715	int i = 0;
1716		1826
1717	RETVAL = settings.max_level;
1718
1719	for (i = 1; i <= settings.max_level; i++)
1720	{
1721	if (levels[i] > exp)
1722	{
1723	RETVAL = i - 1;
1724	break;
1725	}
1726	}
1727	}
1728	OUTPUT: RETVAL
1729
1730	val64
1731	level_to_min_exp (int level)	1827	val64 level_to_min_exp (int level)
1732	CODE:
1733	if (level > settings.max_level)
1734	RETVAL = levels[settings.max_level];
1735	else if (level < 1)
1736	RETVAL = 0;
1737	else
1738	RETVAL = levels[level];
1739	OUTPUT: RETVAL
1740		1828
1741	SV *	1829	SV *
1742	resistance_to_string (int atnr)	1830	resistance_to_string (int atnr)
1743	CODE:	1831	CODE:
1744	if (atnr >= 0 && atnr < NROFATTACKS)	1832	if (atnr >= 0 && atnr < NROFATTACKS)
1745	RETVAL = newSVpv (resist_plus[atnr], 0);	1833	RETVAL = newSVpv (resist_plus[atnr], 0);
1746	else	1834	else
1747	XSRETURN_UNDEF;	1835	XSRETURN_UNDEF;
1748	OUTPUT: RETVAL	1836	OUTPUT: RETVAL
1749		1837
		1838	UUID
		1839	uuid_cur ()
		1840	CODE:
		1841	RETVAL = UUID::cur;
		1842	OUTPUT:
		1843	RETVAL
		1844
		1845	UUID
		1846	uuid_gen ()
		1847	CODE:
		1848	RETVAL = UUID::gen ();
		1849	OUTPUT:
		1850	RETVAL
		1851
		1852	val64
		1853	uuid_seq (UUID uuid)
		1854	CODE:
		1855	RETVAL = uuid.seq;
		1856	OUTPUT:
		1857	RETVAL
		1858
		1859	UUID
		1860	uuid_str (val64 seq)
		1861	CODE:
		1862	RETVAL.seq = seq;
		1863	OUTPUT:
		1864	RETVAL
		1865
		1866	void
		1867	coin_names ()
		1868	PPCODE:
		1869	EXTEND (SP, NUM_COINS);
		1870	for (int i = 0; i < NUM_COINS; ++i)
		1871	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1872
		1873	void
		1874	coin_archetypes ()
		1875	PPCODE:
		1876	EXTEND (SP, NUM_COINS);
		1877	for (int i = 0; i < NUM_COINS; ++i)
		1878	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1879
1750	bool	1880	bool
1751	load_resource_file (const char *filename)	1881	load_resource_file_ (octet_string filename)
		1882
		1883	void
		1884	fix_weight ()
1752		1885
1753	MODULE = cf PACKAGE = cf::attachable	1886	MODULE = cf PACKAGE = cf::attachable
1754		1887
1755	int	1888	int
1756	valid (SV *obj)	1889	valid (SV *obj)
1757	CODE:	1890	CODE:
1758	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1891	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1759	OUTPUT:	1892	OUTPUT:
1760	RETVAL	1893	RETVAL
1761		1894
		1895	bool should_invoke (attachable *obj, int event)
		1896	CODE:
		1897	RETVAL = obj->should_invoke ((event_type)event);
		1898	OUTPUT: RETVAL
		1899
1762	void	1900	void
1763	debug_trace (attachable *obj, bool on = true)	1901	debug_trace (attachable *obj, bool on = true)
1764	CODE:	1902	CODE:
1765	obj->flags &= ~attachable::F_DEBUG_TRACE;	1903	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1766	if (on)	1904	if (on)
1767	obj->flags |= attachable::F_DEBUG_TRACE;	1905	obj->attachable_flags |= attachable::F_DEBUG_TRACE;
1768		1906
1769	int mortals_size ()	1907	int mortals_size ()
1770	CODE:	1908	CODE:
1771	RETVAL = attachable::mortals.size ();	1909	RETVAL = attachable::mortals.size ();
1772	OUTPUT: RETVAL	1910	OUTPUT: RETVAL
…		…
1774	#object *mortals (U32 index)	1912	#object *mortals (U32 index)
1775	# CODE:	1913	# CODE:
1776	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1914	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1777	# OUTPUT: RETVAL	1915	# OUTPUT: RETVAL
1778		1916
1779	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	1917	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h |
1780		1918
1781	MODULE = cf PACKAGE = cf::global	1919	MODULE = cf PACKAGE = cf::global
1782		1920
1783	int invoke (SV *klass, int event, ...)	1921	int invoke (SV *klass, int event, ...)
1784	CODE:	1922	CODE:
…		…
1788	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);	1926	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1789	OUTPUT: RETVAL	1927	OUTPUT: RETVAL
1790		1928
1791	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1929	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1792		1930
1793	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |	1931	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h |
1794		1932
1795	int invoke (object *op, int event, ...)	1933	int invoke (object *op, int event, ...)
1796	CODE:	1934	CODE:
1797	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1935	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1798	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1936	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1820	object *actives (U32 index)	1958	object *actives (U32 index)
1821	CODE:	1959	CODE:
1822	RETVAL = index < actives.size () ? actives [index] : 0;	1960	RETVAL = index < actives.size () ? actives [index] : 0;
1823	OUTPUT: RETVAL	1961	OUTPUT: RETVAL
1824		1962
		1963	int mortals_size ()
		1964	CODE:
		1965	RETVAL = attachable::mortals.size ();
		1966	OUTPUT: RETVAL
		1967
		1968	const_utf8_string slot_use_name (U32 slot)
		1969	ALIAS:
		1970	slot_nonuse_name = 1
		1971	CODE:
		1972	{
		1973	if (slot >= NUM_BODY_LOCATIONS)
		1974	croak ("body slot index out of range");
		1975
		1976	switch (ix)
		1977	{
		1978	case 0: RETVAL = body_locations[slot].use_name; break;
		1979	case 1: RETVAL = body_locations[slot].nonuse_name; break;
		1980	}
		1981	}
		1982	OUTPUT:
		1983	RETVAL
		1984
1825	# missing properties	1985	# missing properties
1826		1986
1827	object *head (object *op)	1987	object *head (object *op)
1828	PROTOTYPE: $	1988	PROTOTYPE: $
1829	CODE:	1989	CODE:
1830	RETVAL = op->head_ ();	1990	RETVAL = op->head_ ();
1831	OUTPUT: RETVAL
1832
1833	int is_head (object *op)
1834	PROTOTYPE: $
1835	CODE:
1836	RETVAL = op->head_ () == op;
1837	OUTPUT: RETVAL	1991	OUTPUT: RETVAL
1838		1992
1839	void	1993	void
1840	inv (object *obj)	1994	inv (object *obj)
1841	PROTOTYPE: $	1995	PROTOTYPE: $
1842	PPCODE:	1996	PPCODE:
1843	{	1997	{
1844	object *o;
1845	for (o = obj->inv; o; o = o->below)	1998	for (object *o = obj->inv; o; o = o->below)
1846	XPUSHs (sv_2mortal (to_sv (o)));	1999	XPUSHs (sv_2mortal (to_sv (o)));
1847	}	2000	}
1848		2001
1849	void	2002	void
1850	set_animation (object *op, int idx)	2003	set_animation (object *op, int idx)
…		…
1855	num_animations (object *op)	2008	num_animations (object *op)
1856	CODE:	2009	CODE:
1857	RETVAL = NUM_ANIMATIONS (op);	2010	RETVAL = NUM_ANIMATIONS (op);
1858	OUTPUT: RETVAL	2011	OUTPUT: RETVAL
1859		2012
		2013	int slot_info (object *op, UV slot, int value = 0)
		2014	ALIAS:
		2015	slot_used = 1
		2016	CODE:
		2017	{
		2018	if (slot >= NUM_BODY_LOCATIONS)
		2019	croak ("body slot index out of range");
		2020
		2021	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		2022
		2023	if (items > 2)
		2024	if (ix)
		2025	op->slot[slot].used = value;
		2026	else
		2027	op->slot[slot].info = value;
		2028	}
		2029	OUTPUT:
		2030	RETVAL
		2031
1860	object *find_best_object_match (object *op, const char *match)	2032	object *find_best_object_match (object *op, utf8_string match)
1861
1862	object *find_marked_object (object *op)
1863
1864	int need_identify (object *obj);
1865		2033
1866	int apply_shop_mat (object *shop_mat, object *op);	2034	int apply_shop_mat (object *shop_mat, object *op);
1867		2035
1868	int move_player (object *op, int dir)	2036	int move (object *op, int dir, object *originator = op)
1869	CODE:	2037	CODE:
1870	RETVAL = move_player (op, dir);	2038	RETVAL = op->move (dir, originator);
1871	OUTPUT:	2039	OUTPUT:
1872	RETVAL	2040	RETVAL
1873		2041
1874	int move (object *op, int dir, object *originator = op)
1875	CODE:
1876	RETVAL = move_ob (op, dir, originator);
1877	OUTPUT:
1878	RETVAL
1879
1880	void apply (object *applier, object *applied, int flags = 0)
1881	CODE:
1882	manual_apply (applied, applier, flags);
1883
1884	void apply_below (object *op)	2042	void apply_below (object *op)
1885	CODE:	2043	CODE:
1886	player_apply_below (op);	2044	player_apply_below (op);
1887		2045
1888	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2046	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1889		2047
1890	object *cf_object_present_archname_inside (object *op, char *whatstr)	2048	int casting_level (object *caster, object *spell)
1891
1892	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1893
1894	int cf_object_change_map (object *op, int x, int y, maptile *map)
1895
1896	#//TODO
1897	object *clone_ (object *op, int recursive = 0)
1898	CODE:
1899	if (recursive)
1900	RETVAL = object_create_clone (op);
1901	else
1902	{
1903	RETVAL = object::create ();
1904	op->copy_to (RETVAL);
1905	}
1906	OUTPUT: RETVAL
1907		2049
1908	int pay_item (object *op, object *buyer)	2050	int pay_item (object *op, object *buyer)
1909	CODE:	2051	CODE:
1910	RETVAL = pay_for_item (op, buyer);	2052	RETVAL = pay_for_item (op, buyer);
1911	OUTPUT: RETVAL	2053	OUTPUT: RETVAL
…		…
1915	RETVAL = pay_for_amount (amount, op);	2057	RETVAL = pay_for_amount (amount, op);
1916	OUTPUT: RETVAL	2058	OUTPUT: RETVAL
1917		2059
1918	void pay_player (object *op, uint64 amount)	2060	void pay_player (object *op, uint64 amount)
1919		2061
1920	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	2062	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1921		2063
1922	int cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg = 0)	2064	int cast_spell (object *op, object *caster, int dir, object *spell_ob, utf8_string stringarg = 0)
1923		2065
1924	void learn_spell (object *op, object *sp, int special_prayer = 0)	2066	void learn_spell (object *op, object *sp, int special_prayer = 0)
1925	CODE:	2067	CODE:
1926	do_learn_spell (op, sp, special_prayer);	2068	do_learn_spell (op, sp, special_prayer);
1927		2069
1928	void forget_spell (object *op, object *sp)	2070	void forget_spell (object *op, object *sp)
1929	CODE:	2071	CODE:
1930	do_forget_spell (op, query_name (sp));	2072	do_forget_spell (op, query_name (sp));
1931		2073
1932	object *check_for_spell (object *op, char *spellname)	2074	object *check_for_spell (object *op, utf8_string spellname)
1933	CODE:	2075	CODE:
1934	RETVAL = check_spell_known (op, spellname);	2076	RETVAL = check_spell_known (op, spellname);
1935	OUTPUT: RETVAL	2077	OUTPUT: RETVAL
1936		2078
1937	int query_money (object *op)	2079	int query_money (object *op)
…		…
1946		2088
1947	void drop (object *who, object *op)	2089	void drop (object *who, object *op)
1948		2090
1949	void pick_up (object *who, object *op)	2091	void pick_up (object *who, object *op)
1950		2092
1951	int cf_object_teleport (object *op, maptile *map, int x, int y)
1952
1953	void update_object (object *op, int action)	2093	void update_object (object *op, int action)
1954		2094
1955	object *cf_create_object_by_name (const char *name)
1956
1957	void change_exp (object *op, uint64 exp, const char *skill_name = 0, int flag = 0)	2095	void change_exp (object *op, uint64 exp, shstr_tmp skill_name = shstr_tmp (), int flag = 0)
1958		2096
1959	void player_lvl_adj (object *who, object *skill = 0)	2097	void player_lvl_adj (object *who, object *skill = 0)
1960		2098
1961	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2099	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1962		2100
1963	int calc_skill_exp (object *who, object *op, object *skill);	2101	int calc_skill_exp (object *who, object *op, object *skill)
1964		2102
1965	void push_button (object *op);	2103	void push_button (object *op, object *originator)
1966		2104
1967	void use_trigger (object *op);	2105	void use_trigger (object *op, object *originator)
1968		2106
1969	void add_button_link (object *button, maptile *map, int connected);	2107	void handle_apply_yield (object *op)
1970		2108
1971	void remove_button_link (object *op);	2109	int convert_item (object *item, object *converter)
1972		2110
		2111	void fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags);
1973		2112
1974	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2113	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1975
1976	object *cf_insert_ob_in_ob (object *ob, object *where)
1977		2114
1978	# no clean way to get an object from an archetype - stupid idiotic	2115	# no clean way to get an object from an archetype - stupid idiotic
1979	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2116	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1980		2117
1981	object *new (const char *archetype = 0)	2118	object *new (utf8_string archetype = 0)
1982	PROTOTYPE: ;$	2119	PROTOTYPE: ;$
1983	CODE:	2120	CODE:
1984	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2121	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1985	OUTPUT:	2122	OUTPUT:
1986	RETVAL	2123	RETVAL
1987		2124
		2125	object *generate (utf8_string arch, object *creator)
		2126	CODE:
		2127	object *obj = get_archetype (arch);
		2128	fix_generated_item (obj, creator, 0, 0, GT_MINIMAL);
		2129	RETVAL = obj;
		2130	OUTPUT:
		2131	RETVAL
		2132
		2133	object *find_object (U32 tag)
		2134
		2135	object *find_object_uuid (UUID i)
		2136
		2137	# TODO: nuke
1988	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2138	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1989	PROTOTYPE: $$$$$$	2139	PROTOTYPE: $$$$$$
1990	CODE:	2140	CODE:
1991	{	2141	{
1992	int unused_type;	2142	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1993	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1994	}
1995		2143
1996	# syntatic sugar for easier use in event callbacks.	2144	if (RETVAL->destroyed ())
1997	const char *options (object *op)
1998	CODE:
1999	RETVAL = op->name;
2000	OUTPUT:
2001	RETVAL	2145	RETVAL = 0;
		2146	}
2002		2147
2003	player *contr (object *op)	2148	shstr
2004	CODE:	2149	object::kv_get (shstr key)
2005	RETVAL = op->contr;
2006	OUTPUT: RETVAL
2007		2150
2008	const char *get_ob_key_value (object *op, const char *key)	2151	void
		2152	object::kv_del (shstr key)
2009		2153
2010	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	2154	void
		2155	object::kv_set (shstr key, shstr value)
2011		2156
2012	object *get_nearest_player (object *ob)	2157	object *get_nearest_player (object *ob)
2013	ALIAS: nearest_player = 0	2158	ALIAS: nearest_player = 0
2014	PREINIT:	2159	PREINIT:
2015	extern object *get_nearest_player (object *);	2160	extern object *get_nearest_player (object *);
…		…
2017	void rangevector (object *ob, object *other, int flags = 0)	2162	void rangevector (object *ob, object *other, int flags = 0)
2018	PROTOTYPE: $$;$	2163	PROTOTYPE: $$;$
2019	PPCODE:	2164	PPCODE:
2020	{	2165	{
2021	rv_vector rv;	2166	rv_vector rv;
		2167
2022	get_rangevector (ob, other, &rv, flags);	2168	get_rangevector (ob, other, &rv, flags);
		2169
2023	EXTEND (SP, 5);	2170	EXTEND (SP, 5);
2024	PUSHs (newSVuv (rv.distance));	2171	PUSHs (sv_2mortal (newSVuv (rv.distance)));
2025	PUSHs (newSViv (rv.distance_x));	2172	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
2026	PUSHs (newSViv (rv.distance_y));	2173	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
2027	PUSHs (newSViv (rv.direction));	2174	PUSHs (sv_2mortal (newSViv (rv.direction)));
2028	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2175	PUSHs (sv_2mortal (to_sv (rv.part)));
2029	}	2176	}
2030		2177
2031	bool on_same_map_as (object *ob, object *other)	2178	bool on_same_map_as (object *ob, object *other)
2032	CODE:	2179	CODE:
2033	RETVAL = on_same_map (ob, other);	2180	RETVAL = on_same_map (ob, other);
2034	OUTPUT: RETVAL	2181	OUTPUT: RETVAL
2035		2182
2036	const char *	2183	const_utf8_string
2037	base_name (object *op, int plural = op->nrof > 1)	2184	base_name (object *op, int plural = op->nrof > 1)
2038	CODE:	2185	CODE:
2039	RETVAL = query_base_name (op, plural);	2186	RETVAL = query_base_name (op, plural);
2040	OUTPUT: RETVAL	2187	OUTPUT: RETVAL
2041		2188
2042	object *decrease_ob_nr (object *op, unsigned long i)	2189	# return the tail of an object, excluding itself
		2190	void
		2191	tail (object *op)
		2192	PPCODE:
		2193	while ((op = op->more))
		2194	XPUSHs (sv_2mortal (to_sv (op)));
2043		2195
2044	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2196	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
2045		2197
2046	player *player (object *op)	2198	player *player (object *op)
2047	CODE:	2199	CODE:
2048	RETVAL = op->contr;	2200	RETVAL = op->contr;
2049	OUTPUT: RETVAL	2201	OUTPUT: RETVAL
2050		2202
2051	void check_score (object *op)	2203	bool move_player (object *op, int dir)
2052		2204
2053	void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2205	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
2054	CODE:	2206	CODE:
2055	new_draw_info (flags, 0, op, txt);	2207	new_draw_info (flags, 0, op, txt);
2056		2208
2057	object *cf_player_send_inventory (object *op)
2058
2059	char *cf_player_get_ip (object *op)
2060	ALIAS: ip = 0
2061
2062	object *cf_player_get_marked_item (object *op)
2063	ALIAS: marked_item = 0
2064
2065	void cf_player_set_marked_item (object *op, object *ob)
2066
2067	partylist *cf_player_get_party (object *op)
2068	ALIAS: party = 0
2069
2070	void cf_player_set_party (object *op, partylist *party)
2071
2072	void kill_player (object *op)	2209	void kill_player (object *op)
2073		2210
		2211	void esrv_send_item (object *pl, object *item)
		2212
2074	void esrv_update_item (object *op, int what, object *item)	2213	void esrv_update_item (object *pl, int what, object *item)
2075	C_ARGS: what, op, item	2214	C_ARGS: what, pl, item
2076		2215
2077	void clear_los (object *op)	2216	void esrv_del_item (object *pl, int tag)
		2217	C_ARGS: pl->contr, tag
2078		2218
2079	int command_summon (object *op, char *params)	2219	int command_summon (object *op, utf8_string params)
2080		2220
2081	int command_arrest (object *op, char *params)	2221	int command_arrest (object *op, utf8_string params)
2082		2222
2083		2223
2084	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2224	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2085		2225
2086	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |	2226	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h |
2087		2227
2088	int invoke (player *pl, int event, ...)	2228	int invoke (player *pl, int event, ...)
2089	CODE:	2229	CODE:
2090	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2230	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2091	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2231	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2101	pl->ob->stats.hp = pl->ob->stats.maxhp;	2241	pl->ob->stats.hp = pl->ob->stats.maxhp;
2102	pl->ob->stats.sp = pl->ob->stats.maxsp;	2242	pl->ob->stats.sp = pl->ob->stats.maxsp;
2103	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2243	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2104	pl->orig_stats = pl->ob->stats;	2244	pl->orig_stats = pl->ob->stats;
2105		2245
2106	void cf_player_move (player *pl, int dir)	2246	# should only be temporary
		2247	void esrv_new_player (player *pl)
2107		2248
2108	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2249	#d# TODO: replace by blocked_los accessor, fix code using this
2109
2110	bool	2250	bool
2111	cell_visible (player *pl, int dx, int dy)	2251	cell_visible (player *pl, int dx, int dy)
2112	CODE:	2252	CODE:
2113	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2253	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2114	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2115	OUTPUT:	2254	OUTPUT:
2116	RETVAL	2255	RETVAL
2117		2256
2118	void	2257	void
2119	send (player *pl, SV *packet)	2258	send (player *pl, SV *packet)
2120	CODE:	2259	CODE:
2121	{	2260	{
2122	STRLEN len;	2261	STRLEN len;
2123	char *buf = SvPVbyte (packet, len);	2262	char *buf = SvPVbyte (packet, len);
2124		2263
		2264	if (len > MAXSOCKBUF)
		2265	pl->failmsg ("[packet too long for client]");
2125	if (pl->ns)	2266	else if (pl->ns)
2126	pl->ns->send_packet (buf, len);	2267	pl->ns->send_packet (buf, len);
2127	}	2268	}
2128
2129	int
2130	listening (player *pl, int new_value = -1)
2131	CODE:
2132	RETVAL = pl->listening;
2133	if (new_value >= 0)
2134	pl->listening = new_value;
2135	OUTPUT:
2136	RETVAL
2137		2269
2138	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2270	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
2139	PROTOTYPE: $;$$$	2271	PROTOTYPE: $;$$$
2140	PPCODE:	2272	PPCODE:
2141	if (GIMME_V != G_VOID)	2273	if (GIMME_V != G_VOID)
…		…
2166	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2298	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2167	OUTPUT: RETVAL	2299	OUTPUT: RETVAL
2168		2300
2169	SV *registry (maptile *map)	2301	SV *registry (maptile *map)
2170		2302
		2303	void
		2304	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2305	PPCODE:
		2306	{
		2307	if (!map->spaces)
		2308	XSRETURN_EMPTY;
		2309
		2310	if (tag)
		2311	{
		2312	shstr_cmp tag_ (tag);
		2313
		2314	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2315	for (object *op = ms->bot; op; op = op->above)
		2316	if (op->tag == tag_)
		2317	XPUSHs (sv_2mortal (to_sv (op)));
		2318	}
		2319	else
		2320	{
		2321	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2322	for (object *op = ms->bot; op; op = op->above)
		2323	if (op->tag)
		2324	XPUSHs (sv_2mortal (to_sv (op)));
		2325	}
		2326	}
		2327
2171	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2328	INCLUDE: $PERL $srcdir/genacc maptile $srcdir/../include/map.h |
		2329
		2330	void
		2331	adjust_daylight ()
		2332	CODE:
		2333	maptile::adjust_daylight ();
		2334
		2335	int
		2336	outdoor_darkness (int darkness = 0)
		2337	CODE:
		2338	RETVAL = maptile::outdoor_darkness;
		2339	if (items)
		2340	maptile::outdoor_darkness = darkness;
		2341	OUTPUT:
		2342	RETVAL
2172		2343
2173	void	2344	void
2174	maptile::instantiate ()	2345	maptile::instantiate ()
2175		2346
2176	maptile *new ()	2347	maptile *new ()
…		…
2208	for (int x = 0; x < THIS->width; ++x)	2379	for (int x = 0; x < THIS->width; ++x)
2209	for (int y = 0; y < THIS->height; ++y)	2380	for (int y = 0; y < THIS->height; ++y)
2210	{	2381	{
2211	for (object *op = THIS->at (x, y).bot; op; op = op->above)	2382	for (object *op = THIS->at (x, y).bot; op; op = op->above)
2212	if (op->flag [FLAG_IS_FLOOR])	2383	if (op->flag [FLAG_IS_FLOOR])
2213	goto skip_space;	2384	goto skip;
2214		2385
2215	{	2386	{
2216	int offs = offset + y * stride + x;	2387	int offs = offset + y * stride + x;
		2388
2217	if (IN_RANGE_EXC (offs, 0, idxlen))	2389	if (IN_RANGE_EXC (offs, 0, idxlen))
2218	{	2390	{
2219	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2391	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
2220	{	2392	{
2221	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2393	object *ob = get_archetype (cfSvPVutf8_nolen (*elem));
2222	ob->flag [FLAG_NO_MAP_SAVE] = true;	2394	ob->flag [FLAG_NO_MAP_SAVE] = true;
2223	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2395	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2396
		2397	if (ob->randomitems && !ob->above)
		2398	{
		2399	ob->create_treasure (ob->randomitems);
		2400
		2401	for (object *op = ob->above; op; op = op->above)
		2402	op->flag [FLAG_NO_MAP_SAVE] = true;
		2403	// TODO: if this is a pickable object, then the item
		2404	// will at a bit weird - saving inside the player
		2405	// will clear the flag, but when the player drops
		2406	// it without logging out, it keeps the flag.
		2407	// nobody ahs reported this, but this can be rather
		2408	// annoying on persistent maps.
		2409	}
2224	}	2410	}
2225	}	2411	}
2226	}	2412	}
2227		2413
2228	skip_space: ;	2414	skip: ;
2229	}	2415	}
2230	}	2416	}
2231		2417
2232	void	2418	void
2233	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)	2419	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
…		…
2239	palette = SvRV (palette);	2425	palette = SvRV (palette);
2240		2426
2241	STRLEN idxlen;	2427	STRLEN idxlen;
2242	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2428	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
2243		2429
2244	region **regionmap = (region **)malloc (	2430	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
2245	(av_len ((AV *)palette) + 1) * sizeof (region *));
2246	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2431	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2247		2432
2248	for (int i = av_len ((AV *)palette) + 1; i--; )	2433	for (int i = av_len ((AV *)palette) + 1; i--; )
2249	regionmap [i] = region::find (	2434	regionmap [i] = region::find (cfSvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2250	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2251		2435
2252	for (int y = 0; y < THIS->height; ++y)	2436	for (int y = 0; y < THIS->height; ++y)
2253	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2437	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2254		2438
2255	sfree (THIS->regions, THIS->size ());	2439	sfree (THIS->regions, THIS->size ());
2256	free (THIS->regionmap);	2440	delete [] THIS->regionmap;
2257		2441
2258	THIS->regions = regions;	2442	THIS->regions = regions;
2259	THIS->regionmap = regionmap;	2443	THIS->regionmap = regionmap;
2260	}	2444	}
2261		2445
2262	void play_sound_map (maptile *map, int x, int y, int sound_num)	2446	void
		2447	maptile::create_region_treasure ()
		2448	CODE:
		2449	for (int x = 0; x < THIS->width; ++x)
		2450	for (int y = 0; y < THIS->height; ++y)
		2451	{
		2452	region *rgn = THIS->region (x, y);
		2453
		2454	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2455	if (object *op = THIS->at (x, y).top)
		2456	if (rgn->treasure && rndm () < rgn->treasure_density)
		2457	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
		2458	}
2263		2459
2264	int out_of_map (maptile *map, int x, int y)	2460	int out_of_map (maptile *map, int x, int y)
2265		2461
2266	void	2462	void
2267	trigger (maptile *map, long connection, bool state = true)	2463	find_link (maptile *map, shstr_tmp connection)
		2464	PPCODE:
		2465	if (oblinkpt *obp = map->find_link (connection))
		2466	for (objectlink *ol = obp->link; ol; ol = ol->next)
		2467	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
		2468
		2469	void
		2470	xy_normalise (maptile *map, int x, int y, int dir = 0)
		2471	PPCODE:
		2472	{
		2473	mapxy pos (map, x, y);
		2474	if (!pos.move (dir).normalise ())
		2475	XSRETURN_EMPTY;
		2476
		2477	EXTEND (SP, 3);
		2478	PUSHs (sv_2mortal (to_sv (pos.m)));
		2479	PUSHs (sv_2mortal (to_sv (pos.x)));
		2480	PUSHs (sv_2mortal (to_sv (pos.y)));
		2481	}
		2482
		2483	mapspace *
		2484	ms (maptile *map, unsigned int x, unsigned int y, int dir = 0)
		2485	PROTOTYPE: $$$;$
2268	CODE:	2486	CODE:
2269	activate_connection (map, connection, state);
2270
2271	void
2272	get_connection (maptile *map, long connection)
2273	PPCODE:
2274	oblinkpt *obp = get_connection_links (map, connection);
2275	if (obp)
2276	for (objectlink *ol = obp->link; ol; ol = ol->next)
2277	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2278
2279	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2280
2281	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2282
2283	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2284	C_ARGS: str, map, nx, ny
2285
2286	void
2287	get_map_flags (maptile *map, int x, int y)
2288	PPCODE:
2289	{	2487	{
2290	maptile *nmap = 0;	2488	mapxy pos (map, x, y);
2291	I16 nx = 0, ny = 0;	2489	if (!pos.move (dir).normalise ())
2292	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2490	XSRETURN_UNDEF;
2293		2491
2294	EXTEND (SP, 4);	2492	RETVAL = &*pos;
2295	PUSHs (sv_2mortal (newSViv (flags)));
2296
2297	if (GIMME_V == G_ARRAY)
2298	{
2299	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));
2300	PUSHs (sv_2mortal (newSViv (nx)));
2301	PUSHs (sv_2mortal (newSViv (ny)));
2302	}
2303	}	2493	}
		2494	OUTPUT:
		2495	RETVAL
2304		2496
2305	void	2497	void
2306	at (maptile *map, unsigned int x, unsigned int y)	2498	at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2307	PROTOTYPE: $$$	2499	PROTOTYPE: $$$;$
2308	PPCODE:	2500	PPCODE:
2309	{	2501	mapxy pos (map, x, y);
2310	object *o;	2502	if (pos.move (dir).normalise ())
2311	maptile *nmap = 0;	2503	for (object *o = pos->bot; o; o = o->above)
2312	I16 nx, ny;	2504	XPUSHs (sv_2mortal (to_sv (o)));
2313
2314	get_map_flags (map, &nmap, x, y, &nx, &ny);
2315
2316	if (nmap)
2317	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2318	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2319	}
2320		2505
2321	SV *	2506	SV *
2322	bot_at (maptile *obj, unsigned int x, unsigned int y)	2507	bot_at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2323	PROTOTYPE: $$$	2508	PROTOTYPE: $$$;$
2324	ALIAS:	2509	ALIAS:
2325	top_at = 1	2510	top_at = 1
2326	flags_at = 2	2511	flags_at = 2
2327	light_at = 3	2512	light_at = 3
2328	move_block_at = 4	2513	move_block_at = 4
2329	move_slow_at = 5	2514	move_slow_at = 5
2330	move_on_at = 6	2515	move_on_at = 6
2331	move_off_at = 7	2516	move_off_at = 7
2332	INIT:
2333	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2334	CODE:	2517	CODE:
		2518	{
		2519	mapxy pos (map, x, y);
		2520	if (!pos.move (dir).normalise ())
		2521	XSRETURN_UNDEF;
		2522
		2523	mapspace &ms = *pos;
		2524
		2525	ms.update ();
		2526
2335	switch (ix)	2527	switch (ix)
2336	{	2528	{
2337	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2529	case 0: RETVAL = to_sv (ms.bot ); break;
2338	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2530	case 1: RETVAL = to_sv (ms.top ); break;
2339	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2531	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2340	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2532	case 3: RETVAL = newSViv (ms.light ); break;
2341	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2533	case 4: RETVAL = newSVuv (ms.move_block); break;
2342	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2534	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2343	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2535	case 6: RETVAL = newSVuv (ms.move_on ); break;
2344	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2536	case 7: RETVAL = newSVuv (ms.move_off ); break;
2345	}	2537	}
		2538	}
2346	OUTPUT: RETVAL	2539	OUTPUT: RETVAL
2347
2348	void fix_walls (maptile *map, int x, int y)
2349
2350	void fix_walls_around (maptile *map, int x, int y)
2351		2540
2352	# worst xs function of my life	2541	# worst xs function of my life
2353	bool	2542	bool
2354	_create_random_map (\	2543	_create_random_map (maptile *self, SV *options)
2355	maptile *self,\
2356	char *wallstyle,\
2357	char *wall_name,\
2358	char *floorstyle,\
2359	char *monsterstyle,\
2360	char *treasurestyle,\
2361	char *layoutstyle,\
2362	char *doorstyle,\
2363	char *decorstyle,\
2364	char *origin_map,\
2365	char *final_map,\
2366	char *exitstyle,\
2367	char *this_map,\
2368	char *exit_on_final_map,\
2369	int xsize,\
2370	int ysize,\
2371	int expand2x,\
2372	int layoutoptions1,\
2373	int layoutoptions2,\
2374	int layoutoptions3,\
2375	int symmetry,\
2376	int difficulty,\
2377	int difficulty_given,\
2378	float difficulty_increase,\
2379	int dungeon_level,\
2380	int dungeon_depth,\
2381	int decoroptions,\
2382	int orientation,\
2383	int origin_y,\
2384	int origin_x,\
2385	U32 random_seed,\
2386	val64 total_map_hp,\
2387	int map_layout_style,\
2388	int treasureoptions,\
2389	int symmetry_used,\
2390	region *region,\
2391	char *custom\
2392	)
2393	CODE:	2544	CODE:
2394	{	2545	{
2395	random_map_params rmp;	2546	random_map_params rmp ((HV *)SvRV (options));
2396
2397	assign (rmp.wallstyle , wallstyle);
2398	assign (rmp.wall_name , wall_name);
2399	assign (rmp.floorstyle , floorstyle);
2400	assign (rmp.monsterstyle , monsterstyle);
2401	assign (rmp.treasurestyle , treasurestyle);
2402	assign (rmp.layoutstyle , layoutstyle);
2403	assign (rmp.doorstyle , doorstyle);
2404	assign (rmp.decorstyle , decorstyle);
2405	assign (rmp.exitstyle , exitstyle);
2406	assign (rmp.exit_on_final_map, exit_on_final_map);
2407
2408	rmp.origin_map = origin_map;
2409	rmp.final_map = final_map;
2410	rmp.this_map = this_map;
2411	rmp.xsize = xsize;
2412	rmp.ysize = ysize;
2413	rmp.expand2x = expand2x;
2414	rmp.layoutoptions1 = layoutoptions1;
2415	rmp.layoutoptions2 = layoutoptions2;
2416	rmp.layoutoptions3 = layoutoptions3;
2417	rmp.symmetry = symmetry;
2418	rmp.difficulty = difficulty;
2419	rmp.difficulty_given = difficulty_given;
2420	rmp.difficulty_increase = difficulty_increase;
2421	rmp.dungeon_level = dungeon_level;
2422	rmp.dungeon_depth = dungeon_depth;
2423	rmp.decoroptions = decoroptions;
2424	rmp.orientation = orientation;
2425	rmp.origin_y = origin_y;
2426	rmp.origin_x = origin_x;
2427	rmp.random_seed = random_seed;
2428	rmp.total_map_hp = total_map_hp;
2429	rmp.map_layout_style = map_layout_style;
2430	rmp.treasureoptions = treasureoptions;
2431	rmp.symmetry_used = symmetry_used;
2432	rmp.region = region;
2433	rmp.custom = custom;
2434
2435	RETVAL = self->generate_random_map (&rmp);	2547	RETVAL = self->generate_random_map (&rmp);
2436	}	2548	}
2437	OUTPUT:	2549	OUTPUT:
2438	RETVAL	2550	RETVAL
2439		2551
		2552	MODULE = cf PACKAGE = cf::mapspace
		2553
		2554	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h |
		2555
2440	MODULE = cf PACKAGE = cf::arch	2556	MODULE = cf PACKAGE = cf::arch
2441		2557
2442	archetype *find (const char *name)	2558	int archetypes_size ()
2443	CODE:	2559	CODE:
2444	RETVAL = archetype::find (name);	2560	RETVAL = archetypes.size ();
2445	OUTPUT:
2446	RETVAL
2447
2448	archetype *first()
2449	PROTOTYPE:
2450	CODE:
2451	RETVAL = first_archetype;
2452	OUTPUT: RETVAL	2561	OUTPUT: RETVAL
2453		2562
		2563	archetype *archetypes (U32 index)
		2564	CODE:
		2565	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2566	OUTPUT: RETVAL
		2567
2454	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2568	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h |
2455		2569
2456	MODULE = cf PACKAGE = cf::party	2570	MODULE = cf PACKAGE = cf::party
2457		2571
2458	partylist *first ()	2572	partylist *first ()
2459	PROTOTYPE:	2573	PROTOTYPE:
2460	CODE:	2574	CODE:
2461	RETVAL = get_firstparty ();	2575	RETVAL = get_firstparty ();
2462	OUTPUT: RETVAL	2576	OUTPUT: RETVAL
2463		2577
2464	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |	2578	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h |
2465		2579
2466	MODULE = cf PACKAGE = cf::region	2580	MODULE = cf PACKAGE = cf::region
2467		2581
2468	void	2582	void
2469	list ()	2583	list ()
2470	PPCODE:	2584	PPCODE:
2471	for_all_regions (rgn)	2585	for_all_regions (rgn)
2472	XPUSHs (sv_2mortal (to_sv (rgn)));	2586	XPUSHs (sv_2mortal (to_sv (rgn)));
2473		2587
2474	region *find (char *name)	2588	int specificity (region *rgn)
2475	PROTOTYPE: $	2589	CODE:
2476	CODE:	2590	RETVAL = 0;
2477	RETVAL = region::find (name);	2591	while (rgn = rgn->parent)
		2592	RETVAL++;
2478	OUTPUT: RETVAL	2593	OUTPUT: RETVAL
2479		2594
2480	region *find_fuzzy (char *name)
2481	PROTOTYPE: $
2482	CODE:
2483	RETVAL = region::find_fuzzy (name);
2484	OUTPUT: RETVAL
2485
2486	INCLUDE: $PERL $srcdir/genacc region ../include/map.h |	2595	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h |
2487		2596
2488	MODULE = cf PACKAGE = cf::living	2597	MODULE = cf PACKAGE = cf::living
2489		2598
2490	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |	2599	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h |
2491		2600
2492	MODULE = cf PACKAGE = cf::settings	2601	MODULE = cf PACKAGE = cf::settings
2493		2602
2494	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |	2603	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h |
2495		2604
2496	MODULE = cf PACKAGE = cf::client	2605	MODULE = cf PACKAGE = cf::client
2497		2606
2498	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |	2607	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h |
2499		2608
2500	int invoke (client *ns, int event, ...)	2609	int invoke (client *ns, int event, ...)
2501	CODE:	2610	CODE:
2502	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2611	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2503	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2612	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2519	CODE:	2628	CODE:
2520	{	2629	{
2521	STRLEN len;	2630	STRLEN len;
2522	char *buf = SvPVbyte (packet, len);	2631	char *buf = SvPVbyte (packet, len);
2523		2632
		2633	if (len > MAXSOCKBUF)
		2634	{
		2635	// ugly
		2636	if (THIS->pl)
		2637	THIS->pl->failmsg ("[packet too long for client]");
		2638	}
		2639	else
2524	THIS->send_packet (buf, len);	2640	THIS->send_packet (buf, len);
2525	}	2641	}
		2642
		2643	faceidx
		2644	client::need_face (utf8_string name, int pri = 0)
		2645	CODE:
		2646	RETVAL = face_find (name, 0);
		2647	if (RETVAL)
		2648	{
		2649	THIS->send_face (RETVAL, pri);
		2650	THIS->flush_fx ();
		2651	}
		2652	OUTPUT:
		2653	RETVAL
		2654
		2655	int
		2656	client::fx_want (int idx, int value = -1)
		2657	CODE:
		2658	if (0 < idx && idx < FT_NUM)
		2659	{
		2660	RETVAL = THIS->fx_want [idx];
		2661	if (items > 2)
		2662	THIS->fx_want [idx] = value;
		2663	}
		2664	else
		2665	RETVAL = 0;
		2666	OUTPUT:
		2667	RETVAL
		2668
		2669	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2670
		2671	faceidx sound_find (utf8_string name)
		2672
		2673	void sound_set (utf8_string str, faceidx face)
		2674
		2675	# dire hack
		2676	void old_sound_index (int idx, faceidx face)
		2677	CODE:
		2678	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2679	old_sound_index [idx] = face;
2526		2680
2527	MODULE = cf PACKAGE = cf::face PREFIX = face_	2681	MODULE = cf PACKAGE = cf::face PREFIX = face_
2528		2682
2529	INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2683	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h |
2530		2684
2531	faceidx face_find (const char *name, faceidx defidx = 0)	2685	faceidx face_find (utf8_string name, faceidx defidx = 0)
2532		2686
2533	faceidx alloc (const char *name)	2687	faceidx alloc (utf8_string name)
2534	CODE:	2688	CODE:
2535	{	2689	{
2536	do	2690	do
2537	{	2691	{
2538	RETVAL = faces.size ();	2692	RETVAL = faces.size ();
…		…
2541	while (!RETVAL); // crude way to leave index 0	2695	while (!RETVAL); // crude way to leave index 0
2542		2696
2543	faces [RETVAL].name = name;	2697	faces [RETVAL].name = name;
2544	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));	2698	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2545		2699
2546	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2700	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2547	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2701	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2702	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
2548	}	2703	}
2549	OUTPUT: RETVAL	2704	OUTPUT: RETVAL
2550		2705
2551	void set (faceidx idx, int visibility, int magicmap)	2706	void set_type (faceidx idx, int value)
		2707	ALIAS:
		2708	set_type = 0
		2709	set_visibility = 1
		2710	set_magicmap = 2
		2711	set_smooth = 3
		2712	set_smoothlevel = 4
2552	CODE:	2713	CODE:
2553	faceinfo *f = face_info (idx);	2714	faceinfo *f = face_info (idx); assert (f);
2554	assert (f);	2715	switch (ix)
2555	f->visibility = visibility;	2716	{
2556	f->magicmap = magicmap;	2717	case 0: f->type = value; break;
2557		2718	case 1: f->visibility = value; break;
2558	void set_smooth (faceidx idx, faceidx smooth)	2719	case 2: f->magicmap = value; break;
2559	CODE:	2720	case 3: f->smooth = value; break;
2560	faceinfo *f = face_info (idx);	2721	case 4: f->smoothlevel = value; break;
2561	assert (f);	2722	}
2562	f->smooth = smooth;
2563		2723
2564	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2724	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2565	CODE:	2725	CODE:
		2726	{
		2727	faceinfo *f = face_info (idx); assert (f);
		2728	facedata *d = &(faceset ? f->data64 : f->data32);
		2729	sv_to (data, d->data);
		2730	STRLEN clen;
		2731	char *cdata = SvPVbyte (chksum, clen);
		2732	clen = min (CHKSUM_MAXLEN, clen);
		2733
		2734	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2735
		2736	if (clen != d->chksum_len || memcmp (d->chksum, cdata, clen))
		2737	{
		2738	d->chksum_len = clen;
		2739	memcpy (d->chksum, cdata, clen);
		2740
		2741	// invalidate existing client face info
		2742	for_all_clients (ns)
		2743	if (ns->faceset == faceset)
		2744	{
		2745	ns->faces_sent [idx] = false;
		2746	ns->force_newmap = true;
		2747	}
		2748	}
		2749	}
		2750
		2751	int get_data_size (faceidx idx, int faceset = 0)
		2752	CODE:
2566	facedata *d = face_data (idx, faceset);	2753	facedata *d = face_data (idx, faceset);
2567	assert (d);	2754	if (!d) XSRETURN_UNDEF;
2568	assert (sv_len (chksum) == CHKSUM_SIZE);	2755	RETVAL = d->data.size ();
2569	sv_to (data, d->data); memcpy (d->chksum, SvPVbyte_nolen (chksum), CHKSUM_SIZE);	2756	OUTPUT:
		2757	RETVAL
		2758
		2759	SV *get_chksum (faceidx idx, int faceset = 0)
		2760	CODE:
		2761	facedata *d = face_data (idx, faceset);
		2762	if (!d) XSRETURN_UNDEF;
		2763	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		2764	OUTPUT:
		2765	RETVAL
		2766
		2767	SV *get_data (faceidx idx, int faceset = 0)
		2768	CODE:
		2769	facedata *d = face_data (idx, faceset);
		2770	if (!d) XSRETURN_UNDEF;
		2771	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2772	OUTPUT:
		2773	RETVAL
2570		2774
2571	void invalidate (faceidx idx)	2775	void invalidate (faceidx idx)
2572	CODE:	2776	CODE:
2573	for_all_clients (ns)	2777	for_all_clients (ns)
		2778	{
2574	ns->faces_sent [idx] = false;	2779	ns->faces_sent [idx] = false;
		2780	ns->force_newmap = true;
		2781	}
2575		2782
2576	void invalidate_all ()	2783	void invalidate_all ()
2577	CODE:	2784	CODE:
2578	for_all_clients (ns)	2785	for_all_clients (ns)
		2786	{
2579	ns->faces_sent.reset ();	2787	ns->faces_sent.reset ();
		2788	ns->force_newmap = true;
		2789	}
2580		2790
		2791	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
		2792
		2793	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h |
		2794
		2795	animidx anim_find (utf8_string name)
		2796	CODE:
		2797	RETVAL = animation::find (name).number;
		2798	OUTPUT: RETVAL
		2799
		2800	animidx set (utf8_string name, SV *frames, int facings = 1)
		2801	CODE:
		2802	{
		2803	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)
		2804	croak ("frames must be an arrayref");
		2805
		2806	AV *av = (AV *)SvRV (frames);
		2807
		2808	animation *anim = &animation::find (name);
		2809	if (anim->number)
		2810	{
		2811	anim->resize (av_len (av) + 1);
		2812	anim->facings = facings;
		2813	}
		2814	else
		2815	anim = &animation::create (name, av_len (av) + 1, facings);
		2816
		2817	for (int i = 0; i < anim->num_animations; ++i)
		2818	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
		2819	}
		2820	OUTPUT: RETVAL
		2821
		2822	void invalidate_all ()
		2823	CODE:
		2824	for_all_clients (ns)
		2825	ns->anims_sent.reset ();
		2826
		2827	MODULE = cf PACKAGE = cf::object::freezer
		2828
		2829	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h |
		2830
		2831	SV *
		2832	new (char *klass)
		2833	CODE:
		2834	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2835	OUTPUT: RETVAL
		2836
		2837	void
		2838	DESTROY (SV *sv)
		2839	CODE:
		2840	object_freezer *self;
		2841	sv_to (sv, self);
		2842	delete self;
		2843
		2844	MODULE = cf PACKAGE = cf::object::thawer
		2845
		2846	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/freezethaw.h |
		2847
		2848	bool
		2849	errors_are_fatal (bool fatal)
		2850	CODE:
		2851	RETVAL = object_thawer::errors_are_fatal;
		2852	object_thawer::errors_are_fatal = fatal;
		2853	OUTPUT:
		2854	RETVAL
		2855
		2856	SV *
		2857	new_from_file (char *klass, octet_string path)
		2858	CODE:
		2859	object_thawer *f = new object_thawer (path);
		2860	if (!*f)
		2861	{
		2862	delete f;
		2863	XSRETURN_UNDEF;
		2864	}
		2865	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2866	OUTPUT: RETVAL
		2867
		2868	void
		2869	DESTROY (SV *sv)
		2870	CODE:
		2871	object_thawer *self;
		2872	sv_to (sv, self);
		2873	delete self;
		2874
		2875	void
		2876	extract_tags (object_thawer *self)
		2877	PPCODE:
		2878	while (self->kw != KW_EOF)
		2879	{
		2880	PUTBACK;
		2881	coroapi::cede_to_tick ();
		2882	SPAGAIN;
		2883
		2884	if (self->kw == KW_tag)
		2885	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2886
		2887	self->skip ();
		2888	}
		2889
		2890	MODULE = cf PACKAGE = cf::layout
		2891
		2892	INCLUDE: $PERL $srcdir/genacc layout $srcdir/../random_maps/random_map.h |
		2893

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines