releasing package jabref version 2.10~beta2+ds-1
[debian/jabref.git] / syncLang.py
index ef9070c..790bc36 100644 (file)
-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
+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
+
+    filesJabRef = filter(lambda s: (s.startswith('JabRef_') and not (s.startswith('JabRef_en'))), os.listdir("resource"));
+    filesJabRef = ["resource/" + i for i in filesJabRef];
+    filesMenu = filter(lambda s: (s.startswith('Menu_') and not (s.startswith('Menu_en'))), os.listdir("resource"));
+    filesMenu = ["resource/" + i for i in filesMenu];
+
+    handleFileSet("resource/JabRef_en.properties", filesJabRef, changeFiles)
+    handleFileSet("resource/Menu_en.properties", filesMenu, changeFiles)
+
+elif (len(sys.argv) >= 2) and ((sys.argv[1] == "-d") or (sys.argv[1] == "-c")):
+    files = filter(lambda s: (s.startswith('JabRef_') and not (s.startswith('JabRef_en'))), os.listdir("resource"));
+    files.extend(filter(lambda s: (s.startswith('Menu_') and not (s.startswith('Menu_en'))), os.listdir("resource")));
+    files = ["resource/" + i for i in files];
+    for file in files:
+        lookForDuplicates(file, sys.argv[1] == "-d")