There’s a lot of ways to burn up your time when designing PCBs, but renaming components can be one of the most frustrating. [Joe Pinzone] wrote in with his solution to the problem. Instead of hunting for each part on the schematic to change them one at a time, he makes a list of the substitutions and then uses a script to make all the changes in the XML files. He didn’t publish a post about his work, but you’ll find the source code he wrote embedded after the break.

The straw that finally broke the camel’s back was a project that included about two hundred components which didn’t seem to have a naming order that made any sense with the actual values of the components. The script is written in C++ (for Windows but [Joe] says this should be easily ported to other systems as well). To use it he creates a CSV file with the current component names in the first column. He then goes through and types what he wants for the new name in the second column. This CSV, along with the BRD and SCH files are then given as inputs for the script (through selecting them all and dragging to the script or as CLI arguments) and it automatically makes the changes.

Of course this is only possible because Cadsoft transitioned to using XML files in Eagle 6.

/*
  Title: EagleCAD XML Batch Component Renamer
  Author: Joe Pinzone, Newbury Ohio
  License: Free ("beer"), with acknowledgement of original author
  Date: January, 2013

  Description:
    * Designed to use a CSV to perform batch renaming of EagleCAD schematic/board components
    * Works only on new Eagle XML format schematic and board files

  To generate CSV file with original component name list:
    * Simply drag ONLY your SCH file or BRD onto the EXE. partsList.csv is automatically generated from that file.

  To perform batch renaming:
    * Generate a CSV with original part names in first column, and replacement names in the second
    * Click and drag your SCH, BRD, and CSV file onto the EXE (use multi-select)
    * ^Alternatively, enter in the file paths as arguments from the command prompt

  Notes:
     * If the entry in the second column of the CSV row (replacement name) is blank, that entry will be skipped,
         and the component will retain it's original name
     * To prevent accidental replacement of identical character strings within the XML file, the program
          looks for the specific XML tags that correspond to component names. Edit the list in the
          "Handy things you can modify" section if Eagle changes things, or if you want to play around.
     * You can only load ONE schematic and ONE board file at a time.
     * You can only have 1000 entries in the CSV file. All others are ignored.
        However, you can increase this by setting the value of #define MAX_CSV_ROWS in the source file.
        I didn't want to take up too much memory unnecessarily, and 1000 is plenty for most people.
     * Live long and prosper
*/

#include <cstring>
#include <string>
#include <iostream>
#include <fstream>

using namespace std;

// Handy things you can modify -----------------------------------------------------------------------------------

   /*
       Path and file name to use when generating a name list
   */
   #define MAX_CSV_ROWS 1000 // change this to allow more entries in the CSV find/replace file if necessary.
                             // The program fails nicely, though - it just ignores entries after row 1000.

   char* partsListGenFile = "./partsList.csv";       // the directory and name of the generated parts list CSV file (if no find/replace CSV file is specified)

   /*
     This is the list of XML entries/tags that contain component names after them (from both SCH and BRD Eagle XML files)
     This list is used to make sure that ONLY component names are modified, and coincidental string matches
        elsewhere in the XML aren't accidentally changed. It happened once to me. It wasn't fun. True story.

     Add/remove tags to this list if Eagle changes their standard, or you decide to adapt this for some other purpose.

     The value of 'numTags' should match the number of elements in the 'xmlTags' array below - make sure they match if you change something!
   */
   int numTags = 5;
   string xmlTags[] = { "part name", \
                        "instance part", \
                        "pinref part", \
                        "element name", \
                        "contactref element" \
                      };

   /*
      When generating the CSV list, we only want one copy of each component name.
      The <part name> XML entries in the schematic files, or the <element name> XML entries in the board files
         only contain one entry per part, so we use those as the lookup strings when generating the CSV.
   */
   string schemXMLTag_part = "part name";
   string boardXMLTag_part = "element name";

// (Global) Variable Declarations  -------------------------------------------------------------------------------

	bool schemFound = false;       // used by parseArguments, marks if schematic file was found in the files loaded
	bool boardFound = false;       // used by parseArguments, marks if board file was found in the files loaded
	bool listFound = false;        // used by parseArguments, marks if find/replace csv file was found in the files loaded

	char* path_schem;              // the file path (full or relative) of the schematic file
	char* path_board;              // the file path (full or relative) of the board file
	char* path_list ;              // the file path (full or relative) of the csv find/replace list

	string list[1000][2];          // The storage array for the find/replace list. FIND string is element 0, REPLACE string is element 1
	int listLength = 0;            // number of populated entries in the list array above (set by the loadList function's return value)

// Function Prototypes	-------------------------------------------------------------------------------------------

	int parseArguments(int argc, char* args[]);    // loads the program arguments (file paths of schematic/board/csv files)

	int processFile(char* XMLFilePath);            // assuming that 'list' is populated, goes line-by-line through specified file and replaces component names
	string processLine(string original);           // used by processFile to process an individual line of text
	string processPart(string original);           // used by processLine to change the part name based on the find/replace list

	int loadList(char* listFilePath);              // parses/loads the list file into memory (into the 'list' array)
	void generateList(char* XMLPath, char* outPath, string xmlReferenceTag); // generates a new CSV component name list from the specified SCH or BRD file

// Program --------------------------------------------------------------------------------------------------------

int main(int argc, char* args[]){

    cout << "EagleCAD XML Batch Component Renamer...\n\n";
    if(!parseArguments(argc, args)) { system("pause"); return 0;} // parse program arguments, pause and close on error

    if(listFound == false){ // if no list was specified, assume that we should generate a parts list instead of doing find/replace
         if(schemFound == true){ generateList(path_schem, partsListGenFile, schemXMLTag_part);} // if schematic file is available, generate the list from that
         else if (boardFound == true){ generateList(path_board, partsListGenFile, boardXMLTag_part);} // if schematic file is not available, generate from board file
    }
    else if (listFound == true){ // if the user specified a find/replace list, do the find/replace
         listLength = loadList(path_list);
         if(schemFound == true){ cout << "Changed <" << processFile(path_schem) << "> lines in schematic.\n"; }
         if(boardFound == true){ cout << "Changed <" << processFile(path_board) << "> lines on board.\n"; }
    }
    cout << endl;
    system("pause");
    return 0;
}

int parseArguments(int argc, char* args[]){
    /*
         Load the file paths from the program arguments into memory
    */
    for(int index = 1; index < argc; index++){
            string buffer = args[index];
            if(buffer.find(".sch") != -1){
                if(schemFound == false){
                    path_schem = args[index];
                    schemFound = true;
                }
                 else{
                      cout << "You may only load ONE schematic file.\n\n";
                      return 0;
                 }
            }

            else if(buffer.find(".brd") != -1){
                 if(boardFound == false){
                     path_board = args[index];
                     boardFound = true;
                 }
                 else{
                      cout << "You may only load ONE board file.\n\n";
                      return 0;
                 }
            }

            else if(buffer.find(".csv") != -1){
                 if(listFound == false){
                     path_list = args[index];
                     listFound = true;
                 }
                 else{
                      cout << "You may only load ONE CSV file.\n\n";
                      return 0;
                 }
            }

            else{
                 cout << "Unknown file: " <<  buffer << endl << endl;
                 return 0;
            }
    }
    if(schemFound == false && boardFound == false){
         cout << "You must specify a schematic (SCH) or board (BRD) file.\n\n";
         return 0;
    }

	return 1;
}

int processFile(char* XMLFilePath){

     ifstream source; // pointer to source file
     ofstream dest;   // pointer to destination file
     int modifiedLines = 0;

     string newPath = XMLFilePath;
     newPath += ".new";

     source.open(XMLFilePath); // i.e. file.sch
     dest.open(newPath.c_str()); // i.e. file.sch.new

     string buffer = "";

     while(!source.eof()){
          getline(source, buffer);
          string temp = processLine(buffer);
          dest << temp << endl;
          if(temp != buffer){ modifiedLines++;}

     }

     source.close();
     dest.close();

     return modifiedLines;
}

string processLine(string original){

    /*
      Things to look for in a schematic file
    */
    string beginning = "";
    string end = "";
    string partName = "";

    for(int tagNum = 0; tagNum < numTags; tagNum++){
        if(original.find("<"+xmlTags[tagNum]+"=\"") != -1){     // look for lines that contain the part names
            beginning = "<"+xmlTags[tagNum]+"=\"";              // this is technically always the same, but I want to be explicit
            break; // shouldn't need this if the line contains only one valid XML tag
        }
    }

    // if there is a name to replace, replace it. Otherwise, return the original string
    if(beginning != ""){ // 'beginning' will still be empty ("") if there isn't a valid tag to be processed
        end = original.substr(beginning.length(),original.length()); // remove the beginning, whatever it may be
        partName = end.substr(0,end.find("\""));                  // clear out the trailing XML, leaving just the name
        end = end.substr(end.find("\""),end.length());               // clear the part name from the 'end'
        return beginning + processPart(partName) + end;              // return the new line with replaced part name
    }
    // we only get here if there was nothing to replace in the 'if' block above
    return original;
}

string processPart(string original){
       for(int index = 0; index < listLength; index++){
           if(original == list[index][0] && list[index][1] != ""){ // don't process lines with no replacement
                return list[index][1];
           }
       }
       return original;
}

int loadList(char* listFilePath){

     ifstream source;
     source.open(listFilePath);
     string buffer = "";
     int entryCount = 0;

     while(!source.eof() && entryCount < MAX_CSV_ROWS){
         buffer = "";
         getline(source, buffer);
         list[entryCount][0] = buffer.substr(0,buffer.find(","));
         list[entryCount][1] = buffer.substr(buffer.find(",")+1,buffer.length());
         entryCount++;

     }

     source.close();
     return entryCount;
}

void generateList(char* XMLPath, char* outPath, string xmlReferenceTag){
     cout << "Generating components list from: \n" << XMLPath << endl << endl;
     ifstream source;
     ofstream dest;

     source.open(XMLPath);
     dest.open(outPath);

     string buffer = "";
     string XMLPretext = "<"+xmlReferenceTag+"=\""; // gotta add the extra characters to look for an actual tag
     int elementCount = 0;
     int lineCount = 0;
     while(!source.eof()){
          buffer = "";
          getline(source, buffer);
          lineCount ++;
          if(buffer.find(XMLPretext) != -1){ // look for lines that contain the part names
               buffer = buffer.substr(XMLPretext.length(),buffer.length()); // clear out the leading XML
               buffer = buffer.substr(0,buffer.find("\"")); // clear out the trailing XML, leaving just the name
               dest << buffer << endl;
               elementCount++;
          }

     }
     source.close();
     dest.close();

     return;
}	// generates CSV parts list from SCH or BRD XML files