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.127 by root, Thu Jan 4 20:15:16 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

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

Diff Legend

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