Index: tools/refactoring/stringmanipulation.py |
diff --git a/tools/refactoring/stringmanipulation.py b/tools/refactoring/stringmanipulation.py |
deleted file mode 100644 |
index 0d9e0ff3a5e13be5fe7182ad1e49053c15227145..0000000000000000000000000000000000000000 |
--- 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 |