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

Diff Legend

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