scripts/buildor/fix_project_references.py

   1 #!/usr/bin/python
   2
   3 import os;
   4 import random;
   5
   6 class fix_project_references:
   7   """ This tool fixes visual studio 2010 projects to have the proper project references.
   8
   9       Project files need to refer to other project files that they are dependent on if visual
  10       studio is to build them properly.  This is a painful task when done manually, but luckily
  11       this script automates the process for you.
  12       It requires an environment variable called BUILD_TOP that points at the top of all files
  13       included in a code base.  This is used to find the dependent projects.
  14
  15
  16 hmmm: this tool is NOT finished.
  17   """
  18
  19 ##############
  20
  21   def __init__(self, argv):
  22     """ Initializes the class with a set of arguments to work with.
  23
  24         The arguments need to be in the form described by print_instructions().
  25     """
  26     self.arguments = argv  # remembers the command line for us.
  27     self.file_buffer = ""  # use for file i/o in the class.
  28     # initializes the list of projects found for the current source code hierarchy.
  29 #hmmm: hier top denoted right now by the variable BUILD_TOP.  may want to document that.
  30     src_dir = os.getenv("BUILD_TOP")
  31     # projects and assets should keep in step, where project[x] is known to create asset[x].
  32     self.projects = self.walk_directory_for_projects(src_dir)  # list of project files.
  33     self.assets = self.locate_all_assets()  # dictionary of assets created by project files.
  34
  35 ##############
  36
  37 #fix
  38   def print_instructions(self):
  39     """ Shows the instructions for using this class. """
  40     print("""
  41 This script will replace all occurrences of a phrase you specify in a set of files.  The
  42 replacement process will be careful about C and C++ syntax and will not replace occurrences
  43 within comments or which are not "complete" phrases (due to other alpha-numeric characters
  44 that abut the phrase).  The arguments to the script are:
  45
  46   {0}: PhraseToReplace  ReplacementPhrase  File1  [File2 ...]
  47
  48 For example, if the phrase to replace is Goop, it will be replaced in these contexts:
  49   Goop[32]
  50   molo-Goop
  51   *Goop
  52 but it will not be found in these contexts:
  53   // doop de Goop
  54   rGoop
  55   Goop23
  56 """.format(self.arguments[0]))
  57
  58   #fix
  59   def validate_and_consume_command_line(self):
  60     """ Performs command line argument handling. """
  61     arg_count = len(self.arguments)
  62 #    for i in range(1, arg_count):
  63 #      print("i is {0}, arg is {1}".format(i, self.arguments[i]))
  64     # we need more than 2 arguments, since there needs to be at least one file also.
  65     if arg_count < 4:
  66       return False
  67     self.phrase_to_replace = self.arguments[1]
  68     self.replacement_bit = self.arguments[2]
  69     print("got phrase to replace: \'{0}\' and replacement: \'{1}\'".format(self.phrase_to_replace, self.replacement_bit))
  70     self.files = self.arguments[3:]
  71     return True
  72
  73 ##############
  74
  75 #hmmm: are these good enough to become part of a file library?
  76
  77   def read_file_data(self, filename):
  78     """ loads the file into our memory buffer for processing. """
  79     try:
  80       our_file = open(filename, "rb")
  81       try:
  82         self.file_buffer = our_file.read()
  83       except IOError:
  84         print("There was an error reading the file {0}".format(filename))
  85         return False
  86       finally:
  87         our_file.close()
  88     except IOError:
  89       print("There was an error opening the file {0}".format(filename))
  90       return False
  91     self.file_lines = self.file_buffer.splitlines()
  92     return True
  93
  94   def write_file_data(self, filename):
  95     """ takes the processed buffer and sends it back out to the filename. """
  96 #    output_filename = filename + ".new"  # safe testing version.
  97     output_filename = filename
  98     try:
  99       our_file = open(output_filename, "wb")
 100       try:
 101         self.file_buffer = our_file.write(self.processed_buffer)
 102       except IOError:
 103         print("There was an error writing the file {0}".format(output_filename))
 104         return False
 105       finally:
 106         our_file.close()
 107     except IOError:
 108       print("There was an error opening the file {0}".format(output_filename))
 109       return False
 110     return True
 111
 112 ##############
 113
 114   #unused?
 115   def is_alphanumeric(self, check_char):
 116     """ given a character, this returns true if it's between a-z, A-Z or 0-9. """
 117     if (check_char[0] == "_"):
 118       return True
 119     if ( (check_char[0] <= "z") and (check_char[0] >= "a")):
 120       return True
 121     if ( (check_char[0] <= "Z") and (check_char[0] >= "A")):
 122       return True
 123     if ( (check_char[0] <= "9") and (check_char[0] >= "0")):
 124       return True
 125     return False
 126
 127   #unused?
 128   def replace_within_string(self, fix_string):
 129     """ given a string to fix, this replaces all appropriate locations of the phrase. """
 130     indy = 0
 131 #    print("got to replace within string")
 132     while (indy < len(fix_string)):
 133       # locate next occurrence of replacement text, if any.
 134       indy = fix_string.find(self.phrase_to_replace, indy)
 135 #      print("find indy={0}".format(indy))
 136       if (indy > -1):
 137 #        print("found occurrence of replacement string")
 138         # we found an occurrence, but we have to validate it's separated enough.
 139         char_before = "?"  # simple default that won't fail our check.
 140         char_after = "?"
 141         if (indy > 0):
 142           char_before = fix_string[indy-1]
 143         if (indy + len(self.phrase_to_replace) < len(fix_string) - 1):
 144           char_after = fix_string[indy+len(self.phrase_to_replace)]
 145 #        print("char before {0}, char after {1}".format(char_before, char_after))
 146         if (not self.is_alphanumeric(char_before) and not self.is_alphanumeric(char_after)):
 147           # this looks like a good candidate for replacement.
 148           fix_string = "{0}{1}{2}".format(fix_string[0:indy], self.replacement_bit, fix_string[indy+len(self.phrase_to_replace):])
 149 #          print("changed string to: {0}".format(fix_string))
 150       else:
 151         break
 152       indy += 1  # no matches means we have to keep skipping forward.
 153     return fix_string  # give back processed form.
 154
 155   #unused?
 156   def process_file_data(self):
 157     """ iterates through the stored version of the file and replaces the phrase. """
 158     self.state = self.EATING_NORMAL_TEXT;
 159     # clear out any previously processed text.
 160     self.processed_buffer = ""   # reset our new version of the file contents.
 161     self.normal_accumulator = ""
 162     self.comment_accumulator = ""
 163     # iterate through the file's lines.
 164     contents = self.file_lines
 165     while (len(contents) > 0):
 166       # get the next line out of the input.
 167       next_line = contents[0]
 168       # drop that line from the remaining items.
 169       contents = contents[1:]
 170 #      print("next line: {0}".format(next_line))
 171       # decide if we need a state transition.
 172       indy = 0
 173       if ((len(next_line) > 0) and (self.state == self.EATING_NORMAL_TEXT) and ('/' in next_line)):
 174         # loop to catch cases where multiple slashes are in line and one IS a comment.
 175         while (indy < len(next_line)):
 176           # locate next slash, if any.
 177           indy = next_line.find('/', indy)
 178           if (indy < 0):
 179             break
 180           if ((len(next_line) > indy + 1) and (next_line[indy + 1] == '/')):
 181             # switch states and handle any pent-up text.
 182             self.normal_accumulator += next_line[0:indy]  # get last tidbit before comment start.
 183             next_line = next_line[indy:]  # keep only the stuff starting at slash.
 184             self.state = self.EATING_ONELINE_COMMENT
 185 #            print("state => oneline comment")
 186             self.emit_normal_accumulator()
 187             break
 188           if ((len(next_line) > indy + 1) and (next_line[indy + 1] == '*')):
 189             # switch states and deal with accumulated text.
 190             self.normal_accumulator += next_line[0:indy]  # get last tidbit before comment start.
 191             next_line = next_line[indy:]  # keep only the stuff starting at slash.
 192             self.state = self.EATING_MULTILINE_COMMENT
 193 #            print("state => multiline comment")
 194             self.emit_normal_accumulator()
 195             break
 196           indy += 1  # no matches means we have to keep skipping forward.
 197
 198       # now handle things appropriately for our current state.
 199       if (self.state == self.EATING_NORMAL_TEXT):
 200         # add the text to the normal accumulator.
 201 #        print("would handle normal text")
 202         self.normal_accumulator += next_line + "\n"
 203       elif (self.state == self.EATING_ONELINE_COMMENT):
 204         # save the text in comment accumulator.
 205 #        print("would handle oneline comment")
 206         self.comment_accumulator += next_line + "\n"
 207         self.emit_comment_accumulator()
 208         self.state = self.EATING_NORMAL_TEXT
 209       elif (self.state == self.EATING_MULTILINE_COMMENT):
 210         # save the text in comment accumulator.
 211 #        print("would handle multiline comment")
 212         self.comment_accumulator += next_line + "\n"
 213         # check for whether the multi-line comment is completed on this line.
 214         if ("*/" in next_line):
 215 #          print("found completion for multiline comment on line.")
 216           self.emit_comment_accumulator()
 217           self.state = self.EATING_NORMAL_TEXT
 218     # verify we're not in the wrong state still.
 219     if (self.state == self.EATING_MULTILINE_COMMENT):
 220       print("file seems to have unclosed multi-line comment.")
 221     # last step is to spit out whatever was trailing in the accumulator.
 222     self.emit_normal_accumulator()
 223     # if we got to here, we seem to have happily consumed the file.
 224     return True
 225
 226   #use for example.
 227   def replace_all_occurrences(self):
 228     """ Orchestrates the process of replacing the phrases. """
 229     # process our command line arguments to see what we need to do.
 230     try_command_line = self.validate_and_consume_command_line()
 231     if (try_command_line != True):
 232       print("failed to process the command line...\n")
 233       self.print_instructions()
 234       exit(1)
 235     # iterate through the list of files we were given and process them.
 236     for i in range(0, len(self.files)):
 237       print("file {0} is \'{1}\'".format(i, self.files[i]))
 238       worked = self.read_file_data(self.files[i])
 239       if (worked is False):
 240         print("skipping since file read failed on: {0}".format(self.files[i]))
 241         continue
 242 #      print("{0} got file contents:\n{1}".format(self.files[i], self.file_lines))
 243       worked = self.process_file_data()
 244       if (worked is False):
 245         print("skipping, since processing failed on: {0}".format(self.files[i]))
 246         continue
 247       worked = self.write_file_data(self.files[i])
 248       if (worked is False):
 249         print("writing file back failed on: {0}".format(self.files[i]))
 250     print("finished processing all files.")
 251
 252 ##############
 253
 254   def repair_project_references(self):
 255     """ the main entry point to the project fixing process.
 256
 257     Operates on one project file at a time by:
 258       1) finding all libraries (lib files) used by the project A,
 259       2) locating the external project that creates each lib file,
 260       3) adding a reference to the external projects to our project A.
 261
 262     We rely on some important assumptions to get this done:
 263       1) project names and project file names are unique across the codebase,
 264       2) the structure of the source code hierarchies uses a compatible architecture,
 265 (which is?)
 266
 267     """
 268     print("repair is unimplemented")
 269
 270 ##############
 271
 272   def extract_xml_tag(self, file_line, tag_name):
 273     """ locates an XML tag with "tag_name" and returns the contents of the tag.
 274
 275     this currently assumes that the start tag, contents, and end tag are all on the same
 276     line of text (which is not a very good assumption in general).
 277     """
 278     if ('<' + tag_name in file_line):
 279       # find the greater than character.
 280       gt_pos = file_line.find('>', 0)
 281       if (gt_pos < 0): return ""  # fail.
 282       tag_close_pos = file_line.find('</' + tag_name, gt_pos + 1);
 283       if (tag_close_pos < 0): return ""  # fail.
 284       return file_line[gt_pos + 1 : tag_close_pos]
 285     return "" # failed to find anything relevant.
 286
 287   def extract_xml_attribute(self, file_line, tag_name, attribute_name):
 288     """ locates an XML tag with "tag_name" and returns the value of the "attribute_name".
 289
 290     """
 291     if ('<' + tag_name not in file_line): return ""
 292     if (attribute_name not in file_line): return ""
 293     attrib_pos = file_line.find(attribute_name, 0)
 294     # find the first quote around the attribute.
 295     quote_pos = file_line.find('"', attrib_pos)
 296     if (quote_pos < 0): return ""  # fail.
 297     quote_close_pos = file_line.find('"', quote_pos + 1)
 298     if (quote_close_pos < 0): return ""  # fail.
 299     return file_line[quote_pos + 1 : quote_close_pos]
 300
 301 ##############
 302
 303   def extract_xml_tag_from_file(self, filename, tag_name):
 304     """ reads in a file and extracts the contents of a particular XML tag.
 305
 306 may not want a file read here.  better to have a nice established way for
 307 dealing with the existing buffer.
 308     """
 309     self.read_file_data(filename)
 310     contents = self.file_lines
 311     while (len(contents) > 0):
 312       # get the next line out of the input.
 313       next_line = contents[0]
 314       # drop that line from the remaining items.
 315       contents = contents[1:]
 316       #hmmm: maybe bad assumption thinking all on one line...
 317       found = self.extract_xml_tag(next_line, tag_name)
 318       if (found != ""): return found
 319     return "" # failed to find anything relevant.
 320
 321 ##############
 322
 323   def extract_guid_from_project_file(self, filename):
 324     """ reads in a visual studio project file and figures out that project's GUID.
 325
 326     note that this will fail horribly if the project has been messed with and is no
 327     longer in microsoft's official format.
 328     """
 329     return self.extract_xml_tag_from_file(filename, 'ProjectGuid')
 330
 331   def extract_filename_from_project_reference(self, file_line):
 332     """ given a ProjectReference line, this pulls out just the filename involved.
 333     """
 334     return self.extract_xml_attribute(file_line, "ProjectReference", "Include")
 335
 336   def find_all_project_references(self, filename):
 337     """ reads in a visual studio project file and locates all references.
 338     """
 339     self.read_file_data(filename)
 340     contents = self.file_lines
 341     refs_list = []
 342     while (len(contents) > 0):
 343       # get the next line out of the input.
 344       next_line = contents[0]
 345       # drop that line from the remaining items.
 346       contents = contents[1:]
 347       ref = self.extract_filename_from_project_reference(next_line)
 348       if (ref != ''):
 349         #print("got reference: " + os.path.basename(ref) + " => " + ref)
 350         refs_list.append(ref)
 351     return refs_list
 352
 353   def parse_dependency_line(self, line):
 354     """ given an AdditionalDependencies line, this finds the libs listed.
 355     """
 356     just_libs = self.extract_xml_tag(line, "AdditionalDependencies")
 357     if (just_libs == ""): return []
 358     lib_list = just_libs.split(';')
 359     # here we scan the list and remove any known-stupid entries.
 360     for i in range(1, len(lib_list)):
 361       if (lib_list[i] == '%(AdditionalDependencies)'):
 362         lib_list = lib_list[0 : i] + lib_list[i + 1 : len(lib_list)]
 363         i -= 1
 364     return lib_list
 365
 366   #hmmm: could be a problem if the debug and release values differ.
 367   def extract_dependencies(self, filename):
 368     """ reads in a visual studio project file and locates all dependencies.
 369
 370     This will produce a list of the lib files used by c++ projects.  These
 371     are what we need to link up to their providing projects, if they're
 372     actually things that we build.
 373     """
 374     self.read_file_data(filename)
 375     contents = self.file_lines
 376     while (len(contents) > 0):
 377       # get the next line out of the input.
 378       next_line = contents[0]
 379       # drop that line from the remaining items.
 380       contents = contents[1:]
 381       if ('AdditionalDependencies' in next_line):
 382         deps = self.parse_dependency_line(next_line)
 383         return deps
 384     return ()  # failed to find right line.
 385
 386 ##############
 387
 388 #hmmm: could also be a problem if the debug and release values differ.
 389   def find_asset_created(self, filename):
 390     """ determines the asset created by a visual studio project file.
 391
 392     This probably only works right on c++ projects.  It will figure out the
 393     item being created by the project using the breadcrumbs provided.
 394     """
 395
 396     # these will need to be filled for us to have correctly determined what the project creates.
 397     project_name = ""
 398     config_type = ""
 399
 400     self.read_file_data(filename)
 401     contents = self.file_lines
 402     while (len(contents) > 0):
 403       # get the next line out of the input.
 404       next_line = contents[0]
 405       # drop that line from the remaining items.
 406       contents = contents[1:]
 407
 408       # we need the ProjectName or RootNamespace.
 409       #hmmm: csproj seems like they will work with this scheme already.
 410       if project_name == "":
 411         temp = self.extract_xml_tag(next_line, "RootNamespace")
 412         if (temp != ""):
 413           project_name = temp
 414 #          print("found project name of " + project_name)
 415           continue
 416
 417       # we look for the ConfigurationType, which tells us:
 418       #   DynamicLibrary | Library | StaticLibrary | Application | WinExe | Exe | Utility
 419       if config_type == "":
 420         temp = self.extract_xml_tag(next_line, "ConfigurationType")
 421         if (temp != ""):
 422           config_type = temp
 423 #          print("found config type of " + config_type)
 424           continue
 425         temp = self.extract_xml_tag(next_line, "OutputType")
 426         if (temp != ""):
 427           config_type = temp
 428 #          print("found output type of " + config_type)
 429           continue
 430
 431       if (config_type != "") and (project_name != ""):
 432         asset_name = project_name
 433         if (config_type == "DynamicLibrary"): asset_name += ".dll"
 434         elif (config_type == "Library"): asset_name += ".dll"
 435         elif (config_type == "StaticLibrary"): asset_name += ".lib"
 436         elif (config_type == "Application"): asset_name += ".exe"
 437         elif (config_type == "WinExe"): asset_name += ".exe"
 438         elif (config_type == "Exe"): asset_name += ".exe"
 439         elif (config_type == "Utility"): return ""
 440         else:
 441           print("unknown configuration type: " + config_type + "\nin proj file: " + filename)
 442           return ""
 443         # we think we're successful in figuring out what should be created.
 444         return asset_name
 445
 446     return ""  # failed to find right lines.
 447
 448 ##############
 449
 450   def walk_directory_for_projects(self, dir):
 451     """ traverses the directory in "dir" and finds all the project files.
 452
 453     the project files are returned as a massive list.
 454     """
 455
 456 #hmmm: important optimization for walk; if the file where we store these things exists,
 457 #      read directly out of that file instead of redoing hierarchy.  people can
 458 #      delete the file when they want a fresh look.
 459
 460     to_return = []
 461
 462     for root, dirs, files in os.walk(dir):
 463 #demo code from web:
 464 #      print root, "consumes",
 465 #      print sum(os.path.getsize(os.path.join(root, name)) for name in files),
 466 #      print "bytes in", len(files), "non-directory files"
 467       if 'CVS' in dirs:
 468         dirs.remove('CVS')  # don't visit CVS directories.
 469       elif '.svn' in dirs:
 470         dirs.remove('.svn')  # don't visit subversion directories either.
 471       for curr_file in files:
 472         indy = len(curr_file) - 4
 473         # see if the file has the right ending to be a visual studio project file.
 474         if curr_file[indy:].lower() == 'proj':
 475           full_path = os.path.join(root, curr_file)
 476 #          print("full path: " + full_path)
 477           # now add this good one to the returned list of projects.
 478           to_return.append(full_path)
 479     return to_return
 480
 481   def find_relative_path(self, our_path, project_file):
 482     """ calculates path between directory at "our_path" to the location of "project_file".
 483
 484     this assumes that the locations are actually rooted at the same place; otherwise there is
 485     no path between the locations.  the location at "our_path" is considered to be the source,
 486     or where we start out.  the location for "project_file" is the target location.
 487     """
 488
 489     # canonicalize these to be linux paths.  we want to be able to split on forward slashes.
 490     sourcel = our_path.replace('\\', '/')
 491     targee = project_file.replace('\\', '/')
 492     # fracture the paths into their directory and filename components.
 493     sourcel = str.split(sourcel, '/')
 494     targee = str.split(targee, '/')
 495     # remove last item, which should be project filename.
 496     targee.pop()
 497     # destroy identical elements until items don't match or one path is gone.
 498     while (len(sourcel) and len(targee) and (sourcel[0] == targee[0])):
 499       sourcel.pop(0)
 500       targee.pop(0)
 501 #    print("after dinner, sourcel now: " + " / ".join(sourcel))
 502 #    print("and targee now: " + " / ".join(targee))
 503     # we comput the directory prefix of dot-dots based on the number of elements left
 504     # in the source path.
 505     prefix = ""
 506     for i in range(0, len(sourcel)):
 507       prefix += "../"
 508     print("calculated a prefix of: " + prefix)
 509 #prove it is right in unit test.
 510     return prefix + "/".join(targee)
 511
 512 ##############
 513
 514   def locate_all_assets(self):
 515     """ locates every project file in our list and determines the asset created by it.
 516
 517     this returns a dictionary of {asset=project} items.  we index by asset way more frequently
 518     than by project, so the asset name is used as our key.
 519     """
 520     to_return = {}
 521     for proj in self.projects:
 522       asset_found = self.find_asset_created(proj)
 523       # make sure we don't record a bogus project with no useful asset.
 524       if (asset_found == ""):
 525         self.projects.remove(proj)  # should be safe for our list iteration.
 526         continue  # skip adding the bogus one.
 527       to_return[asset_found] = proj
 528 #      print("proj " + proj + " creates: " + asset_found)
 529     return to_return
 530
 531 ##############
 532
 533   def locate_referenced_projects(self, project):
 534     """ finds all the libraries needed by the "project" file and returns their project files.
 535     """
 536     to_return = []
 537     # find the libraries and such used by this project.
 538     libs = self.extract_dependencies(project)
 539 #    print("was told the libs used by " + project + " are:\n" + " ".join(libs))
 540     # now find who creates those things.
 541     for current in libs:
 542       # if we know of the library in our list of assets, then we can use it right away.
 543       if current in self.assets:
 544         # this item exists and is created by one of our projects.
 545         proj_needed = self.assets[current]
 546 #        print("asset '" + current + "' created by: " + proj_needed)
 547         to_return.append(proj_needed)
 548         continue
 549       # if we didn't find the thing with it's current name, we'll see if we can convert
 550       # it into a dll and look for that instead.
 551 #      print("looking at piece: " + current[len(current) - 4:])
 552       if current[len(current) - 4:] == ".lib":
 553 #        print("found rogue we can convert to a dll to find: " + current)
 554         current = current[0:-4] + ".dll"
 555 #        print("new name: " + current)
 556         if current in self.assets:
 557           proj_needed = self.assets[current]
 558 #          print("found asset '" + current + "' created by: " + proj_needed)
 559           to_return.append(proj_needed)
 560           continue
 561 #        else:
 562 #          print("could not find '" + current + "' as an asset that we know how to create.");
 563     return to_return
 564
 565   def remove_redundant_references(self, project):
 566     """ cleans out any references in "project" to assets that we intend to update.
 567
 568     this actually modifies the file.  it had better be right.
 569     """
 570 #load file data for the thing
 571 #find references
 572   #see if reference is one we know about
 573   #if so, zap it out of file contents
 574 #write file back out
 575
 576 ##############
 577
 578   def unit_test(self):
 579     """ a sort-of unit test for the functions in this script.
 580
 581     currently geared for manual inspection of the test results.
 582     """
 583     print("testing some of the methods...")
 584     test_file = ""
 585     if len(self.arguments) > 1:
 586       test_file = self.arguments[1]
 587     if test_file == "": test_file = os.getenv("FEISTY_MEOW_APEX") + "/nucleus/applications/nechung/nechung.vcxproj"
 588     print("test file is: " + test_file)
 589
 590     guid = self.extract_guid_from_project_file(test_file)
 591     print("from proj, got a guid of " + guid)
 592
 593     refs = self.find_all_project_references(test_file)
 594     print("refs list is: " + " ".join(refs))
 595
 596 #    libs = self.extract_dependencies(test_file)
 597 #    print("was told the libs used are: " + " ".join(libs))
 598
 599     asset = self.find_asset_created(test_file)
 600     print("our created asset is: " + asset)
 601
 602 #    print("walked directories got:\n" + " ".join(fixit.projects))
 603
 604 #    print("assets found are:\n" + " ".join(fixit.assets))
 605
 606     if (len(fixit.projects) > 0):
 607       rando = random.randint(0, len(fixit.projects) - 1)
 608       print("index chosen to examine: {0}".format(rando))
 609
 610       relpath = self.find_relative_path(os.path.dirname(test_file), fixit.projects[rando])
 611       print("found relative path from source:\n  " + test_file)
 612       print("to target:\n  " + fixit.projects[rando])
 613       print("is this =>\n  " + relpath)
 614
 615     full_refs = self.locate_referenced_projects(test_file)
 616     print("refs found are:\n" + " ".join(full_refs))
 617
 618     self.remove_redundant_references(test_file)
 619     print("we just munged your file!  go check it!  no references should remain that are in our new list.")
 620
 621 #still needed:
 622 # remove any existing references that we now have a replacement for.
 623 #   base this on the basename of the project file?  blah.vcxproj already there e.g.
 624 # spit out xml form of references for the dependent projects.
 625 # put new references into the right place in file.
 626
 627
 628 ##############
 629
 630 # run the script if we are non-interactive.
 631 if __name__ == "__main__":
 632     import sys
 633     fixit = fix_project_references(sys.argv)
 634
 635     # comment this out when script is working.
 636     fixit.unit_test()
 637
 638     print("we're bailing before doing anything real...")
 639     exit(3)
 640
 641     fixit.repair_project_references()
 642
 643 ##############
 644
 645 # parking lot of things to do in future:
 646
 647