src/drill.c

   1 /*
   2  *                            COPYRIGHT
   3  *
   4  *  PCB, interactive printed circuit board design
   5  *  Copyright (C) 1994,1995,1996 Thomas Nau
   6  *
   7  *  This module, drill.c, was written and is Copyright (C) 1997 harry eaton
   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 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif
  33
  34 #include "data.h"
  35 #include "error.h"
  36 #include "mymem.h"
  37
  38 #ifdef HAVE_LIBDMALLOC
  39 #include <dmalloc.h>
  40 #endif
  41
  42 /*
  43  * some local prototypes
  44  */
  45 static void FillDrill (DrillType *, ElementType *, PinType *);
  46 static void InitializeDrill (DrillType *, PinType *, ElementType *);
  47
  48
  49 static void
  50 FillDrill (DrillType *Drill, ElementType *Element, PinType *Pin)
  51 {
  52   Cardinal n;
  53   ElementType **ptr;
  54   PinType **pin;
  55
  56   pin = GetDrillPinMemory (Drill);
  57   *pin = Pin;
  58   if (Element)
  59     {
  60       Drill->PinCount++;
  61       for (n = Drill->ElementN - 1; n != -1; n--)
  62         if (Drill->Element[n] == Element)
  63           break;
  64       if (n == -1)
  65         {
  66           ptr = GetDrillElementMemory (Drill);
  67           *ptr = Element;
  68         }
  69     }
  70   else
  71     Drill->ViaCount++;
  72   if (TEST_FLAG (HOLEFLAG, Pin))
  73     Drill->UnplatedCount++;
  74 }
  75
  76 static void
  77 InitializeDrill (DrillType *drill, PinType *pin, ElementType *element)
  78 {
  79   void *ptr;
  80
  81   drill->DrillSize = pin->DrillingHole;
  82   drill->ElementN = 0;
  83   drill->ViaCount = 0;
  84   drill->PinCount = 0;
  85   drill->UnplatedCount = 0;
  86   drill->ElementMax = 0;
  87   drill->Element = NULL;
  88   drill->PinN = 0;
  89   drill->Pin = NULL;
  90   drill->PinMax = 0;
  91   ptr = (void *) GetDrillPinMemory (drill);
  92   *((PinType **) ptr) = pin;
  93   if (element)
  94     {
  95       ptr = (void *) GetDrillElementMemory (drill);
  96       *((ElementType **) ptr) = element;
  97       drill->PinCount = 1;
  98     }
  99   else
 100     drill->ViaCount = 1;
 101   if (TEST_FLAG (HOLEFLAG, pin))
 102     drill->UnplatedCount = 1;
 103 }
 104
 105 static int
 106 DrillQSort (const void *va, const void *vb)
 107 {
 108   DrillType *a = (DrillType *) va;
 109   DrillType *b = (DrillType *) vb;
 110   return a->DrillSize - b->DrillSize;
 111 }
 112
 113 DrillInfoType *
 114 GetDrillInfo (DataType *top)
 115 {
 116   DrillInfoType *AllDrills;
 117   DrillType *Drill = NULL;
 118   DrillType savedrill, swapdrill;
 119   bool DrillFound = false;
 120   bool NewDrill;
 121
 122   AllDrills = (DrillInfoType *)calloc (1, sizeof (DrillInfoType));
 123   ALLPIN_LOOP (top);
 124   {
 125     if (!DrillFound)
 126       {
 127         DrillFound = true;
 128         Drill = GetDrillInfoDrillMemory (AllDrills);
 129         InitializeDrill (Drill, pin, element);
 130       }
 131     else
 132       {
 133         if (Drill->DrillSize == pin->DrillingHole)
 134           FillDrill (Drill, element, pin);
 135         else
 136           {
 137             NewDrill = false;
 138             DRILL_LOOP (AllDrills);
 139             {
 140               if (drill->DrillSize == pin->DrillingHole)
 141                 {
 142                   Drill = drill;
 143                   FillDrill (Drill, element, pin);
 144                   break;
 145                 }
 146               else if (drill->DrillSize > pin->DrillingHole)
 147                 {
 148                   if (!NewDrill)
 149                     {
 150                       NewDrill = true;
 151                       InitializeDrill (&swapdrill, pin, element);
 152                       Drill = GetDrillInfoDrillMemory (AllDrills);
 153                       Drill->DrillSize = pin->DrillingHole + 1;
 154                       Drill = drill;
 155                     }
 156                   savedrill = *drill;
 157                   *drill = swapdrill;
 158                   swapdrill = savedrill;
 159                 }
 160             }
 161             END_LOOP;
 162             if (AllDrills->Drill[AllDrills->DrillN - 1].DrillSize <
 163                 pin->DrillingHole)
 164               {
 165                 Drill = GetDrillInfoDrillMemory (AllDrills);
 166                 InitializeDrill (Drill, pin, element);
 167               }
 168           }
 169       }
 170   }
 171   ENDALL_LOOP;
 172   VIA_LOOP (top);
 173   {
 174     if (!DrillFound)
 175       {
 176         DrillFound = true;
 177         Drill = GetDrillInfoDrillMemory (AllDrills);
 178         Drill->DrillSize = via->DrillingHole;
 179         FillDrill (Drill, NULL, via);
 180       }
 181     else
 182       {
 183         if (Drill->DrillSize != via->DrillingHole)
 184           {
 185             DRILL_LOOP (AllDrills);
 186             {
 187               if (drill->DrillSize == via->DrillingHole)
 188                 {
 189                   Drill = drill;
 190                   FillDrill (Drill, NULL, via);
 191                   break;
 192                 }
 193             }
 194             END_LOOP;
 195             if (Drill->DrillSize != via->DrillingHole)
 196               {
 197                 Drill = GetDrillInfoDrillMemory (AllDrills);
 198                 Drill->DrillSize = via->DrillingHole;
 199                 FillDrill (Drill, NULL, via);
 200               }
 201           }
 202         else
 203           FillDrill (Drill, NULL, via);
 204       }
 205   }
 206   END_LOOP;
 207   qsort (AllDrills->Drill, AllDrills->DrillN, sizeof (DrillType), DrillQSort);
 208   return (AllDrills);
 209 }
 210
 211 #define ROUND(x,n) ((int)(((x)+(n)/2)/(n))*(n))
 212
 213 void
 214 RoundDrillInfo (DrillInfoType *d, int roundto)
 215 {
 216   unsigned int i = 0;
 217
 218   while ((d->DrillN > 0) && (i < d->DrillN - 1))
 219     {
 220       int diam1 = ROUND (d->Drill[i].DrillSize, roundto);
 221       int diam2 = ROUND (d->Drill[i + 1].DrillSize, roundto);
 222
 223       if (diam1 == diam2)
 224         {
 225           int ei, ej;
 226
 227           d->Drill[i].ElementMax
 228             = d->Drill[i].ElementN + d->Drill[i+1].ElementN;
 229           if (d->Drill[i].ElementMax)
 230             {
 231               d->Drill[i].Element = (ElementType **)realloc (d->Drill[i].Element,
 232                                              d->Drill[i].ElementMax *
 233                                              sizeof (ElementType *));
 234
 235               for (ei = 0; ei < d->Drill[i+1].ElementN; ei++)
 236                 {
 237                   for (ej = 0; ej < d->Drill[i].ElementN; ej++)
 238                     if (d->Drill[i].Element[ej] == d->Drill[i + 1].Element[ei])
 239                       break;
 240                   if (ej == d->Drill[i].ElementN)
 241                     d->Drill[i].Element[d->Drill[i].ElementN++]
 242                       = d->Drill[i + 1].Element[ei];
 243                 }
 244             }
 245           free (d->Drill[i + 1].Element);
 246           d->Drill[i + 1].Element = NULL;
 247
 248           d->Drill[i].PinMax = d->Drill[i].PinN + d->Drill[i + 1].PinN;
 249           d->Drill[i].Pin = (PinType **)realloc (d->Drill[i].Pin,
 250                                      d->Drill[i].PinMax *
 251                                      sizeof (PinType *));
 252           memcpy (d->Drill[i].Pin + d->Drill[i].PinN, d->Drill[i + 1].Pin,
 253                   d->Drill[i + 1].PinN * sizeof (PinType *));
 254           d->Drill[i].PinN += d->Drill[i + 1].PinN;
 255           free (d->Drill[i + 1].Pin);
 256           d->Drill[i + 1].Pin = NULL;
 257
 258           d->Drill[i].PinCount += d->Drill[i + 1].PinCount;
 259           d->Drill[i].ViaCount += d->Drill[i + 1].ViaCount;
 260           d->Drill[i].UnplatedCount += d->Drill[i + 1].UnplatedCount;
 261
 262           d->Drill[i].DrillSize = diam1;
 263
 264           memmove (d->Drill + i + 1,
 265                    d->Drill + i + 2,
 266                    (d->DrillN - i - 2) * sizeof (DrillType));
 267           d->DrillN--;
 268         }
 269       else
 270         {
 271           d->Drill[i].DrillSize = diam1;
 272           i++;
 273         }
 274     }
 275 }
 276
 277 void
 278 FreeDrillInfo (DrillInfoType *Drills)
 279 {
 280   DRILL_LOOP (Drills);
 281   {
 282     free (drill->Element);
 283     free (drill->Pin);
 284   }
 285   END_LOOP;
 286   free (Drills->Drill);
 287   free (Drills);
 288 }