diff options
Diffstat (limited to 'tools/refactoring/stringmanipulation.py')
| -rw-r--r-- | tools/refactoring/stringmanipulation.py | 303 |
1 files changed, 0 insertions, 303 deletions
diff --git a/tools/refactoring/stringmanipulation.py b/tools/refactoring/stringmanipulation.py deleted file mode 100644 index 0d9e0ff3a5..0000000000 --- a/tools/refactoring/stringmanipulation.py +++ /dev/null @@ -1,303 +0,0 @@ -import string - -# returns tuple, [success,updated_string] where the updated string has -# has one less (the first) occurance of match string -def removefirstoccurance( remove_string, match_string ): - lowercase_string = remove_string.lower() - lowercase_match_string = match_string.lower() - lowest_index = lowercase_string.find(lowercase_match_string) - if(lowest_index == -1): - return [False,remove_string] - past_match_index = lowest_index + len(lowercase_match_string) - highest_index = len(remove_string) - remove_string = remove_string[0:lowest_index] + remove_string[past_match_index: highest_index] - return [True,remove_string] - -# returns a string with all occurances of match_string removed -def removealloccurances( remove_string, match_string ): - return_value = [True, remove_string] - while(return_value[0]): - return_value = removefirstoccurance(return_value[1],match_string) - return return_value[1] - -# removes an occurance of match_string only if it's first in the string -# returns tuple [succes, new_string] -def removeprefix( remove_string, match_string ): - lowercase_string = remove_string.lower() - lowercase_match_string = match_string.lower() - lowest_index = lowercase_string.find(lowercase_match_string) - if(lowest_index == -1): - return [False,remove_string] - if(lowest_index != 0): - return [False,remove_string] - past_match_index = lowest_index + len(lowercase_match_string) - highest_index = len(remove_string) - remove_string = remove_string[0:lowest_index] + remove_string[past_match_index: highest_index] -# print lowest_index -# print past_match_index - return [True,remove_string] - -# removes multiple occurances of match string as long as they are first in -# the string -def removeallprefix( remove_string, match_string ): - return_value = [True, remove_string] - while(return_value[0]): - return_value = removeprefix(return_value[1],match_string) - return return_value[1] - -# returns true if extensionstring is a correct extension -def isextension( extensionstring ): - if(len(extensionstring) < 2): - return False - if(extensionstring[0] != '.'): - return False - if(extensionstring[1:len(extensionstring)-1].find('.') != -1): - return False - return True - -# returns the index of start of the last occurance of match_string -def findlastoccurance( original_string, match_string ): - search_index = original_string.find(match_string) - found_index = search_index - last_index = len(original_string) - 1 - while((search_index != -1) and (search_index < last_index)): - search_index = original_string[search_index+1:last_index].find(match_string) - if(search_index != -1): - found_index = search_index - return found_index - -# changes extension from original_extension to new_extension -def changeextension( original_string, original_extension, new_extension): - if(not isextension(original_extension)): - return original_string - if(not isextension(new_extension)): - return original_string - index = findlastoccurance(original_string, original_extension) - if(index == -1): - return original_string - return_value = original_string[0:index] + new_extension - return return_value - -# wanted to do this with str.find however didnt seem to work so do it manually -# returns the index of the first capital letter -def findfirstcapitalletter( original_string ): - for index in range(len(original_string)): - if(original_string[index].lower() != original_string[index]): - return index - return -1 - - -# replaces capital letters with underscore and lower case letter (except very -# first -def lowercasewithunderscore( original_string ): -# ignore the first letter since there should be no underscore in front of it - if(len(original_string) < 2): - return original_string - return_value = original_string[1:len(original_string)] - index = findfirstcapitalletter(return_value) - while(index != -1): - return_value = return_value[0:index] + \ - '_' + \ - return_value[index].lower() + \ - return_value[index+1:len(return_value)] - index = findfirstcapitalletter(return_value) - return_value = original_string[0].lower() + return_value - return return_value - -# my table is a duplicate of strings -def removeduplicates( my_table ): - new_table = [] - for old_string1, new_string1 in my_table: - found = 0 - for old_string2, new_string2 in new_table: - if(old_string1 == old_string2): - found += 1 - if(new_string1 == new_string2): - if(new_string1 == ''): - found += found - else: - found += 1 - if(found == 1): - print 'missmatching set, terminating program' - print old_string1 - print new_string1 - print old_string2 - print new_string2 - quit() - if(found == 2): - break - if(found == 0): - new_table.append([old_string1,new_string1]) - return new_table - -def removenochange( my_table ): - new_table = [] - for old_string, new_string in my_table: - if(old_string != new_string): - new_table.append([old_string,new_string]) - return new_table - -# order table after size of the string (can be used to replace bigger strings -# first which is useful since smaller strings can be inside the bigger string) -# E.g. GIPS is a sub string of GIPSVE if we remove GIPS first GIPSVE will never -# be removed. N is small so no need for fancy sort algorithm. Use selection sort -def ordertablesizefirst( my_table ): - for current_index in range(len(my_table)): - biggest_string = 0 - biggest_string_index = -1 - for search_index in range(len(my_table)): - if(search_index < current_index): - continue - length_of_string = len(my_table[search_index][0]) - if(length_of_string > biggest_string): - biggest_string = length_of_string - biggest_string_index = search_index - if(biggest_string_index == -1): - print 'sorting algorithm failed, program exit' - quit() - old_value = my_table[current_index] - my_table[current_index] = my_table[biggest_string_index] - my_table[biggest_string_index] = old_value - return my_table - -# returns true if string 1 or 2 is a substring of the other, assuming neither -# has whitespaces -def issubstring( string1, string2 ): - if(len(string1) == 0): - return -1 - if(len(string2) == 0): - return -1 - large_string = string1 - small_string = string2 - if(len(string1) < len(string2)): - large_string = string2 - small_string = string1 - - for index in range(len(large_string)): - large_sub_string = large_string[index:index+len(small_string)].lower() - if(large_sub_string ==\ - small_string.lower()): - return index - return -1 - -#not_part_of_word_table = [' ','(',')','{','}',':','\t','*','&','/','[',']','.',',','\n'] -#def ispartofword( char ): -# for item in not_part_of_word_table: -# if(char == item): -# return False -# return True - -# must be numerical,_ or charachter -def ispartofword( char ): - if(char.isalpha()): - return True - if(char.isalnum()): - return True - if(char == '_'): - return True - return False - -# returns the index of the first letter in the word that the current_index -# is pointing to and the size of the word -def getword( line, current_index): - if(current_index < 0): - return [] - line = line.rstrip() - if(len(line) <= current_index): - return [] - if(line[current_index] == ' '): - return [] - start_pos = current_index - while start_pos >= 0: - if(not ispartofword(line[start_pos])): - start_pos += 1 - break - start_pos -= 1 - if(start_pos == -1): - start_pos = 0 - end_pos = current_index - while end_pos < len(line): - if(not ispartofword(line[end_pos])): - break - end_pos += 1 - return [start_pos,end_pos - start_pos] - -# my table is a tuple [string1,string2] complement_to_table is just a list -# of strings to compare to string1 -def complement( my_table, complement_to_table ): - new_table = [] - for index in range(len(my_table)): - found = False; - for compare_string in complement_to_table: - if(my_table[index][0].lower() == compare_string.lower()): - found = True - if(not found): - new_table.append(my_table[index]) - return new_table - -def removestringfromhead( line, remove_string): - for index in range(len(line)): - if(line[index:index+len(remove_string)] != remove_string): - return line[index:index+len(line)] - return '' - -def removeccomment( line ): - comment_string = '//' - for index in range(len(line)): - if(line[index:index+len(comment_string)] == comment_string): - return line[0:index] - return line - -def whitespacestoonespace( line ): - return ' '.join(line.split()) - -def fixabbreviations( original_string ): - previouswascapital = (original_string[0].upper() == original_string[0]) - new_string = '' - for index in range(len(original_string)): - if(index == 0): - new_string += original_string[index] - continue - if(original_string[index] == '_'): - new_string += original_string[index] - previouswascapital = False - continue - if(original_string[index].isdigit()): - new_string += original_string[index] - previouswascapital = False - continue - currentiscapital = (original_string[index].upper() == original_string[index]) - letter_to_add = original_string[index] - if(previouswascapital and currentiscapital): - letter_to_add = letter_to_add.lower() - if(previouswascapital and (not currentiscapital)): - old_letter = new_string[len(new_string)-1] - new_string = new_string[0:len(new_string)-1] - new_string += old_letter.upper() - previouswascapital = currentiscapital - new_string += letter_to_add - return new_string - -def replaceoccurances(old_string, replace_string, replace_with_string): - if (len(replace_string) == 0): - return old_string - if (len(old_string) < len(replace_string)): - return old_string - # Simple implementation, could proably be done smarter - new_string = '' - for index in range(len(old_string)): - #print new_string - if(len(replace_string) > (len(old_string) - index)): - new_string += old_string[index:index + len(old_string)] - break - match = (len(replace_string) > 0) - for replace_index in range(len(replace_string)): - if (replace_string[replace_index] != old_string[index + replace_index]): - match = False - break - if (match): - new_string += replace_with_string - index =+ len(replace_string) - else: - new_string += old_string[index] - return new_string |