--- /dev/null
+#!/usr/bin/python
+
+class phrase_replacer:
+ """ A simple replacement tool that honors some C/C++ syntax when replacing.
+
+ This will take a particular phrase given by the user and find it in a set of
+ documents. That phrase will be replaced when it appears completely, and is not
+ in a C or C++ style comment (// or /* ... */). It also must be clear of any
+ other alphanumeric pollution, and only be surrounded by white space or operation
+ characters.
+ """
+
+ def __init__(self, argv):
+ """ Initializes the class with a set of arguments to work with.
+
+ The arguments need to be in the form described by print_instructions().
+ """
+ self.arguments = argv
+ # we have three states for the processing: consuming normal code (not within a comment),
+ # consuming a single line comment, and consuming a multi-line comment.
+ self.EATING_NORMAL_TEXT = 0
+ self.EATING_ONELINE_COMMENT = 1
+ self.EATING_MULTILINE_COMMENT = 2
+
+ def print_instructions(self):
+ """ Shows the instructions for using this class. """
+ print("""
+This script will replace all occurrences of a phrase you specify in a set of files. The
+replacement process will be careful about C and C++ syntax and will not replace occurrences
+within comments or which are not "complete" phrases (due to other alpha-numeric characters
+that abut the phrase). The arguments to the script are:
+
+ {0}: PhraseToReplace ReplacementPhrase File1 [File2 ...]
+
+For example, if the phrase to replace is Goop, it will be replaced in these contexts:
+ Goop[32]
+ molo-Goop
+ *Goop
+but it will not be found in these contexts:
+ // doop de Goop
+ rGoop
+ Goop23
+""".format(self.arguments[0]))
+
+ def validate_and_consume_command_line(self):
+ """ Performs command line argument handling. """
+ arg_count = len(self.arguments)
+# for i in range(1, arg_count):
+# print("i is {0}, arg is {1}".format(i, self.arguments[i]))
+ # we need more than 2 arguments, since there needs to be at least one file also.
+ if arg_count < 4:
+ return False
+ self.phrase_to_replace = self.arguments[1]
+ self.replacement_bit = self.arguments[2]
+ print("got phrase to replace: \'{0}\' and replacement: \'{1}\'".format(self.phrase_to_replace, self.replacement_bit))
+ self.files = self.arguments[3:]
+ return True
+
+ def read_file_data(self, filename):
+ """ loads the file into our memory buffer for processing. """
+ try:
+ our_file = open(filename, "rb")
+ try:
+ file_buffer = our_file.read()
+ except IOError:
+ print("There was an error reading the file {0}".format(filename))
+ return False
+ finally:
+ our_file.close()
+ except IOError:
+ print("There was an error opening the file {0}".format(filename))
+ return False
+ self.file_lines = file_buffer.splitlines()
+ return True
+
+ def write_file_data(self, filename):
+ """ takes the processed buffer and sends it back out to the filename. """
+# output_filename = filename + ".new" # safe testing version.
+ output_filename = filename
+ try:
+ our_file = open(output_filename, "wb")
+ try:
+ file_buffer = our_file.write(self.processed_buffer)
+ except IOError:
+ print("There was an error writing the file {0}".format(output_filename))
+ return False
+ finally:
+ our_file.close()
+ except IOError:
+ print("There was an error opening the file {0}".format(output_filename))
+ return False
+ return True
+
+ def is_alphanumeric(self, check_char):
+ """ given a character, this returns true if it's between a-z, A-Z or 0-9. """
+ if (check_char[0] == "_"):
+ return True
+ if ( (check_char[0] <= "z") and (check_char[0] >= "a")):
+ return True
+ if ( (check_char[0] <= "Z") and (check_char[0] >= "A")):
+ return True
+ if ( (check_char[0] <= "9") and (check_char[0] >= "0")):
+ return True
+ return False
+
+ def replace_within_string(self, fix_string):
+ """ given a string to fix, this replaces all appropriate locations of the phrase. """
+ indy = 0
+# print("got to replace within string")
+ while (indy < len(fix_string)):
+ # locate next occurrence of replacement text, if any.
+ indy = fix_string.find(self.phrase_to_replace, indy)
+# print("find indy={0}".format(indy))
+ if (indy > -1):
+# print("found occurrence of replacement string")
+ # we found an occurrence, but we have to validate it's separated enough.
+ char_before = "?" # simple default that won't fail our check.
+ char_after = "?"
+ if (indy > 0):
+ char_before = fix_string[indy-1]
+ if (indy + len(self.phrase_to_replace) < len(fix_string) - 1):
+ char_after = fix_string[indy+len(self.phrase_to_replace)]
+# print("char before {0}, char after {1}".format(char_before, char_after))
+ if (not self.is_alphanumeric(char_before) and not self.is_alphanumeric(char_after)):
+ # this looks like a good candidate for replacement.
+ fix_string = "{0}{1}{2}".format(fix_string[0:indy], self.replacement_bit, fix_string[indy+len(self.phrase_to_replace):])
+# print("changed string to: {0}".format(fix_string))
+ else:
+ break
+ indy += 1 # no matches means we have to keep skipping forward.
+ return fix_string # give back processed form.
+
+ def emit_normal_accumulator(self):
+ """ handle emission of a chunk of normal code (without comments). """
+ # process the text to perform the replacement...
+ self.normal_accumulator = self.replace_within_string(self.normal_accumulator)
+ # then send the text into our main buffer; we're done looking at it.
+ self.processed_buffer += self.normal_accumulator
+ self.normal_accumulator = ""
+
+ def emit_comment_accumulator(self):
+ """ emits the piled up text for comments found in the code. """
+ self.processed_buffer += self.comment_accumulator
+ self.comment_accumulator = ""
+
+ def process_file_data(self):
+ """ iterates through the stored version of the file and replaces the phrase. """
+ self.state = self.EATING_NORMAL_TEXT;
+ # clear out any previously processed text.
+ self.processed_buffer = "" # reset our new version of the file contents.
+ self.normal_accumulator = ""
+ self.comment_accumulator = ""
+ # iterate through the file's lines.
+ while (len(self.file_lines) > 0):
+ # get the next line out of the input.
+ next_line = self.file_lines[0]
+ # drop that line from the remaining items.
+ self.file_lines = self.file_lines[1:]
+# print("next line: {0}".format(next_line))
+ # decide if we need a state transition.
+ indy = 0
+ if ((len(next_line) > 0) and (self.state == self.EATING_NORMAL_TEXT) and ('/' in next_line)):
+ # loop to catch cases where multiple slashes are in line and one IS a comment.
+ while (indy < len(next_line)):
+ # locate next slash, if any.
+ indy = next_line.find('/', indy)
+ if (indy < 0):
+ break
+ if ((len(next_line) > indy + 1) and (next_line[indy + 1] == '/')):
+ # switch states and handle any pent-up text.
+ self.normal_accumulator += next_line[0:indy] # get last tidbit before comment start.
+ next_line = next_line[indy:] # keep only the stuff starting at slash.
+ self.state = self.EATING_ONELINE_COMMENT
+# print("state => oneline comment")
+ self.emit_normal_accumulator()
+ break
+ if ((len(next_line) > indy + 1) and (next_line[indy + 1] == '*')):
+ # switch states and deal with accumulated text.
+ self.normal_accumulator += next_line[0:indy] # get last tidbit before comment start.
+ next_line = next_line[indy:] # keep only the stuff starting at slash.
+ self.state = self.EATING_MULTILINE_COMMENT
+# print("state => multiline comment")
+ self.emit_normal_accumulator()
+ break
+ indy += 1 # no matches means we have to keep skipping forward.
+
+ # now handle things appropriately for our current state.
+ if (self.state == self.EATING_NORMAL_TEXT):
+ # add the text to the normal accumulator.
+# print("would handle normal text")
+ self.normal_accumulator += next_line + "\n"
+ elif (self.state == self.EATING_ONELINE_COMMENT):
+ # save the text in comment accumulator.
+# print("would handle oneline comment")
+ self.comment_accumulator += next_line + "\n"
+ self.emit_comment_accumulator()
+ self.state = self.EATING_NORMAL_TEXT
+ elif (self.state == self.EATING_MULTILINE_COMMENT):
+ # save the text in comment accumulator.
+# print("would handle multiline comment")
+ self.comment_accumulator += next_line + "\n"
+ # check for whether the multi-line comment is completed on this line.
+ if ("*/" in next_line):
+# print("found completion for multiline comment on line.")
+ self.emit_comment_accumulator()
+ self.state = self.EATING_NORMAL_TEXT
+ # verify we're not in the wrong state still.
+ if (self.state == self.EATING_MULTILINE_COMMENT):
+ print("file seems to have unclosed multi-line comment.")
+ # last step is to spit out whatever was trailing in the accumulator.
+ self.emit_normal_accumulator()
+ # if we got to here, we seem to have happily consumed the file.
+ return True
+
+ def replace_all_occurrences(self):
+ """ Orchestrates the process of replacing the phrases. """
+ # process our command line arguments to see what we need to do.
+ try_command_line = self.validate_and_consume_command_line()
+ if (try_command_line != True):
+ print("failed to process the command line...\n")
+ self.print_instructions()
+ exit(1)
+ # iterate through the list of files we were given and process them.
+ for i in range(0, len(self.files)):
+ print("file {0} is \'{1}\'".format(i, self.files[i]))
+ worked = self.read_file_data(self.files[i])
+ if (worked is False):
+ print("skipping since file read failed on: {0}".format(self.files[i]))
+ continue
+# print("{0} got file contents:\n{1}".format(self.files[i], self.file_lines))
+ worked = self.process_file_data()
+ if (worked is False):
+ print("skipping, since processing failed on: {0}".format(self.files[i]))
+ continue
+ worked = self.write_file_data(self.files[i])
+ if (worked is False):
+ print("writing file back failed on: {0}".format(self.files[i]))
+ print("finished processing all files.")
+
+
+if __name__ == "__main__":
+ import sys
+ slicer = phrase_replacer(sys.argv)
+ slicer.replace_all_occurrences()
+
+##############
+
+# parking lot of things to do in future:
+
+#hmmm: actually sometimes one DOES want to replace within comments. argh.
+# make ignoring inside comments an optional thing. later.
+
+# hmmm: one little issue here is if the text to be replaced happens to reside on
+# the same line after a multi-line comment. we are okay with ignoring that
+# possibility for now since it seems brain-dead to write code that way.
+
+
projects / feisty_meow.git / blobdiff