server/common/region.C

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 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 GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at <crossfire@schmorp.de>
*/


#include <global.h>
#include <unistd.h>

/* 
 * Pass a char array, returns a pointer to the region of the same name.
 * if it can't find a region of the same name it returns the first region
 * with the 'fallback' property set.
 * if it can't find a matching name /or/ a fallback region it logs an info message 
 * message and returns NULL
 * used by the map parsing code. 
 */
region *
get_region_by_name (const char *region_name)
{
  region *reg;
  char *p = strchr (region_name, '\n');

  if (p)
    *p = '\0';
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (!strcmp (reg->name, region_name))
      return reg;

  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      if (reg->fallback)
        {
          LOG (llevDebug, "region called %s requested, but not found, fallback used.\n", region_name);
          return reg;
        }
    }
  LOG (llevInfo, "Got no region or fallback for region %s.\n", region_name);
  return NULL;
}

/* This might need optimising at some point. */
region *
get_region_by_map (maptile *m)
{
  return get_region_by_name (get_name_of_region_for_map (m));
}

/*
 * Since we won't assume all maps have a region set properly, we need an
 * explicit check that it is, this is much nicer here than scattered throughout
 * the map code.
 */

const char *
get_name_of_region_for_map (const maptile *m)
{
  region *reg;

  if (m->region != NULL)
    return m->region->name;
  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      if (reg->fallback)
        return reg->name;
    }
  LOG (llevInfo, "map %s had no region and I couldn't find a fallback to use.\n", m->name);
  return "unknown";
}

/*
 * Tries to find a region that 'name' corresponds to.
 * It looks, in order, for:
 * an exact match to region name (case insensitive)
 * an exact match to longname (case insensitive)
 * a substring that matches to the longname (eg Kingdom)
 * a substring that matches to the region name (eg nav)
 * if it can find none of these it returns the first parentless region 
 * (there should be only one of these - the top level one)
 * If we got a NULL, then just return the top level region
 * 
 */
region *
get_region_from_string (const char *name)
{
  region *reg;
  char *substr;
  char *p;

  if (name == NULL)
    {
      for (reg = first_region; reg->parent != NULL; reg = reg->parent);
      return reg;
    }
  p = strchr (name, '\n');
  if (p)
    *p = '\0';
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (!strcasecmp (reg->name, name))
      return reg;

  for (reg = first_region; reg != NULL; reg = reg->next)
    if (reg->longname != NULL)
      {
        if (!strcasecmp (reg->longname, name))
          return reg;
      }

  substr = NULL;
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (reg->longname != NULL)
      {
        substr = strstr (reg->longname, name);
        if (substr != NULL)
          return reg;
      }
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (reg->longname != NULL)
      {
        /* 
         * This is not a bug, we want the region that is  most identifiably a discrete 
         * area in the game, eg if we have 'scor', we want to return 'scorn' and not 
         * 'scornarena', regardless of their order on the list so we only look at those 
         * regions with a longname set.
         */
        substr = strstr (reg->name, name);
        if (substr != NULL)
          return reg;
      }
  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      substr = strstr (reg->name, name);
      if (substr != NULL)
        return reg;
    }
  /* if we are still here, we are going to have to give up, and give the top level region */
  for (reg = first_region; reg->parent != NULL; reg = reg->parent);
  return reg;
}

/* 
 * returns 1 if the player is in the region reg, or a child region thereof
 * otherwise returns 0
 * if passed a NULL region returns -1
 */

int
region_is_child_of_region (const region * child, const region * r)
{

  if (r == NULL)
    return -1;
  if (child == NULL)
    return 0;
  if (!strcmp (child->name, r->name))
    return 1;
  else if (child->parent != NULL)
    return region_is_child_of_region (child->parent, r);
  else
    return 0;
}

/* 
 * the longname of a region is not a required field, any given region
 * may want to not set it and use the parent's one instead. so, we:
 * 1. check if a longname is set and if so return it.
 * 2. check if there is a parent and try and call the function against that
 * 3. return a obviously wrong string if we can't get a longname, this should
 *    never happen. We also log a debug message.
 */
const char *
get_region_longname (const region * r)
{

  if (r->longname != NULL)
    return r->longname;
  else if (r->parent != NULL)
    return get_region_longname (r->parent);
  else
    {
      LOG (llevDebug, "NOTICE region %s has no parent and no longname.\n", r->name);
      return "no name can be found for the current region";
    }
}

const char *
get_region_msg (const region * r)
{
  if (r->msg != NULL)
    return r->msg;
  else if (r->parent != NULL)
    return get_region_msg (r->parent);
  else
    {
      LOG (llevDebug, "NOTICE region %s has no parent and no msg.\n", r->name);
      return "no description can be found for the current region";
    }
}

/** Returns an object which is an exit through which the player represented by op should be
 *  sent in order to be imprisoned. If there is no suitable place to which an exit can be 
 *  constructed, then NULL will be returned. The caller is responsible for freeing the object
 *  created by this function.
 */
object *
get_jail_exit (object *op)
{
  region *reg;
  object *exit;

  if (op->type != PLAYER)
    {
      LOG (llevError, "region.c: get_jail_exit called against non-player object.\n");
      return NULL;
    }
  reg = get_region_by_map (op->map);
  while (reg != NULL)
    {
      if (reg->jailmap)
        {
          exit = object::create ();
          EXIT_PATH (exit) = reg->jailmap;
          /* damned exits reset savebed and remove teleports, so the prisoner can't escape */
          SET_FLAG (exit, FLAG_DAMNED);
          EXIT_X (exit) = reg->jailx;
          EXIT_Y (exit) = reg->jaily;
          return exit;
        }
      else
        reg = reg->parent;
    }
  LOG (llevDebug, "No suitable jailmap for region %s was found.\n", reg->name);
  return NULL;
}

/*
 * First initialises the archtype hash-table (init_archetable()).
 * Reads and parses the archetype file (with the first and second-pass
 * functions).
 * Then initialises treasures by calling load_treasures().
 */
void
init_regions (void)
{
  FILE *fp;
  char filename[MAX_BUF];
  int comp;

  if (first_region != NULL)     /* Only do this once */
    return;

  sprintf (filename, "%s/%s/%s", settings.datadir, settings.mapdir, settings.regions);
  LOG (llevDebug, "Reading regions from %s...\n", filename);
  if ((fp = open_and_uncompress (filename, 0, &comp)) == NULL)
    {
      LOG (llevError, " Can't open regions file %s in init_regions.\n", filename);
      return;
    }
  parse_regions (fp);
  assign_region_parents ();
  LOG (llevDebug, " done\n");

  close_and_delete (fp, comp);
}

/* 
 * Allocates and zeros a region struct, this isn't free()'d anywhere, so might
 * be a memory leak, but it shouldn't matter too much since it isn't called that
 * often.... 
 */

region *
get_region_struct (void)
{
  return new region;
}

/*
 * Reads/parses the region file, and copies into a linked list
 * of region structs.
 */
void
parse_regions (FILE * fp)
{
  region *newreg;
  region *reg;

  char buf[HUGE_BUF], msgbuf[HUGE_BUF], *key = NULL, *value, *end;
  int msgpos = 0;

  newreg = NULL;
  while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
    {
      buf[HUGE_BUF - 1] = 0;
      key = buf;
      while (isspace (*key))
        key++;
      if (*key == 0)
        continue;               /* empty line */
      value = strchr (key, ' ');
      if (!value)
        {
          end = strchr (key, '\n');
          *end = 0;
        }
      else
        {
          *value = 0;
          value++;
          while (isspace (*value))
            value++;
          end = strchr (value, '\n');
        }

      /* 
       * This is a bizzare mutated form of the map and archetype parser 
       * rolled into one. Key is the field name, value is what it should 
       * be set to. 
       * We've already done the work to null terminate key,
       * and strip off any leading spaces for both of these.
       * We have not touched the newline at the end of the line -
       * these might be needed for some values. the end pointer 
       * points to the first of the newlines.
       * value could be NULL!  It would be easy enough to just point
       * this to "" to prevent cores, but that would let more errors slide
       * through.
       */
      if (!strcmp (key, "region"))
        {
          *end = 0;
          newreg = get_region_struct ();
          newreg->name = strdup (value);
        }
      else if (!strcmp (key, "parent"))
        {
          /* 
           * Note that this is in the initialisation code, so we don't actually
           * assign the pointer to the parent yet, because it might not have been
           * parsed.
           */
          *end = 0;
          newreg->parent_name = strdup (value);
        }
      else if (!strcmp (key, "longname"))
        {
          *end = 0;
          newreg->longname = strdup (value);
        }
      else if (!strcmp (key, "jail"))
        {
          /* jail entries are of the form: /path/to/map x y */
          char path[MAX_BUF];
          int x, y;

          if (sscanf (value, "%[^ ] %d %d\n", path, &x, &y) != 3)
            {
              LOG (llevError, "region.c: malformated regions entry: jail %s\n", value);
              continue;
            }
          newreg->jailmap = strdup (path);
          newreg->jailx = x;
          newreg->jaily = y;
        }
      else if (!strcmp (key, "msg"))
        {
          while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
            {
              if (!strcmp (buf, "endmsg\n"))
                break;
              else
                {
                  strcpy (msgbuf + msgpos, buf);
                  msgpos += strlen (buf);
                }
            }
          /* 
           * There may be regions with empty messages (eg, msg/endmsg
           * with nothing between). When maps are loaded, this is done
           * so better do it here too...
           */
          if (msgpos != 0)
            newreg->msg = strdup (msgbuf);

          /* we have to reset msgpos, or the next region will store both msg blocks. */
          msgpos = 0;
        }
      else if (!strcmp (key, "fallback"))
        {
          *end = 0;
          newreg->fallback = atoi (value);
        }
      else if (!strcmp (key, "end"))
        {
          /* Place this new region last on the list, if the list is empty put it first */
          for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next);

          if (reg == NULL)
            first_region = newreg;
          else
            reg->next = newreg;
          newreg = NULL;
        }
      else if (!strcmp (key, "nomore"))
        {
          /* we have reached the end of the region specs.... */
          break;
        }
      else
        {
          /* we should never get here, if we have, then something is wrong */
          LOG (llevError, "Got unknown value in region file: %s %s\n", key, value);
        }
    }
  if (!key || strcmp (key, "nomore"))
    LOG (llevError, "Got premature eof on regions file!\n");
}

void
assign_region_parents (void)
{
  region *reg;
  uint32 parent_count = 0;
  uint32 region_count = 0;

  for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next)
    {
      if (reg->parent_name != NULL)
        {
          reg->parent = get_region_by_name (reg->parent_name);
          parent_count++;
        }
      region_count++;
    }
  LOG (llevDebug, "Assigned %u regions with %u parents.", region_count, parent_count);
}
Revision:	1.11
Committed:	Thu Dec 14 22:45:40 2006 UTC (17 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+5 -5 lines
Log Message:	- implement event watcher autoncancellation on reload - used it everywhere - removed lots of compatibility cruft - configure does no longer check for mandatory unix functionality/headers - confgiure now runs much faster
#	Content
1	/*
2	CrossFire, A Multiplayer game for X-windows
3
4	Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen
6
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or
10	(at your 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 GNU General Public License
18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21	The authors can be reached via e-mail at <crossfire@schmorp.de>
22	*/
23
24
25	#include <global.h>
26	#include <unistd.h>
27
28	/*
29	* Pass a char array, returns a pointer to the region of the same name.
30	* if it can't find a region of the same name it returns the first region
31	* with the 'fallback' property set.
32	* if it can't find a matching name /or/ a fallback region it logs an info message
33	* message and returns NULL
34	* used by the map parsing code.
35	*/
36	region *
37	get_region_by_name (const char *region_name)
38	{
39	region *reg;
40	char *p = strchr (region_name, '\n');
41
42	if (p)
43	*p = '\0';
44	for (reg = first_region; reg != NULL; reg = reg->next)
45	if (!strcmp (reg->name, region_name))
46	return reg;
47
48	for (reg = first_region; reg != NULL; reg = reg->next)
49	{
50	if (reg->fallback)
51	{
52	LOG (llevDebug, "region called %s requested, but not found, fallback used.\n", region_name);
53	return reg;
54	}
55	}
56	LOG (llevInfo, "Got no region or fallback for region %s.\n", region_name);
57	return NULL;
58	}
59
60	/* This might need optimising at some point. */
61	region *
62	get_region_by_map (maptile *m)
63	{
64	return get_region_by_name (get_name_of_region_for_map (m));
65	}
66
67	/*
68	* Since we won't assume all maps have a region set properly, we need an
69	* explicit check that it is, this is much nicer here than scattered throughout
70	* the map code.
71	*/
72
73	const char *
74	get_name_of_region_for_map (const maptile *m)
75	{
76	region *reg;
77
78	if (m->region != NULL)
79	return m->region->name;
80	for (reg = first_region; reg != NULL; reg = reg->next)
81	{
82	if (reg->fallback)
83	return reg->name;
84	}
85	LOG (llevInfo, "map %s had no region and I couldn't find a fallback to use.\n", m->name);
86	return "unknown";
87	}
88
89	/*
90	* Tries to find a region that 'name' corresponds to.
91	* It looks, in order, for:
92	* an exact match to region name (case insensitive)
93	* an exact match to longname (case insensitive)
94	* a substring that matches to the longname (eg Kingdom)
95	* a substring that matches to the region name (eg nav)
96	* if it can find none of these it returns the first parentless region
97	* (there should be only one of these - the top level one)
98	* If we got a NULL, then just return the top level region
99	*
100	*/
101	region *
102	get_region_from_string (const char *name)
103	{
104	region *reg;
105	char *substr;
106	char *p;
107
108	if (name == NULL)
109	{
110	for (reg = first_region; reg->parent != NULL; reg = reg->parent);
111	return reg;
112	}
113	p = strchr (name, '\n');
114	if (p)
115	*p = '\0';
116	for (reg = first_region; reg != NULL; reg = reg->next)
117	if (!strcasecmp (reg->name, name))
118	return reg;
119
120	for (reg = first_region; reg != NULL; reg = reg->next)
121	if (reg->longname != NULL)
122	{
123	if (!strcasecmp (reg->longname, name))
124	return reg;
125	}
126
127	substr = NULL;
128	for (reg = first_region; reg != NULL; reg = reg->next)
129	if (reg->longname != NULL)
130	{
131	substr = strstr (reg->longname, name);
132	if (substr != NULL)
133	return reg;
134	}
135	for (reg = first_region; reg != NULL; reg = reg->next)
136	if (reg->longname != NULL)
137	{
138	/*
139	* This is not a bug, we want the region that is most identifiably a discrete
140	* area in the game, eg if we have 'scor', we want to return 'scorn' and not
141	* 'scornarena', regardless of their order on the list so we only look at those
142	* regions with a longname set.
143	*/
144	substr = strstr (reg->name, name);
145	if (substr != NULL)
146	return reg;
147	}
148	for (reg = first_region; reg != NULL; reg = reg->next)
149	{
150	substr = strstr (reg->name, name);
151	if (substr != NULL)
152	return reg;
153	}
154	/* if we are still here, we are going to have to give up, and give the top level region */
155	for (reg = first_region; reg->parent != NULL; reg = reg->parent);
156	return reg;
157	}
158
159	/*
160	* returns 1 if the player is in the region reg, or a child region thereof
161	* otherwise returns 0
162	* if passed a NULL region returns -1
163	*/
164
165	int
166	region_is_child_of_region (const region * child, const region * r)
167	{
168
169	if (r == NULL)
170	return -1;
171	if (child == NULL)
172	return 0;
173	if (!strcmp (child->name, r->name))
174	return 1;
175	else if (child->parent != NULL)
176	return region_is_child_of_region (child->parent, r);
177	else
178	return 0;
179	}
180
181	/*
182	* the longname of a region is not a required field, any given region
183	* may want to not set it and use the parent's one instead. so, we:
184	* 1. check if a longname is set and if so return it.
185	* 2. check if there is a parent and try and call the function against that
186	* 3. return a obviously wrong string if we can't get a longname, this should
187	* never happen. We also log a debug message.
188	*/
189	const char *
190	get_region_longname (const region * r)
191	{
192
193	if (r->longname != NULL)
194	return r->longname;
195	else if (r->parent != NULL)
196	return get_region_longname (r->parent);
197	else
198	{
199	LOG (llevDebug, "NOTICE region %s has no parent and no longname.\n", r->name);
200	return "no name can be found for the current region";
201	}
202	}
203
204	const char *
205	get_region_msg (const region * r)
206	{
207	if (r->msg != NULL)
208	return r->msg;
209	else if (r->parent != NULL)
210	return get_region_msg (r->parent);
211	else
212	{
213	LOG (llevDebug, "NOTICE region %s has no parent and no msg.\n", r->name);
214	return "no description can be found for the current region";
215	}
216	}
217
218	/** Returns an object which is an exit through which the player represented by op should be
219	* sent in order to be imprisoned. If there is no suitable place to which an exit can be
220	* constructed, then NULL will be returned. The caller is responsible for freeing the object
221	* created by this function.
222	*/
223	object *
224	get_jail_exit (object *op)
225	{
226	region *reg;
227	object *exit;
228
229	if (op->type != PLAYER)
230	{
231	LOG (llevError, "region.c: get_jail_exit called against non-player object.\n");
232	return NULL;
233	}
234	reg = get_region_by_map (op->map);
235	while (reg != NULL)
236	{
237	if (reg->jailmap)
238	{
239	exit = object::create ();
240	EXIT_PATH (exit) = reg->jailmap;
241	/* damned exits reset savebed and remove teleports, so the prisoner can't escape */
242	SET_FLAG (exit, FLAG_DAMNED);
243	EXIT_X (exit) = reg->jailx;
244	EXIT_Y (exit) = reg->jaily;
245	return exit;
246	}
247	else
248	reg = reg->parent;
249	}
250	LOG (llevDebug, "No suitable jailmap for region %s was found.\n", reg->name);
251	return NULL;
252	}
253
254	/*
255	* First initialises the archtype hash-table (init_archetable()).
256	* Reads and parses the archetype file (with the first and second-pass
257	* functions).
258	* Then initialises treasures by calling load_treasures().
259	*/
260	void
261	init_regions (void)
262	{
263	FILE *fp;
264	char filename[MAX_BUF];
265	int comp;
266
267	if (first_region != NULL) /* Only do this once */
268	return;
269
270	sprintf (filename, "%s/%s/%s", settings.datadir, settings.mapdir, settings.regions);
271	LOG (llevDebug, "Reading regions from %s...\n", filename);
272	if ((fp = open_and_uncompress (filename, 0, &comp)) == NULL)
273	{
274	LOG (llevError, " Can't open regions file %s in init_regions.\n", filename);
275	return;
276	}
277	parse_regions (fp);
278	assign_region_parents ();
279	LOG (llevDebug, " done\n");
280
281	close_and_delete (fp, comp);
282	}
283
284	/*
285	* Allocates and zeros a region struct, this isn't free()'d anywhere, so might
286	* be a memory leak, but it shouldn't matter too much since it isn't called that
287	* often....
288	*/
289
290	region *
291	get_region_struct (void)
292	{
293	return new region;
294	}
295
296	/*
297	* Reads/parses the region file, and copies into a linked list
298	* of region structs.
299	*/
300	void
301	parse_regions (FILE * fp)
302	{
303	region *newreg;
304	region *reg;
305
306	char buf[HUGE_BUF], msgbuf[HUGE_BUF], key = NULL, value, *end;
307	int msgpos = 0;
308
309	newreg = NULL;
310	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
311	{
312	buf[HUGE_BUF - 1] = 0;
313	key = buf;
314	while (isspace (*key))
315	key++;
316	if (*key == 0)
317	continue; /* empty line */
318	value = strchr (key, ' ');
319	if (!value)
320	{
321	end = strchr (key, '\n');
322	*end = 0;
323	}
324	else
325	{
326	*value = 0;
327	value++;
328	while (isspace (*value))
329	value++;
330	end = strchr (value, '\n');
331	}
332
333	/*
334	* This is a bizzare mutated form of the map and archetype parser
335	* rolled into one. Key is the field name, value is what it should
336	* be set to.
337	* We've already done the work to null terminate key,
338	* and strip off any leading spaces for both of these.
339	* We have not touched the newline at the end of the line -
340	* these might be needed for some values. the end pointer
341	* points to the first of the newlines.
342	* value could be NULL! It would be easy enough to just point
343	* this to "" to prevent cores, but that would let more errors slide
344	* through.
345	*/
346	if (!strcmp (key, "region"))
347	{
348	*end = 0;
349	newreg = get_region_struct ();
350	newreg->name = strdup (value);
351	}
352	else if (!strcmp (key, "parent"))
353	{
354	/*
355	* Note that this is in the initialisation code, so we don't actually
356	* assign the pointer to the parent yet, because it might not have been
357	* parsed.
358	*/
359	*end = 0;
360	newreg->parent_name = strdup (value);
361	}
362	else if (!strcmp (key, "longname"))
363	{
364	*end = 0;
365	newreg->longname = strdup (value);
366	}
367	else if (!strcmp (key, "jail"))
368	{
369	/* jail entries are of the form: /path/to/map x y */
370	char path[MAX_BUF];
371	int x, y;
372
373	if (sscanf (value, "%[^ ] %d %d\n", path, &x, &y) != 3)
374	{
375	LOG (llevError, "region.c: malformated regions entry: jail %s\n", value);
376	continue;
377	}
378	newreg->jailmap = strdup (path);
379	newreg->jailx = x;
380	newreg->jaily = y;
381	}
382	else if (!strcmp (key, "msg"))
383	{
384	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
385	{
386	if (!strcmp (buf, "endmsg\n"))
387	break;
388	else
389	{
390	strcpy (msgbuf + msgpos, buf);
391	msgpos += strlen (buf);
392	}
393	}
394	/*
395	* There may be regions with empty messages (eg, msg/endmsg
396	* with nothing between). When maps are loaded, this is done
397	* so better do it here too...
398	*/
399	if (msgpos != 0)
400	newreg->msg = strdup (msgbuf);
401
402	/* we have to reset msgpos, or the next region will store both msg blocks. */
403	msgpos = 0;
404	}
405	else if (!strcmp (key, "fallback"))
406	{
407	*end = 0;
408	newreg->fallback = atoi (value);
409	}
410	else if (!strcmp (key, "end"))
411	{
412	/* Place this new region last on the list, if the list is empty put it first */
413	for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next);
414
415	if (reg == NULL)
416	first_region = newreg;
417	else
418	reg->next = newreg;
419	newreg = NULL;
420	}
421	else if (!strcmp (key, "nomore"))
422	{
423	/* we have reached the end of the region specs.... */
424	break;
425	}
426	else
427	{
428	/* we should never get here, if we have, then something is wrong */
429	LOG (llevError, "Got unknown value in region file: %s %s\n", key, value);
430	}
431	}
432	if (!key \|\| strcmp (key, "nomore"))
433	LOG (llevError, "Got premature eof on regions file!\n");
434	}
435
436	void
437	assign_region_parents (void)
438	{
439	region *reg;
440	uint32 parent_count = 0;
441	uint32 region_count = 0;
442
443	for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next)
444	{
445	if (reg->parent_name != NULL)
446	{
447	reg->parent = get_region_by_name (reg->parent_name);
448	parent_count++;
449	}
450	region_count++;
451	}
452	LOG (llevDebug, "Assigned %u regions with %u parents.", region_count, parent_count);
453	}