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.227 by root, Tue Jul 10 16:24:00 2007 UTC vs.
Revision 1.290 by root, Sat May 17 14:57:23 2008 UTC

1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann	5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>	6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
7	*	7	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation, either version 3 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
…		…
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*	20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	22	*/
23		23
24	#include "autoconf.h"	24	#include "autoconf.h"
25
26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"
28
29	#define CEDES_PER_TICK 5
30		25
31	#if HAVE_EXECINFO_H	26	#if HAVE_EXECINFO_H
32	# include <execinfo.h>	27	# include <execinfo.h>
33	#endif	28	#endif
34		29
35	#include <plugin_common.h>
36	#include <sounds.h>
37	#include <cstdarg>	30	#include <cstdarg>
38	#include <sproto.h>
39		31
		32	#include "global.h"
40	#include "loader.h"	33	#include "loader.h"
		34	#include "../random_maps/random_map.h"
41	#include "cfperl.h"	35	#include "evthread.h"
42	#include "shstr.h"	36	#include "sproto.h"
43		37
44	#include <unistd.h>	38	#include <unistd.h>
45	#if _POSIX_MEMLOCK	39	#if _POSIX_MEMLOCK
46	# include <sys/mman.h>	40	# include <sys/mman.h>
47	#endif	41	#endif
48		42
		43	#if HAVE_MALLOC_H
		44	# include <malloc.h>
		45	#endif
		46
		47	#if !__GLIBC__
		48	# define malloc_trim(pad) -1
		49	#endif
		50
49	#include <EXTERN.h>	51	#include <EXTERN.h>
50	#include <perl.h>	52	#include <perl.h>
51	#include <XSUB.h>	53	#include <XSUB.h>
52		54
53	#include "CoroAPI.h"	55	#include "CoroAPI.h"
54	#include "perlxsi.c"	56	#include "perlxsi.c"
55		57
56	extern sint64 *levels; // the experience table	58	extern sint64 *levels; // the experience table
57		59
58	typedef object object_ornull;	60	typedef object_thawer &object_thawer_ref;
59	typedef maptile maptile_ornull;	61	typedef object_freezer &object_freezer_ref;
60
61	typedef char *octet_string;
62	typedef char *utf8_string;
63	typedef const char *const_octet_string;
64	typedef const char *const_utf8_string;
65		62
66	typedef std::string std__string;	63	typedef std::string std__string;
67		64
68	#if IVSIZE >= 8
69	typedef IV val64;
70	# define newSVval64 newSViv
71	# define SvVAL64 SvIV
72	#else
73	typedef double val64;
74	# define newSVval64 newSVnv
75	# define SvVAL64 SvNV
76	#endif
77
78	static f_plug_api gethook = cfapi_get_hooks;
79	static f_plug_api object_insert = cfapi_object_insert;
80
81	static PerlInterpreter *perl;	65	static PerlInterpreter *perl;
82		66
83	tstamp NOW, runtime;	67	tstamp NOW, runtime;
		68
		69	static int tick_inhibit;
		70	static int tick_pending;
84		71
85	global gbl_ev;	72	global gbl_ev;
86	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	73	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
87	static SV *sv_runtime, *sv_next_tick;	74	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
88		75
89	bitset<NUM_EVENT_TYPES> ev_want_event;	76	bitset<NUM_EVENT_TYPES> ev_want_event;
90	bitset<NUM_TYPES> ev_want_type;	77	bitset<NUM_TYPES> ev_want_type;
91		78
92	static HV	79	static HV
…		…
99	*stash_cf_arch_wrap,	86	*stash_cf_arch_wrap,
100	*stash_cf_party_wrap,	87	*stash_cf_party_wrap,
101	*stash_cf_region_wrap,	88	*stash_cf_region_wrap,
102	*stash_cf_living_wrap;	89	*stash_cf_living_wrap;
103		90
		91	static inline SV *
		92	newSVpv_utf8 (const char *s)
		93	{
		94	if (!s)
		95	return newSV (0);
		96
		97	SV *sv = newSVpv (s, 0);
		98	SvUTF8_on (sv);
		99	return sv;
		100	}
		101
		102	static inline SV *
		103	newSVpvn_utf8 (const char *s, STRLEN l)
		104	{
		105	if (!s)
		106	return newSV (0);
		107
		108	SV *sv = newSVpvn (s, l);
		109	SvUTF8_on (sv);
		110	return sv;
		111	}
		112
104	// helper cast function, returns super class * or 0	113	// helper cast function, returns super class * or 0
105	template<class super>	114	template<class super>
106	static super *	115	static super *
107	is_a (attachable *at)	116	is_a (attachable *at)
108	{	117	{
…		…
246	delete obj;	255	delete obj;
247	}	256	}
248	}	257	}
249	}	258	}
250		259
		260	void
		261	attachable::set_key (const char *key, const char *value, bool is_utf8)
		262	{
		263	if (!self)
		264	self = newHV ();
		265
		266	if (value)
		267	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		268	else
		269	hv_delete (self, key, strlen (key), G_DISCARD);
		270	}
		271
251	attachable &	272	attachable &
252	attachable::operator =(const attachable &src)	273	attachable::operator =(const attachable &src)
253	{	274	{
254	//if (self || cb)	275	//if (self || cb)
255	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	276	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
…		…
298	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	319	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
299	{	320	{
300	SV *sv;	321	SV *sv;
301		322
302	if (!ptr)	323	if (!ptr)
303	return &PL_sv_undef;	324	return newSV (0);
304		325
305	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	326	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
306	return sv_bless (newRV_noinc ((SV *)hv), stash);	327	return sv_bless (newRV_noinc ((SV *)hv), stash);
307	}	328	}
308		329
…		…
327		348
328	static SV *	349	static SV *
329	newSVattachable (attachable *obj, HV *stash)	350	newSVattachable (attachable *obj, HV *stash)
330	{	351	{
331	if (!obj)	352	if (!obj)
332	return &PL_sv_undef;	353	return newSV (0);
333		354
334	if (!obj->self)	355	if (!obj->self)
		356	obj->self = newHV ();
		357
		358	if (!SvOBJECT (obj->self))
335	{	359	{
336	obj->self = newHV ();
337	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);	360	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
338		361
339	// now bless the object _once_	362	// now bless the object _once_
		363	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
340	return sv_bless (newRV_inc ((SV *)obj->self), stash);	364	return sv_bless (newRV_inc ((SV *)obj->self), stash);
341	}	365	}
342	else	366	else
343	{	367	{
344	SV *sv = newRV_inc ((SV *)obj->self);	368	SV *sv = newRV_inc ((SV *)obj->self);
…		…
381	return SvPTR (sv, klass);	405	return SvPTR (sv, klass);
382	else	406	else
383	return 0;	407	return 0;
384	}	408	}
385		409
386	static inline SV *
387	newSVpv_utf8 (const char *s)
388	{
389	SV *sv = newSVpv (s, 0);
390	SvUTF8_on (sv);
391	return sv;
392	}
393
394	static inline SV *
395	newSVpvn_utf8 (const char *s, STRLEN l)
396	{
397	SV *sv = newSVpvn (s, l);
398	SvUTF8_on (sv);
399	return sv;
400	}
401
402	inline SV *to_sv (const shstr & v) { return v ? newSVpvn_utf8 ((const char *)v, v.length ()) : &PL_sv_undef; }	410	inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length ()); }
403	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }	411	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
404	inline SV *to_sv (bool v) { return newSViv (v); }	412	inline SV *to_sv (bool v) { return newSViv (v); }
405	inline SV *to_sv ( signed char v) { return newSViv (v); }	413	inline SV *to_sv ( signed char v) { return newSViv (v); }
406	inline SV *to_sv (unsigned char v) { return newSViv (v); }	414	inline SV *to_sv (unsigned char v) { return newSViv (v); }
407	inline SV *to_sv ( signed short v) { return newSViv (v); }	415	inline SV *to_sv ( signed short v) { return newSViv (v); }
408	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	416	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
…		…
417	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }	425	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
418	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }	426	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
419	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }	427	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
420	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }	428	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
421	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }	429	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		430	inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
422	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }	431	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
423	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
424	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	432	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
425		433
426	inline SV *to_sv (object & v) { return to_sv (&v); }	434	inline SV *to_sv (object & v) { return to_sv (&v); }
427	inline SV *to_sv (living & v) { return to_sv (&v); }	435	inline SV *to_sv (living & v) { return to_sv (&v); }
428		436
429	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	437	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
430	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }	438	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
431		439
432	inline SV *to_sv (UUID v)	440	inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
433	{
434	char buf[128];
435	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
436	return newSVpv (buf, 0);
437	}
438		441
439	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }	442	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
440	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	443	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
441	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	444	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
442	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	445	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
443	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	446	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
444	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	447	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
445	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	448	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
446	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	449	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
447	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	450	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
448	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	451	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
449	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	452	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
450	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	453	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
451	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	454	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
452	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	455	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
453	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	456	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
454	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }	457	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
455	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	458	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
456	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	459	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
457	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	460	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
458	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }	461	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		462	inline void sv_to (SV *sv, region * &v) { v = (region *)(attachable *)SvPTR_ornull (sv, "cf::region"); }
459	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	463	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
460	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	464	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
461	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
462	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	465	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		466	inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
		467	inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
463		468
464	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	469	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
465	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }	470	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
466		471
467	template<class T>	472	template<class T>
468	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	473	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
469		474
470	template<int N>	475	template<int N>
471	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	476	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
472		477
473	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	478	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
474	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	479	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
475	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	480	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
476	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	481	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
477		482
478	inline void sv_to (SV *sv, std::string &v)	483	inline void sv_to (SV *sv, std::string &v)
479	{	484	{
480	STRLEN len;	485	STRLEN len;
481	char *data = SvPVbyte (sv, len);	486	char *data = SvPVbyte (sv, len);
482	v.assign (data, len);	487	v.assign (data, len);
483	}	488	}
484		489
485	inline void sv_to (SV *sv, UUID &v)	490	inline void sv_to (SV *sv, UUID &v)
486	{	491	{
487	unsigned int version;	492	if (!v.parse (SvPV_nolen (sv)))
488
489	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
490	croak ("unparsable uuid: %s", SvPV_nolen (sv));	493	croak ("unparsable uuid: %s", SvPV_nolen (sv));
491	}	494	}
492		495
493	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	496	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
494		497
…		…
512	break;	515	break;
513		516
514	case DT_STRING:	517	case DT_STRING:
515	{	518	{
516	char *str = (char *)va_arg (ap, const char *);	519	char *str = (char *)va_arg (ap, const char *);
517	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	520	sv = str ? newSVpv (str, 0) : newSV (0);
518	}	521	}
519	break;	522	break;
520		523
521	case DT_DATA:	524	case DT_DATA:
522	{	525	{
523	char *str = (char *)va_arg (ap, const void *);	526	char *str = (char *)va_arg (ap, const void *);
524	int len = va_arg (ap, int);	527	int len = va_arg (ap, int);
525	sv = str ? newSVpv (str, len) : &PL_sv_undef;	528	sv = str ? newSVpv (str, len) : newSV (0);
526	}	529	}
527	break;	530	break;
528		531
529	case DT_OBJECT:	532	case DT_OBJECT:
530	sv = to_sv (va_arg (ap, object *));	533	sv = to_sv (va_arg (ap, object *));
…		…
572	va_end (ap);	575	va_end (ap);
573		576
574	return sv;	577	return sv;
575	}	578	}
576		579
577	static SV *
578	newSVcfapi (int type, ...)
579	{
580	SV *sv;
581
582	va_list ap;
583	va_start (ap, type);
584
585	switch (type)
586	{
587	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
588	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
589	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
590	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
591	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
592	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
593	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
594	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
595	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
596	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
597
598	default:
599	assert (("unhandled type in newSVcfapi", 0));
600	}
601
602	va_end (ap);
603
604	return sv;
605	}
606
607	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	580	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
608		581
609	SV *	582	SV *
610	registry (attachable *ext)	583	registry (attachable *ext)
611	{	584	{
…		…
615	return newRV_inc ((SV *)ext->cb);	588	return newRV_inc ((SV *)ext->cb);
616	}	589	}
617		590
618	/////////////////////////////////////////////////////////////////////////////	591	/////////////////////////////////////////////////////////////////////////////
619		592
620	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
621	{
622	return 0;
623	}
624
625	static CommArray_s rtn_cmd;
626
627	static int
628	runPluginCommand (object *obj, char *params)
629	{
630	return -1;
631	}
632
633	extern "C" void *cfperl_getPluginProperty (int *type, ...)
634	{
635	va_list args;
636	char *propname;
637	int i;
638	va_start (args, type);
639	propname = va_arg (args, char *);
640	//printf ("Property name: %s\n", propname);
641
642	if (!strcmp (propname, "command?"))
643	return NULL;
644	else if (!strcmp (propname, "Identification"))
645	{
646	va_end (args);
647	return (void *)PLUGIN_NAME;
648	}
649	else if (!strcmp (propname, "FullName"))
650	{
651	va_end (args);
652	return (void *)PLUGIN_VERSION;
653	}
654	else
655	va_end (args);
656
657	return NULL;
658	}
659
660	extern "C" int cfperl_postInitPlugin ()
661	{
662	int hooktype = 1;
663	int rtype = 0;
664
665	cf_init_plugin (gethook);
666
667	return 0;
668	}
669
670	extern "C" int cfperl_closePlugin ()
671	{
672	return 0;
673	}
674
675	void	593	void
676	cfperl_init ()	594	cfperl_init ()
677	{	595	{
		596	extern char **environ;
		597
678	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	598	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
679	perl = perl_alloc ();	599	perl = perl_alloc ();
680	perl_construct (perl);	600	perl_construct (perl);
681		601
682	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	602	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
683		603
684	const char *argv[] = {	604	const char *argv[] = {
685	settings.argv [0],	605	settings.argv [0],
686	"-e"	606	"-e"
687	"use Event; use Coro;" // required for bootstrap	607	"use EV; use Coro;" // required for bootstrap
688	"cf->bootstrap;" // required for datadir :*>	608	"cf->bootstrap;" // required for datadir :*>
689	"unshift @INC, cf::datadir ();"	609	"unshift @INC, cf::datadir ();"
690	"require cf;"	610	"require cf;"
691	};	611	};
692		612
693	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	613	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
694	|| perl_run (perl))	614	|| perl_run (perl))
695	{	615	{
696	printf ("unable to initialize perl-interpreter, aborting.\n");	616	printf ("unable to initialize perl-interpreter, aborting.\n");
697	exit (EXIT_FAILURE);	617	exit (EXIT_FAILURE);
698	}	618	}
…		…
949	}	869	}
950		870
951	SV *	871	SV *
952	cfperl_result (int idx)	872	cfperl_result (int idx)
953	{	873	{
954	AV *av = get_av ("cfperl::invoke_results", 0);	874	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
955	if (!av)	875	if (!av)
956	return &PL_sv_undef;	876	return &PL_sv_undef;
957		877
958	SV **sv = av_fetch (av, idx, 0);	878	SV **sv = av_fetch (av, idx, 0);
959	if (!sv)	879	if (!sv)
…		…
973	{	893	{
974	return SvNV (cfperl_result (idx));	894	return SvNV (cfperl_result (idx));
975	}	895	}
976		896
977	/////////////////////////////////////////////////////////////////////////////	897	/////////////////////////////////////////////////////////////////////////////
		898	// various c++ => perl glue functions
		899
		900	void cfperl_tick ()
		901	{
		902	tick_pending = 1;
		903
		904	if (tick_inhibit)
		905	return;
		906
		907	tick_pending = 0;
		908
		909	dSP;
		910
		911	PUSHMARK (SP);
		912	PUTBACK;
		913	call_pv ("cf::tick", G_DISCARD | G_VOID);
		914
		915	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		916	}
978		917
979	void	918	void
980	cfperl_emergency_save ()	919	cfperl_emergency_save ()
981	{	920	{
982	CALL_BEGIN (0);	921	CALL_BEGIN (0);
…		…
1002	CALL_CALL ("ext::books::make_book", G_VOID);	941	CALL_CALL ("ext::books::make_book", G_VOID);
1003	CALL_END;	942	CALL_END;
1004	}	943	}
1005		944
1006	void	945	void
		946	cfperl_expand_cfpod (player *pl, std::string &msg)
		947	{
		948	CALL_BEGIN (2);
		949	CALL_ARG (pl);
		950	CALL_ARG_SV (newSVpvn_utf8 (msg.data (), msg.size ()));
		951	CALL_CALL ("cf::player::expand_cfpod", G_SCALAR);
		952
		953	if (count)
		954	{
		955	STRLEN len;
		956	char *data = SvPVutf8 (TOPs, len);
		957	msg.assign (data, len);
		958	}
		959
		960	CALL_END;
		961	}
		962
		963	void
1007	cfperl_send_msg (client *ns, int color, const char *type, const char *msg)	964	cfperl_send_msg (client *ns, int color, const char *type, const char *msg)
1008	{	965	{
1009	CALL_BEGIN (4);	966	CALL_BEGIN (4);
1010	CALL_ARG (ns);	967	CALL_ARG (ns);
1011	CALL_ARG (color);
1012	CALL_ARG (type);	968	CALL_ARG (type);
1013	CALL_ARG_SV (newSVpv_utf8 (msg));	969	CALL_ARG_SV (newSVpv_utf8 (msg));
		970	CALL_ARG (color);
1014	CALL_CALL ("cf::client::send_msg", G_VOID);	971	CALL_CALL ("cf::client::send_msg", G_VOID);
1015	CALL_END;	972	CALL_END;
		973	}
		974
		975	int
		976	cfperl_can_merge (object *ob1, object *ob2)
		977	{
		978	int can;
		979
		980	CALL_BEGIN (2);
		981	CALL_ARG (ob1);
		982	CALL_ARG (ob2);
		983	CALL_CALL ("cf::_can_merge", G_SCALAR);
		984	can = count && SvTRUE (TOPs);
		985	CALL_END;
		986
		987	return can;
		988	}
		989
		990	player *
		991	player::find (const char *name)
		992	{
		993	CALL_BEGIN (1);
		994	CALL_ARG (name);
		995	CALL_CALL ("cf::player::find", G_SCALAR);
		996
		997	player *retval = 0;
		998	if (count) sv_to (POPs, retval);
		999
		1000	CALL_END;
		1001
		1002	return retval;
		1003	}
		1004
		1005	maptile *
		1006	find_style (const char *dirname, const char *stylename, int difficulty)
		1007	{
		1008	CALL_BEGIN (3);
		1009	CALL_ARG (dirname);
		1010	CALL_ARG (stylename);
		1011	CALL_ARG (difficulty);
		1012	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1013
		1014	maptile *retval = 0;
		1015	if (count) sv_to (POPs, retval);
		1016
		1017	CALL_END;
		1018
		1019	return retval;
1016	}	1020	}
1017		1021
1018	maptile *	1022	maptile *
1019	maptile::find_sync (const char *path, maptile *origin)	1023	maptile::find_sync (const char *path, maptile *origin)
1020	{	1024	{
1021	CALL_BEGIN (2);	1025	CALL_BEGIN (2);
1022	CALL_ARG (path);	1026	CALL_ARG (path);
1023	CALL_ARG (origin);	1027	CALL_ARG (origin);
1024	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1028	CALL_CALL ("cf::map::find_sync", G_SCALAR);
1025		1029
1026	maptile *retval;	1030	maptile *retval = 0;
1027
1028	if (count)
1029	sv_to (POPs, retval);	1031	if (count) sv_to (POPs, retval);
1030	else
1031	retval = 0;
1032		1032
1033	CALL_END;	1033	CALL_END;
1034		1034
1035	return retval;	1035	return retval;
1036	}	1036	}
1037		1037
1038	maptile *	1038	maptile *
1039	maptile::find_async (const char *path, maptile *origin)	1039	maptile::find_async (const char *path, maptile *origin, bool load)
1040	{	1040	{
1041	CALL_BEGIN (2);	1041	CALL_BEGIN (3);
1042	CALL_ARG (path);	1042	CALL_ARG (path);
1043	CALL_ARG (origin);	1043	CALL_ARG (origin);
		1044	CALL_ARG (load);
1044	CALL_CALL ("cf::map::find_async", G_SCALAR);	1045	CALL_CALL ("cf::map::find_async", G_SCALAR);
1045		1046
1046	maptile *retval;	1047	maptile *retval = 0;
1047
1048	if (count)
1049	sv_to (POPs, retval);	1048	if (count) sv_to (POPs, retval);
1050	else
1051	retval = 0;
1052		1049
1053	CALL_END;	1050	CALL_END;
1054		1051
1055	return retval;	1052	return retval;
1056	}	1053	}
…		…
1082	CALL_BEGIN (2);	1079	CALL_BEGIN (2);
1083	CALL_ARG (this);	1080	CALL_ARG (this);
1084	CALL_ARG (exit);	1081	CALL_ARG (exit);
1085	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1082	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
1086	CALL_END;	1083	CALL_END;
		1084	}
		1085
		1086	void
		1087	object::player_goto (const char *path, int x, int y)
		1088	{
		1089	if (type != PLAYER)
		1090	return;
		1091
		1092	CALL_BEGIN (4);
		1093	CALL_ARG (this);
		1094	CALL_ARG (path);
		1095	CALL_ARG (x);
		1096	CALL_ARG (y);
		1097	CALL_CALL ("cf::object::player::goto", G_VOID);
		1098	CALL_END;
		1099	}
		1100
		1101	const char *
		1102	object::ref () const
		1103	{
		1104	if (type == PLAYER)
		1105	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1106	else
		1107	return 0;
		1108	}
		1109
		1110	object *
		1111	object::deref (const char *ref)
		1112	{
		1113	object *retval = 0;
		1114
		1115	if (ref)
		1116	{
		1117	CALL_BEGIN (1);
		1118	CALL_ARG (ref);
		1119	CALL_CALL ("cf::object::deref", G_SCALAR);
		1120
		1121	if (count)
		1122	sv_to (POPs, retval);
		1123
		1124	CALL_END;
		1125	}
		1126
		1127	return retval;
1087	}	1128	}
1088		1129
1089	void	1130	void
1090	log_backtrace (const char *msg)	1131	log_backtrace (const char *msg)
1091	{	1132	{
…		…
1102	#endif	1143	#endif
1103	}	1144	}
1104		1145
1105	/////////////////////////////////////////////////////////////////////////////	1146	/////////////////////////////////////////////////////////////////////////////
1106		1147
1107	struct EventAPI *watcher_base::GEventAPI;	1148	struct EVAPI *evapi::GEVAPI;
1108	struct CoroAPI *coroapi::GCoroAPI;	1149	struct CoroAPI *coroapi::GCoroAPI;
1109
1110	int coroapi::cede_counter;
1111	tstamp coroapi::next_cede;
1112		1150
1113	void coroapi::do_cede_to_tick ()	1151	void coroapi::do_cede_to_tick ()
1114	{	1152	{
1115	cede_counter = 0;	1153	cede_pending = 0;
1116
1117	cede ();	1154	cede ();
1118
1119	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1120	if (next_cede > SvNV (sv_next_tick) - 0.02)
1121	next_cede = SvNV (sv_next_tick);
1122	}
1123
1124	void coroapi::do_cede_every ()
1125	{
1126	cede_counter = 0;
1127
1128	if (coroapi::nready ())
1129	coroapi::cede ();
1130	}
1131
1132	void coroapi::do_cede_to_tick_every ()
1133	{
1134	cede_counter = 0;
1135
1136	cede_to_tick ();
1137	}	1155	}
1138		1156
1139	void	1157	void
1140	coroapi::wait_for_tick ()	1158	coroapi::wait_for_tick ()
1141	{	1159	{
…		…
1150	CALL_BEGIN (0);	1168	CALL_BEGIN (0);
1151	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1169	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1152	CALL_END;	1170	CALL_END;
1153	}	1171	}
1154		1172
1155	static void
1156	iw_dispatch (pe_event *ev)
1157	{
1158	iw *w = (iw *)ev->ext_data;
1159	w->call (*w);
1160	}
1161
1162	void
1163	iw::alloc ()
1164	{
1165	pe = GEventAPI->new_idle (0, 0);
1166
1167	WaREENTRANT_off (pe);
1168	pe->base.callback = (void *)iw_dispatch;
1169	pe->base.ext_data = (void *)this;
1170	}
1171
1172	static void iow_dispatch (pe_event *ev)
1173	{
1174	iow *w = (iow *)ev->ext_data;
1175	w->call (*w, ((pe_ioevent *)ev)->got);
1176	}
1177
1178	void
1179	iow::alloc ()
1180	{
1181	pe = GEventAPI->new_io (0, 0);
1182
1183	WaREENTRANT_off (pe);
1184	pe->base.callback = (void *)iow_dispatch;
1185	pe->base.ext_data = (void *)this;
1186
1187	pe->fd = -1;
1188	pe->poll = 0;
1189	}
1190
1191	void
1192	iow::fd (int fd)
1193	{
1194	pe->fd = fd;
1195	}
1196
1197	int
1198	iow::poll ()
1199	{
1200	return pe->poll;
1201	}
1202
1203	void	1173	void
1204	iow::poll (int events)	1174	iow::poll (int events)
1205	{	1175	{
1206	if (pe->poll != events)	1176	if (events != this->events)
1207	{	1177	{
		1178	int active = ev_is_active ((ev_io *)this);
1208	if (pe->poll) stop ();	1179	if (active) stop ();
1209	pe->poll = events;	1180	ev_io_set ((ev_io *)this, fd, events);
1210	if (pe->poll) start ();	1181	if (active) start ();
1211	}	1182	}
1212	}	1183	}
1213		1184
1214	void	1185	void
1215	_connect_to_perl ()	1186	_connect_to_perl ()
1216	{	1187	{
1217	stash_cf = gv_stashpv ("cf" , 1);	1188	stash_cf = gv_stashpv ("cf", 1);
1218		1189
1219	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1190	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1220	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1191	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1221	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1192	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1222	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1193	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
…		…
1224	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1195	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1225	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1196	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1226	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1197	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1227	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1198	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1228		1199
		1200	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1229	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1201	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1202	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1230	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1203	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1231		1204
1232	cb_global = get_av ("cf::CB_GLOBAL", 1);	1205	cb_global = get_av ("cf::CB_GLOBAL", 1);
1233	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1206	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1234	cb_object = get_av ("cf::CB_OBJECT", 1);	1207	cb_object = get_av ("cf::CB_OBJECT", 1);
1235	cb_player = get_av ("cf::CB_PLAYER", 1);	1208	cb_player = get_av ("cf::CB_PLAYER", 1);
…		…
1240		1213
1241	MODULE = cf PACKAGE = cf PREFIX = cf_	1214	MODULE = cf PACKAGE = cf PREFIX = cf_
1242		1215
1243	BOOT:	1216	BOOT:
1244	{	1217	{
1245	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1218	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1246	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1219	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1247		1220
1248	_connect_to_perl ();	1221	_connect_to_perl ();
1249		1222
1250	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1223	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1251		1224
…		…
1269	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1242	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1270		1243
1271	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1244	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1272		1245
1273	const_iv (MAX_TIME)	1246	const_iv (MAX_TIME)
		1247	const_iv (MAXSOCKBUF)
1274		1248
1275	const_iv (NUM_BODY_LOCATIONS)	1249	const_iv (NUM_BODY_LOCATIONS)
1276	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)	1250	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1277	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)	1251	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1278	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)	1252	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
…		…
1346	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)	1320	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1347	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)	1321	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1348	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)	1322	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1349	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)	1323	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1350	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1324	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1351	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)	1325	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1352	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1326	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1353	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)	1327	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1354		1328
1355	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1329	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1356	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)	1330	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1357	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)	1331	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1358	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)	1332	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1359	const_iv (NDI_ALL)	1333	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
		1334	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR)
1360		1335
1361	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1336	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1362	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1337	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1363		1338
1364	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1339	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
…		…
1422	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1397	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1423		1398
1424	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1399	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1425		1400
1426	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1401	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1427	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)	1402	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1428		1403
1429	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)	1404	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1430	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)	1405	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1431		1406
1432	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1407	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
…		…
1466	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1441	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1467	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)	1442	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1468	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)	1443	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1469	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)	1444	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1470		1445
1471	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1446	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1447	const_iv (MAP_INACTIVE)
1472		1448
1473	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1449	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1474	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1450	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
		1451
		1452	const_iv (VERSION_CS) const_iv (VERSION_SC)
1475		1453
1476	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1454	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1477		1455
1478	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)	1456	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1479		1457
…		…
1489		1467
1490	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1468	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1491	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1469	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1492		1470
1493	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)	1471	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1494	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)	1472	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1495	const_iv (GT_MINIMAL)	1473
		1474	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
		1475	const_iv (FT_RSRC) const_iv (FT_NUM)
1496	};	1476	};
1497		1477
1498	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1478	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1499	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1479	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1500		1480
…		…
1534		1514
1535	for_all_objects (op)	1515	for_all_objects (op)
1536	op->reattach ();	1516	op->reattach ();
1537	}	1517	}
1538		1518
1539	void _post_tick ()
1540	CODE:
1541	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1542
1543	# support function for map-world.ext	1519	# support function for map-world.ext
1544	void _quantise (SV *data_sv, SV *plt_sv)	1520	void _quantise (SV *data_sv, SV *plt_sv)
1545	CODE:	1521	CODE:
1546	{	1522	{
1547	if (!SvROK (plt_sv) || SvTYPE (SvRV (plt_sv)) != SVt_PVAV)	1523	if (!SvROK (plt_sv) || SvTYPE (SvRV (plt_sv)) != SVt_PVAV)
…		…
1580	}	1556	}
1581		1557
1582	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1558	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1583	}	1559	}
1584		1560
		1561	void evthread_start (int aiofd)
		1562
		1563	void cede_to_tick ()
		1564	CODE:
		1565	coroapi::cede_to_tick ();
		1566
		1567	NV till_tick ()
		1568	CODE:
		1569	RETVAL = SvNVX (sv_next_tick) - now ();
		1570	OUTPUT:
		1571	RETVAL
		1572
		1573	int tick_inhibit ()
		1574	CODE:
		1575	RETVAL = tick_inhibit;
		1576	OUTPUT:
		1577	RETVAL
		1578
		1579	void tick_inhibit_inc ()
		1580	CODE:
		1581	++tick_inhibit;
		1582
		1583	void tick_inhibit_dec ()
		1584	CODE:
		1585	if (!--tick_inhibit)
		1586	if (tick_pending)
		1587	{
		1588	ev_async_send (EV_DEFAULT, &tick_watcher);
		1589	coroapi::cede ();
		1590	}
		1591
		1592	void server_tick ()
		1593	CODE:
		1594	{
		1595	NOW = ev_now (EV_DEFAULT);
		1596	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1597	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1598	runtime = SvNVX (sv_runtime);
		1599
		1600	server_tick ();
		1601
		1602	NOW = ev_time ();
		1603	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1604	runtime += TICK;
		1605	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1606	}
		1607
1585	NV floor (NV x)	1608	NV floor (NV x)
1586		1609
1587	NV ceil (NV x)	1610	NV ceil (NV x)
1588		1611
1589	NV rndm (...)	1612	NV rndm (...)
		1613	ALIAS:
		1614	rmg_rndm = 1
1590	CODE:	1615	CODE:
		1616	{
		1617	rand_gen &gen = ix ? rmg_rndm : rndm;
1591	switch (items)	1618	switch (items)
1592	{	1619	{
1593	case 0: RETVAL = rndm (); break;	1620	case 0: RETVAL = gen (); break;
1594	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1621	case 1: RETVAL = gen (SvUV (ST (0))); break;
1595	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1622	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1596	default: croak ("cf::rndm requires none, one or two parameters."); break;	1623	default: croak ("cf::rndm requires none, one or two parameters."); break;
1597	}	1624	}
		1625	}
1598	OUTPUT:	1626	OUTPUT:
1599	RETVAL	1627	RETVAL
1600		1628
1601	NV clamp (NV value, NV min_value, NV max_value)	1629	NV clamp (NV value, NV min_value, NV max_value)
1602	CODE:	1630	CODE:
…		…
1608	CODE:	1636	CODE:
1609	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1637	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1610	OUTPUT:	1638	OUTPUT:
1611	RETVAL	1639	RETVAL
1612		1640
1613	void cede_to_tick ()	1641	void weaken (...)
1614	CODE:	1642	PROTOTYPE: @
1615	coroapi::cede_to_tick ();	1643	CODE:
1616		1644	while (items > 0)
1617	void server_tick ()	1645	sv_rvweaken (ST (--items));
1618	CODE:
1619	NOW = now ();
1620	runtime = SvNVx (sv_runtime);
1621	server_tick ();
1622		1646
1623	void	1647	void
1624	log_backtrace (utf8_string msg)	1648	log_backtrace (utf8_string msg)
1625		1649
1626	void	1650	void
…		…
1631	octet_string path_combine (octet_string base, octet_string path)	1655	octet_string path_combine (octet_string base, octet_string path)
1632	PROTOTYPE: $$	1656	PROTOTYPE: $$
1633		1657
1634	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1658	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1635	PROTOTYPE: $$	1659	PROTOTYPE: $$
1636
1637	const_octet_string
1638	get_maps_directory (octet_string path)
1639	PROTOTYPE: $
1640	ALIAS: maps_directory = 0
1641	CODE:
1642	RETVAL = create_pathname (path);
1643	OUTPUT: RETVAL
1644		1660
1645	void	1661	void
1646	sub_generation_inc ()	1662	sub_generation_inc ()
1647	CODE:	1663	CODE:
1648	PL_sub_generation++;	1664	PL_sub_generation++;
…		…
1673		1689
1674	void abort ()	1690	void abort ()
1675		1691
1676	void reset_signals ()	1692	void reset_signals ()
1677		1693
1678	void fork_abort (octet_string cause = "cf::fork_abort")	1694	void fork_abort (const_octet_string cause = "cf::fork_abort")
1679		1695
1680	void cleanup (octet_string cause, bool make_core = false)	1696	void cleanup (const_octet_string cause, bool make_core = false)
1681		1697
1682	void emergency_save ()	1698	void emergency_save ()
1683		1699
1684	void _exit (int status = EXIT_SUCCESS)	1700	void _exit (int status = EXIT_SUCCESS)
1685		1701
1686	UV sv_2watcher (SV *w)
1687	CODE:
1688	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1689	OUTPUT:
1690	RETVAL
1691
1692	#if _POSIX_MEMLOCK	1702	#if _POSIX_MEMLOCK
1693		1703
1694	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1704	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1705	INIT:
		1706	#if __GLIBC__
		1707	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1708	#endif
1695		1709
1696	int munlockall ()	1710	int munlockall ()
1697		1711
1698	#endif	1712	#endif
		1713
		1714	int
		1715	malloc_trim (IV pad = 0)
		1716
		1717	void
		1718	mallinfo ()
		1719	PPCODE:
		1720	{
		1721	#if __GLIBC__
		1722	struct mallinfo mai = mallinfo ();
		1723	EXTEND (SP, 10*2);
		1724	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1725	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1726	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1727	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1728	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1729	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1730	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1731	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1732	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1733	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1734	#endif
		1735	EXTEND (SP, 2*2);
		1736	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1737	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1738	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1739	}
1699		1740
1700	int find_animation (utf8_string text)	1741	int find_animation (utf8_string text)
1701	PROTOTYPE: $	1742	PROTOTYPE: $
1702		1743
1703	int random_roll (int min, int max, object *op, int goodbad);	1744	int random_roll (int min, int max, object *op, int goodbad);
…		…
1741	RETVAL = newSVpv (resist_plus[atnr], 0);	1782	RETVAL = newSVpv (resist_plus[atnr], 0);
1742	else	1783	else
1743	XSRETURN_UNDEF;	1784	XSRETURN_UNDEF;
1744	OUTPUT: RETVAL	1785	OUTPUT: RETVAL
1745		1786
		1787	UUID
		1788	uuid_cur ()
		1789	CODE:
		1790	RETVAL = UUID::cur;
		1791	OUTPUT:
		1792	RETVAL
		1793
		1794	UUID
		1795	uuid_gen ()
		1796	CODE:
		1797	RETVAL = UUID::gen ();
		1798	OUTPUT:
		1799	RETVAL
		1800
		1801	val64
		1802	uuid_seq (UUID uuid)
		1803	CODE:
		1804	RETVAL = uuid.seq;
		1805	OUTPUT:
		1806	RETVAL
		1807
		1808	UUID
		1809	uuid_str (val64 seq)
		1810	CODE:
		1811	RETVAL.seq = seq;
		1812	OUTPUT:
		1813	RETVAL
		1814
		1815	void
		1816	coin_names ()
		1817	PPCODE:
		1818	EXTEND (SP, NUM_COINS);
		1819	for (int i = 0; i < NUM_COINS; ++i)
		1820	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1821
		1822	void
		1823	coin_archetypes ()
		1824	PPCODE:
		1825	EXTEND (SP, NUM_COINS);
		1826	for (int i = 0; i < NUM_COINS; ++i)
		1827	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1828
1746	bool	1829	bool
1747	load_resource_file (octet_string filename)	1830	load_resource_file_ (octet_string filename)
		1831
		1832	void
		1833	fix_weight ()
1748		1834
1749	MODULE = cf PACKAGE = cf::attachable	1835	MODULE = cf PACKAGE = cf::attachable
1750		1836
1751	int	1837	int
1752	valid (SV *obj)	1838	valid (SV *obj)
…		…
1770	#object *mortals (U32 index)	1856	#object *mortals (U32 index)
1771	# CODE:	1857	# CODE:
1772	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1858	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1773	# OUTPUT: RETVAL	1859	# OUTPUT: RETVAL
1774		1860
1775	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	1861	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1776		1862
1777	MODULE = cf PACKAGE = cf::global	1863	MODULE = cf PACKAGE = cf::global
1778		1864
1779	int invoke (SV *klass, int event, ...)	1865	int invoke (SV *klass, int event, ...)
1780	CODE:	1866	CODE:
…		…
1816	object *actives (U32 index)	1902	object *actives (U32 index)
1817	CODE:	1903	CODE:
1818	RETVAL = index < actives.size () ? actives [index] : 0;	1904	RETVAL = index < actives.size () ? actives [index] : 0;
1819	OUTPUT: RETVAL	1905	OUTPUT: RETVAL
1820		1906
		1907	int mortals_size ()
		1908	CODE:
		1909	RETVAL = attachable::mortals.size ();
		1910	OUTPUT: RETVAL
		1911
1821	const char *slot_use_name (U32 slot)	1912	const char *slot_use_name (U32 slot)
1822	ALIAS:	1913	ALIAS:
1823	slot_nonuse_name = 1	1914	slot_nonuse_name = 1
1824	CODE:	1915	CODE:
1825	{	1916	{
…		…
1846	void	1937	void
1847	inv (object *obj)	1938	inv (object *obj)
1848	PROTOTYPE: $	1939	PROTOTYPE: $
1849	PPCODE:	1940	PPCODE:
1850	{	1941	{
1851	object *o;
1852	for (o = obj->inv; o; o = o->below)	1942	for (object *o = obj->inv; o; o = o->below)
1853	XPUSHs (sv_2mortal (to_sv (o)));	1943	XPUSHs (sv_2mortal (to_sv (o)));
1854	}	1944	}
1855		1945
1856	void	1946	void
1857	set_animation (object *op, int idx)	1947	set_animation (object *op, int idx)
…		…
1889		1979
1890	int need_identify (object *obj);	1980	int need_identify (object *obj);
1891		1981
1892	int apply_shop_mat (object *shop_mat, object *op);	1982	int apply_shop_mat (object *shop_mat, object *op);
1893		1983
1894	int move_player (object *op, int dir)
1895	CODE:
1896	RETVAL = move_player (op, dir);
1897	OUTPUT:
1898	RETVAL
1899
1900	int move (object *op, int dir, object *originator = op)	1984	int move (object *op, int dir, object *originator = op)
1901	CODE:	1985	CODE:
1902	RETVAL = move_ob (op, dir, originator);	1986	RETVAL = move_ob (op, dir, originator);
1903	OUTPUT:	1987	OUTPUT:
1904	RETVAL	1988	RETVAL
…		…
1911	CODE:	1995	CODE:
1912	player_apply_below (op);	1996	player_apply_below (op);
1913		1997
1914	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	1998	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1915		1999
1916	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)
1917
1918	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1919
1920	int cf_object_change_map (object *op, int x, int y, maptile *map)
1921
1922	#//TODO
1923	object *clone_ (object *op, int recursive = 0)
1924	CODE:
1925	if (recursive)
1926	RETVAL = object_create_clone (op);
1927	else
1928	{
1929	RETVAL = object::create ();
1930	op->copy_to (RETVAL);
1931	}
1932	OUTPUT: RETVAL
1933
1934	int pay_item (object *op, object *buyer)	2000	int pay_item (object *op, object *buyer)
1935	CODE:	2001	CODE:
1936	RETVAL = pay_for_item (op, buyer);	2002	RETVAL = pay_for_item (op, buyer);
1937	OUTPUT: RETVAL	2003	OUTPUT: RETVAL
1938		2004
…		…
1972		2038
1973	void drop (object *who, object *op)	2039	void drop (object *who, object *op)
1974		2040
1975	void pick_up (object *who, object *op)	2041	void pick_up (object *who, object *op)
1976		2042
1977	int cf_object_teleport (object *op, maptile *map, int x, int y)
1978
1979	void update_object (object *op, int action)	2043	void update_object (object *op, int action)
1980		2044
1981	object *cf_create_object_by_name (utf8_string name)
1982
1983	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2045	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1984		2046
1985	void player_lvl_adj (object *who, object *skill = 0)	2047	void player_lvl_adj (object *who, object *skill = 0)
1986		2048
1987	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2049	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
…		…
1994		2056
1995	void add_button_link (object *button, maptile *map, int connected);	2057	void add_button_link (object *button, maptile *map, int connected);
1996		2058
1997	void remove_button_link (object *op);	2059	void remove_button_link (object *op);
1998		2060
		2061	void handle_apply_yield (object *op);
		2062
1999		2063
2000	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2064	MODULE = cf PACKAGE = cf::object PREFIX = cf_
2001
2002	object *cf_insert_ob_in_ob (object *ob, object *where)
2003		2065
2004	# no clean way to get an object from an archetype - stupid idiotic	2066	# no clean way to get an object from an archetype - stupid idiotic
2005	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2067	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
2006		2068
2007	object *new (utf8_string archetype = 0)	2069	object *new (utf8_string archetype = 0)
…		…
2016	# TODO: nuke	2078	# TODO: nuke
2017	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2079	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
2018	PROTOTYPE: $$$$$$	2080	PROTOTYPE: $$$$$$
2019	CODE:	2081	CODE:
2020	{	2082	{
2021	int unused_type;	2083	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
2022	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
2023	}	2084	}
2024		2085
2025	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2086	shstr
		2087	object::kv_get (shstr key)
2026		2088
2027	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2089	void
		2090	object::kv_del (shstr key)
		2091
		2092	void
		2093	object::kv_set (shstr key, shstr value)
2028		2094
2029	object *get_nearest_player (object *ob)	2095	object *get_nearest_player (object *ob)
2030	ALIAS: nearest_player = 0	2096	ALIAS: nearest_player = 0
2031	PREINIT:	2097	PREINIT:
2032	extern object *get_nearest_player (object *);	2098	extern object *get_nearest_player (object *);
…		…
2040	EXTEND (SP, 5);	2106	EXTEND (SP, 5);
2041	PUSHs (newSVuv (rv.distance));	2107	PUSHs (newSVuv (rv.distance));
2042	PUSHs (newSViv (rv.distance_x));	2108	PUSHs (newSViv (rv.distance_x));
2043	PUSHs (newSViv (rv.distance_y));	2109	PUSHs (newSViv (rv.distance_y));
2044	PUSHs (newSViv (rv.direction));	2110	PUSHs (newSViv (rv.direction));
2045	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2111	PUSHs (to_sv (rv.part));
2046	}	2112	}
2047		2113
2048	bool on_same_map_as (object *ob, object *other)	2114	bool on_same_map_as (object *ob, object *other)
2049	CODE:	2115	CODE:
2050	RETVAL = on_same_map (ob, other);	2116	RETVAL = on_same_map (ob, other);
…		…
2054	base_name (object *op, int plural = op->nrof > 1)	2120	base_name (object *op, int plural = op->nrof > 1)
2055	CODE:	2121	CODE:
2056	RETVAL = query_base_name (op, plural);	2122	RETVAL = query_base_name (op, plural);
2057	OUTPUT: RETVAL	2123	OUTPUT: RETVAL
2058		2124
2059	object *decrease_ob_nr (object *op, unsigned long i)	2125	# return the tail of an object, excluding itself
		2126	void
		2127	tail (object *op)
		2128	PPCODE:
		2129	while ((op = op->more))
		2130	XPUSHs (sv_2mortal (to_sv (op)));
2060		2131
2061	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2132	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
2062		2133
2063	player *player (object *op)	2134	player *player (object *op)
2064	CODE:	2135	CODE:
2065	RETVAL = op->contr;	2136	RETVAL = op->contr;
2066	OUTPUT: RETVAL	2137	OUTPUT: RETVAL
2067		2138
		2139	bool move_player (object *op, int dir)
		2140
2068	void check_score (object *op)	2141	void check_score (object *op)
2069		2142
2070	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2143	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
2071	CODE:	2144	CODE:
2072	new_draw_info (flags, 0, op, txt);	2145	new_draw_info (flags, 0, op, txt);
2073		2146
2074	void kill_player (object *op)	2147	void kill_player (object *op)
2075		2148
		2149	void esrv_send_item (object *pl, object *item)
		2150
2076	void esrv_update_item (object *op, int what, object *item)	2151	void esrv_update_item (object *pl, int what, object *item)
2077	C_ARGS: what, op, item	2152	C_ARGS: what, pl, item
		2153
		2154	void esrv_del_item (object *pl, int tag)
		2155	C_ARGS: pl->contr, tag
2078		2156
2079	int command_summon (object *op, utf8_string params)	2157	int command_summon (object *op, utf8_string params)
2080		2158
2081	int command_arrest (object *op, utf8_string params)	2159	int command_arrest (object *op, utf8_string params)
2082		2160
…		…
2103	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2181	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2104	pl->orig_stats = pl->ob->stats;	2182	pl->orig_stats = pl->ob->stats;
2105		2183
2106	void clear_los (player *pl)	2184	void clear_los (player *pl)
2107		2185
2108	void cf_player_move (player *pl, int dir)
2109
2110	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2111
2112	bool	2186	bool
2113	cell_visible (player *pl, int dx, int dy)	2187	cell_visible (player *pl, int dx, int dy)
2114	CODE:	2188	CODE:
2115	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2189	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
2116	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];	2190	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
…		…
2122	CODE:	2196	CODE:
2123	{	2197	{
2124	STRLEN len;	2198	STRLEN len;
2125	char *buf = SvPVbyte (packet, len);	2199	char *buf = SvPVbyte (packet, len);
2126		2200
		2201	if (len > MAXSOCKBUF)
		2202	pl->failmsg ("[packet too long for client]");
2127	if (pl->ns)	2203	else if (pl->ns)
2128	pl->ns->send_packet (buf, len);	2204	pl->ns->send_packet (buf, len);
2129	}	2205	}
2130		2206
2131	int	2207	int
2132	listening (player *pl, int new_value = -1)	2208	listening (player *pl, int new_value = -1)
…		…
2168	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2244	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2169	OUTPUT: RETVAL	2245	OUTPUT: RETVAL
2170		2246
2171	SV *registry (maptile *map)	2247	SV *registry (maptile *map)
2172		2248
		2249	void
		2250	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2251	PPCODE:
		2252	{
		2253	if (!map->spaces)
		2254	XSRETURN_EMPTY;
		2255
		2256	if (tag)
		2257	{
		2258	shstr_cmp tag_ (tag);
		2259
		2260	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2261	for (object *op = ms->bot; op; op = op->above)
		2262	if (op->tag == tag_)
		2263	XPUSHs (sv_2mortal (to_sv (op)));
		2264	}
		2265	else
		2266	{
		2267	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2268	for (object *op = ms->bot; op; op = op->above)
		2269	if (op->tag)
		2270	XPUSHs (sv_2mortal (to_sv (op)));
		2271	}
		2272	}
		2273
2173	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2274	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
2174		2275
2175	void	2276	void
2176	maptile::instantiate ()	2277	maptile::instantiate ()
2177		2278
…		…
2254	palette = SvRV (palette);	2355	palette = SvRV (palette);
2255		2356
2256	STRLEN idxlen;	2357	STRLEN idxlen;
2257	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2358	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
2258		2359
2259	region **regionmap = (region **)malloc (	2360	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
2260	(av_len ((AV *)palette) + 1) * sizeof (region *));
2261	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2361	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2262		2362
2263	for (int i = av_len ((AV *)palette) + 1; i--; )	2363	for (int i = av_len ((AV *)palette) + 1; i--; )
2264	regionmap [i] = region::find (	2364	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2265	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2266		2365
2267	for (int y = 0; y < THIS->height; ++y)	2366	for (int y = 0; y < THIS->height; ++y)
2268	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2367	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2269		2368
2270	sfree (THIS->regions, THIS->size ());	2369	sfree (THIS->regions, THIS->size ());
2271	free (THIS->regionmap);	2370	delete [] THIS->regionmap;
2272		2371
2273	THIS->regions = regions;	2372	THIS->regions = regions;
2274	THIS->regionmap = regionmap;	2373	THIS->regionmap = regionmap;
2275	}	2374	}
2276		2375
…		…
2297	}	2396	}
2298		2397
2299	op->destroy ();	2398	op->destroy ();
2300	}	2399	}
2301		2400
2302	void play_sound_map (maptile *map, int x, int y, int sound_num)
2303
2304	int out_of_map (maptile *map, int x, int y)	2401	int out_of_map (maptile *map, int x, int y)
2305		2402
2306	void	2403	void
2307	trigger (maptile *map, long connection, bool state = true)	2404	trigger (maptile *map, long connection, bool state = true)
2308	CODE:	2405	CODE:
…		…
2312	get_connection (maptile *map, long connection)	2409	get_connection (maptile *map, long connection)
2313	PPCODE:	2410	PPCODE:
2314	oblinkpt *obp = get_connection_links (map, connection);	2411	oblinkpt *obp = get_connection_links (map, connection);
2315	if (obp)	2412	if (obp)
2316	for (objectlink *ol = obp->link; ol; ol = ol->next)	2413	for (objectlink *ol = obp->link; ol; ol = ol->next)
2317	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2414	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2318
2319	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2320
2321	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2322
2323	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2324	C_ARGS: str, map, nx, ny
2325		2415
2326	void	2416	void
2327	get_map_flags (maptile *map, int x, int y)	2417	get_map_flags (maptile *map, int x, int y)
2328	PPCODE:	2418	PPCODE:
2329	{	2419	{
…		…
2334	EXTEND (SP, 4);	2424	EXTEND (SP, 4);
2335	PUSHs (sv_2mortal (newSViv (flags)));	2425	PUSHs (sv_2mortal (newSViv (flags)));
2336		2426
2337	if (GIMME_V == G_ARRAY)	2427	if (GIMME_V == G_ARRAY)
2338	{	2428	{
2339	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2429	PUSHs (sv_2mortal (to_sv (nmap)));
2340	PUSHs (sv_2mortal (newSViv (nx)));	2430	PUSHs (sv_2mortal (newSViv (nx)));
2341	PUSHs (sv_2mortal (newSViv (ny)));	2431	PUSHs (sv_2mortal (newSViv (ny)));
2342	}	2432	}
2343	}	2433	}
2344		2434
…		…
2353		2443
2354	get_map_flags (map, &nmap, x, y, &nx, &ny);	2444	get_map_flags (map, &nmap, x, y, &nx, &ny);
2355		2445
2356	if (nmap)	2446	if (nmap)
2357	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2447	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2358	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2448	XPUSHs (sv_2mortal (to_sv (o)));
2359	}	2449	}
2360		2450
2361	SV *	2451	SV *
2362	bot_at (maptile *obj, unsigned int x, unsigned int y)	2452	bot_at (maptile *obj, unsigned int x, unsigned int y)
2363	PROTOTYPE: $$$	2453	PROTOTYPE: $$$
…		…
2372	INIT:	2462	INIT:
2373	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;	2463	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2374	CODE:	2464	CODE:
2375	switch (ix)	2465	switch (ix)
2376	{	2466	{
2377	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2467	case 0: RETVAL = to_sv (GET_MAP_OB (obj, x, y)); break;
2378	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2468	case 1: RETVAL = to_sv (GET_MAP_TOP (obj, x, y)); break;
2379	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2469	case 2: RETVAL = newSVuv (GET_MAP_FLAGS (obj, x, y)); break;
2380	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2470	case 3: RETVAL = newSViv (GET_MAP_LIGHT (obj, x, y)); break;
2381	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2471	case 4: RETVAL = newSVuv (GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2382	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2472	case 5: RETVAL = newSVuv (GET_MAP_MOVE_SLOW (obj, x, y)); break;
2383	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2473	case 6: RETVAL = newSVuv (GET_MAP_MOVE_ON (obj, x, y)); break;
2384	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2474	case 7: RETVAL = newSVuv (GET_MAP_MOVE_OFF (obj, x, y)); break;
2385	}	2475	}
2386	OUTPUT: RETVAL	2476	OUTPUT: RETVAL
2387		2477
2388	void fix_walls (maptile *map, int x, int y)	2478	void fix_walls (maptile *map, int x, int y)
2389		2479
…		…
2477	OUTPUT:	2567	OUTPUT:
2478	RETVAL	2568	RETVAL
2479		2569
2480	MODULE = cf PACKAGE = cf::arch	2570	MODULE = cf PACKAGE = cf::arch
2481		2571
2482	archetype *find (utf8_string name)
2483	CODE:
2484	RETVAL = archetype::find (name);
2485	OUTPUT:
2486	RETVAL
2487
2488	int archetypes_size ()	2572	int archetypes_size ()
2489	CODE:	2573	CODE:
2490	RETVAL = archetypes.size ();	2574	RETVAL = archetypes.size ();
2491	OUTPUT: RETVAL	2575	OUTPUT: RETVAL
2492		2576
…		…
2576	CODE:	2660	CODE:
2577	{	2661	{
2578	STRLEN len;	2662	STRLEN len;
2579	char *buf = SvPVbyte (packet, len);	2663	char *buf = SvPVbyte (packet, len);
2580		2664
		2665	if (len > MAXSOCKBUF)
		2666	{
		2667	// ugly
		2668	if (THIS->pl)
		2669	THIS->pl->failmsg ("[packet too long for client]");
		2670	}
		2671	else
2581	THIS->send_packet (buf, len);	2672	THIS->send_packet (buf, len);
2582	}	2673	}
		2674
		2675	faceidx
		2676	client::need_face (utf8_string name, int pri = 0)
		2677	CODE:
		2678	RETVAL = face_find (name, 0);
		2679	if (RETVAL)
		2680	{
		2681	THIS->send_face (RETVAL, pri);
		2682	THIS->flush_fx ();
		2683	}
		2684	OUTPUT:
		2685	RETVAL
		2686
		2687	int
		2688	client::fx_want (int idx, int value = -1)
		2689	CODE:
		2690	if (0 < idx && idx < FT_NUM)
		2691	{
		2692	RETVAL = THIS->fx_want [idx];
		2693	if (items > 2)
		2694	THIS->fx_want [idx] = value;
		2695	}
		2696	else
		2697	RETVAL = 0;
		2698	OUTPUT:
		2699	RETVAL
		2700
		2701	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2702
		2703	faceidx sound_find (utf8_string name)
		2704
		2705	void sound_set (utf8_string str, faceidx face)
		2706
		2707	# dire hack
		2708	void old_sound_index (int idx, faceidx face)
		2709	CODE:
		2710	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2711	old_sound_index [idx] = face;
2583		2712
2584	MODULE = cf PACKAGE = cf::face PREFIX = face_	2713	MODULE = cf PACKAGE = cf::face PREFIX = face_
2585		2714
2586	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2715	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2587		2716
…		…
2611	set_visibility = 1	2740	set_visibility = 1
2612	set_magicmap = 2	2741	set_magicmap = 2
2613	set_smooth = 3	2742	set_smooth = 3
2614	set_smoothlevel = 4	2743	set_smoothlevel = 4
2615	CODE:	2744	CODE:
2616	faceinfo *f = face_info (idx);	2745	faceinfo *f = face_info (idx); assert (f);
2617	assert (f);
2618	switch (ix)	2746	switch (ix)
2619	{	2747	{
2620	case 0: f->type = value; break;	2748	case 0: f->type = value; break;
2621	case 1: f->visibility = value; break;	2749	case 1: f->visibility = value; break;
2622	case 2: f->magicmap = value; break;	2750	case 2: f->magicmap = value; break;
…		…
2625	}	2753	}
2626		2754
2627	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2755	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2628	CODE:	2756	CODE:
2629	{	2757	{
2630	facedata *d = face_data (idx, faceset);	2758	faceinfo *f = face_info (idx); assert (f);
2631	assert (d);	2759	facedata *d = &(faceset ? f->data64 : f->data32);
2632	sv_to (data, d->data);	2760	sv_to (data, d->data);
2633	STRLEN clen;	2761	STRLEN clen;
2634	char *cdata = SvPVbyte (chksum, clen);	2762	char *cdata = SvPVbyte (chksum, clen);
2635	clen = min (CHKSUM_SIZE, clen);	2763	clen = min (CHKSUM_SIZE, clen);
2636		2764
…		…
2646	ns->force_newmap = true;	2774	ns->force_newmap = true;
2647	}	2775	}
2648	}	2776	}
2649	}	2777	}
2650		2778
		2779	int get_data_size (faceidx idx, int faceset = 0)
		2780	CODE:
		2781	facedata *d = face_data (idx, faceset);
		2782	if (!d) XSRETURN_UNDEF;
		2783	RETVAL = d->data.size ();
		2784	OUTPUT:
		2785	RETVAL
		2786
		2787	SV *get_chksum (faceidx idx, int faceset = 0)
		2788	CODE:
		2789	facedata *d = face_data (idx, faceset);
		2790	if (!d) XSRETURN_UNDEF;
		2791	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
		2792	OUTPUT:
		2793	RETVAL
		2794
		2795	SV *get_data (faceidx idx, int faceset = 0)
		2796	CODE:
		2797	facedata *d = face_data (idx, faceset);
		2798	if (!d) XSRETURN_UNDEF;
		2799	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2800	OUTPUT:
		2801	RETVAL
		2802
2651	void invalidate (faceidx idx)	2803	void invalidate (faceidx idx)
2652	CODE:	2804	CODE:
2653	for_all_clients (ns)	2805	for_all_clients (ns)
2654	{	2806	{
2655	ns->faces_sent [idx] = false;	2807	ns->faces_sent [idx] = false;
…		…
2698	void invalidate_all ()	2850	void invalidate_all ()
2699	CODE:	2851	CODE:
2700	for_all_clients (ns)	2852	for_all_clients (ns)
2701	ns->anims_sent.reset ();	2853	ns->anims_sent.reset ();
2702		2854
		2855	MODULE = cf PACKAGE = cf::object::freezer
		2856
		2857	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		2858
		2859	SV *
		2860	new (char *klass)
		2861	CODE:
		2862	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2863	OUTPUT: RETVAL
		2864
		2865	void
		2866	DESTROY (SV *sv)
		2867	CODE:
		2868	object_freezer *self;
		2869	sv_to (sv, self);
		2870	delete self;
		2871
		2872	MODULE = cf PACKAGE = cf::object::thawer
		2873
		2874	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		2875
		2876	SV *
		2877	new_from_file (char *klass, octet_string path)
		2878	CODE:
		2879	object_thawer *f = new object_thawer (path);
		2880	if (!*f)
		2881	{
		2882	delete f;
		2883	XSRETURN_UNDEF;
		2884	}
		2885	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2886	OUTPUT: RETVAL
		2887
		2888	void
		2889	DESTROY (SV *sv)
		2890	CODE:
		2891	object_thawer *self;
		2892	sv_to (sv, self);
		2893	delete self;
		2894
		2895	void
		2896	extract_tags (object_thawer *self)
		2897	PPCODE:
		2898	while (self->kw != KW_EOF)
		2899	{
		2900	PUTBACK;
		2901	coroapi::cede_to_tick ();
		2902	SPAGAIN;
		2903
		2904	if (self->kw == KW_tag)
		2905	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2906
		2907	self->skip ();
		2908	}
		2909

Diff Legend

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