server/server/freezethaw.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 *
 * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
 * Copyright (©) 2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 *
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#include "global.h" // bug in cfperl.h, doesn't include interface_class stuff
#include "logger.h"
#include "cfperl.h"
#include "kw_hash.h"

object_freezer::object_freezer ()
: dynbuf_text (128 * 1024, 64 * 1024)
{
  av = newAV ();
}

object_freezer::~object_freezer ()
{
  SvREFCNT_dec (av);
}

void
object_freezer::put_ (attachable *ext)
{
  ext->optimise ();

  if (ext->self)
    {
      int idx = AvFILLp ((AV *)av) + 1;
      av_store (av, idx, newRV_inc ((SV *)ext->self));

      put (KW(oid), sint32(idx));
    }
}

bool
object_freezer::save (const char *path)
{
  CALL_BEGIN (3);
  CALL_ARG_SV (newSVpv (path, 0));
  CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
  CALL_ARG_SV (newRV_inc ((SV *)av));
  CALL_CALL ("cf::object_freezer_save", G_VOID | G_DISCARD);
  CALL_END;

  return 1;
}

char *
object_freezer::as_string ()
{
  CALL_BEGIN (2);
  CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
  CALL_ARG_SV (newRV_inc ((SV *)av));
  CALL_CALL ("cf::object_freezer_as_string", G_SCALAR);

  char *res = count > 0
                ? strdup (SvPVX (POPs))
                : strdup ("[fatal error]");

  CALL_END;

  return res;
}

#if 0
void
fprintf (object_freezer &freezer, const char *format, ...)
{
  va_list ap;

  va_start (ap, format);

  int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);

  if (len >= 0)
    freezer.alloc (len);

  va_end (ap);
}

// XXX: function not returning an int
void
fputs (const char *s, object_freezer &freezer)
{
  freezer.add (s);
}
#endif

static const char thawer_eof[] = "\n\n\n\0\0\0";

bool object_thawer::errors_are_fatal = true;

object_thawer::object_thawer (const char *data, AV *perlav)
: name (strdup ("(memory stream)"))
{
  init ("(memory stream)");

  av   = perlav;
  text = newSVpv (data, 0); sv_catpv (text, thawer_eof);
  line = SvPVbyte_nolen (text);
  next ();
}

object_thawer::object_thawer (const_utf8_string path)
{
  init_from_file (path);
}

// convenience constructor
object_thawer::object_thawer (const_utf8_string dir, const_utf8_string file)
{
  init_from_file (format ("%s/%s", dir, file));
}

void
object_thawer::init (const_utf8_string path)
{
  name    = strdup (path);
  av      = 0;
  text    = 0;
  line    = 0;
  linenum = 0;

  kw      = KW_ERROR;
  kw_str  = 0;
  value   = 0;
}

void
object_thawer::init_from_file (const_utf8_string path)
{
  init (path);

  CALL_BEGIN (1);
  CALL_ARG_SV (newSVpv (path, 0));
  CALL_CALL ("cf::object_thawer_load", G_ARRAY);

  if (count == 2)
    {
      // second value - perl objects
      {
        SV *sv = POPs;
        if (SvROK (sv))
          av = (AV *)SvREFCNT_inc (SvRV (sv));
      }

      // first value - text part, pad with 3 zeroes
      {
        SV *sv = POPs;
        STRLEN len;
        char *sv_ = SvPVbyte (sv, len);
        text = newSV (len + sizeof (thawer_eof));
        SvCUR_set (text, len + sizeof (thawer_eof));
        memcpy (SvPVX (text), sv_, len);
        memcpy (SvPVX (text) + len, thawer_eof, sizeof (thawer_eof));

        line = SvPVX (text);
        next ();
      }
    }

  CALL_END;
}

void
object_thawer::get (attachable *obj, int oid)
{
  if (!av || oid < 0) // this is actually an error of sorts
    return;

  SV **svp = av_fetch ((AV *)av, oid, 0);

  if (!svp || !SvROK (*svp))
    {
      LOG (llevError, "trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
      return;
    }

  if (!SvROK (*svp))
    {
      LOG (llevError, "deserialised perl object is not an RV\n");
      return;
    }

  HV *hv = (HV *)SvRV (*svp);

  if (SvTYPE (hv) != SVt_PVHV)
    {
      LOG (llevError, "deserialised perl object is not a PVHV\n");
      return;
    }

  if (obj->self)
    {
      // the hard way(?)

      CALL_BEGIN (2);
      CALL_ARG_SV (newRV_inc ((SV *)obj->self));
      CALL_ARG_SV (newRV_inc ((SV *)hv));
      PUTBACK;
      call_method ("thawer_merge", G_DISCARD | G_EVAL);
      SPAGAIN;
      CALL_END;
    }
  else
    {
      // the easy way(?)

      obj->self = hv;
      SvRV_set (*svp, &PL_sv_undef);

      sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
    }

  obj->reattach ();
}

object_thawer::~object_thawer ()
{
  if (text) SvREFCNT_dec (text);
  if (av)   SvREFCNT_dec (av);

  resolve_delayed_derefs (false);

  free ((void *)name);
}

static void
error_out ()
{
  if (object_thawer::errors_are_fatal)
    {
      LOG (llevError, "(parse errors at this time are fatal, exiting)");
      exit (1);
    }
}

void
object_thawer::parse_warn (const char *msg) const
{
  LOG (llevWarn, "%s:%d, \"%s %s\": %s\n",
       this->name, linenum,
       kw_str ? kw_str : "<null>",
       value  ? value  : "<null>",
       msg);
}

bool
object_thawer::parse_error (const char *type, const char *name, bool skip) const
{
  if (!type) type = "file section";
  if (!name) name = "generic";

  switch (kw)
    {
      case KW_EOF:
        LOG (llevError, "%s:%d end of file while reading %s '%s', aborting load.\n",
             this->name, linenum, type, name);
        error_out ();
        return false;

      case KW_ERROR:
        LOG (llevError, "%s:%d error while reading %s '%s', at '%s', aborting load.\n",
             this->name, linenum,
             type, name,
             kw_str ? kw_str : "<file load>");
        error_out ();
        return false;

      default:
        LOG (llevError, "%s:%d unexpected line (%s %s) while reading %s '%s', %s.\n",
             this->name, linenum,
             kw_str ? kw_str : "<null>",
             value  ? value  : "<null>",
             type, name,
             skip ? "skipping line" : "aborting load");
        error_out ();
        return skip;
    }
}

void
object_thawer::next ()
{
  if (!line)
    {
      kw = KW_ERROR;
      return;
    }

  for (;;)
    {
      char *p = line;

      if (ecb_expect_false (*p <= ' '))
        {
          // skip whitespace (only some files need this)
          while (*p == ' ' || *p == '\t')
            p++;

          line = p;
        }

      if (!*p)
        {
          kw = KW_EOF;
          break;
        }

      // parse keyword
      while (*p > ' ')
        p++;

      int klen = p - line;

      value_nn = "";
      value = 0;

      if (*p++ != '\n')
        {
          // parse value
          while (*(unsigned char *)p <= ' ' && *p != '\n')
            ++p;

          value_nn = value = p;

          while (*p != '\n')
            p++;

          *p++ = 0;
        }

      ++linenum;
      line [klen] = 0;
      keyword_idx *kw_idx = kw_lex::match (line, klen);

      kw_str = line;
      line = p;

      if (kw_idx)
        {
          kw = kw_idx->index;
          break;
        }
      else if (!*kw_str || *kw_str == '#')
        ; // empty/comment line
      else
        {
          kw = KW_ERROR;
          break;
        }
    }
}

bool
object_thawer::next_line ()
{
  if (!line)
    {
      kw = KW_ERROR;
      return 0;
    }

  for (;;)
    {
      char *p = line;

      if (ecb_expect_false (*p <= ' '))
        {
          // skip whitespace (only some files need this)
          while (*p == ' ' || *p == '\t')
            p++;

          line = p;
        }

      if (!*p)
        {
          kw = KW_EOF;
          return 0;
        }

      kw       = KW_value;
      kw_str   = p;
      value_nn = p;
      value    = p;

      // parse till newline
      while (*p > '\n')
        p++;

      if (*p == '\n')
        *p++ = 0;

      ++linenum;

      line = p;

      if (*kw_str && *kw_str != '#')
        break;

      // empty/comment line -> skip it
    }

  return 1;
}

void
object_thawer::skip ()
{
  shstr ml;

  switch (kw)
    {
      case KW_msg:     get_ml (KW_endmsg    , ml); break;
      case KW_lore:    get_ml (KW_endlore   , ml); break;
      case KW_maplore: get_ml (KW_endmaplore, ml); break;
      default:                                     break;
    }

  next ();
}
 
void
object_thawer::skip_block ()
{
  // must not stop at KW_ERROR, as those signify custom keys
  while (kw != KW_EOF)
    {
      keyword w = kw;
      skip ();

      if (0 && (w == KW_map || w == KW_arch || w == KW_object || w == KW_region))
        skip_block ();
      else if (w == KW_end)
        break;
    }
}

void
object_thawer::get_ml (keyword kend, shstr &sh)
{
  char kw[128];

  int klen = keyword_len [kend];

  kw [0] = '\n';
  memcpy (kw + 1, keyword_str [kend], klen);
  kw [klen + 1] = '\n';
  kw [klen + 2] = 0;

  ++linenum;

  // first test for completely empty msg... "endXXX\n"
  if (!strncmp (line, kw + 1, klen + 1))
    {
      sh = 0;

      line += klen + 1;

      return;
    }
  else
    {
      // multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)

      char *end = strstr (line, kw);

      if (!end)
        {
          sh = 0;
          return;
        }

      *end = 0;
      sh = line;

      // count line numbers
      while (line < end)
        linenum += *line++ == '\n';

      line += keyword_len [kend];

      while (*line++ != '\n')
        ;

      ++linenum;
    }
}

sint32
object_thawer::get_sint32 () const
{
  const char *p = value_nn;

  sint32 val = 0;
  bool negate;

  if (*p == '-')
    {
      negate = true;
      ++p;
    }
  else
    negate = false;

  do
    {
      val *= 10;
      val += *p++ - '0';
    }
  while (*p);

  return negate ? -val : val;
}

void
object_thawer::delayed_deref (attachable *op, object_ptr &ptr, const char *ref)
{
  op->refcnt_inc ();
  delayed_ref r = { op, &ptr, ref ? strdup (ref) : 0 };
  delrefs.push_back (r);
  ptr = 0;
}

void
object_thawer::resolve_delayed_derefs (bool deref)
{
  while (!delrefs.empty ())
    {
      delayed_ref r = delrefs.back ();
      delrefs.pop_back ();

      if (deref)
        *r.ptr = object::deref (r.ref);

      free ((void *)r.ref);
      r.op->refcnt_dec ();
    }
}
Revision:	1.49
Committed:	Wed Dec 5 19:03:27 2018 UTC (5 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.48:	+2 -2 lines
Log Message:	some bugfixes
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
5	* Copyright (©) 2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
6	*
7	* Deliantra is free software: you can redistribute it and/or modify it under
8	* the terms of the Affero GNU General Public License as published by the
9	* Free Software Foundation, either version 3 of the License, or (at your
10	* option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the Affero GNU General Public License
18	* and the GNU General Public License along with this program. If not, see
19	* <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/
23
24	#include "global.h" // bug in cfperl.h, doesn't include interface_class stuff
25	#include "logger.h"
26	#include "cfperl.h"
27	#include "kw_hash.h"
28
29	object_freezer::object_freezer ()
30	: dynbuf_text (128 * 1024, 64 * 1024)
31	{
32	av = newAV ();
33	}
34
35	object_freezer::~object_freezer ()
36	{
37	SvREFCNT_dec (av);
38	}
39
40	void
41	object_freezer::put_ (attachable *ext)
42	{
43	ext->optimise ();
44
45	if (ext->self)
46	{
47	int idx = AvFILLp ((AV *)av) + 1;
48	av_store (av, idx, newRV_inc ((SV *)ext->self));
49
50	put (KW(oid), sint32(idx));
51	}
52	}
53
54	bool
55	object_freezer::save (const char *path)
56	{
57	CALL_BEGIN (3);
58	CALL_ARG_SV (newSVpv (path, 0));
59	CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
60	CALL_ARG_SV (newRV_inc ((SV *)av));
61	CALL_CALL ("cf::object_freezer_save", G_VOID \| G_DISCARD);
62	CALL_END;
63
64	return 1;
65	}
66
67	char *
68	object_freezer::as_string ()
69	{
70	CALL_BEGIN (2);
71	CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
72	CALL_ARG_SV (newRV_inc ((SV *)av));
73	CALL_CALL ("cf::object_freezer_as_string", G_SCALAR);
74
75	char *res = count > 0
76	? strdup (SvPVX (POPs))
77	: strdup ("[fatal error]");
78
79	CALL_END;
80
81	return res;
82	}
83
84	#if 0
85	void
86	fprintf (object_freezer &freezer, const char *format, ...)
87	{
88	va_list ap;
89
90	va_start (ap, format);
91
92	int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
93
94	if (len >= 0)
95	freezer.alloc (len);
96
97	va_end (ap);
98	}
99
100	// XXX: function not returning an int
101	void
102	fputs (const char *s, object_freezer &freezer)
103	{
104	freezer.add (s);
105	}
106	#endif
107
108	static const char thawer_eof[] = "\n\n\n\0\0\0";
109
110	bool object_thawer::errors_are_fatal = true;
111
112	object_thawer::object_thawer (const char data, AV perlav)
113	: name (strdup ("(memory stream)"))
114	{
115	init ("(memory stream)");
116
117	av = perlav;
118	text = newSVpv (data, 0); sv_catpv (text, thawer_eof);
119	line = SvPVbyte_nolen (text);
120	next ();
121	}
122
123	object_thawer::object_thawer (const_utf8_string path)
124	{
125	init_from_file (path);
126	}
127
128	// convenience constructor
129	object_thawer::object_thawer (const_utf8_string dir, const_utf8_string file)
130	{
131	init_from_file (format ("%s/%s", dir, file));
132	}
133
134	void
135	object_thawer::init (const_utf8_string path)
136	{
137	name = strdup (path);
138	av = 0;
139	text = 0;
140	line = 0;
141	linenum = 0;
142
143	kw = KW_ERROR;
144	kw_str = 0;
145	value = 0;
146	}
147
148	void
149	object_thawer::init_from_file (const_utf8_string path)
150	{
151	init (path);
152
153	CALL_BEGIN (1);
154	CALL_ARG_SV (newSVpv (path, 0));
155	CALL_CALL ("cf::object_thawer_load", G_ARRAY);
156
157	if (count == 2)
158	{
159	// second value - perl objects
160	{
161	SV *sv = POPs;
162	if (SvROK (sv))
163	av = (AV *)SvREFCNT_inc (SvRV (sv));
164	}
165
166	// first value - text part, pad with 3 zeroes
167	{
168	SV *sv = POPs;
169	STRLEN len;
170	char *sv_ = SvPVbyte (sv, len);
171	text = newSV (len + sizeof (thawer_eof));
172	SvCUR_set (text, len + sizeof (thawer_eof));
173	memcpy (SvPVX (text), sv_, len);
174	memcpy (SvPVX (text) + len, thawer_eof, sizeof (thawer_eof));
175
176	line = SvPVX (text);
177	next ();
178	}
179	}
180
181	CALL_END;
182	}
183
184	void
185	object_thawer::get (attachable *obj, int oid)
186	{
187	if (!av \|\| oid < 0) // this is actually an error of sorts
188	return;
189
190	SV *svp = av_fetch ((AV )av, oid, 0);
191
192	if (!svp \|\| !SvROK (*svp))
193	{
194	LOG (llevError, "trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
195	return;
196	}
197
198	if (!SvROK (*svp))
199	{
200	LOG (llevError, "deserialised perl object is not an RV\n");
201	return;
202	}
203
204	HV hv = (HV )SvRV (*svp);
205
206	if (SvTYPE (hv) != SVt_PVHV)
207	{
208	LOG (llevError, "deserialised perl object is not a PVHV\n");
209	return;
210	}
211
212	if (obj->self)
213	{
214	// the hard way(?)
215
216	CALL_BEGIN (2);
217	CALL_ARG_SV (newRV_inc ((SV *)obj->self));
218	CALL_ARG_SV (newRV_inc ((SV *)hv));
219	PUTBACK;
220	call_method ("thawer_merge", G_DISCARD \| G_EVAL);
221	SPAGAIN;
222	CALL_END;
223	}
224	else
225	{
226	// the easy way(?)
227
228	obj->self = hv;
229	SvRV_set (*svp, &PL_sv_undef);
230
231	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);
232	}
233
234	obj->reattach ();
235	}
236
237	object_thawer::~object_thawer ()
238	{
239	if (text) SvREFCNT_dec (text);
240	if (av) SvREFCNT_dec (av);
241
242	resolve_delayed_derefs (false);
243
244	free ((void *)name);
245	}
246
247	static void
248	error_out ()
249	{
250	if (object_thawer::errors_are_fatal)
251	{
252	LOG (llevError, "(parse errors at this time are fatal, exiting)");
253	exit (1);
254	}
255	}
256
257	void
258	object_thawer::parse_warn (const char *msg) const
259	{
260	LOG (llevWarn, "%s:%d, \"%s %s\": %s\n",
261	this->name, linenum,
262	kw_str ? kw_str : "<null>",
263	value ? value : "<null>",
264	msg);
265	}
266
267	bool
268	object_thawer::parse_error (const char type, const char name, bool skip) const
269	{
270	if (!type) type = "file section";
271	if (!name) name = "generic";
272
273	switch (kw)
274	{
275	case KW_EOF:
276	LOG (llevError, "%s:%d end of file while reading %s '%s', aborting load.\n",
277	this->name, linenum, type, name);
278	error_out ();
279	return false;
280
281	case KW_ERROR:
282	LOG (llevError, "%s:%d error while reading %s '%s', at '%s', aborting load.\n",
283	this->name, linenum,
284	type, name,
285	kw_str ? kw_str : "<file load>");
286	error_out ();
287	return false;
288
289	default:
290	LOG (llevError, "%s:%d unexpected line (%s %s) while reading %s '%s', %s.\n",
291	this->name, linenum,
292	kw_str ? kw_str : "<null>",
293	value ? value : "<null>",
294	type, name,
295	skip ? "skipping line" : "aborting load");
296	error_out ();
297	return skip;
298	}
299	}
300
301	void
302	object_thawer::next ()
303	{
304	if (!line)
305	{
306	kw = KW_ERROR;
307	return;
308	}
309
310	for (;;)
311	{
312	char *p = line;
313
314	if (ecb_expect_false (*p <= ' '))
315	{
316	// skip whitespace (only some files need this)
317	while (p == ' ' \|\| p == '\t')
318	p++;
319
320	line = p;
321	}
322
323	if (!*p)
324	{
325	kw = KW_EOF;
326	break;
327	}
328
329	// parse keyword
330	while (*p > ' ')
331	p++;
332
333	int klen = p - line;
334
335	value_nn = "";
336	value = 0;
337
338	if (*p++ != '\n')
339	{
340	// parse value
341	while ((unsigned char )p <= ' ' && *p != '\n')
342	++p;
343
344	value_nn = value = p;
345
346	while (*p != '\n')
347	p++;
348
349	*p++ = 0;
350	}
351
352	++linenum;
353	line [klen] = 0;
354	keyword_idx *kw_idx = kw_lex::match (line, klen);
355
356	kw_str = line;
357	line = p;
358
359	if (kw_idx)
360	{
361	kw = kw_idx->index;
362	break;
363	}
364	else if (!kw_str \|\| kw_str == '#')
365	; // empty/comment line
366	else
367	{
368	kw = KW_ERROR;
369	break;
370	}
371	}
372	}
373
374	bool
375	object_thawer::next_line ()
376	{
377	if (!line)
378	{
379	kw = KW_ERROR;
380	return 0;
381	}
382
383	for (;;)
384	{
385	char *p = line;
386
387	if (ecb_expect_false (*p <= ' '))
388	{
389	// skip whitespace (only some files need this)
390	while (p == ' ' \|\| p == '\t')
391	p++;
392
393	line = p;
394	}
395
396	if (!*p)
397	{
398	kw = KW_EOF;
399	return 0;
400	}
401
402	kw = KW_value;
403	kw_str = p;
404	value_nn = p;
405	value = p;
406
407	// parse till newline
408	while (*p > '\n')
409	p++;
410
411	if (*p == '\n')
412	*p++ = 0;
413
414	++linenum;
415
416	line = p;
417
418	if (kw_str && kw_str != '#')
419	break;
420
421	// empty/comment line -> skip it
422	}
423
424	return 1;
425	}
426
427	void
428	object_thawer::skip ()
429	{
430	shstr ml;
431
432	switch (kw)
433	{
434	case KW_msg: get_ml (KW_endmsg , ml); break;
435	case KW_lore: get_ml (KW_endlore , ml); break;
436	case KW_maplore: get_ml (KW_endmaplore, ml); break;
437	default: break;
438	}
439
440	next ();
441	}
442
443	void
444	object_thawer::skip_block ()
445	{
446	// must not stop at KW_ERROR, as those signify custom keys
447	while (kw != KW_EOF)
448	{
449	keyword w = kw;
450	skip ();
451
452	if (0 && (w == KW_map \|\| w == KW_arch \|\| w == KW_object \|\| w == KW_region))
453	skip_block ();
454	else if (w == KW_end)
455	break;
456	}
457	}
458
459	void
460	object_thawer::get_ml (keyword kend, shstr &sh)
461	{
462	char kw[128];
463
464	int klen = keyword_len [kend];
465
466	kw [0] = '\n';
467	memcpy (kw + 1, keyword_str [kend], klen);
468	kw [klen + 1] = '\n';
469	kw [klen + 2] = 0;
470
471	++linenum;
472
473	// first test for completely empty msg... "endXXX\n"
474	if (!strncmp (line, kw + 1, klen + 1))
475	{
476	sh = 0;
477
478	line += klen + 1;
479
480	return;
481	}
482	else
483	{
484	// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
485
486	char *end = strstr (line, kw);
487
488	if (!end)
489	{
490	sh = 0;
491	return;
492	}
493
494	*end = 0;
495	sh = line;
496
497	// count line numbers
498	while (line < end)
499	linenum += *line++ == '\n';
500
501	line += keyword_len [kend];
502
503	while (*line++ != '\n')
504	;
505
506	++linenum;
507	}
508	}
509
510	sint32
511	object_thawer::get_sint32 () const
512	{
513	const char *p = value_nn;
514
515	sint32 val = 0;
516	bool negate;
517
518	if (*p == '-')
519	{
520	negate = true;
521	++p;
522	}
523	else
524	negate = false;
525
526	do
527	{
528	val *= 10;
529	val += *p++ - '0';
530	}
531	while (*p);
532
533	return negate ? -val : val;
534	}
535
536	void
537	object_thawer::delayed_deref (attachable op, object_ptr &ptr, const char ref)
538	{
539	op->refcnt_inc ();
540	delayed_ref r = { op, &ptr, ref ? strdup (ref) : 0 };
541	delrefs.push_back (r);
542	ptr = 0;
543	}
544
545	void
546	object_thawer::resolve_delayed_derefs (bool deref)
547	{
548	while (!delrefs.empty ())
549	{
550	delayed_ref r = delrefs.back ();
551	delrefs.pop_back ();
552
553	if (deref)
554	*r.ptr = object::deref (r.ref);
555
556	free ((void *)r.ref);
557	r.op->refcnt_dec ();
558	}
559	}