eagle4-1.ulp

use this script, you can make ealge file to protel file

/*
 *  EAGLE-UserLanguageProgram konvertiert ein board
 *  oder/und ein schematic in eine TARGETText-Datei.
 *
 *  IBF Dezember 2003 , Version 1.8, f黵 Eagle 4.1 !
 */

//Einstellungen fuer die Konvertierung_________________________________________

enum { NEIN, JA};

int BoardUndSchematic = JA; //(JA) Das zum Board/Schematic zugehoerige
                            //Schematic/Board wird ebenfalls konvertiert.
                            //(NEIN) Nur das Board/Schematic wird konvertiert.

int auto = 0;

//TargetKonstanten____________________________________________________________

//Boolean
enum { FALSE, TRUE};

//Farben
enum { TARGET_SCHWARZ, TARGET_DBLAU, TARGET_DGRUEN, TARGET_DCYAN,
       TARGET_DROT, TARGET_DMAGENTA, TARGET_BRAUN, TARGET_HGRAU, TARGET_DGRAU,
       TARGET_HBLAU, TARGET_HGRUEN, TARGET_HCYAN, TARGET_HROT,
       TARGET_HMAGENTA, TARGET_GELB, TARGET_WEISS};

//EbenenFunktionen
enum { TARGET_EF_KUPFERUNTEN, TARGET_EF_KUPFERINNEN, TARGET_EF_KUPFEROBEN,
       TARGET_EF_BESTUECKUNGUNTEN, TARGET_EF_BESTUECKUNGOBEN,
       TARGET_EF_LOESCHUNTEN, TARGET_EF_LOESCHINNEN, TARGET_EF_LOESCHOBEN,
       TARGET_EF_FLAECHEUNTEN, TARGET_EF_FLAECHEINNEN, TARGET_EF_FLAECHEOBEN,
       TARGET_EF_LOETSTOPUNTEN, TARGET_EF_LOETSTOPOBEN, TARGET_EF_BOHRLOECHER,
       TARGET_EF_LOETPASTEUNTEN, TARGET_EF_LOETPASTEOBEN, TARGET_EF_GOLDUNTEN,
       TARGET_EF_GOLDOBEN, TARGET_EF_KLEBERUNTEN, TARGET_EF_KLEBEROBEN,
       TARGET_EF_BEMASSUNG, TARGET_EF_UMRISS, TARGET_EF_FRAESEN,
       TARGET_EF_LOETPUNKTNUMMERN, TARGET_EF_SONSTIGE, TARGET_EF_LUFTLINIE,
       TARGET_EF_FEHLER}; 

//TextFunktionen
enum { TARGET_TF_NORMAL, TARGET_TF_BAUTEIL, TARGET_TF_WERT, TARGET_TF_SYMBOL,
       TARGET_TF_SIGNAL, TARGET_TF_ANSCHLUSS, TARGET_TF_BAUART, 
       TARGET_TF_ARTIKELNUMMER, TARGET_TF_HERSTELLER_LIEFERANT, 
       TARGET_TF_BESTELLNUMMER, TARGET_TF_EKPREIS}; 

//Einf乬emodus bei Symbolen
enum { TARGET_EFG_NEXT, TARGET_EFG_MUST, TARGET_EFG_REQUEST};

// AnschlussFunktionen
enum { TARGET_AF_NC, TARGET_AF_INPUT, TARGET_AF_OUTPUT, TARGET_AF_IO,
       TARGET_AF_OC, TARGET_AF_POWER, TARGET_AF_PASSIV, TARGET_AF_TRISTATE,
       TARGET_AF_SUP};  

//TargetVariablen, initialisieren mit SetEagleVorlage()_______________________

int NurPlatine;
int TargetEbeneFarbe[];
int TargetEbeneBezug[];
int TargetEbeneFunktion[];

//Eagle2TargetFunktionen______________________________________________________

//Einem Eaglelayer wird eine g乶stige Ebene in Target zugeordnet.

int EL2TL(int EagleEbene)
{
  switch (EagleEbene) {
    case LAYER_TOP : return 16; break;
    case 2 : return 10; break;
    case 3 : return 13; break;
    case 4 : return 13; break;
    case 5 : return 13; break;
    case 6 : return 13; break;
    case 7 : return 13; break;
    case 8 : return 13; break;
    case 9 : return 13; break;
    case 10 : return 13; break;
    case 11 : return 13; break;
    case 12 : return 13; break;
    case 13 : return 13; break;
    case 14 : return 13; break;
    case 15 : return 13; break;
    case LAYER_BOTTOM : return 2; break;
    case LAYER_PADS: return 100; break;
    case LAYER_VIAS: return 100; break;
    case LAYER_UNROUTED: return 27; break;
    case LAYER_DIMENSION: return 23; break;
    case LAYER_TPLACE: return 21; break;
    case LAYER_BPLACE: return 7; break;
    case LAYER_TDOCU: return 21; break;
    case LAYER_BDOCU: return 7; break;
    case LAYER_TORIGINS: return 21; break;
    case LAYER_BORIGINS: return 7; break;
    case LAYER_TNAMES: return 21; break;
    case LAYER_BNAMES: return 7; break;
    case LAYER_TVALUES: return 21; break;
    case LAYER_BVALUES: return 7; break;
    case LAYER_TSTOP: return 18; break;
    case LAYER_BSTOP: return 4; break;
    case LAYER_TCREAM: return 19; break;
    case LAYER_BCREAM: return 5; break;
    case LAYER_TFINISH: return 17; break;
    case LAYER_BFINISH: return 3; break;
    case LAYER_TGLUE: return 20; break;
    case LAYER_BGLUE: return 6; break;
    case LAYER_TTEST: return 21; break;
    case LAYER_BTEST: return 7; break;
    case LAYER_TKEEPOUT: return 21; break;
    case LAYER_BKEEPOUT: return 7; break;
    case LAYER_TRESTRICT: return 21; break;
    case LAYER_BRESTRICT: return 7; break;
    case LAYER_VRESTRICT: return 100; break;
    case LAYER_DRILLS: return 100; break;
    case LAYER_HOLES: return 24; break;
    case LAYER_MILLING: return 25; break;
    case LAYER_MEASURES: return 22; break;
    case LAYER_DOCUMENT: return 22; break;
    case LAYER_REFERENCE: return 23; break;
    case LAYER_NETS: return 91; break;
    case LAYER_BUSSES: return 92; break;
    case LAYER_PINS: return 93; break;
    case LAYER_SYMBOLS: return 94; break;
    case LAYER_NAMES: return 95; break;
    case LAYER_VALUES: return 96; break;
    case LAYER_USER: return 28; break;
    default: return 100;
  } 
}

//Diese Funktion wird fuer Texte in Target benoetigt.
//In Target koennen Sie jedem Text eine TextFunktion zuordnen.
//Die "Funktion" eines Textes ist in Eagle aus dem Layer ersichtlich.

int TextFunktion(int EagleEbene)
{
  switch (EagleEbene) {
    case LAYER_TOP : return TARGET_TF_NORMAL; break;
    case LAYER_BOTTOM : return TARGET_TF_NORMAL; break;
    case LAYER_DIMENSION: return TARGET_TF_NORMAL; break;
    case LAYER_TPLACE: return TARGET_TF_BAUTEIL; break;
    case LAYER_BPLACE: return TARGET_TF_BAUTEIL; break;
    case LAYER_TDOCU: return TARGET_TF_BAUTEIL; break;
    case LAYER_BDOCU: return TARGET_TF_BAUTEIL; break;
    case LAYER_TNAMES: return TARGET_TF_BAUTEIL; break;
    case LAYER_BNAMES: return TARGET_TF_BAUTEIL; break;
    case LAYER_TVALUES: return TARGET_TF_WERT; break;
    case LAYER_BVALUES: return TARGET_TF_WERT; break;
    case LAYER_TTEST: return TARGET_TF_NORMAL; break;
    case LAYER_BTEST: return TARGET_TF_NORMAL; break;
    case LAYER_MEASURES: return TARGET_TF_NORMAL; break;
    case LAYER_DOCUMENT: return TARGET_TF_NORMAL; break;
    case LAYER_REFERENCE: return TARGET_TF_NORMAL; break;
    case 96: return TARGET_TF_WERT; break; // SchaltplanWerte
    default: return TARGET_TF_NORMAL;
  }
}

//Diese Funktion wird fuer (Loet-)Punkte in Target benoetigt.
//Konvertiert ein EaglePadForm in eine entsprechende TargetPunktForm.

int PunktForm(int EPF) // EaglePadForm to TargetPunktForm
{
  switch (EPF) {
    case PAD_SHAPE_SQUARE: return 2; break;
    case PAD_SHAPE_ROUND: return 0; break;
    case PAD_SHAPE_OCTAGON: return 1; break;
    //case PAD_SHAPE_XLONGOCT: return 1; break;
    //case PAD_SHAPE_YLONGOCT: return 1; break;
    default: return 0;
  }
}

//In Eagle gibt es lediglich vier festgelegte PinLaengen.
//Target benoetigt die AnschlussLaenge in Mikrometer.

int AnschlussLaenge(int EPL) // EaglePinLength
{
  switch (EPL) {
    case PIN_LENGTH_POINT: return 1; break;
    case PIN_LENGTH_SHORT: return 2540; break; //0.1 inch
    case PIN_LENGTH_MIDDLE: return 2540*2; break;
    case PIN_LENGTH_LONG: return 2540*3; break;
  }
}

//EinfuegeModus (AddLevel) fuer Symbole
//In Target gibt es nur Must, Next und Request 

int EinfuegeModus(int AddLevel)
{
  switch (AddLevel) {
    case GATE_ADDLEVEL_MUST: return TARGET_EFG_MUST; break;
    case GATE_ADDLEVEL_CAN: return TARGET_EFG_NEXT; break;
    case GATE_ADDLEVEL_NEXT: return TARGET_EFG_NEXT; break;
    case GATE_ADDLEVEL_REQUEST: return TARGET_EFG_REQUEST; break;
    case GATE_ADDLEVEL_ALWAYS: return TARGET_EFG_MUST; break;
  }
}

//Funktion der Anschluesse

int AnschlussFunktion(int Direction)
{
  switch (Direction) {
    case PIN_DIRECTION_NC: return TARGET_AF_NC; break;
    case PIN_DIRECTION_IN: return TARGET_AF_INPUT; break;
    case PIN_DIRECTION_OUT: return TARGET_AF_OUTPUT; break;
    case PIN_DIRECTION_IO: return TARGET_AF_IO; break;
    case PIN_DIRECTION_OC: return TARGET_AF_OC; break;
    case PIN_DIRECTION_PWR: return TARGET_AF_POWER; break;
    case PIN_DIRECTION_PAS: return TARGET_AF_PASSIV; break;
    case PIN_DIRECTION_HIZ: return TARGET_AF_TRISTATE; break;
    case PIN_DIRECTION_SUP: return TARGET_AF_SUP; break;
  }
}

//Anschluss mit Inverter

int InverterPunkt(int Function)
{
  if (Function == PIN_FUNCTION_FLAG_DOT) {
    return TRUE;
  }
  else return FALSE;
} 

//Anschluss mit Clock

int Taktpfeil(int Function)
{
  if (Function == PIN_FUNCTION_FLAG_CLK) {
    return TRUE;
  }
  else return FALSE;
} 

//TargetFunktionen____________________________________________________________

int TEFarbe(int TargetEbene) // Standard TargetEbenenFarben
{
  if (TargetEbene < 28) return TargetEbeneFarbe[TargetEbene];
  else return TARGET_DGRUEN;
}

int TEBezug(int TargetEbene) // Standard TargetEbenenBezug
{
  if (TargetEbene < 28) return TargetEbeneBezug[TargetEbene];
  else return 255;
}

int TEFunktion(int TargetEbene) // Standard TargetEbenenFunktion
{
  if (TargetEbene < 28) return TargetEbeneFunktion[TargetEbene];
  else return TARGET_EF_SONSTIGE;
}

//Tools_______________________________________________________________________

int rx,ry;
void rotate(real x0,real y0,real x,real y,real grad)
{
  real rad=2*PI*grad/360;
  x-=x0;
  y-=y0;
  rx=round(x0+cos(rad)*x-sin(rad)*y);
  ry=round(y0+sin(rad)*x+cos(rad)*y);
}

int DrehungUm180(real W2, real W1)
{
  if (W1 == 0 && W2 == 180 || W1 == 90 && W2 == 270 || W1 == 180 && W2 == 0
    || W1 == 180 && W2 == 360 || W1 == 270 && W2 == 90) {
    return TRUE;
  } 
  else return FALSE;
}

int GetLeftX(UL_TEXT T, real SymbolWinkel)
{
  int lx = T.x;
  int TextBreite = int(T.size * 0.7 * strlen(T.value));
  if (T.mirror)  {
    if (SymbolWinkel == 0) {
      lx-=TextBreite;
    }
    else if (SymbolWinkel == 90) {
      lx-=T.size;
    }
    else if (SymbolWinkel == 180) {
      lx+=TextBreite;
    }
    else if (SymbolWinkel == 270) {
      lx+=T.size;
    }
  }
  if (DrehungUm180(T.angle, SymbolWinkel)) {
    if (SymbolWinkel == 0) {
      lx-=TextBreite;
    }
    else if (SymbolWinkel == 90) {
      lx+=T.size;
    }
    else if (SymbolWinkel == 180) {
      lx+=TextBreite;
    }
    else if (SymbolWinkel == 270) {
      lx-=T.size;
    }
  }
  return lx;
}

real GetTextWinkel(real TextWinkel)
{
  if (TextWinkel == 0) {
    return 0;
  }
  else if (TextWinkel == 90) {
    return 90;
  }
  else if (TextWinkel == 180) {
    return 0;
  }
  else if (TextWinkel == 270) {
    return 90;
  }
  else return TextWinkel;
}

int GetLeftY(UL_TEXT T, real SymbolWinkel)
{
  int ly = T.y;
  int TextBreite = int(T.size * 0.7 * strlen(T.value));
  if (DrehungUm180(T.angle, SymbolWinkel)) {
    if (SymbolWinkel == 0) {
      ly-=T.size;
    }
    else if (SymbolWinkel == 90) {
      ly-=TextBreite;
    }
    else if (SymbolWinkel == 180) {
      ly+=T.size;
    }
    else if (SymbolWinkel == 270) {
      ly+=TextBreite;
    }
  }
  return ly;
}

int IstZahl(string Text)
{
  for (int i = 0; Text[i] && isdigit(Text[i]); ++i); 
  return (i == strlen(Text));
}

string GetPraefix(string BauteilName)
{
  for (int i = 0; BauteilName[i] && !isdigit(BauteilName[i]); ++i); 
  return strsub(BauteilName, 0, i);
}

string GetOrdnungsNr(string BauteilName)
{
  for (int i = 0; BauteilName[i] && !isdigit(BauteilName[i]); ++i); 
  for (int j = i; BauteilName[j] && isdigit(BauteilName[j]); ++j); 
  return strsub(BauteilName, i, j-i);
}

string GetSuffix(string BauteilName)
{
  for (int i = 0; BauteilName[i] && !isdigit(BauteilName[i]); ++i); 
  for (int j = i; BauteilName[j] && isdigit(BauteilName[j]); ++j); 
  for (int k = j; BauteilName[k] && !isdigit(BauteilName[k]); ++k); 
  return strsub(BauteilName, j, k-j);
}

int BauteilInPlatine(string name)
{
  int gefunden=FALSE;
  if (project.board) project.board(B) {
    B.elements(E) {
      if ((E.name == name)&&(!gefunden)) gefunden=TRUE;
    }
  }
  if (gefunden) return TRUE;
  else return FALSE;
}


int GetBauteilNr(string name)
{
  int BauteilNr=0;
  int gefunden=FALSE;
  if (project.board) project.board(B) {
    B.elements(E) {
      if (!gefunden) BauteilNr++;
      if ((E.name == name)&&(!gefunden)) gefunden=TRUE;
    }
  }
  if (project.schematic && !gefunden) project.schematic(Sch) {
    Sch.sheets(S) {    
      S.parts(P) {
        if (!gefunden) BauteilNr++;
        if ((P.name == name)&&(!gefunden)) gefunden=TRUE;
      }
    }
  }
  if (gefunden) return BauteilNr;
  else return 0;
}

int GetSignalNr(string name)
{
  int SignalNr=0;
  int gefunden=FALSE;
  if (project.board) project.board(B) {
    B.signals(S) {
      if (!gefunden) SignalNr++;
      if (S.name == name && !gefunden) gefunden=TRUE;
    }
  }
  else {
    schematic(sch) {
      sch.nets(N) {
        if (!gefunden) SignalNr++;
        if (N.name == name && !gefunden) gefunden=TRUE;
      }
    }
  }
  if (gefunden) return SignalNr;
  else return 0;
}

string GetSignalName(UL_PIN P)
{
  string name;
  if (schematic) schematic(sch) {
    sch.nets(n) {
      n.pinrefs(ref) {
        if (ref.pin.name == P.name) {
          name= n.name;
        }
      }
    }
  }
  return name;
}

int GetSymbolNr(UL_PART P, string name)
{
  int SymbolNr=0;
  int gefunden=FALSE;
  P.instances(I) {
    if (!gefunden) SymbolNr++;
    if (I.name == name && !gefunden) gefunden=TRUE;
  }
  if (gefunden) return SymbolNr;
  else return 0;
}

int GetPinNr(UL_PIN P)
{
  int PinNr=0;
  string strPin;
  P.texts(T) {
    strPin=T.value;
    for (int i = 0; strPin[i] && isdigit(strPin[i]); ++i); 
    if (i == strlen(T.value)) {
      PinNr = strtol(T.value);
    }
  }
  return PinNr;
}

/*
int GetAnschlussNr(string SymbolName,string AnschlussName)
{
  int AnschlussNr=0;
  int gefunden=FALSE;
  if (project.board) project.board(B) {
    B.elements(E) {
      if (E.name == SymbolName) {
        AnschlussNr=0;
        E.package.contacts(C) { 
          if (!gefunden) AnschlussNr++;
          if (C.name == AnschlussName && !gefunden) gefunden=TRUE;
        }