Repacking framework: also remove the buildlib directory.
[debian/jabref.git] / syncLang.py
index ad835403d3f64396a74378d1b4616b7c7f44d83b..ef9070cdc0c7179c1877958b595afd5197e7071f 100644 (file)
-import sys
-import os
-import re
-
-keyFiles = {}
-
-# Builds a list of all translation keys in the list of lines.
-def indexFile(lines):
-    allKeys = []
-    for line in lines:
-        comment = line.find("#")
-        if (comment != 0):
-            index = line.find("=")
-            while ((index > 0) and (line[index-1]=="\\")):
-                index = line.find("=", index+1)
-            if (index > 0):
-                allKeys.append(line[0:index])
-    allKeys.sort()
-    return allKeys
-        
-
-# Finds all keys in the first list that are not present in the second list:
-def findMissingKeys(first, second):
-    missing = []
-    for key in first:
-        if not key in second:
-            missing.append(key)
-    return missing
-
-
-# Appends all the given keys to the file:
-def appendMissingKeys(filename, keys):
-    file = open(filename, "a")
-    file.write("\n")
-    for key in keys:
-        file.write(key+"=\n")
-
-def handleFileSet(mainFile, files, changeFiles):
-    f1 = open(mainFile)
-    lines = f1.readlines()
-    f1.close()
-    keys = indexFile(lines)
-    keysPresent = []
-    for i in range(0, len(files)):
-        f2 = open(files[i])
-        lines = f2.readlines()
-        f2.close()
-        keysPresent.append(indexFile(lines))
-        missing = findMissingKeys(keys, keysPresent[i])
-        
-        print "\n\nFile '"+files[i]+"'\n"
-        if len(missing) == 0:
-            print "----> No missing keys."
-        else:
-            print "----> Missing keys:"
-            for key in missing:
-                print key
-
-            if changeFiles == 1:
-                print "Update file?",
-                if raw_input() in ['y', 'Y']:
-                    appendMissingKeys(files[i], missing)
-            print ""
-        
-        # See if this file has keys that are not in the main file:
-        redundant = findMissingKeys(keysPresent[i], keys)
-        if len(redundant) > 0:
-            print "----> Possible obsolete keys (not in English language file):"
-            for key in redundant:
-                print key
-                
-            #if changeFiles == 1:
-            #   print "Update file?",
-            #   if raw_input() in ['y', 'Y']:
-            #       removeRedundantKeys(files[i], redundant)
-            print ""
-        
-def handleJavaCode(filename, lines, keyList, notTermList):
-    #Extract first string parameter from Globals.lang call. E.g., Globals.lang("Default")
-    reOnlyString = r'"((\\"|[^"])*)"[^"]*'
-    patt = re.compile(r'Globals\s*\.\s*lang\s*\(\s*' + reOnlyString)
-    #second pattern as Mr Dlib contribution indirectly uses Global.lang
-    patta = re.compile(r'LocalizationSupport.message\(' + reOnlyString)
-    pattOnlyString = re.compile(reOnlyString)
-
-    #Find multiline Globals lang statements. E.g.:
-    #Globals.lang("This is my string" +
-    # "with a long text")
-    patt2 = re.compile(r'Globals\s*\.\s*lang\s*\(([^)])*$')
-
-    pattPlus = re.compile(r'^\s*\+')
-
-    eList = list(enumerate(lines.split("\n")))
-    i = 0
-    while i < len(eList):
-        linenum, curline = eList[i]
-        
-        #Remove Java single line comments
-        if curline.find("http://") < 0:
-            curline = re.sub("//.*", "", curline)
-
-        while (curline != ""):
-            result = patt.search(curline)
-            if (not result):
-                result = patta.search(curline)
-            result2 = patt2.search(curline)
-
-            found = ""
-
-            if result2 and curline.find('",') < 0:
-                # not terminated
-                # but it could be a multiline string
-                if result:
-                    curText = result.group(1)
-                    searchForPlus = True
-                else:
-                    curText = ""
-                    searchForPlus = False
-                origI = i
-                #inspect next line
-                while i+1 < len(eList):
-                    linenum2, curline2 = eList[i+1]
-                    if (not searchForPlus) or pattPlus.search(curline2):
-                        #from now on, we always have to search for a plus
-                        searchForPlus = True
-
-                        #The current line has been handled here, therefore indicate to handle the next line
-                        i = i+1
-                        linenum = linenum2
-                        curline = curline2
-
-                        #Search for the occurence of a string
-                        result = pattOnlyString.search(curline2)
-                        if result:
-                            curText = curText + result.group(1)
-                            #check for several strings in this line
-                            if curline2.count('\"') > 2:
-                                break
-                            #check for several arguments in the line
-                            if curline2.find('",') > 0:
-                                break
-                            if curline2.endswith(")"):
-                                break
-                        else:
-                            #plus sign at the beginning found, but no string
-                            break
-                    else:
-                        #no continuation found
-                        break
-
-                if origI == i:
-                    print "%s:%d: Not terminated: %s"%(filename, linenum+1, curline)
-                else:
-                    found = curText
-
-            if result or (found != ""):
-                if (found == ""):
-                    #not a multiline string, found via the single line matching
-                    #full string in one line
-                    found = result.group(1)
-
-                found = found.replace(" ", "_")
-                #replace characters that need to be escaped in the language file
-                found = found.replace("=", r"\=").replace(":",r"\:")
-                #replace Java-escaped " to plain "
-                found = found.replace(r'\"','"')
-                #Java-escaped \ to plain \ need not to be converted - they have to be kept
-                #e.g., "\\#" has to be contained as "\\#" in the key
-                #found = found.replace('\\\\','\\')
-                if (found != "") and (found not in keyList):
-                    keyList.append(found)
-                    keyFiles[found] = (filename, linenum)
-                    #print "Adding ", found
-                #else:
-                #   print "Not adding: "+found
-                    
-            #Prepare a possible second run (multiple Globals.lang on this line)
-            if result:
-                lastPos = result.span()[1]
-                #regular expression is greedy. It will match until Globals.lang("
-                #therefore, we have to adjust lastPos
-                lastPos = lastPos - 14
-                if len(curline) <= lastPos:
-                    curline = ""
-                else:
-                    curline = curline[lastPos:]
-            else:
-                #terminate processing of this line, continue to next line
-                curline = ""
-                
-        i = i+1
-            
-# Find all Java source files in the given directory, and read the lines of each,
-# calling handleJavaCode on the contents:   
-def handleDir(lists, dirname, fnames):
-    keyList, notTermList = lists    
-    for file in fnames:
-        if len(file) > 6 and file[(len(file)-5):len(file)] == ".java":
-            fl = open(dirname+os.sep+file)
-            lines = fl.read()
-            fl.close()
-            handleJavaCode(dirname + os.sep + file, lines, keyList, notTermList)
-            
-# Go through subdirectories and call handleDir on all diroctories:                      
-def traverseFileTree(dir):
-    keyList = []
-    notTermList = []
-    os.path.walk(dir, handleDir, (keyList, notTermList))
-    print "Keys found: "+str(len(keyList))
-    return keyList
-
-    
-# Searches out all translation calls in the Java source files, and reports which
-# are not present in the given resource file.
-#
-# arg: mainFile: a .properties file with the keys to sync with
-def findNewKeysInJavaCode(mainFile, dir, update):
-    keystempo = []
-    keyListtempo = []
-    f1 = open(mainFile)
-    lines = f1.readlines()
-    f1.close()
-    keys = indexFile(lines)
-    keyList = traverseFileTree(dir)
-   
-    # Open the file again, for appending:
-    if update:
-        f1 = open(mainFile, "a")
-        f1.write("\n")
-        
-    # Look for keys that are used in the code, but not present in the language file:
-    for key in keyList:
-        value = key.replace("\\:",":").replace("\\=", "=")
-        if key not in keys:
-            fileName, lineNum = keyFiles[key]
-            print "%s:%i:Missing key: %s"%(fileName, lineNum + 1, value)
-            if update:
-                f1.write(key+"="+value+"\n")
-    
-    # Look for keys in the language file that are not used in the code:
-    for key in keys:
-        if key not in keyList:
-            print "Possible obsolete key: "+key
-        
-    if update:
-        f1.close()
-    
-    
-def lookForDuplicates(file, displayKeys):
-    duplicount = 0
-    f1 = open(file)
-    lines = f1.readlines()
-    f1.close()
-    mappings = {}
-    emptyVals = 0
-    for line in lines:
-        comment = line.find("#")
-        index = line.find("=")
-        if (comment != 0) and (index > 0):
-            key = line[0:index]
-            value = line[index+1:].strip()
-            if key in mappings:
-                mappings[key].append(value)
-                duplicount += 1
-                if displayKeys:
-                 print "Duplicate: "+file+": "+key+" =",
-                 print mappings[key]
-            else:
-                mappings[key] = [value]
-                if value == "":
-                   emptyVals = emptyVals + 1
-                    if displayKeys:
-                     print "Empty value: "+file+": "+key
-                #print "New: "+value
-    if duplicount > 0:
-       dupstring = str(duplicount)+" duplicates. "
-    else:
-       dupstring = ""
-    if emptyVals > 0:
-        emptStr = str(emptyVals)+" empty values. "
-    else:
-       emptStr = ""
-    if duplicount+emptyVals > 0:
-       okString = ""
-    else:
-       okString = "ok"
-    print file+": "+dupstring+emptStr+okString
-    #print file+": "+str(emptyVals)+" empty values."
-        
-        
-############# Main part ###################
-
-if len(sys.argv) == 1:
-    print """This program must be run from the "src" directory right below the jabref base directory.
-    
-Usage: syncLang.py option   
-Option can be one of the following:
-    -c: Search the language files for empty and duplicate translations. Display only
-        counts for duplicated and empty values in each language file.
-
-    -d: Search the language files for empty and duplicate translations. 
-        For each duplicate set found, a list will be printed showing the various 
-        translations for the same key. There is currently to option to remove duplicates
-        automatically.
-        
-    -s [-u]: Search the Java source files for language keys. All keys that are found in the source files
-        but not in "JabRef_en.properties" are listed. If the -u option is specified, these keys will
-        automatically be added to "JabRef_en.properties".
-        
-        The program will also list "Not terminated" keys. These are keys that are concatenated over 
-        more than one line, that the program is not (currently) able to resolve.
-        
-        Finally, the program will list "Possible obsolete keys". These are keys that are present in
-        "JabRef_en.properties", but could not be found in the Java source code. Note that the 
-        "Not terminated" keys will be likely to appear here, since they were not resolved.
-        
-    -t [-u]: Compare the contents of "JabRef_en.properties" and "Menu_en.properties" against the other 
-        language files. The program will list for all the other files which keys from the English
-        file are missing. Additionally, the program will list keys in the other files which are
-        not present in the English file - possible obsolete keys.
-        
-        If the -u option is specified, all missing keys will automatically be added to the files.
-        There is currently no option to remove obsolete keys automatically.
-"""
-    
-elif (len(sys.argv) >= 2) and (sys.argv[1] == "-s"):
-    if (len(sys.argv) >= 3) and (sys.argv[2] == "-u"):
-        update = 1
-    else:
-        update = 0
-    findNewKeysInJavaCode("resource/JabRef_en.properties", ".", update)
-    
-elif (len(sys.argv) >= 2) and (sys.argv[1] == "-t"):
-    if (len(sys.argv) >= 3) and (sys.argv[2] == "-u"):
-        changeFiles = 1
-    else:
-        changeFiles = 0
-        
-    handleFileSet("resource/JabRef_en.properties", ("resource/JabRef_de.properties",\
-        "resource/JabRef_fr.properties", "resource/JabRef_it.properties",\
-        "resource/JabRef_ja.properties", "resource/JabRef_pt_BR.properties",\
-        "resource/JabRef_nl.properties", "resource/JabRef_da.properties",\
-        "resource/JabRef_no.properties", "resource/JabRef_tr.properties",\
-        "resource/JabRef_vi.properties", "resource/JabRef_in.properties", \
-        "resource/JabRef_zh.properties"), changeFiles)
-    handleFileSet("resource/Menu_en.properties", ("resource/Menu_de.properties",\
-        "resource/Menu_fr.properties", "resource/Menu_it.properties",\
-        "resource/Menu_ja.properties", "resource/Menu_pt_BR.properties",\
-        "resource/Menu_nl.properties", "resource/Menu_da.properties",\
-        "resource/Menu_es.properties",\
-        "resource/Menu_no.properties", "resource/Menu_tr.properties",\
-        "resource/Menu_vi.properties", "resource/Menu_in.properties",\
-        "resource/Menu_zh.properties"), changeFiles)
-        
-elif (len(sys.argv) >= 2) and ((sys.argv[1] == "-d") or (sys.argv[1] == "-c")):
-    files = ("resource/JabRef_en.properties", "resource/JabRef_de.properties",\
-        "resource/JabRef_fr.properties", "resource/JabRef_it.properties",\
-        "resource/JabRef_ja.properties", "resource/JabRef_pt_BR.properties",\
-        "resource/JabRef_no.properties", "resource/JabRef_nl.properties",\
-        "resource/JabRef_da.properties",\
-        "resource/JabRef_tr.properties",\
-        "resource/JabRef_vi.properties", "resource/JabRef_in.properties",\
-        "resource/JabRef_zh.properties",\
-        "resource/Menu_en.properties", "resource/Menu_de.properties",\
-        "resource/Menu_fr.properties", "resource/Menu_it.properties",\
-        "resource/Menu_ja.properties", "resource/Menu_pt_BR.properties",\
-        "resource/Menu_no.properties", "resource/Menu_nl.properties",\
-        "resource/Menu_da.properties", "resource/Menu_es.properties", \
-        "resource/Menu_tr.properties",\
-        "resource/Menu_vi.properties", "resource/Menu_in.properties",\
-        "resource/Menu_zh.properties")
-    for file in files:
-        lookForDuplicates(file, sys.argv[1] == "-d")
+import sys\r
+import os\r
+import re\r
+\r
+keyFiles = {}\r
+\r
+# Builds a list of all translation keys in the list of lines.\r
+def indexFile(lines):\r
+    allKeys = []\r
+    for line in lines:\r
+        comment = line.find("#")\r
+        if (comment != 0):\r
+            index = line.find("=")\r
+            while ((index > 0) and (line[index-1]=="\\")):\r
+                index = line.find("=", index+1)\r
+            if (index > 0):\r
+                allKeys.append(line[0:index])\r
+    allKeys.sort()\r
+    return allKeys\r
+        \r
+\r
+# Finds all keys in the first list that are not present in the second list:\r
+def findMissingKeys(first, second):\r
+    missing = []\r
+    for key in first:\r
+        if not key in second:\r
+            missing.append(key)\r
+    return missing\r
+\r
+\r
+# Appends all the given keys to the file:\r
+def appendMissingKeys(filename, keys):\r
+    file = open(filename, "a")\r
+    file.write("\n")\r
+    for key in keys:\r
+        file.write(key+"=\n")\r
+\r
+def handleFileSet(mainFile, files, changeFiles):\r
+    f1 = open(mainFile)\r
+    lines = f1.readlines()\r
+    f1.close()\r
+    keys = indexFile(lines)\r
+    keysPresent = []\r
+    for i in range(0, len(files)):\r
+        f2 = open(files[i])\r
+        lines = f2.readlines()\r
+        f2.close()\r
+        keysPresent.append(indexFile(lines))\r
+        missing = findMissingKeys(keys, keysPresent[i])\r
+        \r
+        print "\n\nFile '"+files[i]+"'\n"\r
+        if len(missing) == 0:\r
+            print "----> No missing keys."\r
+        else:\r
+            print "----> Missing keys:"\r
+            for key in missing:\r
+                print key\r
+\r
+            if changeFiles == 1:\r
+                print "Update file?",\r
+                if raw_input() in ['y', 'Y']:\r
+                    appendMissingKeys(files[i], missing)\r
+            print ""\r
+        \r
+        # See if this file has keys that are not in the main file:\r
+        redundant = findMissingKeys(keysPresent[i], keys)\r
+        if len(redundant) > 0:\r
+            print "----> Possible obsolete keys (not in English language file):"\r
+            for key in redundant:\r
+                print key\r
+                \r
+            #if changeFiles == 1:\r
+            #   print "Update file?",\r
+            #   if raw_input() in ['y', 'Y']:\r
+            #       removeRedundantKeys(files[i], redundant)\r
+            print ""\r
+        \r
+def handleJavaCode(filename, lines, keyList, notTermList):\r
+    #Extract first string parameter from Globals.lang call. E.g., Globals.lang("Default")\r
+    reOnlyString = r'"((\\"|[^"])*)"[^"]*'\r
+    patt = re.compile(r'Globals\s*\.\s*lang\s*\(\s*' + reOnlyString)\r
+    #second pattern as Mr Dlib contribution indirectly uses Global.lang\r
+    patta = re.compile(r'LocalizationSupport.message\(' + reOnlyString)\r
+    pattOnlyString = re.compile(reOnlyString)\r
+\r
+    #Find multiline Globals lang statements. E.g.:\r
+    #Globals.lang("This is my string" +\r
+    # "with a long text")\r
+    patt2 = re.compile(r'Globals\s*\.\s*lang\s*\(([^)])*$')\r
+\r
+    pattPlus = re.compile(r'^\s*\+')\r
+\r
+    eList = list(enumerate(lines.split("\n")))\r
+    i = 0\r
+    while i < len(eList):\r
+        linenum, curline = eList[i]\r
+        \r
+        #Remove Java single line comments\r
+        if curline.find("http://") < 0:\r
+            curline = re.sub("//.*", "", curline)\r
+\r
+        while (curline != ""):\r
+            result = patt.search(curline)\r
+            if (not result):\r
+                result = patta.search(curline)\r
+            result2 = patt2.search(curline)\r
+\r
+            found = ""\r
+\r
+            if result2 and curline.find('",') < 0:\r
+                # not terminated\r
+                # but it could be a multiline string\r
+                if result:\r
+                    curText = result.group(1)\r
+                    searchForPlus = True\r
+                else:\r
+                    curText = ""\r
+                    searchForPlus = False\r
+                origI = i\r
+                #inspect next line\r
+                while i+1 < len(eList):\r
+                    linenum2, curline2 = eList[i+1]\r
+                    if (not searchForPlus) or pattPlus.search(curline2):\r
+                        #from now on, we always have to search for a plus\r
+                        searchForPlus = True\r
+\r
+                        #The current line has been handled here, therefore indicate to handle the next line\r
+                        i = i+1\r
+                        linenum = linenum2\r
+                        curline = curline2\r
+\r
+                        #Search for the occurence of a string\r
+                        result = pattOnlyString.search(curline2)\r
+                        if result:\r
+                            curText = curText + result.group(1)\r
+                            #check for several strings in this line\r
+                            if curline2.count('\"') > 2:\r
+                                break\r
+                            #check for several arguments in the line\r
+                            if curline2.find('",') > 0:\r
+                                break\r
+                            if curline2.endswith(")"):\r
+                                break\r
+                        else:\r
+                            #plus sign at the beginning found, but no string\r
+                            break\r
+                    else:\r
+                        #no continuation found\r
+                        break\r
+\r
+                if origI == i:\r
+                    print "%s:%d: Not terminated: %s"%(filename, linenum+1, curline)\r
+                else:\r
+                    found = curText\r
+\r
+            if result or (found != ""):\r
+                if (found == ""):\r
+                    #not a multiline string, found via the single line matching\r
+                    #full string in one line\r
+                    found = result.group(1)\r
+\r
+                found = found.replace(" ", "_")\r
+                #replace characters that need to be escaped in the language file\r
+                found = found.replace("=", r"\=").replace(":",r"\:")\r
+                #replace Java-escaped " to plain "\r
+                found = found.replace(r'\"','"')\r
+                #Java-escaped \ to plain \ need not to be converted - they have to be kept\r
+                #e.g., "\\#" has to be contained as "\\#" in the key\r
+                #found = found.replace('\\\\','\\')\r
+                if (found != "") and (found not in keyList):\r
+                    keyList.append(found)\r
+                    keyFiles[found] = (filename, linenum)\r
+                    #print "Adding ", found\r
+                #else:\r
+                #   print "Not adding: "+found\r
+                    \r
+            #Prepare a possible second run (multiple Globals.lang on this line)\r
+            if result:\r
+                lastPos = result.span()[1]\r
+                #regular expression is greedy. It will match until Globals.lang("\r
+                #therefore, we have to adjust lastPos\r
+                lastPos = lastPos - 14\r
+                if len(curline) <= lastPos:\r
+                    curline = ""\r
+                else:\r
+                    curline = curline[lastPos:]\r
+            else:\r
+                #terminate processing of this line, continue to next line\r
+                curline = ""\r
+                \r
+        i = i+1\r
+            \r
+# Find all Java source files in the given directory, and read the lines of each,\r
+# calling handleJavaCode on the contents:   \r
+def handleDir(lists, dirname, fnames):\r
+    keyList, notTermList = lists    \r
+    for file in fnames:\r
+        if len(file) > 6 and file[(len(file)-5):len(file)] == ".java":\r
+            fl = open(dirname+os.sep+file)\r
+            lines = fl.read()\r
+            fl.close()\r
+            handleJavaCode(dirname + os.sep + file, lines, keyList, notTermList)\r
+            \r
+# Go through subdirectories and call handleDir on all diroctories:                      \r
+def traverseFileTree(dir):\r
+    keyList = []\r
+    notTermList = []\r
+    os.path.walk(dir, handleDir, (keyList, notTermList))\r
+    print "Keys found: "+str(len(keyList))\r
+    return keyList\r
+\r
+    \r
+# Searches out all translation calls in the Java source files, and reports which\r
+# are not present in the given resource file.\r
+#\r
+# arg: mainFile: a .properties file with the keys to sync with\r
+def findNewKeysInJavaCode(mainFile, dir, update):\r
+    keystempo = []\r
+    keyListtempo = []\r
+    f1 = open(mainFile)\r
+    lines = f1.readlines()\r
+    f1.close()\r
+    keys = indexFile(lines)\r
+    keyList = traverseFileTree(dir)\r
+   \r
+    # Open the file again, for appending:\r
+    if update:\r
+        f1 = open(mainFile, "a")\r
+        f1.write("\n")\r
+        \r
+    # Look for keys that are used in the code, but not present in the language file:\r
+    for key in keyList:\r
+        value = key.replace("\\:",":").replace("\\=", "=")\r
+        if key not in keys:\r
+            fileName, lineNum = keyFiles[key]\r
+            print "%s:%i:Missing key: %s"%(fileName, lineNum + 1, value)\r
+            if update:\r
+                f1.write(key+"="+value+"\n")\r
+    \r
+    # Look for keys in the language file that are not used in the code:\r
+    for key in keys:\r
+        if key not in keyList:\r
+            print "Possible obsolete key: "+key\r
+        \r
+    if update:\r
+        f1.close()\r
+    \r
+    \r
+def lookForDuplicates(file, displayKeys):\r
+    duplicount = 0\r
+    f1 = open(file)\r
+    lines = f1.readlines()\r
+    f1.close()\r
+    mappings = {}\r
+    emptyVals = 0\r
+    for line in lines:\r
+        comment = line.find("#")\r
+        index = line.find("=")\r
+        if (comment != 0) and (index > 0):\r
+            key = line[0:index]\r
+            value = line[index+1:].strip()\r
+            if key in mappings:\r
+                mappings[key].append(value)\r
+                duplicount += 1\r
+                if displayKeys:\r
+                 print "Duplicate: "+file+": "+key+" =",\r
+                 print mappings[key]\r
+            else:\r
+                mappings[key] = [value]\r
+                if value == "":\r
+                   emptyVals = emptyVals + 1\r
+                    if displayKeys:\r
+                     print "Empty value: "+file+": "+key\r
+                #print "New: "+value\r
+    if duplicount > 0:\r
+       dupstring = str(duplicount)+" duplicates. "\r
+    else:\r
+       dupstring = ""\r
+    if emptyVals > 0:\r
+        emptStr = str(emptyVals)+" empty values. "\r
+    else:\r
+       emptStr = ""\r
+    if duplicount+emptyVals > 0:\r
+       okString = ""\r
+    else:\r
+       okString = "ok"\r
+    print file+": "+dupstring+emptStr+okString\r
+    #print file+": "+str(emptyVals)+" empty values."\r
+        \r
+        \r
+############# Main part ###################\r
+\r
+if len(sys.argv) == 1:\r
+    print """This program must be run from the "src" directory right below the jabref base directory.\r
+    \r
+Usage: syncLang.py option   \r
+Option can be one of the following:\r
\r
+    -c: Search the language files for empty and duplicate translations. Display only\r
+        counts for duplicated and empty values in each language file.\r
+\r
+    -d: Search the language files for empty and duplicate translations. \r
+        For each duplicate set found, a list will be printed showing the various \r
+        translations for the same key. There is currently to option to remove duplicates\r
+        automatically.\r
+        \r
+    -s [-u]: Search the Java source files for language keys. All keys that are found in the source files\r
+        but not in "JabRef_en.properties" are listed. If the -u option is specified, these keys will\r
+        automatically be added to "JabRef_en.properties".\r
+        \r
+        The program will also list "Not terminated" keys. These are keys that are concatenated over \r
+        more than one line, that the program is not (currently) able to resolve.\r
+        \r
+        Finally, the program will list "Possible obsolete keys". These are keys that are present in\r
+        "JabRef_en.properties", but could not be found in the Java source code. Note that the \r
+        "Not terminated" keys will be likely to appear here, since they were not resolved.\r
+        \r
+    -t [-u]: Compare the contents of "JabRef_en.properties" and "Menu_en.properties" against the other \r
+        language files. The program will list for all the other files which keys from the English\r
+        file are missing. Additionally, the program will list keys in the other files which are\r
+        not present in the English file - possible obsolete keys.\r
+        \r
+        If the -u option is specified, all missing keys will automatically be added to the files.\r
+        There is currently no option to remove obsolete keys automatically.\r
+"""\r
+    \r
+elif (len(sys.argv) >= 2) and (sys.argv[1] == "-s"):\r
+    if (len(sys.argv) >= 3) and (sys.argv[2] == "-u"):\r
+        update = 1\r
+    else:\r
+        update = 0\r
+    findNewKeysInJavaCode("resource/JabRef_en.properties", ".", update)\r
+    \r
+elif (len(sys.argv) >= 2) and (sys.argv[1] == "-t"):\r
+    if (len(sys.argv) >= 3) and (sys.argv[2] == "-u"):\r
+        changeFiles = 1\r
+    else:\r
+        changeFiles = 0\r
+        \r
+    handleFileSet("resource/JabRef_en.properties", ("resource/JabRef_de.properties",\\r
+        "resource/JabRef_fr.properties", "resource/JabRef_it.properties",\\r
+        "resource/JabRef_ja.properties", "resource/JabRef_pt_BR.properties",\\r
+        "resource/JabRef_nl.properties", "resource/JabRef_da.properties",\\r
+        "resource/JabRef_no.properties", "resource/JabRef_tr.properties",\\r
+        "resource/JabRef_vi.properties", "resource/JabRef_in.properties", \\r
+        "resource/JabRef_zh.properties"), changeFiles)\r
+    handleFileSet("resource/Menu_en.properties", ("resource/Menu_de.properties",\\r
+        "resource/Menu_fr.properties", "resource/Menu_it.properties",\\r
+        "resource/Menu_ja.properties", "resource/Menu_pt_BR.properties",\\r
+        "resource/Menu_nl.properties", "resource/Menu_da.properties",\\r
+        "resource/Menu_es.properties",\\r
+        "resource/Menu_no.properties", "resource/Menu_tr.properties",\\r
+        "resource/Menu_vi.properties", "resource/Menu_in.properties",\\r
+        "resource/Menu_zh.properties"), changeFiles)\r
+        \r
+elif (len(sys.argv) >= 2) and ((sys.argv[1] == "-d") or (sys.argv[1] == "-c")):\r
+    files = ("resource/JabRef_en.properties", "resource/JabRef_de.properties",\\r
+        "resource/JabRef_fr.properties", "resource/JabRef_it.properties",\\r
+        "resource/JabRef_ja.properties", "resource/JabRef_pt_BR.properties",\\r
+        "resource/JabRef_no.properties", "resource/JabRef_nl.properties",\\r
+        "resource/JabRef_da.properties",\\r
+        "resource/JabRef_tr.properties",\\r
+        "resource/JabRef_vi.properties", "resource/JabRef_in.properties",\\r
+        "resource/JabRef_zh.properties",\\r
+        "resource/Menu_en.properties", "resource/Menu_de.properties",\\r
+        "resource/Menu_fr.properties", "resource/Menu_it.properties",\\r
+        "resource/Menu_ja.properties", "resource/Menu_pt_BR.properties",\\r
+        "resource/Menu_no.properties", "resource/Menu_nl.properties",\\r
+        "resource/Menu_da.properties", "resource/Menu_es.properties", \\r
+        "resource/Menu_tr.properties",\\r
+        "resource/Menu_vi.properties", "resource/Menu_in.properties",\\r
+        "resource/Menu_zh.properties")\r
+    for file in files:\r
+        lookForDuplicates(file, sys.argv[1] == "-d")\r