#usage "<b>Export UNIDAT format</b>\n"
       "<p>"
       "<author>Author: support@cadsoft.de</author>"

// THIS PROGRAM IS PROVIDED AS IS AND WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED

///////////////////////////////////////////////////////////////////////////////////////////
// Rudi Hofer, CadSoft, rudi.hofer@cadsoft.de, 9/1999
//
// Revision 1.1: shape names derived from element names instead of package names (unique!)
// Revision 1.2: output limited to elements with package in routine "component"
// Revision 1.3: output of round pads corrected
// Revision 2.0: shape names again derived from package names (seems to be the only
//               solution which makes sense)
//
// Revision 3.0: include Crossref.ULP with Pin_Name from Sheet     -- alf@cadsoft.de
// Revision 4.0: for EAGLE Version 4.0 with Dialog                 -- alf@cadsoft.de
// Revision 5.0: exports Polygon of signals                        -- alf@cadsoft.de
//
///////////////////////////////////////////////////////////////////////////////////////////
// Since version 2.0 all packages with the same name must be identical (avoid REPLACE!)
///////////////////////////////////////////////////////////////////////////////////////////
// This ULP generates output for UNICAM software which is able to convert the
// data for automatic mounting and test equipment. The resolution is fixed to 1/100 mm.
//
// To generate the output, load the board and run this ULP.
//
// You can provide properties like "partnumber", "tolerance" etc. in the
// component library:
//
// - define a user layer named UNIDAT
// - add texts in the form "propertyname=value" to this layer, e.g.
//   partnumber=12345
//   pos_tolerance=0.05
// - see array property[] below for predefined property names
// - by changing the array contents you can change the property names
//   (do not change the number of array entries!)
//
// OUTPUT OF PROPERTIES IS ONLY POSSIBLE IF FORWARD & BACK ANNOTATION IS USED AND
// IF THE SCHEMATIC AND THE BOARD ARE LOADED!
// THE PROGRAM HAS TO BE EXECUTED FROM THE BOARD WINDOW!
//
//
// Pads of the shape type OCTAGON are changed to round, if the following variable
// is set to 1 (otherwise set to 0)

   int disp_oct_as_round = 1;
//
///////////////////////////////////////////////////////////////////////////////////////////

/* Dieses ULP erzeugt eine Cross-Referenzliste zwischen Pad und Pin ***
 * Dabei wird eine Liste generiert, in der die Koordinaten
 * der Pads/Netze im Board, in Bezug zu den Pins/Netze im
 * Schaltplan(Sheet Nr.) stehen.
 * A. Zaffran CadSoft 07.09.1999
 */

/*

%COMPONENT
C1|N$5|sheet2|15.240,8.890|mm|
C1|1|N$5|sheet2|15.240,8.890|mm|
|  | |     |       |    |
|  | |     |       X    Y
|  | |    Seite
|  | Netzname
|  Pad-Name
Bauteil

%PINS
IC1|IC1A|FILTER|1|I0|sheet1|25.40,22.86|mm|
|    |     |    |  |   |      |     |
|    |     |    |  |   |      X     Y
|    |     |    |  |   Seite
|    |     |    |  Symbolischer Pin-Name
|    |     |    Numerischer Pin-Name
|    |     Netzname
|    Gate-Name
Bauteil

*/

int   px[], py[], ps[], PinPoints = 0;  // Pin: x, y, sheet, counter
string  pa[],      pg[],      pc[],         pn[],    pnn[];
     // Part-name, gate-name, contact-name, pinname, pin-netname

int   padx[], pady[], pads[], PadPoints = 0;  // Pad: x, y, sheet, counter
string  padd[], padn[], padnn[];              // devicename, padname, pad-netname

int   sheetload = 0;
string proz = "%";
string Pad_Pin = "";

enum { bottom = 16 };

string reffile;
string unifile;

string ULPversion = filename(argv[0]);

//-----------------------------------------------------

string user_layer_name = "unidat", // layer name for property definitions (lower case!)
       jobname,
//     jobrevision = "1.0",
       layer_name[],
       property_assign_char = "=",
       property[] = {"partnumber"        // propterty[0] is partnumber and so on
                    ,"parttype"
                    ,"description"
                    ,"pos_tolerance"
                    ,"neg_tolerance"
                    ,"user1"
                    ,"user2"
                    ,"user3"
                    },
       property_value[],
       padshape[] = {"S","R","O","X","Y"},// shapes square, round, oct, xlongoct, ylongoct
       padname,
       shapename[];

real   ang2, cx, cy, rx, ry, x, y, x1, x2, y1, y2, r, a1, a2;;

int    i,
       padcount,
       pad_is_numeric,
       max_property = 7,
       new,
       sx = 0;

// --------------------------------------------------------------------

void test(void) {
  string ref;
  int nr = fileread(ref, reffile);
  string uni;
  int nu = fileread(uni, unifile);
  dlgDialog("UNIDAT File export") {
     dlgLabel("UNIDAT File: " + unifile);
     dlgTextView(uni);
     dlgLabel("Cross reference file: " + reffile);
     dlgTextView(ref);
     dlgHBoxLayout { dlgSpacing(400); }
     dlgHBoxLayout {
        dlgStretch(1);
        dlgPushButton("+&OK") dlgAccept();
        dlgStretch(1);
        }
     };


  return;
  }

void Header(string name)
  {
  printf(";This file is generated by %s from:\n", ULPversion);
  printf(";%s';\n", name);
  }

int search_Pad_Pin(string name, string pad) {
   for (int pin = 0; pin < PinPoints; pin++) {
      if (pa[pin] == name && pc[pin] == pad){
         break;
         }
      }
   if (pin == PinPoints) pin = -2;
   return pin;
   }

// --------------------------------------------------------------------

real u2u(int x) { // resolution 1/100 mm
   x = round(x * 100)/100;
   return u2mm(x);  // if mm
  }

real u2ang(real x) {
  if (x > 360)
     x = x -360;
  x = round(x * 10)/10;
  return x;
  }

//-----------------------------------------------------
void rot(real alfa, real xt, real yt) { // change if finer rotation possible
  if (alfa == 0) {
     x = xt; y = yt;
     }
  else if (alfa == 90) {
     x = yt;  y = -xt;
     }
  else if (alfa == 180) {
     x = -xt; y = -yt;
     }
  else if (alfa == 270) {
     x = -yt; y = xt;
     }
  else {
     printf ("\nERROR: Rotation of %g not allowed!!!\n\n", alfa);
     }
  x = round(x * 100)/100; y = round(y * 100)/100; // resolution 1/100 mm
  }
//-----------------------------------------------------
string padtype(UL_CONTACT C) { // name contains shape SROXY or SM for SMD
  string s;                    // diam_drill (in 1/100mm) or smdx_y in (1/100 mm)
  real pdi, pdr, sx, sy;       // e.g. SR_140_80 or SM_100_120
  if (C.pad) {
     pdi = round(u2u(C.pad.diameter[bottom]) * 100);
     pdr = round(u2u(C.pad.drill) * 100);                  // not used
     sprintf(s, "P%s_%03.0f", padshape[C.pad.shape[bottom]], pdi); // pdr could be used, too
     }
  if (C.smd) {
     sx = round(u2u(C.smd.dx) * 100);
     sy = round(u2u(C.smd.dy) * 100);
     sprintf(s, "SM_%03.0f_%03.0f", sx, sy);
     }
  return s;
  }
//-----------------------------------------------------
string viatype(UL_VIA V) {
  string s;                    // diam_drill (in 1/100mm)
  real pdi, pdr, sx, sy;       // e.g. SR_140_80 or SM_100_120
  pdi = round(u2u(V.diameter[bottom]) * 100);
  pdr = round(u2u(V.drill) * 100);                      // not used
  sprintf(s, "P%s_%03.0f", padshape[V.shape[bottom]], pdi);     // pdr could be used, too
  return s;
  }
//-----------------------------------------------------
void print_pad_shape(string s) {
  real x, y, w, wx, wy, a, b, c, d;
  string s1;
  sprintf(s1, "%s.%s", strsub(s, 3, 1), strsub(s, 4, 2));
  x = strtod(s1);
  if (strsub(s, 1, 1) == padshape[0]) { // look for padshape S|R|O|X|Y
     w = x/2;
     printf("L (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g)\n",
                 w, w,   w,-w,  -w,-w,  -w, w,   w, w);
     }
  if (strsub(s, 1, 1) == padshape[1]) {
     printf("C 0,0,%s.%s\n", strsub(s, 3, 1), strsub(s, 4, 2));
     }
  if (strsub(s, 1, 1) == padshape[2]) {
     if (!disp_oct_as_round) {
        x = x/2;
        w = x/2;
        printf("L (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g)\n",
                    w, x,   x, w,   x,-w,   w,-x,  -w,-x,  -x,-w,  -x, w,  -w, x,   w, x);
        }
     else {
        printf("C 0,0,%s.%s\n", strsub(s, 3, 1), strsub(s, 4, 2));
        }
     }
  if (strsub(s, 1, 1) == padshape[3]) { // xlong
     a = 3*x/8; b = x/2; c = x/8; d = x/4; // dimension ratio x:y = 2:1
     printf("L (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g)\n",
                 a,d, b,c, b,-c, a,-d, -a,-d, -b,-c, -b,c, -a,d, a,d);
     }
  if (strsub(s, 1, 1) == padshape[4]) { // ylong
     c = 3*x/8; d = x/2; a = x/8; b = x/4; // dimension ratio x:y = 2:1
     printf("L (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g)\n",
                 a,d, b,c, b,-c, a,-d, -a,-d, -b,-c, -b,c, -a,d, a,d);

     }
  if (strsub(s, 1, 1) == "M") {         // look for padshape M = SMD
     sprintf(s1, "%s.%s", strsub(s, 7, 1), strsub(s, 8, 2));
     y = strtod(s1);
     wx = x/2; wy = y/2;
     printf("L (%g,%g) (%g,%g) (%g,%g) (%g,%g) (%g,%g)\n",
                wx, wy,  wx,-wy,  -wx,-wy,  -wx, wy,  wx, wy);
     }
  }
//-----------------------------------------------------
void center(UL_ELEMENT E) { // returns cx, cy
  real xmin, xmax, ymin, ymax;
  xmin = u2u(E.x); xmax = xmin;
  ymin = u2u(E.y); ymax = ymin;
  E.package.wires(W){
    if (W.layer == LAYER_TPLACE || W.layer == LAYER_BPLACE) {
       xmin = min(u2u(W.x1),xmin);
       xmin = min(u2u(W.x2),xmin);
       ymin = min(u2u(W.y1),ymin);
       ymin = min(u2u(W.y2),ymin);
       xmax = max(u2u(W.x1),xmax);
       xmax = max(u2u(W.x2),xmax);
       ymax = max(u2u(W.y1),ymax);
       ymax = max(u2u(W.y2),ymax);
       }
    }
  cx = (xmin+xmax)/2; cy = (ymin+ymax)/2;
  }
//-----------------------------------------------------
string smd_info(UL_ELEMENT E) {
  E.package.contacts(C) {
    if (C.pad)
       return "THT";
    else
       return "SMD";
    }
  return "SMD"; // in case it has no electrical connection (e.g. fiducial)
  }

//---------------------------------------------------
void get_user_parameters(UL_ELEMENT E) { // assign property_values[]
  string s, pname, pvalue;
  int    pos, len;
  if (project.schematic) {
     project.schematic(S) {
       S.parts(P) {
         if (P.name == E.name) {
            P.instances(I) {
              for (i = 0; i <= max_property; i++) { // clear properties
                  property_value[i] = "";
                  }
              I.gate.symbol.texts(T) {
                if (strlwr(layer_name[T.layer]) == user_layer_name) {

                   s = T.value;
                   len = strlen(s);
                   pos = strstr(s, property_assign_char);
                   if (pos > 0) {
                      pname  = strsub(s, 0, pos);
                      pvalue = strsub(s, pos+1, len - pos);
                      i = 0;
                      while (i <= max_property) {
                        if (property[i] == strlwr(pname)) {
                           property_value[i] = pvalue;
                           }
                        i++;
                        }
                      }

                   }
                }
              }
           }
         }
       }
     }
  else { // no schematic -> no properties
     for (i = 0; i <= max_property; i++) { // clear properties
         property_value[i] = "";
         }
     }
  }
//---------------------------------------------------
string signame(string elname, string padname) {
  string s = "";
  board(B) {
    B.signals(S) {
      S.contactrefs(C) {
        if (C.element.name == elname) {
           if (C.contact.name == padname) {
              s = S.name;
              }
           }
        }
      }
    }
  return s;
  }
//////////////////////////////////////////////////////
void create_info () {
  int t = time();
  printf ("%%%%%%INFO\n");
  printf ("DATE=%02d.%02d.%02d %02d:%02d:%02d\n",
          t2day(t),t2month(t),t2year(t),t2hour(t),t2minute(t),t2second(t));
  printf ("DELIMITER=|\n");
  printf ("UNITS=MM\n");
  printf ("UNIDAT_VERSION=1.2\n");           // Unidat Software Version
  printf ("JOB_NAME=%s\n", jobname);
//printf ("JOB_REVISION=%s\n", jobrevision); // get from somewhere
  printf ("NR_OF_PCBOARDS=1\n");
  printf ("TOP_LAYER=1\n");
  printf ("BOTTOM_LAYER=16\n");
  printf ("CADSOFTWARE=EAGLE %d.%d\n", EAGLE_VERSION, EAGLE_RELEASE);
  // schematic information could be added here
  // e.g. create script file which creates a postscript schematic file
  }

//////////////////////////////////////////////////////
void outline(UL_BOARD B) {
  printf ("\n%%%%OUTLINE\n");
  printf ("%%GRAFITEM\n");
  B.wires(W) {
    if(W.curve) {
      if (W.layer == LAYER_DIMENSION) {
        printf("A %g,%g,%g,%.1f,%.1f\n",
               u2u(W.arc.xc),u2u(W.arc.yc),u2u(W.arc.radius),u2ang(W.arc.angle1),u2ang(W.arc.angle2 - W.arc.angle1));
      }
    }
    else {
      if (W.layer == LAYER_DIMENSION) {
         printf("L (%g,%g) (%g,%g)\n", u2u(W.x1), u2u(W.y1), u2u(W.x2), u2u(W.y2));
        }
      }
    }
  B.circles(C) {
    if (C.layer == LAYER_DIMENSION) {
       printf("C %g,%g,%g\n", u2u(C.x), u2u(C.y), u2u(C.radius));
      }
    }
  B.elements(E) {
    E.package.wires(W) {
      if(W.curve) {
        if (W.layer == LAYER_DIMENSION) {
          printf("A %g,%g,%g,%.1f,%.1f\n",
                 u2u(W.arc.xc),u2u(W.arc.yc),u2u(W.arc.radius),u2ang(W.arc.angle1),u2ang(W.arc.angle2 - W.arc.angle1));
        }
      }
      else {
        if (W.layer == LAYER_DIMENSION) {
           printf("L (%g,%g) (%g,%g)\n", u2u(W.x1), u2u(W.y1), u2u(W.x2), u2u(W.y2));
          }
        }
      }
    }
  printf ("%%ENDGRAFITEM\n");
  }
//////////////////////////////////////////////////////
void fiducials(UL_BOARD B) {
  printf ("\n%%%%FIDUCIALS\n");
  }
//////////////////////////////////////////////////////
void component(UL_BOARD B) {
  printf ("\n%%%%COMPONENT\n");
  B.elements(E) { // add exclusion for el. w/o package!!!
    if (E.package) {
       get_user_parameters(E);                   // get user defined prop. from spec. layer
       printf("%s|",E.name);                     // NAME
       printf("%s|",property_value[0]);          // PARTNUMBER
       printf("|");                              // PARTCODE not used
       printf("%s|",property_value[1]);          // PARTTYPE
       printf("%s|",property_value[2]);          // PARTDESCRIPTION
       printf("%s|",E.package.name);             // SHAPE (e.g. SH_IC1) // special version
       printf("%.1f|",u2ang(E.angle));           // ROTATION
       if (E.mirror)                             // ASSEMBLY SIDE
          printf("bottom|");
       else
          printf("top|");
       printf("%g|%g|",u2u(E.x), u2u(E.y));      // X,Y
       center(E);
       printf("%g|%g|",cx, cy);                  // X,Y of center point
       printf("%s|", smd_info(E));               // SMD or Through-hole
       printf("|0|");                    	          // VALUE = 0
       printf("%s|",property_value[3]);          // POS TOLERANCE
       printf("%s|",property_value[4]);          // NEG TOLERANCE
       printf("%s|",property_value[5]);          // USER1
       printf("%s|",property_value[6]);          // USER2
       printf("%s",property_value[7]);           // USER3
       printf("\n");
       }
    }
  }
//////////////////////////////////////////////////////
void other_drillings(UL_BOARD B) {
  printf ("\n%%%%OTHER_DRILLINGS\n");
  }
//////////////////////////////////////////////////////
void component_pin(UL_BOARD B) {
  printf ("\n%%%%COMPONENT_PIN\n");
  B.elements(E) {
    pad_is_numeric = 1;
    E.package.contacts(C) { // test if name numeric
      padname = C.name;
      for (i = 0; padname[i]; ++i) {
          if (!isdigit(padname[i])) {
             pad_is_numeric = 0;
             }
          }
      }
    padcount = 1;
    rx = u2u(E.x); ry = u2u(E.y);                     // origin of package
    E.package.contacts(C) {

      printf("%s|",E.name);                           // COMP. NAME

      if (pad_is_numeric) {
         printf("%s|", C.name);                       // PADNR
         }
      else {
         printf("%d|", padcount);
         padcount++;
        }
      int pin = search_Pad_Pin(E.name, C.name);
     if (sheetload) {
      if (pin < 0) {
         printf("|");                                 // Gate not placed
         }
      else {
         printf("%s|", pn[pin]);                      // PIN NAME
         }
      }
     else {
      printf("no-sheet|");
      }

      printf("%s|", signame(E.name, C.name));         // NET NAME
      x1 = u2u(C.x)-rx; y1 = u2u(C.y)-ry;
      rot(E.angle, x1, y1); // get x,y
      printf("%g|%g|", x, y);                         // REL. POSITION OF PADS
      if (C.pad) {
         printf("%s|", padtype(C));                   // PADTYPE TOP
         printf("%.1f|", u2ang(E.angle));             // PAD ORIENTATION TOP
         printf("%s|", padtype(C));                   // PADTYPE BOTTOM
         printf("%.1f", u2ang(E.angle));              // PAD ORIENTATION BOTTOM
         }
      if (C.smd) {
         if (C.smd.layer == LAYER_TOP) {
            printf("%s|", padtype(C));                // PADTYPE TOP
            printf("%.1f|", u2ang(E.angle));          // PAD ORIENTATION TOP
            printf("|");                              // BOTTOM empty
            }
         else {
            printf("||");                             // TOP empty
            printf("%s|", padtype(C));                // PADTYPE BOTTOM
            printf("%.1f", u2ang(E.angle));           // PAD ORIENTATION BOTTOM
            }
         }
      printf("\n");
      }
    }
  }
//////////////////////////////////////////////////////
void pad(UL_BOARD B) {
  string t[];
  int    i, j = 0, new;
  printf ("\n%%%%PAD\n");
  B.elements(E) {
    E.package.contacts(C) {
      new = 1;                    // padtype not generated yet
      for (i = 0; t[i]; i++) {
          if (t[i] == padtype(C))
             new = 0;             // padtype exists
          }
      if (new) {
         t[j] = padtype(C);
         j++;
         printf("PAD=%s\n", padtype(C));
         printf("%%GRAFITEM\n");
         printf("FC 9,0,0,0\n");
         print_pad_shape(padtype(C));
         printf("%%ENDGRAFITEM\n");
         }
      }
    }
  B.signals(S) {
    S.vias(V) {
      new = 1;
      for (i = 0; t[i]; i++) {
          if (t[i] == viatype(V))
             new = 0;             // padtype exists
          }
      if (new) {
         t[j] = viatype(V);
         j++;
         printf("PAD=%s\n", viatype(V));
         printf("%%GRAFITEM\n");
         printf("FC 9,0,0,0\n");
         print_pad_shape(viatype(V));
         printf("%%ENDGRAFITEM\n");
         }
      }
    }
  }
//////////////////////////////////////////////////////
void shape(UL_BOARD B) { // what if mirrored?
  sx = 0;
  printf ("\n%%%%SHAPE\n");
  B.elements(E) {
    new = 1;                    // padstacktype not generated yet
    for (i = 0; shapename[i]; i++) {
        if (shapename[i] == E.package.name)
           new = 0;             // shapename exists
        }
    if (new) {
       shapename[sx] = E.package.name;
       sx++;
       printf ("SHAPE=%s\n", E.package.name);
       printf ("%%SHAPEOUTLINE\n");
       printf ("%%GRAFITEM\n");
       rx = u2u(E.x); ry = u2u(E.y); // origin for rot function
         E.package.wires(W) {
           if (W.curve) {
             if (W.arc.layer == LAYER_TPLACE || W.arc.layer == LAYER_BPLACE) {
                  x1 = u2u(W.arc.xc)-rx; y1 = u2u(W.arc.yc)-ry;
                  rot(E.angle, x1, y1); // new coord x,y
                  printf("A %g,%g,%g,%.1f,%.1f\n",
                         x, y, u2u(W.arc.radius),u2ang(W.arc.angle1 - E.angle),u2ang(W.arc.angle2 - W.arc.angle1));
             }
           }
           else {
             if (W.layer == LAYER_TPLACE || W.layer == LAYER_BPLACE) {
                x1 = u2u(W.x1)-rx; y1 = u2u(W.y1)-ry; x2 = u2u(W.x2)-rx; y2 = u2u(W.y2)-ry;
                rot(E.angle, x1, y1); x1 = x; y1 = y;
                rot(E.angle, x2, y2); x2 = x; y2 = y;
                printf("L (%g,%g) (%g,%g)\n", x1, y1, x2, y2);
             }
           }
         }
         E.package.circles(C) {
           if (C.layer == LAYER_TPLACE || C.layer == LAYER_BPLACE) {
              x1 = u2u(C.x)-rx; y1 = u2u(C.y)-ry;
              rot(E.angle, x1, y1);
              printf("C %g,%g,%g\n", x, y, u2u(C.radius));
             }
           }
         printf ("%%ENDGRAFITEM\n");
         printf ("%%PACKAGEDIMENSION\n");
         printf ("%%PINLIST\n");
         pad_is_numeric = 1;
         E.package.contacts(C) { // test if name numeric
           padname = C.name;
           for (i = 0; padname[i]; ++i) {
               if (!isdigit(padname[i])) {
                  pad_is_numeric = 0;
                  }
               }
           }
         padcount = 1;
         E.package.contacts(C) {
           if (pad_is_numeric) {
              printf("%s|", C.name);                             // PADNR
              }
           else {
              printf("%d|", padcount);
              padcount++;
              }
           x1 = u2u(C.x)-rx; y1 = u2u(C.y)-ry;
           rot(E.angle, x1, y1); // get x,y
           printf("%g|%g|", x, y);                               // REL. POSITION OF PADS
           if (C.pad) {
              printf("%s|", padtype(C));                         // PADTYPE TOP
              printf("%.1f|", u2ang(E.angle));                   // PAD ORIENTATION TOP
              printf("%s|", padtype(C));                         // PADTYPE BOTTOM
              printf("%.1f", u2ang(E.angle));                    // PAD ORIENTATION BOTTOM
              }
           if (C.smd) {
              if (C.smd.layer == LAYER_TOP) {
                 printf("%s|", padtype(C));                      // PADTYPE TOP
                 printf("%.1f|", u2ang(E.angle));                // PAD ORIENTATION TOP
                 printf("|");                                    // BOTTOM empty
                 }
              else {
                 printf("||");                                   // TOP empty
                 printf("%s|", padtype(C));                      // PADTYPE BOTTOM
                 printf("%.1f", u2ang(E.angle));                 // PAD ORIENTATION BOTTOM
                 }
              }
           printf("\n");
         }
       }
    }
  }
//////////////////////////////////////////////////////
void via(UL_BOARD B) {
  int i;
  printf("\n%%%%VIA\n");
  B.signals(S) {
    S.vias(V) {
      i++;
      printf("VIA%d|%s|%g|%g|1|16|%s|0|%s|0|Y|Y\n",
             i, S.name, u2u(V.x), u2u(V.y), viatype(V), viatype(V));
      }
    }
  }
//////////////////////////////////////////////////////
void track(UL_BOARD B) {
  printf("\n%%%%TRACK\n");
  B.signals(S) {
    printf("NET=%s\n", S.name);
    printf("%%GRAFITEM\n");
    S.wires(W) {
      printf("N %d\n", W.layer);
      printf("W %g\n", u2u(W.width));
      printf("FC 0,0,0,0\n");
      printf("L (%g,%g) (%g,%g)\n", u2u(W.x1), u2u(W.y1), u2u(W.x2), u2u(W.y2));
      }
    S.polygons(POL) {
      POL.contours(W) {
        printf("N %d\n", W.layer);
        printf("W %g\n", u2u(W.width));
        printf("FC 0,0,0,0\n");
        printf("L (%g,%g) (%g,%g)\n", u2u(W.x1), u2u(W.y1), u2u(W.x2), u2u(W.y2));
        }
      POL.fillings(W) {
        printf("N %d\n", W.layer);
        printf("W %g\n", u2u(W.width));
        printf("FC 0,0,0,0\n");
        printf("L (%g,%g) (%g,%g)\n", u2u(W.x1), u2u(W.y1), u2u(W.x2), u2u(W.y2));
        }
      }

    printf("%%ENDGRAFITEM\n");
    }
  }
//////////////////////////////////////////////////////
void create_pcboard_section(UL_BOARD B) {
//  printf ("\n%%%%%%PCBOARDIdentifier\n");
  outline(B);
//panelstructure();
  fiducials(B);
  component(B);
  other_drillings(B);
  component_pin(B);
//subcomponent();
//testpad();
  pad(B);
  shape(B);
  via(B);
  track(B);
//summary();
  }
//////////////////////////////////////////////////////

//main
// *** Board coord. ***
if (board) board(B) {
   reffile = filesetext(B.name, ".ref");
   output(reffile, "wt") {
     Header(B.name);
     printf("%sCOMPONENT\n", proz);

     // *** collect all pads ***
   B.elements(E) {
     E.package.contacts(C) {
       if (C.pad) {
          padx[PadPoints] = C.pad.x;
          pady[PadPoints] = C.pad.y;
          padd[PadPoints] = E.name;
          padn[PadPoints] = C.name;
          padnn[PadPoints] = "*nc*";      // *** default not connected ***
          PadPoints++;
          }
       }
     }

     B.signals(S) {
         // *** if pad connected to net ***
       S.contactrefs(C) {
         for (int pad = 0; pad < PadPoints; pad++) {
             if (padx[pad] == C.contact.x && pady[pad] == C.contact.y) {
                padnn[pad] = S.name;       // *** connectad to net-name ***
                                           // default *nc* = not connected
                break;
                }
             }
         }
       }

     // **** Sheet coord. ****
     if (project.schematic) {
        sheetload = 1;
        project.schematic(S) {

       // *** collect all Pins ***
       S.sheets(SH) {
         SH.parts(PA) {                           // *** IC1   ***

           int gate = 0;
           PA.device.gates(G) {
             gate++;
             }
           int dir = 5;                           // Dirction PWR
           int Pinn = 0;                          // Pin counter for Gate
           PA.instances(IN) {                     // *** IC1A  ***
             IN.gate.symbol.pins(P) {

               if (P.contact) {
                  if (P.direction != 5) {         // only PWR-Pins in Gate ?
                     dir = P.direction;
                     }
                  pc[PinPoints] = P.contact.name;        // PAD name von Connect/Pad
                  px[PinPoints] = P.x;
                  py[PinPoints] = P.y;
                  ps[PinPoints] = IN.sheet;              // SHEET#
                  pa[PinPoints] = PA.name;               // PART name
                  pg[PinPoints] = IN.name;               // Part+GATE name
                  pn[PinPoints] = P.name;                // PIN name
                  PinPoints++;
                  Pinn ++;
                  }
               else {
                  gate = 0;        // Reset Gate counter - Supply Symbol has no Gates
                  // pc[PinPoints] = " no pac.";             // kein Pad-Name nur Symbol!!
                  }
               }
             }
           if (PinPoints > 0) {
             switch (gate) {
               case 2 : if (dir == 5) {
                           // Gate-Name wird angezeigt
                           break;
                           }
                         if (dir != 5) {
                           pg[PinPoints -1] = pa[PinPoints - 1];  // Gatename wird nicht angezeigt
                           break;
                           }
               case 1 :  for (int gp = 0; gp < Pinn; gp++) {
                            pg[PinPoints - gp -1] = "";               // clear all Pin-Gate-name
                            }

               case 0 :  // printf("no Gates (Supply?) =%d\n", gate);

               }
             }
           }
         }
       }

     // *** print all Pad ccord.
     for (int pad = 0; pad < PadPoints; pad++) {
        for (int p = 0; p < PinPoints; p++) {
          if (padd[pad] == pa[p] && padn[pad] == pc[p]) {
             pads[pad] = ps[p];                        // copy Sheet# to Pad
             pnn[p] = padnn[pad];                      // Signal name to Pin
             }
          }
        printf("%s|%s|%s|sheet%d|", padd[pad], padn[pad], padnn[pad], pads[pad]);
        printf("%.3f,%.3f|mm|\n", u2mm(padx[pad]), u2mm(pady[pad]));
        }

     // ***  %PINS ***
     printf("%sPINS\n", proz);

     // *** print all Pin sheet/coord. ***
     for (int pin = 0; pin < PinPoints; pin++) {
        printf("%s|%s|%s|%s|%s|sheet%d|%.2f,%.2f|mm|\n",
        pa[pin], pg[pin], pnn[pin], pc[pin], pn[pin], ps[pin], u2mm(px[pin]), u2mm(py[pin]));
        }
     }
   else {
     dlgMessageBox("Please load Schematic first! No data generated!", "OK");
     exit (-1);
     }
   }
 }

 if (board) board(B) {
    jobname = filename(B.name);
    jobname = strsub(jobname, 0, strlen(jobname) - 4);
    unifile = filesetext(B.name, ".uni");
    output(unifile, "wt") {
       create_info();
       create_pcboard_section(B);
       }
    test();
    exit (0);
    }

 else {
  dlgMessageBox("<qt>Start <b>" + ULPversion + "</b> from a <b>Board</b></qt>", "OK");
  exit (-2);
  }