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

Diff Legend

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