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   data->Element = g_list_append (data->Element, new_obj);
 412   data->ElementN ++;
 413
 414   return new_obj;
 415 }
 416
 417 static void
 418 FreeElement (ElementType *data)
 419 {
 420   g_slice_free (ElementType, data);
 421 }
 422
 423 /* ---------------------------------------------------------------------------
 424  * get next slot for a library menu, allocates memory if necessary
 425  */
 426 LibraryMenuType *
 427 GetLibraryMenuMemory (LibraryType *lib)
 428 {
 429   LibraryMenuType *menu = lib->Menu;
 430
 431   /* realloc new memory if necessary and clear it */
 432   if (lib->MenuN >= lib->MenuMax)
 433     {
 434       lib->MenuMax += STEP_LIBRARYMENU;
 435       menu = (LibraryMenuType *)realloc (menu, lib->MenuMax * sizeof (LibraryMenuType));
 436       lib->Menu = menu;
 437       memset (menu + lib->MenuN, 0,
 438               STEP_LIBRARYMENU * sizeof (LibraryMenuType));
 439     }
 440   return (menu + lib->MenuN++);
 441 }
 442
 443 /* ---------------------------------------------------------------------------
 444  * get next slot for a library entry, allocates memory if necessary
 445  */
 446 LibraryEntryType *
 447 GetLibraryEntryMemory (LibraryMenuType *Menu)
 448 {
 449   LibraryEntryType *entry = Menu->Entry;
 450
 451   /* realloc new memory if necessary and clear it */
 452   if (Menu->EntryN >= Menu->EntryMax)
 453     {
 454       Menu->EntryMax += STEP_LIBRARYENTRY;
 455       entry = (LibraryEntryType *)realloc (entry, Menu->EntryMax * sizeof (LibraryEntryType));
 456       Menu->Entry = entry;
 457       memset (entry + Menu->EntryN, 0,
 458               STEP_LIBRARYENTRY * sizeof (LibraryEntryType));
 459     }
 460   return (entry + Menu->EntryN++);
 461 }
 462
 463 /* ---------------------------------------------------------------------------
 464  * get next slot for a DrillElement, allocates memory if necessary
 465  */
 466 ElementType **
 467 GetDrillElementMemory (DrillType *Drill)
 468 {
 469   ElementType **element;
 470
 471   element = Drill->Element;
 472
 473   /* realloc new memory if necessary and clear it */
 474   if (Drill->ElementN >= Drill->ElementMax)
 475     {
 476       Drill->ElementMax += STEP_ELEMENT;
 477       element = (ElementType **)realloc (element,
 478                          Drill->ElementMax * sizeof (ElementType *));
 479       Drill->Element = element;
 480       memset (element + Drill->ElementN, 0,
 481               STEP_ELEMENT * sizeof (ElementType *));
 482     }
 483   return (element + Drill->ElementN++);
 484 }
 485
 486 /* ---------------------------------------------------------------------------
 487  * get next slot for a DrillPoint, allocates memory if necessary
 488  */
 489 PinType **
 490 GetDrillPinMemory (DrillType *Drill)
 491 {
 492   PinType **pin;
 493
 494   pin = Drill->Pin;
 495
 496   /* realloc new memory if necessary and clear it */
 497   if (Drill->PinN >= Drill->PinMax)
 498     {
 499       Drill->PinMax += STEP_POINT;
 500       pin = (PinType **)realloc (pin, Drill->PinMax * sizeof (PinType *));
 501       Drill->Pin = pin;
 502       memset (pin + Drill->PinN, 0, STEP_POINT * sizeof (PinType *));
 503     }
 504   return (pin + Drill->PinN++);
 505 }
 506
 507 /* ---------------------------------------------------------------------------
 508  * get next slot for a Drill, allocates memory if necessary
 509  */
 510 DrillType *
 511 GetDrillInfoDrillMemory (DrillInfoType *DrillInfo)
 512 {
 513   DrillType *drill = DrillInfo->Drill;
 514
 515   /* realloc new memory if necessary and clear it */
 516   if (DrillInfo->DrillN >= DrillInfo->DrillMax)
 517     {
 518       DrillInfo->DrillMax += STEP_DRILL;
 519       drill = (DrillType *)realloc (drill, DrillInfo->DrillMax * sizeof (DrillType));
 520       DrillInfo->Drill = drill;
 521       memset (drill + DrillInfo->DrillN, 0, STEP_DRILL * sizeof (DrillType));
 522     }
 523   return (drill + DrillInfo->DrillN++);
 524 }
 525
 526 /* ---------------------------------------------------------------------------
 527  * frees memory used by a polygon
 528  */
 529 void
 530 FreePolygonMemory (PolygonType *polygon)
 531 {
 532   if (polygon == NULL)
 533     return;
 534
 535   free (polygon->Points);
 536   free (polygon->HoleIndex);
 537
 538   if (polygon->Clipped)
 539     poly_Free (&polygon->Clipped);
 540   poly_FreeContours (&polygon->NoHoles);
 541
 542   memset (polygon, 0, sizeof (PolygonType));
 543 }
 544
 545 /* ---------------------------------------------------------------------------
 546  * frees memory used by a box list
 547  */
 548 void
 549 FreeBoxListMemory (BoxListType *Boxlist)
 550 {
 551   if (Boxlist)
 552     {
 553       free (Boxlist->Box);
 554       memset (Boxlist, 0, sizeof (BoxListType));
 555     }
 556 }
 557
 558 /* ---------------------------------------------------------------------------
 559  * frees memory used by a net
 560  */
 561 void
 562 FreeNetListMemory (NetListType *Netlist)
 563 {
 564   if (Netlist)
 565     {
 566       NET_LOOP (Netlist);
 567       {
 568         FreeNetMemory (net);
 569       }
 570       END_LOOP;
 571       free (Netlist->Net);
 572       memset (Netlist, 0, sizeof (NetListType));
 573     }
 574 }
 575
 576 /* ---------------------------------------------------------------------------
 577  * frees memory used by a net list
 578  */
 579 void
 580 FreeNetListListMemory (NetListListType *Netlistlist)
 581 {
 582   if (Netlistlist)
 583     {
 584       NETLIST_LOOP (Netlistlist);
 585       {
 586         FreeNetListMemory (netlist);
 587       }
 588       END_LOOP;
 589       free (Netlistlist->NetList);
 590       memset (Netlistlist, 0, sizeof (NetListListType));
 591     }
 592 }
 593
 594 /* ---------------------------------------------------------------------------
 595  * frees memory used by a subnet
 596  */
 597 void
 598 FreeNetMemory (NetType *Net)
 599 {
 600   if (Net)
 601     {
 602       free (Net->Connection);
 603       memset (Net, 0, sizeof (NetType));
 604     }
 605 }
 606 /* ---------------------------------------------------------------------------
 607  * frees memory used by an attribute list
 608  */
 609 static void
 610 FreeAttributeListMemory (AttributeListType *list)
 611 {
 612   int i;
 613
 614   for (i = 0; i < list->Number; i++)
 615     {
 616       free (list->List[i].name);
 617       free (list->List[i].value);
 618     }
 619   free (list->List);
 620   list->List = NULL;
 621   list->Max = 0;
 622 }
 623
 624 /* ---------------------------------------------------------------------------
 625  * frees memory used by an element
 626  */
 627 void
 628 FreeElementMemory (ElementType *element)
 629 {
 630   if (element == NULL)
 631     return;
 632
 633   ELEMENTNAME_LOOP (element);
 634   {
 635     free (textstring);
 636   }
 637   END_LOOP;
 638   PIN_LOOP (element);
 639   {
 640     free (pin->Name);
 641     free (pin->Number);
 642   }
 643   END_LOOP;
 644   PAD_LOOP (element);
 645   {
 646     free (pad->Name);
 647     free (pad->Number);
 648   }
 649   END_LOOP;
 650
 651   g_list_free_full (element->Pin,  (GDestroyNotify)FreePin);
 652   g_list_free_full (element->Pad,  (GDestroyNotify)FreePad);
 653   g_list_free_full (element->Line, (GDestroyNotify)FreeLine);
 654   g_list_free_full (element->Arc,  (GDestroyNotify)FreeArc);
 655
 656   FreeAttributeListMemory (&element->Attributes);
 657   memset (element, 0, sizeof (ElementType));
 658 }
 659
 660 /* ---------------------------------------------------------------------------
 661  * free memory used by PCB
 662  */
 663 void
 664 FreePCBMemory (PCBType *pcb)
 665 {
 666   int i;
 667
 668   if (pcb == NULL)
 669     return;
 670
 671   free (pcb->Name);
 672   free (pcb->Filename);
 673   free (pcb->PrintFilename);
 674   FreeDataMemory (pcb->Data);
 675   free (pcb->Data);
 676   /* release font symbols */
 677   for (i = 0; i <= MAX_FONTPOSITION; i++)
 678     free (pcb->Font.Symbol[i].Line);
 679   FreeLibraryMemory (&pcb->NetlistLib);
 680   NetlistChanged (0);
 681   FreeAttributeListMemory (&pcb->Attributes);
 682   /* clear struct */
 683   memset (pcb, 0, sizeof (PCBType));
 684 }
 685
 686 /* ---------------------------------------------------------------------------
 687  * free memory used by data struct
 688  */
 689 void
 690 FreeDataMemory (DataType *data)
 691 {
 692   LayerType *layer;
 693   int i;
 694
 695   if (data == NULL)
 696     return;
 697
 698   VIA_LOOP (data);
 699   {
 700     free (via->Name);
 701   }
 702   END_LOOP;
 703   g_list_free_full (data->Via, (GDestroyNotify)FreeVia);
 704   ELEMENT_LOOP (data);
 705   {
 706     FreeElementMemory (element);
 707   }
 708   END_LOOP;
 709   g_list_free_full (data->Element, (GDestroyNotify)FreeElement);
 710   g_list_free_full (data->Rat, (GDestroyNotify)FreeRat);
 711
 712   for (layer = data->Layer, i = 0; i < MAX_LAYER + 2; layer++, i++)
 713     {
 714       FreeAttributeListMemory (&layer->Attributes);
 715       TEXT_LOOP (layer);
 716       {
 717         free (text->TextString);
 718       }
 719       END_LOOP;
 720       if (layer->Name)
 721         free (layer->Name);
 722       LINE_LOOP (layer);
 723       {
 724         if (line->Number)
 725           free (line->Number);
 726       }
 727       END_LOOP;
 728       g_list_free_full (layer->Line, (GDestroyNotify)FreeLine);
 729       g_list_free_full (layer->Arc, (GDestroyNotify)FreeArc);
 730       g_list_free_full (layer->Text, (GDestroyNotify)FreeText);
 731       POLYGON_LOOP (layer);
 732       {
 733         FreePolygonMemory (polygon);
 734       }
 735       END_LOOP;
 736       g_list_free_full (layer->Polygon, (GDestroyNotify)FreePolygon);
 737       if (layer->line_tree)
 738         r_destroy_tree (&layer->line_tree);
 739       if (layer->arc_tree)
 740         r_destroy_tree (&layer->arc_tree);
 741       if (layer->text_tree)
 742         r_destroy_tree (&layer->text_tree);
 743       if (layer->polygon_tree)
 744         r_destroy_tree (&layer->polygon_tree);
 745     }
 746
 747   if (data->element_tree)
 748     r_destroy_tree (&data->element_tree);
 749   for (i = 0; i < MAX_ELEMENTNAMES; i++)
 750     if (data->name_tree[i])
 751       r_destroy_tree (&data->name_tree[i]);
 752   if (data->via_tree)
 753     r_destroy_tree (&data->via_tree);
 754   if (data->pin_tree)
 755     r_destroy_tree (&data->pin_tree);
 756   if (data->pad_tree)
 757     r_destroy_tree (&data->pad_tree);
 758   if (data->rat_tree)
 759     r_destroy_tree (&data->rat_tree);
 760   /* clear struct */
 761   memset (data, 0, sizeof (DataType));
 762 }
 763
 764 /* ---------------------------------------------------------------------------
 765  * releases the memory that's allocated by the library
 766  */
 767 void
 768 FreeLibraryMemory (LibraryType *lib)
 769 {
 770   MENU_LOOP (lib);
 771   {
 772     ENTRY_LOOP (menu);
 773     {
 774       free (entry->AllocatedMemory);
 775       free (entry->ListEntry);
 776     }
 777     END_LOOP;
 778     free (menu->Entry);
 779     free (menu->Name);
 780   }
 781   END_LOOP;
 782   free (lib->Menu);
 783
 784   /* clear struct */
 785   memset (lib, 0, sizeof (LibraryType));
 786 }
 787
 788 /* ---------------------------------------------------------------------------
 789  * reallocates memory for a dynamic length string if necessary
 790  */
 791 static void
 792 DSRealloc (DynamicStringType *Ptr, size_t Length)
 793 {
 794   int input_null = (Ptr->Data == NULL);
 795   if (input_null || Length >= Ptr->MaxLength)
 796     {
 797       Ptr->MaxLength = Length + 512;
 798       Ptr->Data = (char *)realloc (Ptr->Data, Ptr->MaxLength);
 799       if (input_null)
 800         Ptr->Data[0] = '\0';
 801     }
 802 }
 803
 804 /* ---------------------------------------------------------------------------
 805  * adds one character to a dynamic string
 806  */
 807 void
 808 DSAddCharacter (DynamicStringType *Ptr, char Char)
 809 {
 810   size_t position = Ptr->Data ? strlen (Ptr->Data) : 0;
 811
 812   DSRealloc (Ptr, position + 1);
 813   Ptr->Data[position++] = Char;
 814   Ptr->Data[position] = '\0';
 815 }
 816
 817 /* ---------------------------------------------------------------------------
 818  * add a string to a dynamic string
 819  */
 820 void
 821 DSAddString (DynamicStringType *Ptr, const char *S)
 822 {
 823   size_t position = Ptr->Data ? strlen (Ptr->Data) : 0;
 824
 825   if (S && *S)
 826     {
 827       DSRealloc (Ptr, position + 1 + strlen (S));
 828       strcat (&Ptr->Data[position], S);
 829     }
 830 }
 831
 832 /* ----------------------------------------------------------------------
 833  * clears a dynamic string
 834  */
 835 void
 836 DSClearString (DynamicStringType *Ptr)
 837 {
 838   if (Ptr->Data)
 839     Ptr->Data[0] = '\0';
 840 }
 841
 842 /* ---------------------------------------------------------------------------
 843  * strips leading and trailing blanks from the passed string and
 844  * returns a pointer to the new 'duped' one or NULL if the old one
 845  * holds only white space characters
 846  */
 847 char *
 848 StripWhiteSpaceAndDup (const char *S)
 849 {
 850   const char *p1, *p2;
 851   char *copy;
 852   size_t length;
 853
 854   if (!S || !*S)
 855     return (NULL);
 856
 857   /* strip leading blanks */
 858   for (p1 = S; *p1 && isspace ((int) *p1); p1++);
 859
 860   /* strip trailing blanks and get string length */
 861   length = strlen (p1);
 862   for (p2 = p1 + length - 1; length && isspace ((int) *p2); p2--, length--);
 863
 864   /* string is not empty -> allocate memory */
 865   if (length)
 866     {
 867       copy = (char *)realloc (NULL, length + 1);
 868       strncpy (copy, p1, length);
 869       copy[length] = '\0';
 870       return (copy);
 871     }
 872   else
 873     return (NULL);
 874 }