src/drill.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 module, drill.c, was written and is Copyright (C) 1997 harry eaton
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  *  Contact addresses for paper mail and Email:
  26  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  27  *  Thomas.Nau@rz.uni-ulm.de
  28  *
  29  */
  30
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"
  34 #endif
  35
  36 #include "data.h"
  37 #include "error.h"
  38 #include "mymem.h"
  39
  40 #ifdef HAVE_LIBDMALLOC
  41 #include <dmalloc.h>
  42 #endif
  43
  44 RCSID ("$Id$");
  45
  46
  47
  48
  49 /*
  50  * some local prototypes
  51  */
  52 static void FillDrill (DrillTypePtr, ElementTypePtr, PinTypePtr);
  53 static void InitializeDrill (DrillTypePtr, PinTypePtr, ElementTypePtr);
  54
  55
  56 static void
  57 FillDrill (DrillTypePtr Drill, ElementTypePtr Element, PinTypePtr Pin)
  58 {
  59   Cardinal n;
  60   ElementTypeHandle ptr;
  61   PinTypeHandle pin;
  62
  63   pin = GetDrillPinMemory (Drill);
  64   *pin = Pin;
  65   if (Element)
  66     {
  67       Drill->PinCount++;
  68       for (n = Drill->ElementN - 1; n != -1; n--)
  69         if (Drill->Element[n] == Element)
  70           break;
  71       if (n == -1)
  72         {
  73           ptr = GetDrillElementMemory (Drill);
  74           *ptr = Element;
  75         }
  76     }
  77   else
  78     Drill->ViaCount++;
  79   if (TEST_FLAG (HOLEFLAG, Pin))
  80     Drill->UnplatedCount++;
  81 }
  82
  83 static void
  84 InitializeDrill (DrillTypePtr drill, PinTypePtr pin, ElementTypePtr element)
  85 {
  86   void *ptr;
  87
  88   drill->DrillSize = pin->DrillingHole;
  89   drill->ElementN = 0;
  90   drill->ViaCount = 0;
  91   drill->PinCount = 0;
  92   drill->UnplatedCount = 0;
  93   drill->ElementMax = 0;
  94   drill->Element = NULL;
  95   drill->PinN = 0;
  96   drill->Pin = NULL;
  97   drill->PinMax = 0;
  98   ptr = (void *) GetDrillPinMemory (drill);
  99   *((PinTypeHandle) ptr) = pin;
 100   if (element)
 101     {
 102       ptr = (void *) GetDrillElementMemory (drill);
 103       *((ElementTypeHandle) ptr) = element;
 104       drill->PinCount = 1;
 105     }
 106   else
 107     drill->ViaCount = 1;
 108   if (TEST_FLAG (HOLEFLAG, pin))
 109     drill->UnplatedCount = 1;
 110 }
 111
 112 static int
 113 DrillQSort (const void *va, const void *vb)
 114 {
 115   DrillType *a = (DrillType *) va;
 116   DrillType *b = (DrillType *) vb;
 117   return a->DrillSize - b->DrillSize;
 118 }
 119
 120 DrillInfoTypePtr
 121 GetDrillInfo (DataTypePtr top)
 122 {
 123   DrillInfoTypePtr AllDrills;
 124   DrillTypePtr Drill = NULL;
 125   DrillType savedrill, swapdrill;
 126   bool DrillFound = false;
 127   bool NewDrill;
 128
 129   AllDrills = MyCalloc (1, sizeof (DrillInfoType), "GetAllDrillInfo()");
 130   ALLPIN_LOOP (top);
 131   {
 132     if (!DrillFound)
 133       {
 134         DrillFound = true;
 135         Drill = GetDrillInfoDrillMemory (AllDrills);
 136         InitializeDrill (Drill, pin, element);
 137       }
 138     else
 139       {
 140         if (Drill->DrillSize == pin->DrillingHole)
 141           FillDrill (Drill, element, pin);
 142         else
 143           {
 144             NewDrill = false;
 145             DRILL_LOOP (AllDrills);
 146             {
 147               if (drill->DrillSize == pin->DrillingHole)
 148                 {
 149                   Drill = drill;
 150                   FillDrill (Drill, element, pin);
 151                   break;
 152                 }
 153               else if (drill->DrillSize > pin->DrillingHole)
 154                 {
 155                   if (!NewDrill)
 156                     {
 157                       NewDrill = true;
 158                       InitializeDrill (&swapdrill, pin, element);
 159                       Drill = GetDrillInfoDrillMemory (AllDrills);
 160                       Drill->DrillSize = pin->DrillingHole + 1;
 161                       Drill = drill;
 162                     }
 163                   savedrill = *drill;
 164                   *drill = swapdrill;
 165                   swapdrill = savedrill;
 166                 }
 167             }
 168             END_LOOP;
 169             if (AllDrills->Drill[AllDrills->DrillN - 1].DrillSize <
 170                 pin->DrillingHole)
 171               {
 172                 Drill = GetDrillInfoDrillMemory (AllDrills);
 173                 InitializeDrill (Drill, pin, element);
 174               }
 175           }
 176       }
 177   }
 178   ENDALL_LOOP;
 179   VIA_LOOP (top);
 180   {
 181     if (!DrillFound)
 182       {
 183         DrillFound = true;
 184         Drill = GetDrillInfoDrillMemory (AllDrills);
 185         Drill->DrillSize = via->DrillingHole;
 186         FillDrill (Drill, NULL, via);
 187       }
 188     else
 189       {
 190         if (Drill->DrillSize != via->DrillingHole)
 191           {
 192             DRILL_LOOP (AllDrills);
 193             {
 194               if (drill->DrillSize == via->DrillingHole)
 195                 {
 196                   Drill = drill;
 197                   FillDrill (Drill, NULL, via);
 198                   break;
 199                 }
 200             }
 201             END_LOOP;
 202             if (Drill->DrillSize != via->DrillingHole)
 203               {
 204                 Drill = GetDrillInfoDrillMemory (AllDrills);
 205                 Drill->DrillSize = via->DrillingHole;
 206                 FillDrill (Drill, NULL, via);
 207               }
 208           }
 209         else
 210           FillDrill (Drill, NULL, via);
 211       }
 212   }
 213   END_LOOP;
 214   qsort (AllDrills->Drill, AllDrills->DrillN, sizeof (DrillType), DrillQSort);
 215   return (AllDrills);
 216 }
 217
 218 #define ROUND(x,n) ((int)(((x)+(n)/2)/(n))*(n))
 219
 220 void
 221 RoundDrillInfo (DrillInfoTypePtr d, int roundto)
 222 {
 223   unsigned int i = 0;
 224
 225   while ((d->DrillN > 0) && (i < d->DrillN - 1))
 226     {
 227       int diam1 = ROUND (d->Drill[i].DrillSize, roundto);
 228       int diam2 = ROUND (d->Drill[i + 1].DrillSize, roundto);
 229
 230       if (diam1 == diam2)
 231         {
 232           int ei, ej;
 233
 234           d->Drill[i].ElementMax
 235             = d->Drill[i].ElementN + d->Drill[i+1].ElementN;
 236           if (d->Drill[i].ElementMax)
 237             {
 238               d->Drill[i].Element = MyRealloc (d->Drill[i].Element,
 239                                                d->Drill[i].ElementMax *
 240                                                sizeof(ElementTypePtr),
 241                                                "RoundDrillInfo");
 242
 243               for (ei = 0; ei < d->Drill[i+1].ElementN; ei++)
 244                 {
 245                   for (ej = 0; ej < d->Drill[i].ElementN; ej++)
 246                     if (d->Drill[i].Element[ej] == d->Drill[i + 1].Element[ei])
 247                       break;
 248                   if (ej == d->Drill[i].ElementN)
 249                     d->Drill[i].Element[d->Drill[i].ElementN++]
 250                       = d->Drill[i + 1].Element[ei];
 251                 }
 252             }
 253           MYFREE (d->Drill[i + 1].Element);
 254
 255           d->Drill[i].PinMax = d->Drill[i].PinN + d->Drill[i + 1].PinN;
 256           d->Drill[i].Pin = MyRealloc (d->Drill[i].Pin,
 257                                        d->Drill[i].PinMax *
 258                                        sizeof (PinTypePtr), "RoundDrillInfo");
 259           memcpy (d->Drill[i].Pin + d->Drill[i].PinN, d->Drill[i + 1].Pin,
 260                   d->Drill[i + 1].PinN * sizeof (PinTypePtr));
 261           d->Drill[i].PinN += d->Drill[i + 1].PinN;
 262           MYFREE (d->Drill[i + 1].Pin);
 263
 264           d->Drill[i].PinCount += d->Drill[i + 1].PinCount;
 265           d->Drill[i].ViaCount += d->Drill[i + 1].ViaCount;
 266           d->Drill[i].UnplatedCount += d->Drill[i + 1].UnplatedCount;
 267
 268           d->Drill[i].DrillSize = diam1;
 269
 270           memmove (d->Drill + i + 1,
 271                    d->Drill + i + 2,
 272                    (d->DrillN - i - 2) * sizeof (DrillType));
 273           d->DrillN--;
 274         }
 275       else
 276         {
 277           d->Drill[i].DrillSize = diam1;
 278           i++;
 279         }
 280     }
 281 }
 282
 283 void
 284 FreeDrillInfo (DrillInfoTypePtr Drills)
 285 {
 286   DRILL_LOOP (Drills);
 287   {
 288     MYFREE (drill->Element);
 289     MYFREE (drill->Pin);
 290   }
 291   END_LOOP;
 292   MYFREE (Drills->Drill);
 293   SaveFree (Drills);
 294 }