src/report.c

   1 /*
   2  *                            COPYRIGHT
   3  *
   4  *  PCB, interactive printed circuit board design
   5  *  Copyright (C) 1994,1995,1996,1997,1998,1999 Thomas Nau
   6  *
   7  *  This module, report.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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  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 <math.h>
  35
  36 #include "report.h"
  37 #include "crosshair.h"
  38 #include "data.h"
  39 #include "drill.h"
  40 #include "error.h"
  41 #include "search.h"
  42 #include "misc.h"
  43 #include "mymem.h"
  44 #include "rats.h"
  45 #include "rtree.h"
  46 #include "strflags.h"
  47 #include "macro.h"
  48 #include "undo.h"
  49 #include "find.h"
  50 #include "draw.h"
  51 #include "pcb-printf.h"
  52 #ifdef HAVE_REGEX_H
  53 #include <regex.h>
  54 #endif
  55
  56 #ifdef HAVE_REGCOMP
  57 #undef HAVE_RE_COMP
  58 #endif
  59
  60 #if defined(HAVE_REGCOMP) || defined(HAVE_RE_COMP)
  61 #define USE_RE
  62 #endif
  63
  64 #ifdef HAVE_LIBDMALLOC
  65 #include <dmalloc.h>
  66 #endif
  67
  68 #define USER_UNITMASK (Settings.grid_unit->allow)
  69
  70 static int
  71 ReportDrills (int argc, char **argv, Coord x, Coord y)
  72 {
  73   DrillInfoType *AllDrills;
  74   Cardinal n;
  75   char *stringlist, *thestring;
  76   int total_drills = 0;
  77
  78   AllDrills = GetDrillInfo (PCB->Data);
  79   RoundDrillInfo (AllDrills, 100);
  80
  81   for (n = 0; n < AllDrills->DrillN; n++)
  82     {
  83       total_drills += AllDrills->Drill[n].PinCount;
  84       total_drills += AllDrills->Drill[n].ViaCount;
  85       total_drills += AllDrills->Drill[n].UnplatedCount;
  86     }
  87
  88   stringlist = (char *)malloc (512L + AllDrills->DrillN * 64L);
  89
  90   /* Use tabs for formatting since can't count on a fixed font anymore.
  91      |  And even that probably isn't going to work in all cases.
  92    */
  93   sprintf (stringlist,
  94            "There are %d different drill sizes used in this layout, %d holes total\n\n"
  95            "Drill Diam. (%s)\t# of Pins\t# of Vias\t# of Elements\t# Unplated\n",
  96            AllDrills->DrillN, total_drills, Settings.grid_unit->suffix);
  97   thestring = stringlist;
  98   while (*thestring != '\0')
  99     thestring++;
 100   for (n = 0; n < AllDrills->DrillN; n++)
 101     {
 102       pcb_sprintf (thestring,
 103                "%10m*\t\t%d\t\t%d\t\t%d\t\t%d\n",
 104                Settings.grid_unit->suffix,
 105                AllDrills->Drill[n].DrillSize,
 106                AllDrills->Drill[n].PinCount, AllDrills->Drill[n].ViaCount,
 107                AllDrills->Drill[n].ElementN,
 108                AllDrills->Drill[n].UnplatedCount);
 109       while (*thestring != '\0')
 110         thestring++;
 111     }
 112   FreeDrillInfo (AllDrills);
 113   /* create dialog box */
 114   gui->report_dialog ("Drill Report", stringlist);
 115
 116   free (stringlist);
 117   return 0;
 118 }
 119
 120
 121 static const char reportdialog_syntax[] = "ReportDialog()";
 122
 123 static const char reportdialog_help[] =
 124   "Report on the object under the crosshair";
 125
 126 /* %start-doc actions ReportDialog
 127
 128 This is a shortcut for @code{Report(Object)}.
 129
 130 %end-doc */
 131
 132 static int
 133 ReportDialog (int argc, char **argv, Coord x, Coord y)
 134 {
 135   void *ptr1, *ptr2, *ptr3;
 136   int type;
 137   char report[2048];
 138
 139   type = SearchScreen (x, y, REPORT_TYPES, &ptr1, &ptr2, &ptr3);
 140   if (type == NO_TYPE)
 141     type =
 142       SearchScreen (x, y, REPORT_TYPES | LOCKED_TYPE, &ptr1, &ptr2, &ptr3);
 143
 144   switch (type)
 145     {
 146     case VIA_TYPE:
 147       {
 148         PinType *via;
 149 #ifndef NDEBUG
 150         if (gui->shift_is_pressed ())
 151           {
 152             __r_dump_tree (PCB->Data->via_tree->root, 0);
 153             return 0;
 154           }
 155 #endif
 156         via = (PinType *) ptr2;
 157         if (TEST_FLAG (HOLEFLAG, via))
 158           pcb_sprintf (&report[0], "%m+VIA ID# %ld; Flags:%s\n"
 159                    "(X,Y) = %$mD.\n"
 160                    "It is a pure hole of diameter %$mS.\n"
 161                    "Name = \"%s\"."
 162                    "%s", USER_UNITMASK, via->ID, flags_to_string (via->Flags, VIA_TYPE),
 163                    via->X, via->Y, via->DrillingHole, EMPTY (via->Name),
 164                    TEST_FLAG (LOCKFLAG, via) ? "It is LOCKED.\n" : "");
 165         else
 166           pcb_sprintf (&report[0], "%m+VIA ID# %ld;  Flags:%s\n"
 167                    "(X,Y) = %$mD.\n"
 168                    "Copper width = %$mS. Drill width = %$mS.\n"
 169                    "Clearance width in polygons = %$mS.\n"
 170                    "Annulus = %$mS.\n"
 171                    "Solder mask hole = %$mS (gap = %$mS).\n"
 172                    "Name = \"%s\"."
 173                    "%s", USER_UNITMASK, via->ID, flags_to_string (via->Flags, VIA_TYPE),
 174                    via->X, via->Y,
 175                    via->Thickness,
 176                    via->DrillingHole,
 177                    via->Clearance / 2,
 178                    (via->Thickness - via->DrillingHole) / 2,
 179                    via->Mask,
 180                    (via->Mask - via->Thickness) / 2,
 181                    EMPTY (via->Name), TEST_FLAG (LOCKFLAG, via) ?
 182                    "It is LOCKED.\n" : "");
 183         break;
 184       }
 185     case PIN_TYPE:
 186       {
 187         PinType *Pin;
 188         ElementType *element;
 189 #ifndef NDEBUG
 190         if (gui->shift_is_pressed ())
 191           {
 192             __r_dump_tree (PCB->Data->pin_tree->root, 0);
 193             return 0;
 194           }
 195 #endif
 196         Pin = (PinType *) ptr2;
 197         element = (ElementType *) ptr1;
 198
 199         PIN_LOOP (element);
 200         {
 201           if (pin == Pin)
 202             break;
 203         }
 204         END_LOOP;
 205         if (TEST_FLAG (HOLEFLAG, Pin))
 206           pcb_sprintf (&report[0], "%m+PIN ID# %ld; Flags:%s\n"
 207                    "(X,Y) = %$mD.\n"
 208                    "It is a mounting hole. Drill width = %$mS.\n"
 209                    "It is owned by element %$mS.\n"
 210                    "%s", USER_UNITMASK, Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
 211                    Pin->X, Pin->Y, Pin->DrillingHole,
 212                    EMPTY (element->Name[1].TextString),
 213                    TEST_FLAG (LOCKFLAG, Pin) ? "It is LOCKED.\n" : "");
 214         else
 215           pcb_sprintf (&report[0],
 216                    "%m+PIN ID# %ld;  Flags:%s\n" "(X,Y) = %$mD.\n"
 217                    "Copper width = %$mS. Drill width = %$mS.\n"
 218                    "Clearance width to Polygon = %$mS.\n"
 219                    "Annulus = %$mS.\n"
 220                    "Solder mask hole = %$mS (gap = %$mS).\n"
 221                    "Name = \"%s\".\n"
 222                    "It is owned by element %s\n as pin number %s.\n"
 223                    "%s", USER_UNITMASK,
 224                    Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
 225                    Pin->X, Pin->Y, Pin->Thickness,
 226                    Pin->DrillingHole,
 227                    Pin->Clearance / 2,
 228                    (Pin->Thickness - Pin->DrillingHole) / 2,
 229                    Pin->Mask,
 230                    (Pin->Mask - Pin->Thickness) / 2,
 231                    EMPTY (Pin->Name),
 232                    EMPTY (element->Name[1].TextString), EMPTY (Pin->Number),
 233                    TEST_FLAG (LOCKFLAG, Pin) ? "It is LOCKED.\n" : "");
 234         break;
 235       }
 236     case LINE_TYPE:
 237       {
 238         LineType *line;
 239 #ifndef NDEBUG
 240         if (gui->shift_is_pressed ())
 241           {
 242             LayerType *layer = (LayerType *) ptr1;
 243             __r_dump_tree (layer->line_tree->root, 0);
 244             return 0;
 245           }
 246 #endif
 247         line = (LineType *) ptr2;
 248         pcb_sprintf (&report[0], "%m+LINE ID# %ld;  Flags:%s\n"
 249                  "FirstPoint(X,Y)  = %$mD, ID = %ld.\n"
 250                  "SecondPoint(X,Y) = %$mD, ID = %ld.\n"
 251                  "Width = %$mS.\nClearance width in polygons = %$mS.\n"
 252                  "It is on layer %d\n"
 253                  "and has name \"%s\".\n"
 254                  "%s", USER_UNITMASK,
 255                  line->ID, flags_to_string (line->Flags, LINE_TYPE),
 256                  line->Point1.X, line->Point1.Y, line->Point1.ID,
 257                  line->Point2.X, line->Point2.Y, line->Point2.ID,
 258                  line->Thickness, line->Clearance / 2,
 259                  GetLayerNumber (PCB->Data, (LayerType *) ptr1),
 260                  UNKNOWN (line->Number),
 261                  TEST_FLAG (LOCKFLAG, line) ? "It is LOCKED.\n" : "");
 262         break;
 263       }
 264     case RATLINE_TYPE:
 265       {
 266         RatType *line;
 267 #ifndef NDEBUG
 268         if (gui->shift_is_pressed ())
 269           {
 270             __r_dump_tree (PCB->Data->rat_tree->root, 0);
 271             return 0;
 272           }
 273 #endif
 274         line = (RatType *) ptr2;
 275         pcb_sprintf (&report[0], "%m+RAT-LINE ID# %ld;  Flags:%s\n"
 276                  "FirstPoint(X,Y)  = %$mD; ID = %ld; "
 277                  "connects to layer group %d.\n"
 278                  "SecondPoint(X,Y) = %$mD; ID = %ld; "
 279                  "connects to layer group %d.\n",
 280                  USER_UNITMASK, line->ID, flags_to_string (line->Flags, LINE_TYPE),
 281                  line->Point1.X, line->Point1.Y,
 282                  line->Point1.ID, line->group1,
 283                  line->Point2.X, line->Point2.Y,
 284                  line->Point2.ID, line->group2);
 285         break;
 286       }
 287     case ARC_TYPE:
 288       {
 289         ArcType *Arc;
 290         BoxType *box;
 291 #ifndef NDEBUG
 292         if (gui->shift_is_pressed ())
 293           {
 294             LayerType *layer = (LayerType *) ptr1;
 295             __r_dump_tree (layer->arc_tree->root, 0);
 296             return 0;
 297           }
 298 #endif
 299         Arc = (ArcType *) ptr2;
 300         box = GetArcEnds (Arc);
 301
 302         pcb_sprintf (&report[0], "%m+ARC ID# %ld;  Flags:%s\n"
 303                  "CenterPoint(X,Y) = %$mD.\n"
 304                  "Radius = %$mS, Thickness = %$mS.\n"
 305                  "Clearance width in polygons = %$mS.\n"
 306                  "StartAngle = %ma degrees, DeltaAngle = %ma degrees.\n"
 307                  "Bounding Box is %$mD, %$mD.\n"
 308                  "That makes the end points at %$mD and %$mD.\n"
 309                  "It is on layer %d.\n"
 310                  "%s", USER_UNITMASK, Arc->ID, flags_to_string (Arc->Flags, ARC_TYPE),
 311                  Arc->X, Arc->Y,
 312                  Arc->Width, Arc->Thickness,
 313                  Arc->Clearance / 2, Arc->StartAngle, Arc->Delta,
 314                  Arc->BoundingBox.X1, Arc->BoundingBox.Y1,
 315                  Arc->BoundingBox.X2, Arc->BoundingBox.Y2,
 316                  box->X1, box->Y1,
 317                  box->X2, box->Y2,
 318                  GetLayerNumber (PCB->Data, (LayerType *) ptr1),
 319                  TEST_FLAG (LOCKFLAG, Arc) ? "It is LOCKED.\n" : "");
 320         break;
 321       }
 322     case POLYGON_TYPE:
 323       {
 324         PolygonType *Polygon;
 325 #ifndef NDEBUG
 326         if (gui->shift_is_pressed ())
 327           {
 328             LayerType *layer = (LayerType *) ptr1;
 329             __r_dump_tree (layer->polygon_tree->root, 0);
 330             return 0;
 331           }
 332 #endif
 333         Polygon = (PolygonType *) ptr2;
 334
 335         pcb_sprintf (&report[0], "%m+POLYGON ID# %ld;  Flags:%s\n"
 336                  "Its bounding box is %$mD %$mD.\n"
 337                  "It has %d points and could store %d more\n"
 338                  "  without using more memory.\n"
 339                  "It has %d holes and resides on layer %d.\n"
 340                  "%s", USER_UNITMASK, Polygon->ID,
 341                  flags_to_string (Polygon->Flags, POLYGON_TYPE),
 342                  Polygon->BoundingBox.X1, Polygon->BoundingBox.Y1,
 343                  Polygon->BoundingBox.X2, Polygon->BoundingBox.Y2,
 344                  Polygon->PointN, Polygon->PointMax - Polygon->PointN,
 345                  Polygon->HoleIndexN,
 346                  GetLayerNumber (PCB->Data, (LayerType *) ptr1),
 347                  TEST_FLAG (LOCKFLAG, Polygon) ? "It is LOCKED.\n" : "");
 348         break;
 349       }
 350     case PAD_TYPE:
 351       {
 352         Coord len;
 353         PadType *Pad;
 354         ElementType *element;
 355 #ifndef NDEBUG
 356         if (gui->shift_is_pressed ())
 357           {
 358             __r_dump_tree (PCB->Data->pad_tree->root, 0);
 359             return 0;
 360           }
 361 #endif
 362         Pad = (PadType *) ptr2;
 363         element = (ElementType *) ptr1;
 364
 365         PAD_LOOP (element);
 366         {
 367           {
 368             if (pad == Pad)
 369               break;
 370           }
 371         }
 372         END_LOOP;
 373         len = Distance (Pad->Point1.X, Pad->Point1.Y, Pad->Point2.X, Pad->Point2.Y);
 374         pcb_sprintf (&report[0], "%m+PAD ID# %ld;  Flags:%s\n"
 375                  "FirstPoint(X,Y)  = %$mD; ID = %ld.\n"
 376                  "SecondPoint(X,Y) = %$mD; ID = %ld.\n"
 377                  "Width = %$mS.  Length = %$mS.\n"
 378                  "Clearance width in polygons = %$mS.\n"
 379                  "Solder mask = %$mS x %$mS (gap = %$mS).\n"
 380                  "Name = \"%s\".\n"
 381                  "It is owned by SMD element %s\n"
 382                  "  as pin number %s and is on the %s\n"
 383                  "side of the board.\n"
 384                  "%s", USER_UNITMASK, Pad->ID,
 385                  flags_to_string (Pad->Flags, PAD_TYPE),
 386                  Pad->Point1.X, Pad->Point1.Y, Pad->Point1.ID,
 387                  Pad->Point2.X, Pad->Point2.Y, Pad->Point2.ID,
 388                  Pad->Thickness, len + Pad->Thickness,
 389                  Pad->Clearance / 2,
 390                  Pad->Mask, len + Pad->Mask,
 391                  (Pad->Mask - Pad->Thickness) / 2,
 392                  EMPTY (Pad->Name),
 393                  EMPTY (element->Name[1].TextString),
 394                  EMPTY (Pad->Number),
 395                  TEST_FLAG (ONSOLDERFLAG,
 396                             Pad) ? "solder (bottom)" : "component",
 397                  TEST_FLAG (LOCKFLAG, Pad) ? "It is LOCKED.\n" : "");
 398         break;
 399       }
 400     case ELEMENT_TYPE:
 401       {
 402         ElementType *element;
 403 #ifndef NDEBUG
 404         if (gui->shift_is_pressed ())
 405           {
 406             __r_dump_tree (PCB->Data->element_tree->root, 0);
 407             return 0;
 408           }
 409 #endif
 410         element = (ElementType *) ptr2;
 411         pcb_sprintf (&report[0], "%m+ELEMENT ID# %ld;  Flags:%s\n"
 412                  "BoundingBox %$mD %$mD.\n"
 413                  "Descriptive Name \"%s\".\n"
 414                  "Name on board \"%s\".\n"
 415                  "Part number name \"%s\".\n"
 416                  "It is %$mS tall and is located at (X,Y) = %$mD %s.\n"
 417                  "Mark located at point (X,Y) = %$mD.\n"
 418                  "It is on the %s side of the board.\n"
 419                  "%s", USER_UNITMASK,
 420                  element->ID, flags_to_string (element->Flags, ELEMENT_TYPE),
 421                  element->BoundingBox.X1, element->BoundingBox.Y1,
 422                  element->BoundingBox.X2, element->BoundingBox.Y2,
 423                  EMPTY (element->Name[0].TextString),
 424                  EMPTY (element->Name[1].TextString),
 425                  EMPTY (element->Name[2].TextString),
 426                  SCALE_TEXT (FONT_CAPHEIGHT, element->Name[1].Scale),
 427                  element->Name[1].X, element->Name[1].Y,
 428                  TEST_FLAG (HIDENAMEFLAG, element) ? ",\n  but it's hidden" : "",
 429                  element->MarkX, element->MarkY,
 430                  TEST_FLAG (ONSOLDERFLAG, element) ? "solder (bottom)" : "component",
 431                  TEST_FLAG (LOCKFLAG, element) ? "It is LOCKED.\n" : "");
 432         break;
 433       }
 434     case TEXT_TYPE:
 435 #ifndef NDEBUG
 436       if (gui->shift_is_pressed ())
 437         {
 438           LayerType *layer = (LayerType *) ptr1;
 439           __r_dump_tree (layer->text_tree->root, 0);
 440           return 0;
 441         }
 442 #endif
 443     case ELEMENTNAME_TYPE:
 444       {
 445         char laynum[32];
 446         TextType *text;
 447 #ifndef NDEBUG
 448         if (gui->shift_is_pressed ())
 449           {
 450             __r_dump_tree (PCB->Data->name_tree[NAME_INDEX (PCB)]->root, 0);
 451             return 0;
 452           }
 453 #endif
 454         text = (TextType *) ptr2;
 455
 456         if (type == TEXT_TYPE)
 457           sprintf (laynum, "It is on layer %d.",
 458                    GetLayerNumber (PCB->Data, (LayerType *) ptr1));
 459         pcb_sprintf (&report[0], "%m+TEXT ID# %ld;  Flags:%s\n"
 460                  "Located at (X,Y) = %$mD.\n"
 461                  "Characters are %$mS tall.\n"
 462                  "Value is \"%s\".\n"
 463                  "Direction is %d.\n"
 464                  "The bounding box is %$mD %$mD.\n"
 465                  "%s\n"
 466                  "%s", USER_UNITMASK, text->ID, flags_to_string (text->Flags, TEXT_TYPE),
 467                  text->X, text->Y, SCALE_TEXT (FONT_CAPHEIGHT, text->Scale),
 468                  text->TextString, text->Direction,
 469                  text->BoundingBox.X1, text->BoundingBox.Y1,
 470                  text->BoundingBox.X2, text->BoundingBox.Y2,
 471                  (type == TEXT_TYPE) ? laynum : "It is an element name.",
 472                  TEST_FLAG (LOCKFLAG, text) ? "It is LOCKED.\n" : "");
 473         break;
 474       }
 475     case LINEPOINT_TYPE:
 476     case POLYGONPOINT_TYPE:
 477       {
 478         PointType *point = (PointType *) ptr2;
 479         pcb_sprintf (&report[0], "%m+POINT ID# %ld.\n"
 480                  "Located at (X,Y) = %$mD.\n"
 481                  "It belongs to a %s on layer %d.\n", USER_UNITMASK, point->ID,
 482                  point->X, point->Y,
 483                  (type == LINEPOINT_TYPE) ? "line" : "polygon",
 484                  GetLayerNumber (PCB->Data, (LayerType *) ptr1));
 485         break;
 486       }
 487     case NO_TYPE:
 488       report[0] = '\0';
 489       break;
 490
 491     default:
 492       sprintf (&report[0], "Unknown\n");
 493       break;
 494     }
 495
 496   if (report[0] == '\0')
 497     {
 498       Message (_("Nothing found to report on\n"));
 499       return 1;
 500     }
 501   /* create dialog box */
 502   gui->report_dialog ("Report", &report[0]);
 503
 504   return 0;
 505 }
 506
 507 static int
 508 ReportFoundPins (int argc, char **argv, Coord x, Coord y)
 509 {
 510   static DynamicStringType list;
 511   char temp[64];
 512   int col = 0;
 513
 514   DSClearString (&list);
 515   DSAddString (&list, "The following pins/pads are FOUND:\n");
 516   ELEMENT_LOOP (PCB->Data);
 517   {
 518     PIN_LOOP (element);
 519     {
 520       if (TEST_FLAG (FOUNDFLAG, pin))
 521         {
 522           sprintf (temp, "%s-%s,%c",
 523                    NAMEONPCB_NAME (element),
 524                    pin->Number,
 525                    ((col++ % (COLUMNS + 1)) == COLUMNS) ? '\n' : ' ');
 526           DSAddString (&list, temp);
 527         }
 528     }
 529     END_LOOP;
 530     PAD_LOOP (element);
 531     {
 532       if (TEST_FLAG (FOUNDFLAG, pad))
 533         {
 534           sprintf (temp, "%s-%s,%c",
 535                    NAMEONPCB_NAME (element), pad->Number,
 536                    ((col++ % (COLUMNS + 1)) == COLUMNS) ? '\n' : ' ');
 537           DSAddString (&list, temp);
 538         }
 539     }
 540     END_LOOP;
 541   }
 542   END_LOOP;
 543
 544   gui->report_dialog ("Report", list.Data);
 545   return 0;
 546 }
 547
 548 /* Assumes that we start with a blank connection state,
 549  * e.g. ClearFlagOnAllObjects() has been run.
 550  * Does not add its own changes to the undo system
 551  */
 552 static double
 553 XYtoNetLength (Coord x, Coord y, int *found)
 554 {
 555   double length;
 556
 557   length = 0;
 558   *found = 0;
 559
 560   /* NB: The third argument here, 'false' ensures LookupConnection
 561    *     does not add its changes to the undo system.
 562    */
 563   LookupConnection (x, y, false, PCB->Grid, FOUNDFLAG, true);
 564
 565   ALLLINE_LOOP (PCB->Data);
 566   {
 567     if (TEST_FLAG (FOUNDFLAG, line))
 568       {
 569         double l;
 570         int dx, dy;
 571         dx = line->Point1.X - line->Point2.X;
 572         dy = line->Point1.Y - line->Point2.Y;
 573         l = sqrt ((double)dx*dx + (double)dy*dy);
 574         length += l;
 575         *found = 1;
 576       }
 577   }
 578   ENDALL_LOOP;
 579
 580   ALLARC_LOOP (PCB->Data);
 581   {
 582     if (TEST_FLAG (FOUNDFLAG, arc))
 583       {
 584         double l;
 585         /* FIXME: we assume width==height here */
 586         l = M_PI * 2*arc->Width * abs(arc->Delta)/360.0;
 587         length += l;
 588         *found = 1;
 589       }
 590   }
 591   ENDALL_LOOP;
 592
 593   return length;
 594 }
 595
 596 static int
 597 ReportAllNetLengths (int argc, char **argv, Coord x, Coord y)
 598 {
 599   int ni;
 600   int found;
 601
 602   /* Reset all connection flags and save an undo-state to get back
 603    * to the state the board was in when we started this function.
 604    *
 605    * After this, we don't add any changes to the undo system, but
 606    * ensure we get back to a point where we can Undo() our changes
 607    * by resetting the connections with ClearFlagOnAllObjects() before
 608    * calling Undo() at the end of the procedure.
 609    */
 610   ClearFlagOnAllObjects (true, FOUNDFLAG);
 611   IncrementUndoSerialNumber ();
 612
 613   for (ni = 0; ni < PCB->NetlistLib.MenuN; ni++)
 614     {
 615       char *netname = PCB->NetlistLib.Menu[ni].Name + 2;
 616       char *ename = PCB->NetlistLib.Menu[ni].Entry[0].ListEntry;
 617       char *pname;
 618       bool got_one = 0;
 619
 620       ename = strdup (ename);
 621       pname = strchr (ename, '-');
 622       if (! pname)
 623         {
 624           free (ename);
 625           continue;
 626         }
 627       *pname++ = 0;
 628
 629       ELEMENT_LOOP (PCB->Data);
 630       {
 631         char *es = element->Name[NAMEONPCB_INDEX].TextString;
 632         if (es && strcmp (es, ename) == 0)
 633           {
 634             PIN_LOOP (element);
 635             {
 636               if (strcmp (pin->Number, pname) == 0)
 637                 {
 638                   x = pin->X;
 639                   y = pin->Y;
 640                   got_one = 1;
 641                   break;
 642                 }
 643             }
 644             END_LOOP;
 645             PAD_LOOP (element);
 646             {
 647               if (strcmp (pad->Number, pname) == 0)
 648                 {
 649                   x = (pad->Point1.X + pad->Point2.X) / 2;
 650                   y = (pad->Point1.Y + pad->Point2.Y) / 2;
 651                   got_one = 1;
 652                   break;
 653                 }
 654             }
 655             END_LOOP;
 656           }
 657       }
 658       END_LOOP;
 659
 660       if (got_one)
 661         {
 662           char buf[50];
 663           const char *units_name = argv[0];
 664           Coord length;
 665
 666           if (argc < 1)
 667             units_name = Settings.grid_unit->suffix;
 668
 669           length = XYtoNetLength (x, y, &found);
 670
 671           /* Reset connectors for the next lookup */
 672           ClearFlagOnAllObjects (false, FOUNDFLAG);
 673
 674           pcb_sprintf(buf, "%$m*", units_name, length);
 675           gui->log("Net %s length %s\n", netname, buf);
 676         }
 677     }
 678
 679   ClearFlagOnAllObjects (false, FOUNDFLAG);
 680   Undo (true);
 681   return 0;
 682 }
 683
 684 static int
 685 ReportNetLength (int argc, char **argv, Coord x, Coord y)
 686 {
 687   Coord length = 0;
 688   char *netname = 0;
 689   int found = 0;
 690
 691   gui->get_coords ("Click on a connection", &x, &y);
 692
 693   /* Reset all connection flags and save an undo-state to get back
 694    * to the state the board was in when we started this function.
 695    *
 696    * After this, we don't add any changes to the undo system, but
 697    * ensure we get back to a point where we can Undo() our changes
 698    * by resetting the connections with ClearFlagOnAllObjects() before
 699    * calling Undo() at the end of the procedure.
 700    */
 701   ClearFlagOnAllObjects (true, FOUNDFLAG);
 702   IncrementUndoSerialNumber ();
 703
 704   length = XYtoNetLength (x, y, &found);
 705
 706   if (!found)
 707     {
 708       ClearFlagOnAllObjects (false, FOUNDFLAG);
 709       Undo (true);
 710       gui->log ("No net under cursor.\n");
 711       return 1;
 712     }
 713
 714   ELEMENT_LOOP (PCB->Data);
 715   {
 716     PIN_LOOP (element);
 717     {
 718       if (TEST_FLAG (FOUNDFLAG, pin))
 719         {
 720           int ni, nei;
 721           char *ename = element->Name[NAMEONPCB_INDEX].TextString;
 722           char *pname = pin->Number;
 723           char *n;
 724
 725           if (ename && pname)
 726             {
 727               n = Concat (ename, "-", pname, NULL);
 728               for (ni = 0; ni < PCB->NetlistLib.MenuN; ni++)
 729                 for (nei = 0; nei < PCB->NetlistLib.Menu[ni].EntryN; nei++)
 730                   {
 731                     if (strcmp (PCB->NetlistLib.Menu[ni].Entry[nei].ListEntry, n) == 0)
 732                       {
 733                         netname = PCB->NetlistLib.Menu[ni].Name + 2;
 734                         goto got_net_name; /* four for loops deep */
 735                       }
 736                   }
 737             }
 738         }
 739     }
 740     END_LOOP;
 741     PAD_LOOP (element);
 742     {
 743       if (TEST_FLAG (FOUNDFLAG, pad))
 744         {
 745           int ni, nei;
 746           char *ename = element->Name[NAMEONPCB_INDEX].TextString;
 747           char *pname = pad->Number;
 748           char *n;
 749
 750           if (ename && pname)
 751             {
 752               n = Concat (ename, "-", pname, NULL);
 753               for (ni = 0; ni < PCB->NetlistLib.MenuN; ni++)
 754                 for (nei = 0; nei < PCB->NetlistLib.Menu[ni].EntryN; nei++)
 755                   {
 756                     if (strcmp (PCB->NetlistLib.Menu[ni].Entry[nei].ListEntry, n) == 0)
 757                       {
 758                         netname = PCB->NetlistLib.Menu[ni].Name + 2;
 759                         goto got_net_name; /* four for loops deep */
 760                       }
 761                   }
 762             }
 763         }
 764     }
 765     END_LOOP;
 766   }
 767   END_LOOP;
 768
 769 got_net_name:
 770   ClearFlagOnAllObjects (false, FOUNDFLAG);
 771   Undo (true);
 772
 773   {
 774     char buf[50];
 775     pcb_sprintf(buf, "%$m*", Settings.grid_unit->suffix, length);
 776     if (netname)
 777       gui->log ("Net \"%s\" length: %s\n", netname, buf);
 778     else
 779       gui->log ("Net length: %s\n", buf);
 780   }
 781
 782   return 0;
 783 }
 784
 785 static int
 786 ReportNetLengthByName (char *tofind, int x, int y)
 787 {
 788   int result;
 789   char *netname = 0;
 790   Coord length = 0;
 791   int found = 0;
 792   int i;
 793   LibraryMenuType *net;
 794   ConnectionType conn;
 795   int net_found = 0;
 796 #if defined(USE_RE)
 797   int use_re = 0;
 798 #endif
 799 #if defined(HAVE_REGCOMP)
 800   regex_t elt_pattern;
 801   regmatch_t match;
 802 #endif
 803 #if defined(HAVE_RE_COMP)
 804   char *elt_pattern;
 805 #endif
 806
 807   if (!PCB)
 808     return 1;
 809
 810   if (!tofind)
 811     return 1;
 812
 813 #if defined(USE_RE)
 814       use_re = 1;
 815       for (i = 0; i < PCB->NetlistLib.MenuN; i++)
 816         {
 817           net = PCB->NetlistLib.Menu + i;
 818           if (strcasecmp (tofind, net->Name + 2) == 0)
 819             use_re = 0;
 820         }
 821       if (use_re)
 822         {
 823 #if defined(HAVE_REGCOMP)
 824           result =
 825             regcomp (&elt_pattern, tofind,
 826                      REG_EXTENDED | REG_ICASE | REG_NOSUB);
 827           if (result)
 828             {
 829               char errorstring[128];
 830
 831               regerror (result, &elt_pattern, errorstring, 128);
 832               Message (_("regexp error: %s\n"), errorstring);
 833               regfree (&elt_pattern);
 834               return (1);
 835             }
 836 #endif
 837 #if defined(HAVE_RE_COMP)
 838           if ((elt_pattern = re_comp (tofind)) != NULL)
 839             {
 840               Message (_("re_comp error: %s\n"), elt_pattern);
 841               return (1);
 842             }
 843 #endif
 844         }
 845 #endif
 846
 847   for (i = 0; i < PCB->NetlistLib.MenuN; i++)
 848     {
 849       net = PCB->NetlistLib.Menu + i;
 850
 851 #if defined(USE_RE)
 852           if (use_re)
 853             {
 854 #if defined(HAVE_REGCOMP)
 855               if (regexec (&elt_pattern, net->Name + 2, 1, &match, 0) != 0)
 856                 continue;
 857 #endif
 858 #if defined(HAVE_RE_COMP)
 859               if (re_exec (net->Name + 2) != 1)
 860                 continue;
 861 #endif
 862             }
 863           else
 864 #endif
 865           if (strcasecmp (net->Name + 2, tofind))
 866             continue;
 867
 868         if (SeekPad (net->Entry, &conn, false))
 869         {
 870           switch (conn.type)
 871           {
 872             case PIN_TYPE:
 873               x = ((PinType *) (conn.ptr2))->X;
 874               y = ((PinType *) (conn.ptr2))->Y;
 875               net_found=1;
 876               break;
 877             case PAD_TYPE:
 878               x = ((PadType *) (conn.ptr2))->Point1.X;
 879               y = ((PadType *) (conn.ptr2))->Point1.Y;
 880               net_found=1;
 881               break;
 882           }
 883           if (net_found)
 884             break;
 885         }
 886     }
 887
 888   if (!net_found)
 889     {
 890       gui->log ("No net named %s\n", tofind);
 891       return 1;
 892     }
 893
 894 #ifdef HAVE_REGCOMP
 895   if (use_re)
 896     regfree (&elt_pattern);
 897 #endif
 898
 899   /* Reset all connection flags and save an undo-state to get back
 900    * to the state the board was in when we started.
 901    *
 902    * After this, we don't add any changes to the undo system, but
 903    * ensure we get back to a point where we can Undo() our changes
 904    * by resetting the connections with ClearFlagOnAllObjects() before
 905    * calling Undo() when we are finished.
 906    */
 907   ClearFlagOnAllObjects (true, FOUNDFLAG);
 908   IncrementUndoSerialNumber ();
 909
 910   length = XYtoNetLength (x, y, &found);
 911   netname = net->Name + 2;
 912
 913   ClearFlagOnAllObjects (false, FOUNDFLAG);
 914   Undo (true);
 915
 916   if (!found)
 917     {
 918       if (net_found)
 919         gui->log ("Net found, but no lines or arcs were flagged.\n");
 920       else
 921         gui->log ("Net not found.\n");
 922
 923       return 1;
 924     }
 925
 926   {
 927     char buf[50];
 928     pcb_sprintf(buf, "%$m*", Settings.grid_unit->suffix, length);
 929     if (netname)
 930       gui->log ("Net \"%s\" length: %s\n", netname, buf);
 931     else
 932       gui->log ("Net length: %s\n", buf);
 933   }
 934
 935   return 0;
 936 }
 937
 938 /* ---------------------------------------------------------------------------
 939  * reports on an object
 940  * syntax:
 941  */
 942
 943 static const char report_syntax[] = "Report(Object|DrillReport|FoundPins|NetLength|AllNetLengths|[,name])";
 944
 945 static const char report_help[] = "Produce various report.";
 946
 947 /* %start-doc actions Report
 948
 949 @table @code
 950
 951 @item Object
 952 The object under the crosshair will be reported, describing various
 953 aspects of the object.
 954
 955 @item DrillReport
 956 A report summarizing the number of drill sizes used, and how many of
 957 each, will be produced.
 958
 959 @item FoundPins
 960 A report listing all pins and pads which are marked as ``found'' will
 961 be produced.
 962
 963 @item NetLength
 964 The name and length of the net under the crosshair will be reported to
 965 the message log.
 966
 967 @item AllNetLengths
 968 The name and length of the net under the crosshair will be reported to
 969 the message log.  An optional parameter specifies mm, mil, pcb, or in
 970 units
 971
 972 @end table
 973
 974 %end-doc */
 975
 976 static int
 977 Report (int argc, char **argv, Coord x, Coord y)
 978 {
 979   if ((argc < 1) || (argc > 2))
 980     AUSAGE (report);
 981   else if (strcasecmp (argv[0], "Object") == 0)
 982     {
 983       gui->get_coords ("Click on an object", &x, &y);
 984       return ReportDialog (argc - 1, argv + 1, x, y);
 985     }
 986   else if (strcasecmp (argv[0], "DrillReport") == 0)
 987     return ReportDrills (argc - 1, argv + 1, x, y);
 988   else if (strcasecmp (argv[0], "FoundPins") == 0)
 989     return ReportFoundPins (argc - 1, argv + 1, x, y);
 990   else if ((strcasecmp (argv[0], "NetLength") == 0) && (argc == 1))
 991     return ReportNetLength (argc - 1, argv + 1, x, y);
 992   else if (strcasecmp (argv[0], "AllNetLengths") == 0)
 993     return ReportAllNetLengths (argc - 1, argv + 1, x, y);
 994   else if ((strcasecmp (argv[0], "NetLength") == 0) && (argc == 2))
 995     return ReportNetLengthByName (argv[1], x, y);
 996   else if (argc == 2)
 997     AUSAGE (report);
 998   else
 999     AFAIL (report);
1000   return 1;
1001 }
1002
1003 HID_Action report_action_list[] = {
1004   {"ReportObject", "Click on an object", ReportDialog,
1005    reportdialog_help, reportdialog_syntax}
1006   ,
1007   {"Report", 0, Report,
1008    report_help, report_syntax}
1009 };
1010
1011 REGISTER_ACTIONS (report_action_list)