src/mymem.c

   1 /* $Id$ */
   2
   3 /*
   4  *                            COPYRIGHT
   5  *
   6  *  PCB, interactive printed circuit board design
   7  *  Copyright (C) 1994,1995,1996 Thomas Nau
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  *  Contact addresses for paper mail and Email:
  24  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  25  *  Thomas.Nau@rz.uni-ulm.de
  26  *
  27  */
  28
  29
  30 /* memory management functions
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include "global.h"
  38
  39 #include <memory.h>
  40
  41 #include "data.h"
  42 #include "error.h"
  43 #include "mymem.h"
  44 #include "misc.h"
  45 #include "rats.h"
  46 #include "rtree.h"
  47
  48 #ifdef HAVE_LIBDMALLOC
  49 #include <dmalloc.h>
  50 #endif
  51
  52 RCSID ("$Id$");
  53
  54 /* ---------------------------------------------------------------------------
  55  * local prototypes
  56  */
  57 static void DSRealloc (DynamicStringTypePtr, size_t);
  58
  59
  60 /* This API is quite new, provide a version here */
  61 #if !GLIB_CHECK_VERSION (2, 28, 0)
  62 static void
  63 g_list_free_full (GList *list, GDestroyNotify free_func)
  64 {
  65   g_list_foreach (list, (GFunc) free_func, NULL);
  66   g_list_free (list);
  67 }
  68 #endif
  69
  70 /* ---------------------------------------------------------------------------
  71  * get next slot for a rubberband connection, allocates memory if necessary
  72  */
  73 RubberbandTypePtr
  74 GetRubberbandMemory (void)
  75 {
  76   RubberbandTypePtr ptr = Crosshair.AttachedObject.Rubberband;
  77
  78   /* realloc new memory if necessary and clear it */
  79   if (Crosshair.AttachedObject.RubberbandN >=
  80       Crosshair.AttachedObject.RubberbandMax)
  81     {
  82       Crosshair.AttachedObject.RubberbandMax += STEP_RUBBERBAND;
  83       ptr = (RubberbandTypePtr)realloc (ptr, Crosshair.AttachedObject.RubberbandMax *
  84                           sizeof (RubberbandType));
  85       Crosshair.AttachedObject.Rubberband = ptr;
  86       memset (ptr + Crosshair.AttachedObject.RubberbandN, 0,
  87               STEP_RUBBERBAND * sizeof (RubberbandType));
  88     }
  89   return (ptr + Crosshair.AttachedObject.RubberbandN++);
  90 }
  91
  92 void **
  93 GetPointerMemory (PointerListTypePtr list)
  94 {
  95   void **ptr = list->Ptr;
  96
  97   /* realloc new memory if necessary and clear it */
  98   if (list->PtrN >= list->PtrMax)
  99     {
 100       list->PtrMax = STEP_POINT + (2 * list->PtrMax);
 101       ptr = (void **)realloc (ptr, list->PtrMax * sizeof (void *));
 102       list->Ptr = ptr;
 103       memset (ptr + list->PtrN, 0,
 104               (list->PtrMax - list->PtrN) * sizeof (void *));
 105     }
 106   return (ptr + list->PtrN++);
 107 }
 108
 109 void
 110 FreePointerListMemory (PointerListTypePtr list)
 111 {
 112   free (list->Ptr);
 113   memset (list, 0, sizeof (PointerListType));
 114 }
 115
 116 /* ---------------------------------------------------------------------------
 117  * get next slot for a box, allocates memory if necessary
 118  */
 119 BoxTypePtr
 120 GetBoxMemory (BoxListTypePtr Boxes)
 121 {
 122   BoxTypePtr box = Boxes->Box;
 123
 124   /* realloc new memory if necessary and clear it */
 125   if (Boxes->BoxN >= Boxes->BoxMax)
 126     {
 127       Boxes->BoxMax = STEP_POINT + (2 * Boxes->BoxMax);
 128       box = (BoxTypePtr)realloc (box, Boxes->BoxMax * sizeof (BoxType));
 129       Boxes->Box = box;
 130       memset (box + Boxes->BoxN, 0,
 131               (Boxes->BoxMax - Boxes->BoxN) * sizeof (BoxType));
 132     }
 133   return (box + Boxes->BoxN++);
 134 }
 135
 136
 137 /* ---------------------------------------------------------------------------
 138  * get next slot for a connection, allocates memory if necessary
 139  */
 140 ConnectionTypePtr
 141 GetConnectionMemory (NetTypePtr Net)
 142 {
 143   ConnectionTypePtr con = Net->Connection;
 144
 145   /* realloc new memory if necessary and clear it */
 146   if (Net->ConnectionN >= Net->ConnectionMax)
 147     {
 148       Net->ConnectionMax += STEP_POINT;
 149       con = (ConnectionTypePtr)realloc (con, Net->ConnectionMax * sizeof (ConnectionType));
 150       Net->Connection = con;
 151       memset (con + Net->ConnectionN, 0,
 152               STEP_POINT * sizeof (ConnectionType));
 153     }
 154   return (con + Net->ConnectionN++);
 155 }
 156
 157 /* ---------------------------------------------------------------------------
 158  * get next slot for a subnet, allocates memory if necessary
 159  */
 160 NetTypePtr
 161 GetNetMemory (NetListTypePtr Netlist)
 162 {
 163   NetTypePtr net = Netlist->Net;
 164
 165   /* realloc new memory if necessary and clear it */
 166   if (Netlist->NetN >= Netlist->NetMax)
 167     {
 168       Netlist->NetMax += STEP_POINT;
 169       net = (NetTypePtr)realloc (net, Netlist->NetMax * sizeof (NetType));
 170       Netlist->Net = net;
 171       memset (net + Netlist->NetN, 0, STEP_POINT * sizeof (NetType));
 172     }
 173   return (net + Netlist->NetN++);
 174 }
 175
 176 /* ---------------------------------------------------------------------------
 177  * get next slot for a net list, allocates memory if necessary
 178  */
 179 NetListTypePtr
 180 GetNetListMemory (NetListListTypePtr Netlistlist)
 181 {
 182   NetListTypePtr netlist = Netlistlist->NetList;
 183
 184   /* realloc new memory if necessary and clear it */
 185   if (Netlistlist->NetListN >= Netlistlist->NetListMax)
 186     {
 187       Netlistlist->NetListMax += STEP_POINT;
 188       netlist = (NetListTypePtr)realloc (netlist,
 189                          Netlistlist->NetListMax * sizeof (NetListType));
 190       Netlistlist->NetList = netlist;
 191       memset (netlist + Netlistlist->NetListN, 0,
 192               STEP_POINT * sizeof (NetListType));
 193     }
 194   return (netlist + Netlistlist->NetListN++);
 195 }
 196 /* ---------------------------------------------------------------------------
 197  * get next slot for a pin, allocates memory if necessary
 198  */
 199 PinType *
 200 GetPinMemory (ElementType *element)
 201 {
 202   PinType *new_obj;
 203
 204   new_obj = g_slice_new0 (PinType);
 205   element->Pin = g_list_append (element->Pin, new_obj);
 206   element->PinN ++;
 207
 208   return new_obj;
 209 }
 210
 211 static void
 212 FreePin (PinType *data)
 213 {
 214   g_slice_free (PinType, data);
 215 }
 216
 217 /* ---------------------------------------------------------------------------
 218  * get next slot for a pad, allocates memory if necessary
 219  */
 220 PadType *
 221 GetPadMemory (ElementType *element)
 222 {
 223   PadType *new_obj;
 224
 225   new_obj = g_slice_new0 (PadType);
 226   element->Pad = g_list_append (element->Pad, new_obj);
 227   element->PadN ++;
 228
 229   return new_obj;
 230 }
 231
 232 static void
 233 FreePad (PadType *data)
 234 {
 235   g_slice_free (PadType, data);
 236 }
 237
 238 /* ---------------------------------------------------------------------------
 239  * get next slot for a via, allocates memory if necessary
 240  */
 241 PinType *
 242 GetViaMemory (DataType *data)
 243 {
 244   PinType *new_obj;
 245
 246   new_obj = g_slice_new0 (PinType);
 247   data->Via = g_list_append (data->Via, new_obj);
 248   data->ViaN ++;
 249
 250   return new_obj;
 251 }
 252
 253 static void
 254 FreeVia (PinType *data)
 255 {
 256   g_slice_free (PinType, data);
 257 }
 258
 259 /* ---------------------------------------------------------------------------
 260  * get next slot for a Rat, allocates memory if necessary
 261  */
 262 RatType *
 263 GetRatMemory (DataType *data)
 264 {
 265   RatType *new_obj;
 266
 267   new_obj = g_slice_new0 (RatType);
 268   data->Rat = g_list_append (data->Rat, new_obj);
 269   data->RatN ++;
 270
 271   return new_obj;
 272 }
 273
 274 static void
 275 FreeRat (RatType *data)
 276 {
 277   g_slice_free (RatType, data);
 278 }
 279
 280 /* ---------------------------------------------------------------------------
 281  * get next slot for a line, allocates memory if necessary
 282  */
 283 LineType *
 284 GetLineMemory (LayerType *layer)
 285 {
 286   LineType *new_obj;
 287
 288   new_obj = g_slice_new0 (LineType);
 289   layer->Line = g_list_append (layer->Line, new_obj);
 290   layer->LineN ++;
 291
 292   return new_obj;
 293 }
 294
 295 static void
 296 FreeLine (LineType *data)
 297 {
 298   g_slice_free (LineType, data);
 299 }
 300
 301 /* ---------------------------------------------------------------------------
 302  * get next slot for an arc, allocates memory if necessary
 303  */
 304 ArcTypePtr
 305 GetArcMemory (LayerType *layer)
 306 {
 307   ArcType *new_obj;
 308
 309   new_obj = g_slice_new0 (ArcType);
 310   layer->Arc = g_list_append (layer->Arc, new_obj);
 311   layer->ArcN ++;
 312
 313   return new_obj;
 314 }
 315
 316 static void
 317 FreeArc (ArcType *data)
 318 {
 319   g_slice_free (ArcType, data);
 320 }
 321
 322 /* ---------------------------------------------------------------------------
 323  * get next slot for a text object, allocates memory if necessary
 324  */
 325 TextTypePtr
 326 GetTextMemory (LayerType *layer)
 327 {
 328   TextType *new_obj;
 329
 330   new_obj = g_slice_new0 (TextType);
 331   layer->Text = g_list_append (layer->Text, new_obj);
 332   layer->TextN ++;
 333
 334   return new_obj;
 335 }
 336
 337 static void
 338 FreeText (TextType *data)
 339 {
 340   g_slice_free (TextType, data);
 341 }
 342
 343 /* ---------------------------------------------------------------------------
 344  * get next slot for a polygon object, allocates memory if necessary
 345  */
 346 PolygonType *
 347 GetPolygonMemory (LayerType *layer)
 348 {
 349   PolygonType *new_obj;
 350
 351   new_obj = g_slice_new0 (PolygonType);
 352   layer->Polygon = g_list_append (layer->Polygon, new_obj);
 353   layer->PolygonN ++;
 354
 355   return new_obj;
 356 }
 357
 358 static void
 359 FreePolygon (PolygonType *data)
 360 {
 361   g_slice_free (PolygonType, data);
 362 }
 363
 364 /* ---------------------------------------------------------------------------
 365  * gets the next slot for a point in a polygon struct, allocates memory
 366  * if necessary
 367  */
 368 PointTypePtr
 369 GetPointMemoryInPolygon (PolygonTypePtr Polygon)
 370 {
 371   PointTypePtr points = Polygon->Points;
 372
 373   /* realloc new memory if necessary and clear it */
 374   if (Polygon->PointN >= Polygon->PointMax)
 375     {
 376       Polygon->PointMax += STEP_POLYGONPOINT;
 377       points = (PointTypePtr)realloc (points, Polygon->PointMax * sizeof (PointType));
 378       Polygon->Points = points;
 379       memset (points + Polygon->PointN, 0,
 380               STEP_POLYGONPOINT * sizeof (PointType));
 381     }
 382   return (points + Polygon->PointN++);
 383 }
 384
 385 /* ---------------------------------------------------------------------------
 386  * gets the next slot for a point in a polygon struct, allocates memory
 387  * if necessary
 388  */
 389 Cardinal *
 390 GetHoleIndexMemoryInPolygon (PolygonTypePtr Polygon)
 391 {
 392   Cardinal *holeindex = Polygon->HoleIndex;
 393
 394   /* realloc new memory if necessary and clear it */
 395   if (Polygon->HoleIndexN >= Polygon->HoleIndexMax)
 396     {
 397       Polygon->HoleIndexMax += STEP_POLYGONHOLEINDEX;
 398       holeindex = (Cardinal *)realloc (holeindex, Polygon->HoleIndexMax * sizeof (int));
 399       Polygon->HoleIndex = holeindex;
 400       memset (holeindex + Polygon->HoleIndexN, 0,
 401               STEP_POLYGONHOLEINDEX * sizeof (int));
 402     }
 403   return (holeindex + Polygon->HoleIndexN++);
 404 }
 405
 406 /* ---------------------------------------------------------------------------
 407  * get next slot for an element, allocates memory if necessary
 408  */
 409 ElementType *
 410 GetElementMemory (DataType *data)
 411 {
 412   ElementType *new_obj;
 413
 414   new_obj = g_slice_new0 (ElementType);
 415   data->Element = g_list_append (data->Element, new_obj);
 416   data->ElementN ++;
 417
 418   return new_obj;
 419 }
 420
 421 static void
 422 FreeElement (ElementType *data)
 423 {
 424   g_slice_free (ElementType, data);
 425 }
 426
 427 /* ---------------------------------------------------------------------------
 428  * get next slot for a library menu, allocates memory if necessary
 429  */
 430 LibraryMenuTypePtr
 431 GetLibraryMenuMemory (LibraryTypePtr lib)
 432 {
 433   LibraryMenuTypePtr menu = lib->Menu;
 434
 435   /* realloc new memory if necessary and clear it */
 436   if (lib->MenuN >= lib->MenuMax)
 437     {
 438       lib->MenuMax += STEP_LIBRARYMENU;
 439       menu = (LibraryMenuTypePtr)realloc (menu, lib->MenuMax * sizeof (LibraryMenuType));
 440       lib->Menu = menu;
 441       memset (menu + lib->MenuN, 0,
 442               STEP_LIBRARYMENU * sizeof (LibraryMenuType));
 443     }
 444   return (menu + lib->MenuN++);
 445 }
 446
 447 /* ---------------------------------------------------------------------------
 448  * get next slot for a library entry, allocates memory if necessary
 449  */
 450 LibraryEntryTypePtr
 451 GetLibraryEntryMemory (LibraryMenuTypePtr Menu)
 452 {
 453   LibraryEntryTypePtr entry = Menu->Entry;
 454
 455   /* realloc new memory if necessary and clear it */
 456   if (Menu->EntryN >= Menu->EntryMax)
 457     {
 458       Menu->EntryMax += STEP_LIBRARYENTRY;
 459       entry = (LibraryEntryTypePtr)realloc (entry, Menu->EntryMax * sizeof (LibraryEntryType));
 460       Menu->Entry = entry;
 461       memset (entry + Menu->EntryN, 0,
 462               STEP_LIBRARYENTRY * sizeof (LibraryEntryType));
 463     }
 464   return (entry + Menu->EntryN++);
 465 }
 466
 467 /* ---------------------------------------------------------------------------
 468  * get next slot for a DrillElement, allocates memory if necessary
 469  */
 470 ElementTypeHandle
 471 GetDrillElementMemory (DrillTypePtr Drill)
 472 {
 473   ElementTypePtr *element;
 474
 475   element = Drill->Element;
 476
 477   /* realloc new memory if necessary and clear it */
 478   if (Drill->ElementN >= Drill->ElementMax)
 479     {
 480       Drill->ElementMax += STEP_ELEMENT;
 481       element = (ElementTypePtr *)realloc (element,
 482                          Drill->ElementMax * sizeof (ElementTypeHandle));
 483       Drill->Element = element;
 484       memset (element + Drill->ElementN, 0,
 485               STEP_ELEMENT * sizeof (ElementTypeHandle));
 486     }
 487   return (element + Drill->ElementN++);
 488 }
 489
 490 /* ---------------------------------------------------------------------------
 491  * get next slot for a DrillPoint, allocates memory if necessary
 492  */
 493 PinTypeHandle
 494 GetDrillPinMemory (DrillTypePtr Drill)
 495 {
 496   PinTypePtr *pin;
 497
 498   pin = Drill->Pin;
 499
 500   /* realloc new memory if necessary and clear it */
 501   if (Drill->PinN >= Drill->PinMax)
 502     {
 503       Drill->PinMax += STEP_POINT;
 504       pin = (PinTypePtr *)realloc (pin, Drill->PinMax * sizeof (PinTypeHandle));
 505       Drill->Pin = pin;
 506       memset (pin + Drill->PinN, 0, STEP_POINT * sizeof (PinTypeHandle));
 507     }
 508   return (pin + Drill->PinN++);
 509 }
 510
 511 /* ---------------------------------------------------------------------------
 512  * get next slot for a Drill, allocates memory if necessary
 513  */
 514 DrillTypePtr
 515 GetDrillInfoDrillMemory (DrillInfoTypePtr DrillInfo)
 516 {
 517   DrillTypePtr drill = DrillInfo->Drill;
 518
 519   /* realloc new memory if necessary and clear it */
 520   if (DrillInfo->DrillN >= DrillInfo->DrillMax)
 521     {
 522       DrillInfo->DrillMax += STEP_DRILL;
 523       drill = (DrillTypePtr)realloc (drill, DrillInfo->DrillMax * sizeof (DrillType));
 524       DrillInfo->Drill = drill;
 525       memset (drill + DrillInfo->DrillN, 0, STEP_DRILL * sizeof (DrillType));
 526     }
 527   return (drill + DrillInfo->DrillN++);
 528 }
 529
 530 /* ---------------------------------------------------------------------------
 531  * frees memory used by a polygon
 532  */
 533 void
 534 FreePolygonMemory (PolygonType *polygon)
 535 {
 536   if (polygon == NULL)
 537     return;
 538
 539   free (polygon->Points);
 540   free (polygon->HoleIndex);
 541
 542   if (polygon->Clipped)
 543     poly_Free (&polygon->Clipped);
 544   poly_FreeContours (&polygon->NoHoles);
 545
 546   memset (polygon, 0, sizeof (PolygonType));
 547 }
 548
 549 /* ---------------------------------------------------------------------------
 550  * frees memory used by a box list
 551  */
 552 void
 553 FreeBoxListMemory (BoxListTypePtr Boxlist)
 554 {
 555   if (Boxlist)
 556     {
 557       free (Boxlist->Box);
 558       memset (Boxlist, 0, sizeof (BoxListType));
 559     }
 560 }
 561
 562 /* ---------------------------------------------------------------------------
 563  * frees memory used by a net
 564  */
 565 void
 566 FreeNetListMemory (NetListTypePtr Netlist)
 567 {
 568   if (Netlist)
 569     {
 570       NET_LOOP (Netlist);
 571       {
 572         FreeNetMemory (net);
 573       }
 574       END_LOOP;
 575       free (Netlist->Net);
 576       memset (Netlist, 0, sizeof (NetListType));
 577     }
 578 }
 579
 580 /* ---------------------------------------------------------------------------
 581  * frees memory used by a net list
 582  */
 583 void
 584 FreeNetListListMemory (NetListListTypePtr Netlistlist)
 585 {
 586   if (Netlistlist)
 587     {
 588       NETLIST_LOOP (Netlistlist);
 589       {
 590         FreeNetListMemory (netlist);
 591       }
 592       END_LOOP;
 593       free (Netlistlist->NetList);
 594       memset (Netlistlist, 0, sizeof (NetListListType));
 595     }
 596 }
 597
 598 /* ---------------------------------------------------------------------------
 599  * frees memory used by a subnet
 600  */
 601 void
 602 FreeNetMemory (NetTypePtr Net)
 603 {
 604   if (Net)
 605     {
 606       free (Net->Connection);
 607       memset (Net, 0, sizeof (NetType));
 608     }
 609 }
 610 /* ---------------------------------------------------------------------------
 611  * frees memory used by an attribute list
 612  */
 613 static void
 614 FreeAttributeListMemory (AttributeListTypePtr list)
 615 {
 616   int i;
 617
 618   for (i = 0; i < list->Number; i++)
 619     {
 620       free (list->List[i].name);
 621       free (list->List[i].value);
 622     }
 623   free (list->List);
 624   list->List = NULL;
 625   list->Max = 0;
 626 }
 627
 628 /* ---------------------------------------------------------------------------
 629  * frees memory used by an element
 630  */
 631 void
 632 FreeElementMemory (ElementType *element)
 633 {
 634   if (element == NULL)
 635     return;
 636
 637   ELEMENTNAME_LOOP (element);
 638   {
 639     free (textstring);
 640   }
 641   END_LOOP;
 642   PIN_LOOP (element);
 643   {
 644     free (pin->Name);
 645     free (pin->Number);
 646   }
 647   END_LOOP;
 648   PAD_LOOP (element);
 649   {
 650     free (pad->Name);
 651     free (pad->Number);
 652   }
 653   END_LOOP;
 654
 655   g_list_free_full (element->Pin,  (GDestroyNotify)FreePin);
 656   g_list_free_full (element->Pad,  (GDestroyNotify)FreePad);
 657   g_list_free_full (element->Line, (GDestroyNotify)FreeLine);
 658   g_list_free_full (element->Arc,  (GDestroyNotify)FreeArc);
 659
 660   FreeAttributeListMemory (&element->Attributes);
 661   memset (element, 0, sizeof (ElementType));
 662 }
 663
 664 /* ---------------------------------------------------------------------------
 665  * free memory used by PCB
 666  */
 667 void
 668 FreePCBMemory (PCBType *pcb)
 669 {
 670   int i;
 671
 672   if (pcb == NULL)
 673     return;
 674
 675   free (pcb->Name);
 676   free (pcb->Filename);
 677   free (pcb->PrintFilename);
 678   FreeDataMemory (pcb->Data);
 679   free (pcb->Data);
 680   /* release font symbols */
 681   for (i = 0; i <= MAX_FONTPOSITION; i++)
 682     free (pcb->Font.Symbol[i].Line);
 683   FreeLibraryMemory (&pcb->NetlistLib);
 684   FreeAttributeListMemory (&pcb->Attributes);
 685   /* clear struct */
 686   memset (pcb, 0, sizeof (PCBType));
 687 }
 688
 689 /* ---------------------------------------------------------------------------
 690  * free memory used by data struct
 691  */
 692 void
 693 FreeDataMemory (DataType *data)
 694 {
 695   LayerTypePtr layer;
 696   int i;
 697
 698   if (data == NULL)
 699     return;
 700
 701   VIA_LOOP (data);
 702   {
 703     free (via->Name);
 704   }
 705   END_LOOP;
 706   g_list_free_full (data->Via, (GDestroyNotify)FreeVia);
 707   ELEMENT_LOOP (data);
 708   {
 709     FreeElementMemory (element);
 710   }
 711   END_LOOP;
 712   g_list_free_full (data->Element, (GDestroyNotify)FreeElement);
 713   g_list_free_full (data->Rat, (GDestroyNotify)FreeRat);
 714
 715   for (layer = data->Layer, i = 0; i < MAX_LAYER + 2; layer++, i++)
 716     {
 717       FreeAttributeListMemory (&layer->Attributes);
 718       TEXT_LOOP (layer);
 719       {
 720         free (text->TextString);
 721       }
 722       END_LOOP;
 723       if (layer->Name)
 724         free (layer->Name);
 725       LINE_LOOP (layer);
 726       {
 727         if (line->Number)
 728           free (line->Number);
 729       }
 730       END_LOOP;
 731       g_list_free_full (layer->Line, (GDestroyNotify)FreeLine);
 732       g_list_free_full (layer->Arc, (GDestroyNotify)FreeArc);
 733       g_list_free_full (layer->Text, (GDestroyNotify)FreeText);
 734       POLYGON_LOOP (layer);
 735       {
 736         FreePolygonMemory (polygon);
 737       }
 738       END_LOOP;
 739       g_list_free_full (layer->Polygon, (GDestroyNotify)FreePolygon);
 740       if (layer->line_tree)
 741         r_destroy_tree (&layer->line_tree);
 742       if (layer->arc_tree)
 743         r_destroy_tree (&layer->arc_tree);
 744       if (layer->text_tree)
 745         r_destroy_tree (&layer->text_tree);
 746       if (layer->polygon_tree)
 747         r_destroy_tree (&layer->polygon_tree);
 748     }
 749
 750   if (data->element_tree)
 751     r_destroy_tree (&data->element_tree);
 752   for (i = 0; i < MAX_ELEMENTNAMES; i++)
 753     if (data->name_tree[i])
 754       r_destroy_tree (&data->name_tree[i]);
 755   if (data->via_tree)
 756     r_destroy_tree (&data->via_tree);
 757   if (data->pin_tree)
 758     r_destroy_tree (&data->pin_tree);
 759   if (data->pad_tree)
 760     r_destroy_tree (&data->pad_tree);
 761   if (data->rat_tree)
 762     r_destroy_tree (&data->rat_tree);
 763   /* clear struct */
 764   memset (data, 0, sizeof (DataType));
 765 }
 766
 767 /* ---------------------------------------------------------------------------
 768  * releases the memory that's allocated by the library
 769  */
 770 void
 771 FreeLibraryMemory (LibraryTypePtr lib)
 772 {
 773   MENU_LOOP (lib);
 774   {
 775     ENTRY_LOOP (menu);
 776     {
 777       free (entry->AllocatedMemory);
 778       free (entry->ListEntry);
 779     }
 780     END_LOOP;
 781     free (menu->Entry);
 782     free (menu->Name);
 783   }
 784   END_LOOP;
 785   free (lib->Menu);
 786
 787   /* clear struct */
 788   memset (lib, 0, sizeof (LibraryType));
 789 }
 790
 791 /* ---------------------------------------------------------------------------
 792  * reallocates memory for a dynamic length string if necessary
 793  */
 794 static void
 795 DSRealloc (DynamicStringTypePtr Ptr, size_t Length)
 796 {
 797   int input_null = (Ptr->Data == NULL);
 798   if (input_null || Length >= Ptr->MaxLength)
 799     {
 800       Ptr->MaxLength = Length + 512;
 801       Ptr->Data = (char *)realloc (Ptr->Data, Ptr->MaxLength);
 802       if (input_null)
 803         Ptr->Data[0] = '\0';
 804     }
 805 }
 806
 807 /* ---------------------------------------------------------------------------
 808  * adds one character to a dynamic string
 809  */
 810 void
 811 DSAddCharacter (DynamicStringTypePtr Ptr, char Char)
 812 {
 813   size_t position = Ptr->Data ? strlen (Ptr->Data) : 0;
 814
 815   DSRealloc (Ptr, position + 1);
 816   Ptr->Data[position++] = Char;
 817   Ptr->Data[position] = '\0';
 818 }
 819
 820 /* ---------------------------------------------------------------------------
 821  * add a string to a dynamic string
 822  */
 823 void
 824 DSAddString (DynamicStringTypePtr Ptr, const char *S)
 825 {
 826   size_t position = Ptr->Data ? strlen (Ptr->Data) : 0;
 827
 828   if (S && *S)
 829     {
 830       DSRealloc (Ptr, position + 1 + strlen (S));
 831       strcat (&Ptr->Data[position], S);
 832     }
 833 }
 834
 835 /* ----------------------------------------------------------------------
 836  * clears a dynamic string
 837  */
 838 void
 839 DSClearString (DynamicStringTypePtr Ptr)
 840 {
 841   if (Ptr->Data)
 842     Ptr->Data[0] = '\0';
 843 }
 844
 845 /* ---------------------------------------------------------------------------
 846  * strips leading and trailing blanks from the passed string and
 847  * returns a pointer to the new 'duped' one or NULL if the old one
 848  * holds only white space characters
 849  */
 850 char *
 851 StripWhiteSpaceAndDup (const char *S)
 852 {
 853   const char *p1, *p2;
 854   char *copy;
 855   size_t length;
 856
 857   if (!S || !*S)
 858     return (NULL);
 859
 860   /* strip leading blanks */
 861   for (p1 = S; *p1 && isspace ((int) *p1); p1++);
 862
 863   /* strip trailing blanks and get string length */
 864   length = strlen (p1);
 865   for (p2 = p1 + length - 1; length && isspace ((int) *p2); p2--, length--);
 866
 867   /* string is not empty -> allocate memory */
 868   if (length)
 869     {
 870       copy = (char *)realloc (NULL, length + 1);
 871       strncpy (copy, p1, length);
 872       copy[length] = '\0';
 873       return (copy);
 874     }
 875   else
 876     return (NULL);
 877 }