pandory500/SDL_GameControllerDB
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
SDL_GameControllerDB/check.py
Philippe Groarke 04ebce52ee Update to SDL 2.0.9.
2018-12-01 10:52:53 -05:00

483 lines
16 KiB
Python
Executable file
Raw Blame History

#!/usr/bin/env python
'''
Simple DirectMedia Layer
Copyright (C) 2017-2018 Philippe Groarke <philippe.groarke@gmail.com>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
'''
import sys
# if sys.version_info[0] != 3:
# print("This script requires Python 3.")
# exit(1)
from os import path
from collections import OrderedDict
import string
import collections
import shutil
import argparse
import csv
import re
import copy
FILE_HEADER = "# Game Controller DB for SDL in %s format\n" \
"# Source: https://github.com/gabomdq/SDL_GameControllerDB\n"
sdl_version = "2.0.9"
mappings_dict = OrderedDict([
("Windows", {}),
("Mac OS X", {}),
("Linux", {}),
("Android", {}),
("iOS", {}),
])
header_mappings_dict = copy.deepcopy(mappings_dict)
parser = argparse.ArgumentParser()
parser.add_argument("input_file", help="database file to check, " \
"ex. gamecontrollerdb.txt")
parser.add_argument("--format", help="sorts, formats and removes duplicates",
action="store_true")
parser.add_argument("--convert_guids", help="convert Windows and macOS " \
"GUIDs to the newer SDL 2.0.5 format",
action="store_true")
parser.add_argument("--add_missing_platform", help="adds a platform "\
"field if it is missing on Windows and Mac OS X 2.0.4 entries",
action="store_true")
parser.add_argument("--import_header", metavar="sdl_header",
help="imports and overrides mappings using SDL_gamecontrollerdb.h")
class Mapping:
GUID_REGEX = re.compile(r"^(xinput|[0-9a-fA-F]{32,32})$")
BUTTON_REGEXES = {
"+a": re.compile(r"^[0-9]+\~?$"),
"-a": re.compile(r"^[0-9]+\~?$"),
"a": re.compile(r"^[0-9]+\~?$"),
"b": re.compile(r"^[0-9]+$"),
"h": re.compile(r"^[0-9]+\.(1|2|4|8)$"),
}
def __init__(self, mapping_string, line_number, add_missing_platform = False):
if not mapping_string.endswith(",\n") and not mapping_string.endswith(","):
raise ValueError("Mapping should end with comma (,)")
self.guid = ""
self.name = ""
self.platform = ""
self.line_number = 0
self.__keys = {
"+leftx": "",
"+lefty": "",
"+rightx": "",
"+righty": "",
"-leftx": "",
"-lefty": "",
"-rightx": "",
"-righty": "",
"a": "",
"b": "",
"back": "",
"dpdown": "",
"dpleft": "",
"dpright": "",
"dpup": "",
"guide": "",
"leftshoulder": "",
"leftstick": "",
"lefttrigger": "",
"leftx": "",
"lefty": "",
"rightshoulder": "",
"rightstick": "",
"righttrigger": "",
"rightx": "",
"righty": "",
"start": "",
"x": "",
"y": "",
}
self.line_number = line_number
reader = csv.reader([mapping_string], skipinitialspace=True)
mapping = next(reader)
mapping = list(filter(None, mapping))
self.set_guid(mapping[0])
mapping.pop(0)
self.set_name(mapping[0])
mapping.pop(0)
self.set_platform(mapping, add_missing_platform)
self.set_keys(mapping)
# Remove empty mappings.
self.__keys = {k:v for (k,v) in self.__keys.items() if v is not ""}
def set_guid(self, guid):
global sdl_version
if not self.GUID_REGEX.match(guid):
raise ValueError("GUID malformed.", guid)
if sdl_version == "2.0.4" or sdl_version == "2.0.5":
self.guid = guid
return
if guid[20:32] == "504944564944":
raise ValueError("GUID in SDL 2.0.4 format, please update your "\
"mapping software.")
if guid[4:16] == "000000000000" and guid[20:32] == "000000000000":
raise ValueError("GUID in SDL 2.0.4 format, please update your "\
"mapping software.")
self.guid = guid
def set_name(self, name):
name = re.sub(r" +", " ", name)
self.name = name
def __get_missing_platform(self):
if self.guid[20:32] == "504944564944":
print("Adding 'platform:Windows' to %s" % (self.name))
return ("platform:Windows")
elif self.guid[4:16] == "000000000000" \
and self.guid[20:32] == "000000000000":
print("Adding 'platform:Mac OS X' to %s" % (self.name))
return ("platform:Mac OS X")
else:
raise ValueError("Add missing platform : Cannot determine platform"\
" confidently.")
def set_platform(self, mapping, add_missing_platform):
remove_field_from_mapping = True
platform_kv = next((x for x in mapping if "platform:" in x), None)
if platform_kv == None:
if add_missing_platform:
platform_kv = self.__get_missing_platform()
remove_field_from_mapping = False
else:
raise ValueError("Required 'platform' field not found.")
platform = platform_kv.split(':')[1]
if platform not in mappings_dict.keys():
raise ValueError("Invalid platform.", platform)
self.platform = platform
if not remove_field_from_mapping:
return
index = mapping.index(platform_kv)
mapping.pop(index)
def set_keys(self, mapping):
throw = False
error_msg = ""
for kv in mapping:
button_key, button_val = kv.split(':')
if not button_key in self.__keys:
raise ValueError("Unrecognized key.", button_key)
# Gather duplicates.
if self.__keys[button_key] is not "":
throw = True
error_msg += "%s (was %s:%s), " \
% (kv, button_key, self.__keys[button_key])
continue
for butt,regex in self.BUTTON_REGEXES.items():
if not button_val.startswith(butt):
continue
val = button_val.replace(butt, "")
if not regex.match(val):
raise ValueError("Invalid value.", butt, val)
self.__keys[button_key] = button_val
break
if throw:
raise ValueError("Duplicate keys detected.", error_msg)
def __str__(self):
ret = "Mapping {\n guid: %s\n name: %s\n platform: %s\n" \
% (self.guid, self.name, self.platform)
ret += " Keys {\n"
for key,val in self.__keys.items():
ret += " %s: %s\n" % (key, val)
ret += " }\n}"
return ret
def __eq__(self, other):
ret = True
ret &= self.guid == other.guid
ret &= self.name == other.name
ret &= self.platform == other.platform
ret &= self.__keys == other.__keys
return ret
def __ne__(self, other):
return not self.__eq__(other)
def serialize(self):
ret = "%s,%s," % (self.guid, self.name)
sorted_keys = sorted(self.__keys.items())
for key,val in sorted_keys:
ret += "%s:%s," % (key, val)
ret += "platform:%s," % (self.platform)
return ret
# https://hg.libsdl.org/SDL/rev/20855a38e048
def convert_guid(self):
if self.platform == "Windows":
if self.guid[20:32] != "504944564944":
return False
guid = self.guid
guid = guid[:20] + "000000000000"
guid = guid[:16] + guid[4:8] + guid[20:]
guid = guid[:8] + guid[:4] + guid[12:]
guid = "03000000" + guid[8:]
guid = guid.lower()
print("%s : Converted %s GUID. From %s to %s" \
%(self.platform, self.name, self.guid, guid))
self.guid = guid
elif self.platform == "Mac OS X":
if self.guid[4:16] != "000000000000" \
or self.guid[20:32] != "000000000000":
return False
guid = self.guid
guid = guid[:20] + "000000000000"
guid = guid[:8] + guid[:4] + guid[12:]
guid = "03000000" + guid[8:]
guid = guid.lower()
print("%s : Converted %s GUID. From %s to %s" \
% (self.platform, self.name, self.guid, guid))
self.guid = guid
else:
return False
return True
def import_header(mappings_dict, filepath, debug_out = False):
class Platform:
XINPUT = 0
WINDOWS = 1
OSX = 2
LINUX = 3
ANDROID = 4
IOS = 5
NONE = 6
current_platform = Platform.NONE
input_file = open(filepath, mode="r")
for lineno, line in enumerate(input_file):
if "#if SDL_JOYSTICK_XINPUT" in line:
current_platform = Platform.XINPUT
continue
elif "#if SDL_JOYSTICK_DINPUT" in line:
current_platform = Platform.WINDOWS
continue
elif "#if defined(__MACOSX__)" in line:
current_platform = Platform.OSX
continue
elif "#if defined(__LINUX__)" in line:
current_platform = Platform.LINUX
continue
elif "#if defined(__ANDROID__)" in line:
current_platform = Platform.ANDROID
continue
elif "#if defined(SDL_JOYSTICK_MFI)" in line:
current_platform = Platform.IOS
continue
elif "#endif" in line:
current_platform = Platform.NONE
continue
if current_platform == Platform.NONE:
continue
mapping_string = line[line.find('"') + 1:]
mapping_string = mapping_string[:mapping_string.find('"')]
if current_platform == Platform.XINPUT:
mapping_string += "platform:Windows,"
if current_platform == Platform.WINDOWS:
mapping_string += "platform:Windows,"
if current_platform == Platform.OSX:
mapping_string += "platform:Mac OS X,"
if current_platform == Platform.LINUX:
mapping_string += "platform:Linux,"
if current_platform == Platform.ANDROID:
mapping_string += "platform:Android,"
if current_platform == Platform.IOS:
mapping_string += "platform:iOS,"
try:
mapping = Mapping(mapping_string, lineno + 1)
except ValueError as e:
print("\nError at line #" + str(lineno + 1))
print(e.args)
print("Ignoring mapping")
print(line)
continue
if debug_out:
print("%s : Importing %s" % (mapping.platform, mapping.name))
mappings_dict[mapping.platform][mapping.guid] = mapping
input_file.close()
def main():
global mappings_dict # { "platform": { "guid": Mapping }}
global header_mappings_dict # { "platform": { "guid": Mapping }}
global sdl_version
global parser
args = parser.parse_args()
success = True
if "204" in args.input_file:
sdl_version = "2.0.4"
elif "205" in args.input_file:
sdl_version = "2.0.5"
if args.add_missing_platform:
if sdl_version != "2.0.4":
print("Cannot add missing platforms on newer SDL database.")
args.add_missing_platform = False
else:
print("Will try to add missing platforms. Requires SDL 2.0.4 GUID.")
if not args.format:
print("Use --format option to save database. Running in debug "\
"output mode...")
# Tests.
print("\nApplying checks.")
import_header(header_mappings_dict,
"data/SDL_gamecontrollerdb" + sdl_version + ".h", False)
input_file = open(args.input_file, mode="r")
for lineno, line in enumerate(input_file):
if line.startswith('#') or line == '\n':
continue
try:
mapping = Mapping(line, lineno + 1, args.add_missing_platform)
except ValueError as e:
print("\nError at line #" + str(lineno + 1))
print(e.args)
print("In mapping")
print(line)
success = False
continue
if mapping.guid in mappings_dict[mapping.platform]:
print("\nDuplicate detected at line #" + str(lineno + 1))
prev_mapping = mappings_dict[mapping.platform][mapping.guid]
print("Previous mapping at line #" + str(prev_mapping.line_number))
print("In mapping")
print(line)
success = False
continue
if mapping.guid in header_mappings_dict[mapping.platform]:
if mapping != header_mappings_dict[mapping.platform][mapping.guid]:
print("\nCannot modify upstream SDL header mapping at line #" \
+ str(lineno + 1))
print("If you have problems with an official SDL mapping, " \
"please report the issue or send a pull request to " \
"the SDL project : libsdl.org.")
print("In mapping")
print(line)
success = False
continue
mappings_dict[mapping.platform][mapping.guid] = mapping
input_file.close()
if success:
print("No mapping errors found.")
else:
sys.exit(1)
# Misc tools.
if args.convert_guids:
print("Converting GUIDs to SDL 2.0.5+ format.")
if not args.format:
print("Use --format option to save database. Running in debug " \
"output mode...")
for platform,p_dict in mappings_dict.items():
for guid,mapping in p_dict.items():
if mapping.convert_guid():
del mappings_dict[platform][guid]
if mapping.guid in mappings_dict[platform]:
print("\nDuplicate detected when converting GUID.")
prev_mapping = mappings_dict[platform][mapping.guid]
print("Previous mapping %s" % prev_mapping.name)
print("Ignoring new mapping")
print(mapping.serialize())
print("\n")
continue
mappings_dict[platform][mapping.guid] = mapping
if args.import_header is not None:
print("Importing mappings from %s" % args.import_header)
if not args.format:
print("Use --format option to save database. Running in debug "\
"output mode...")
import_header(mappings_dict, args.import_header, not args.format)
if args.format:
print("\nFormatting db.")
out_filename = path.splitext(input_file.name)[0] + "_format.txt"
out_file = open(out_filename, 'w')
out_file.write(FILE_HEADER % sdl_version)
for platform,p_dict in mappings_dict.items():
out_file.write("\n")
out_file.write("# " + platform + "\n")
sorted_p_dict = sorted(p_dict.items(),
key=lambda x: ("%s\x00%s" % (x[1].name, x[0])).lower())
for guid,mapping in sorted_p_dict:
out_file.write(mapping.serialize() + "\n")
out_file.close()
backup_filename = (path.join(path.split(input_file.name)[0],
".bak." + path.split(input_file.name)[1]))
shutil.copyfile(input_file.name, backup_filename)
shutil.move(out_filename, input_file.name)
if __name__ == "__main__":
main()
Reference in a new issue View git blame Copy permalink