src/mymem.c

   1 /*
   2  *                            COPYRIGHT
   3  *
   4  *  PCB, interactive printed circuit board design
   5  *  Copyright (C) 1994,1995,1996 Thomas Nau
   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  *  Contact addresses for paper mail and Email:
  22  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  23  *  Thomas.Nau@rz.uni-ulm.de
  24  *
  25  */
  26
  27
  28 /* memory management functions
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #include "global.h"
  36
  37 #include <memory.h>
  38
  39 #include "data.h"
  40 #include "error.h"
  41 #include "mymem.h"
  42 #include "misc.h"
  43 #include "rats.h"
  44 #include "rtree.h"
  45
  46 #ifdef HAVE_LIBDMALLOC
  47 #include <dmalloc.h>
  48 #endif
  49
  50 /* ---------------------------------------------------------------------------
  51  * local prototypes
  52  */
  53 static void DSRealloc (DynamicStringType *, size_t);
  54
  55
  56 /* This API is quite new, provide a version here */
  57 #if !GLIB_CHECK_VERSION (2, 28, 0)
  58 static void
  59 g_list_free_full (GList *list, GDestroyNotify free_func)
  60 {
  61   g_list_foreach (list, (GFunc) free_func, NULL);
  62   g_list_free (list);
  63 }
  64 #endif
  65
  66 /* ---------------------------------------------------------------------------
  67  * get next slot for a rubberband connection, allocates memory if necessary
  68  */
  69 RubberbandType *
  70 GetRubberbandMemory (void)
  71 {
  72   RubberbandType *ptr = Crosshair.AttachedObject.Rubberband;
  73
  74   /* realloc new memory if necessary and clear it */
  75   if (Crosshair.AttachedObject.RubberbandN >=
  76       Crosshair.AttachedObject.RubberbandMax)
  77     {
  78       Crosshair.AttachedObject.RubberbandMax += STEP_RUBBERBAND;
  79       ptr = (RubberbandType *)realloc (ptr, Crosshair.AttachedObject.RubberbandMax *
  80                           sizeof (RubberbandType));
  81       Crosshair.AttachedObject.Rubberband = ptr;
  82       memset (ptr + Crosshair.AttachedObject.RubberbandN, 0,
  83               STEP_RUBBERBAND * sizeof (RubberbandType));
  84     }
  85   return (ptr + Crosshair.AttachedObject.RubberbandN++);
  86 }
  87
  88 void **
  89 GetPointerMemory (PointerListType *list)
  90 {
  91   void **ptr = list->Ptr;
  92
  93   /* realloc new memory if necessary and clear it */
  94   if (list->PtrN >= list->PtrMax)
  95     {
  96       list->PtrMax = STEP_POINT + (2 * list->PtrMax);
  97       ptr = (void **)realloc (ptr, list->PtrMax * sizeof (void *));
  98       list->Ptr = ptr;
  99       memset (ptr + list->PtrN, 0,
 100               (list->PtrMax - list->PtrN) * sizeof (void *));
 101     }
 102   return (ptr + list->PtrN++);
 103 }
 104
 105 void
 106 FreePointerListMemory (PointerListType *list)
 107 {
 108   free (list->Ptr);
 109   memset (list, 0, sizeof (PointerListType));
 110 }
 111
 112 /* ---------------------------------------------------------------------------
 113  * get next slot for a box, allocates memory if necessary
 114  */
 115 BoxType *
 116 GetBoxMemory (BoxListType *Boxes)
 117 {
 118   BoxType *box = Boxes->Box;
 119
 120   /* realloc new memory if necessary and clear it */
 121   if (Boxes->BoxN >= Boxes->BoxMax)
 122     {
 123       Boxes->BoxMax = STEP_POINT + (2 * Boxes->BoxMax);
 124       box = (BoxType *)realloc (box, Boxes->BoxMax * sizeof (BoxType));
 125       Boxes->Box = box;
 126       memset (box + Boxes->BoxN, 0,
 127               (Boxes->BoxMax - Boxes->BoxN) * sizeof (BoxType));
 128     }
 129   return (box + Boxes->BoxN++);
 130 }
 131
 132
 133 /* ---------------------------------------------------------------------------
 134  * get next slot for a connection, allocates memory if necessary
 135  */
 136 ConnectionType *
 137 GetConnectionMemory (NetType *Net)
 138 {
 139   ConnectionType *con = Net->Connection;
 140
 141   /* realloc new memory if necessary and clear it */
 142   if (Net->ConnectionN >= Net->ConnectionMax)
 143     {
 144       Net->ConnectionMax += STEP_POINT;
 145       con = (ConnectionType *)realloc (con, Net->ConnectionMax * sizeof (ConnectionType));
 146       Net->Connection = con;
 147       memset (con + Net->ConnectionN, 0,
 148               STEP_POINT * sizeof (ConnectionType));
 149     }
 150   return (con + Net->ConnectionN++);
 151 }
 152
 153 /* ---------------------------------------------------------------------------
 154  * get next slot for a subnet, allocates memory if necessary
 155  */
 156 NetType *
 157 GetNetMemory (NetListType *Netlist)
 158 {
 159   NetType *net = Netlist->Net;
 160
 161   /* realloc new memory if necessary and clear it */
 162   if (Netlist->NetN >= Netlist->NetMax)
 163     {
 164       Netlist->NetMax += STEP_POINT;
 165       net = (NetType *)realloc (net, Netlist->NetMax * sizeof (NetType));
 166       Netlist->Net = net;
 167       memset (net + Netlist->NetN, 0, STEP_POINT * sizeof (NetType));
 168     }
 169   return (net + Netlist->NetN++);
 170 }
 171
 172 /* ---------------------------------------------------------------------------
 173  * get next slot for a net list, allocates memory if necessary
 174  */
 175 NetListType *
 176 GetNetListMemory (NetListListType *Netlistlist)
 177 {
 178   NetListType *netlist = Netlistlist->NetList;
 179
 180   /* realloc new memory if necessary and clear it */
 181   if (Netlistlist->NetListN >= Netlistlist->NetListMax)
 182     {
 183       Netlistlist->NetListMax += STEP_POINT;
 184       netlist = (NetListType *)realloc (netlist,
 185                          Netlistlist->NetListMax * sizeof (NetListType));
 186       Netlistlist->NetList = netlist;
 187       memset (netlist + Netlistlist->NetListN, 0,
 188               STEP_POINT * sizeof (NetListType));
 189     }
 190   return (netlist + Netlistlist->NetListN++);
 191 }
 192 /* ---------------------------------------------------------------------------
 193  * get next slot for a pin, allocates memory if necessary
 194  */
 195 PinType *
 196 GetPinMemory (ElementType *element)
 197 {
 198   PinType *new_obj;
 199
 200   new_obj = g_slice_new0 (PinType);
 201   element->Pin = g_list_append (element->Pin, new_obj);
 202   element->PinN ++;
 203
 204   return new_obj;
 205 }
 206
 207 static void
 208 FreePin (PinType *data)
 209 {
 210   g_slice_free (PinType, data);
 211 }
 212
 213 /* ---------------------------------------------------------------------------
 214  * get next slot for a pad, allocates memory if necessary
 215  */
 216 PadType *
 217 GetPadMemory (ElementType *element)
 218 {
 219   PadType *new_obj;
 220
 221   new_obj = g_slice_new0 (PadType);
 222   element->Pad = g_list_append (element->Pad, new_obj);
 223   element->PadN ++;
 224
 225   return new_obj;
 226 }
 227
 228 static void
 229 FreePad (PadType *data)
 230 {
 231   g_slice_free (PadType, data);
 232 }
 233
 234 /* ---------------------------------------------------------------------------
 235  * get next slot for a via, allocates memory if necessary
 236  */
 237 PinType *
 238 GetViaMemory (DataType *data)
 239 {
 240   PinType *new_obj;
 241
 242   new_obj = g_slice_new0 (PinType);
 243   data->Via = g_list_append (data->Via, new_obj);
 244   data->ViaN ++;
 245
 246   return new_obj;
 247 }
 248
 249 static void
 250 FreeVia (PinType *data)
 251 {
 252   g_slice_free (PinType, data);
 253 }
 254
 255 /* ---------------------------------------------------------------------------
 256  * get next slot for a Rat, allocates memory if necessary
 257  */
 258 RatType *
 259 GetRatMemory (DataType *data)
 260 {
 261   RatType *new_obj;
 262
 263   new_obj = g_slice_new0 (RatType);
 264   data->Rat = g_list_append (data->Rat, new_obj);
 265   data->RatN ++;
 266
 267   return new_obj;
 268 }
 269
 270 static void
 271 FreeRat (RatType *data)
 272 {
 273   g_slice_free (RatType, data);
 274 }
 275
 276 /* ---------------------------------------------------------------------------
 277  * get next slot for a line, allocates memory if necessary
 278  */
 279 LineType *
 280 GetLineMemory (LayerType *layer)
 281 {
 282   LineType *new_obj;
 283
 284   new_obj = g_slice_new0 (LineType);
 285   layer->Line = g_list_append (layer->Line, new_obj);
 286   layer->LineN ++;
 287
 288   return new_obj;
 289 }
 290
 291 static void
 292 FreeLine (LineType *data)
 293 {
 294   g_slice_free (LineType, data);
 295 }
 296
 297 /* ---------------------------------------------------------------------------
 298  * get next slot for an arc, allocates memory if necessary
 299  */
 300 ArcType *
 301 GetArcMemory (LayerType *layer)
 302 {
 303   ArcType *new_obj;
 304
 305   new_obj = g_slice_new0 (ArcType);
 306   layer->Arc = g_list_append (layer->Arc, new_obj);
 307   layer->ArcN ++;
 308
 309   return new_obj;
 310 }
 311
 312 static void
 313 FreeArc (ArcType *data)
 314 {
 315   g_slice_free (ArcType, data);
 316 }
 317
 318 /* ---------------------------------------------------------------------------
 319  * get next slot for a text object, allocates memory if necessary
 320  */
 321 TextType *
 322 GetTextMemory (LayerType *layer)
 323 {
 324   TextType *new_obj;
 325
 326   new_obj = g_slice_new0 (TextType);
 327   layer->Text = g_list_append (layer->Text, new_obj);
 328   layer->TextN ++;
 329
 330   return new_obj;
 331 }
 332
 333 static void
 334 FreeText (TextType *data)
 335 {
 336   g_slice_free (TextType, data);
 337 }
 338
 339 /* ---------------------------------------------------------------------------
 340  * get next slot for a polygon object, allocates memory if necessary
 341  */
 342 PolygonType *
 343 GetPolygonMemory (LayerType *layer)
 344 {
 345   PolygonType *new_obj;
 346
 347   new_obj = g_slice_new0 (PolygonType);
 348   layer->Polygon = g_list_append (layer->Polygon, new_obj);
 349   layer->PolygonN ++;
 350
 351   return new_obj;
 352 }
 353
 354 static void
 355 FreePolygon (PolygonType *data)
 356 {
 357   g_slice_free (PolygonType, data);
 358 }
 359
 360 /* ---------------------------------------------------------------------------
 361  * gets the next slot for a point in a polygon struct, allocates memory
 362  * if necessary
 363  */
 364 PointType *
 365 GetPointMemoryInPolygon (PolygonType *Polygon)
 366 {
 367   PointType *points = Polygon->Points;
 368
 369   /* realloc new memory if necessary and clear it */
 370   if (Polygon->PointN >= Polygon->PointMax)
 371     {
 372       Polygon->PointMax += STEP_POLYGONPOINT;
 373       points = (PointType *)realloc (points, Polygon->PointMax * sizeof (PointType));
 374       Polygon->Points = points;
 375       memset (points + Polygon->PointN, 0,
 376               STEP_POLYGONPOINT * sizeof (PointType));
 377     }
 378   return (points + Polygon->PointN++);
 379 }
 380
 381 /* ---------------------------------------------------------------------------
 382  * gets the next slot for a point in a polygon struct, allocates memory
 383  * if necessary
 384  */
 385 Cardinal *
 386 GetHoleIndexMemoryInPolygon (PolygonType *Polygon)
 387 {
 388   Cardinal *holeindex = Polygon->HoleIndex;
 389
 390   /* realloc new memory if necessary and clear it */
 391   if (Polygon->HoleIndexN >= Polygon->HoleIndexMax)
 392     {
 393       Polygon->HoleIndexMax += STEP_POLYGONHOLEINDEX;
 394       holeindex = (Cardinal *)realloc (holeindex, Polygon->HoleIndexMax * sizeof (int));
 395       Polygon->HoleIndex = holeindex;
 396       memset (holeindex + Polygon->HoleIndexN, 0,
 397               STEP_POLYGONHOLEINDEX * sizeof (int));
 398     }
 399   return (holeindex + Polygon->HoleIndexN++);
 400 }
 401
 402 /* ---------------------------------------------------------------------------
 403  * get next slot for an element, allocates memory if necessary
 404  */
 405 ElementType *
 406 GetElementMemory (DataType *data)
 407 {
 408   ElementType *new_obj;
 409
 410   new_obj = g_slice_new0 (ElementType);
 411
 412   if (data != NULL)
 413     {
 414       data->Element = g_list_append (data->Element, new_obj);
 415       data->ElementN ++;
 416     }
 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 LibraryMenuType *
 431 GetLibraryMenuMemory (LibraryType *lib)
 432 {
 433   LibraryMenuType *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 = (LibraryMenuType *)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 LibraryEntryType *
 451 GetLibraryEntryMemory (LibraryMenuType *Menu)
 452 {
 453   LibraryEntryType *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 = (LibraryEntryType *)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 ElementType **
 471 GetDrillElementMemory (DrillType *Drill)
 472 {
 473   ElementType **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 = (ElementType **)realloc (element,
 482                          Drill->ElementMax * sizeof (ElementType *));
 483       Drill->Element = element;
 484       memset (element + Drill->ElementN, 0,
 485               STEP_ELEMENT * sizeof (ElementType *));
 486     }
 487   return (element + Drill->ElementN++);
 488 }
 489
 490 /* ---------------------------------------------------------------------------
 491  * get next slot for a DrillPoint, allocates memory if necessary
 492  */
 493 PinType **
 494 GetDrillPinMemory (DrillType *Drill)
 495 {
 496   PinType **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 = (PinType **)realloc (pin, Drill->PinMax * sizeof (PinType *));
 505       Drill->Pin = pin;
 506       memset (pin + Drill->PinN, 0, STEP_POINT * sizeof (PinType *));
 507     }
 508   return (pin + Drill->PinN++);
 509 }
 510
 511 /* ---------------------------------------------------------------------------
 512  * get next slot for a Drill, allocates memory if necessary
 513  */
 514 DrillType *
 515 GetDrillInfoDrillMemory (DrillInfoType *DrillInfo)
 516 {
 517   DrillType *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 = (DrillType *)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 (BoxListType *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 (NetListType *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 (NetListListType *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 (NetType *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 (AttributeListType *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   NetlistChanged (0);
 685   FreeAttributeListMemory (&pcb->Attributes);
 686   /* clear struct */
 687   memset (pcb, 0, sizeof (PCBType));
 688 }
 689
 690 /* ---------------------------------------------------------------------------
 691  * free memory used by data struct
 692  */
 693 void
 694 FreeDataMemory (DataType *data)
 695 {
 696   LayerType *layer;
 697   int i;
 698
 699   if (data == NULL)
 700     return;
 701
 702   VIA_LOOP (data);
 703   {
 704     free (via->Name);
 705   }
 706   END_LOOP;
 707   g_list_free_full (data->Via, (GDestroyNotify)FreeVia);
 708   ELEMENT_LOOP (data);
 709   {
 710     FreeElementMemory (element);
 711   }
 712   END_LOOP;
 713   g_list_free_full (data->Element, (GDestroyNotify)FreeElement);
 714   g_list_free_full (data->Rat, (GDestroyNotify)FreeRat);
 715
 716   for (layer = data->Layer, i = 0; i < MAX_LAYER + 2; layer++, i++)
 717     {
 718       FreeAttributeListMemory (&layer->Attributes);
 719       TEXT_LOOP (layer);
 720       {
 721         free (text->TextString);
 722       }
 723       END_LOOP;
 724       if (layer->Name)
 725         free (layer->Name);
 726       LINE_LOOP (layer);
 727       {
 728         if (line->Number)
 729           free (line->Number);
 730       }
 731       END_LOOP;
 732       g_list_free_full (layer->Line, (GDestroyNotify)FreeLine);
 733       g_list_free_full (layer->Arc, (GDestroyNotify)FreeArc);
 734       g_list_free_full (layer->Text, (GDestroyNotify)FreeText);
 735       POLYGON_LOOP (layer);
 736       {
 737         FreePolygonMemory (polygon);
 738       }
 739       END_LOOP;
 740       g_list_free_full (layer->Polygon, (GDestroyNotify)FreePolygon);
 741       if (layer->line_tree)
 742         r_destroy_tree (&layer->line_tree);
 743       if (layer->arc_tree)
 744         r_destroy_tree (&layer->arc_tree);
 745       if (layer->text_tree)
 746         r_destroy_tree (&layer->text_tree);
 747       if (layer->polygon_tree)
 748         r_destroy_tree (&layer->polygon_tree);
 749     }
 750
 751   if (data->element_tree)
 752     r_destroy_tree (&data->element_tree);
 753   for (i = 0; i < MAX_ELEMENTNAMES; i++)
 754     if (data->name_tree[i])
 755       r_destroy_tree (&data->name_tree[i]);
 756   if (data->via_tree)
 757     r_destroy_tree (&data->via_tree);
 758   if (data->pin_tree)
 759     r_destroy_tree (&data->pin_tree);
 760   if (data->pad_tree)
 761     r_destroy_tree (&data->pad_tree);
 762   if (data->rat_tree)
 763     r_destroy_tree (&data->rat_tree);
 764   /* clear struct */
 765   memset (data, 0, sizeof (DataType));
 766 }
 767
 768 /* ---------------------------------------------------------------------------
 769  * releases the memory that's allocated by the library
 770  */
 771 void
 772 FreeLibraryMemory (LibraryType *lib)
 773 {
 774   MENU_LOOP (lib);
 775   {
 776     ENTRY_LOOP (menu);
 777     {
 778       free (entry->AllocatedMemory);
 779       free (entry->ListEntry);
 780     }
 781     END_LOOP;
 782     free (menu->Entry);
 783     free (menu->Name);
 784   }
 785   END_LOOP;
 786   free (lib->Menu);
 787
 788   /* clear struct */
 789   memset (lib, 0, sizeof (LibraryType));
 790 }
 791
 792 /* ---------------------------------------------------------------------------
 793  * reallocates memory for a dynamic length string if necessary
 794  */
 795 static void
 796 DSRealloc (DynamicStringType *Ptr, size_t Length)
 797 {
 798   int input_null = (Ptr->Data == NULL);
 799   if (input_null || Length >= Ptr->MaxLength)
 800     {
 801       Ptr->MaxLength = Length + 512;
 802       Ptr->Data = (char *)realloc (Ptr->Data, Ptr->MaxLength);
 803       if (input_null)
 804         Ptr->Data[0] = '\0';
 805     }
 806 }
 807
 808 /* ---------------------------------------------------------------------------
 809  * adds one character to a dynamic string
 810  */
 811 void
 812 DSAddCharacter (DynamicStringType *Ptr, char Char)
 813 {
 814   size_t position = Ptr->Data ? strlen (Ptr->Data) : 0;
 815
 816   DSRealloc (Ptr, position + 1);
 817   Ptr->Data[position++] = Char;
 818   Ptr->Data[position] = '\0';
 819 }
 820
 821 /* ---------------------------------------------------------------------------
 822  * add a string to a dynamic string
 823  */
 824 void
 825 DSAddString (DynamicStringType *Ptr, const char *S)
 826 {
 827   size_t position = Ptr->Data ? strlen (Ptr->Data) : 0;
 828
 829   if (S && *S)
 830     {
 831       DSRealloc (Ptr, position + 1 + strlen (S));
 832       strcat (&Ptr->Data[position], S);
 833     }
 834 }
 835
 836 /* ----------------------------------------------------------------------
 837  * clears a dynamic string
 838  */
 839 void
 840 DSClearString (DynamicStringType *Ptr)
 841 {
 842   if (Ptr->Data)
 843     Ptr->Data[0] = '\0';
 844 }
 845
 846 /* ---------------------------------------------------------------------------
 847  * strips leading and trailing blanks from the passed string and
 848  * returns a pointer to the new 'duped' one or NULL if the old one
 849  * holds only white space characters
 850  */
 851 char *
 852 StripWhiteSpaceAndDup (const char *S)
 853 {
 854   const char *p1, *p2;
 855   char *copy;
 856   size_t length;
 857
 858   if (!S || !*S)
 859     return (NULL);
 860
 861   /* strip leading blanks */
 862   for (p1 = S; *p1 && isspace ((int) *p1); p1++);
 863
 864   /* strip trailing blanks and get string length */
 865   length = strlen (p1);
 866   for (p2 = p1 + length - 1; length && isspace ((int) *p2); p2--, length--);
 867
 868   /* string is not empty -> allocate memory */
 869   if (length)
 870     {
 871       copy = (char *)realloc (NULL, length + 1);
 872       strncpy (copy, p1, length);
 873       copy[length] = '\0';
 874       return (copy);
 875     }
 876   else
 877     return (NULL);
 878 }