style: Fix PEP8 whitespace issues in Python files

Done with `autopep8 --select=E2,W2`, fixes:

- E201 - Remove extraneous whitespace.
- E202 - Remove extraneous whitespace.
- E203 - Remove extraneous whitespace.
- E211 - Remove extraneous whitespace.
- E221 - Fix extraneous whitespace around keywords.
- E222 - Fix extraneous whitespace around keywords.
- E223 - Fix extraneous whitespace around keywords.
- E224 - Remove extraneous whitespace around operator.
- E225 - Fix missing whitespace around operator.
- E226 - Fix missing whitespace around operator.
- E227 - Fix missing whitespace around operator.
- E228 - Fix missing whitespace around operator.
- E231 - Add missing whitespace.
- E231 - Fix various deprecated code (via lib2to3).
- E241 - Fix extraneous whitespace around keywords.
- E242 - Remove extraneous whitespace around operator.
- E251 - Remove whitespace around parameter '=' sign.
- E261 - Fix spacing after comment hash.
- E262 - Fix spacing after comment hash.
- E265 - Format block comments.
- E271 - Fix extraneous whitespace around keywords.
- E272 - Fix extraneous whitespace around keywords.
- E273 - Fix extraneous whitespace around keywords.
- E274 - Fix extraneous whitespace around keywords.
- W291 - Remove trailing whitespace.
- W293 - Remove trailing whitespace.

SConstruct

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-EnsureSConsVersion(0,14);
+EnsureSConsVersion(0, 14);
 
 
 import string
@@ -14,86 +14,86 @@ methods.update_version()
 
 # scan possible build platforms
 
-platform_list = [] # list of platforms
-platform_opts = {} # options for each platform
-platform_flags = {} # flags for each platform
+platform_list = []  # list of platforms
+platform_opts = {}  # options for each platform
+platform_flags = {}  # flags for each platform
 
 
-active_platforms=[]
-active_platform_ids=[]
-platform_exporters=[]
-global_defaults=[]
+active_platforms = []
+active_platform_ids = []
+platform_exporters = []
+global_defaults = []
 
 for x in glob.glob("platform/*"):
-    if (not os.path.isdir(x) or not os.path.exists(x+"/detect.py")):
+    if (not os.path.isdir(x) or not os.path.exists(x + "/detect.py")):
         continue
-    tmppath="./"+x
+    tmppath = "./" + x
 
     sys.path.append(tmppath)
     import detect
 
-    if (os.path.exists(x+"/export/export.cpp")):
+    if (os.path.exists(x + "/export/export.cpp")):
         platform_exporters.append(x[9:])
-    if (os.path.exists(x+"/globals/global_defaults.cpp")):
+    if (os.path.exists(x + "/globals/global_defaults.cpp")):
         global_defaults.append(x[9:])
     if (detect.is_active()):
-        active_platforms.append( detect.get_name() )
+        active_platforms.append(detect.get_name())
         active_platform_ids.append(x);
     if (detect.can_build()):
-        x=x.replace("platform/","") # rest of world
-        x=x.replace("platform\\","") # win32
-        platform_list+=[x]
-        platform_opts[x]=detect.get_opts()
-        platform_flags[x]=detect.get_flags()
+        x = x.replace("platform/", "")  # rest of world
+        x = x.replace("platform\\", "")  # win32
+        platform_list += [x]
+        platform_opts[x] = detect.get_opts()
+        platform_flags[x] = detect.get_flags()
     sys.path.remove(tmppath)
     sys.modules.pop('detect')
 
-module_list=methods.detect_modules()
+module_list = methods.detect_modules()
 
 
-#print "Detected Platforms: "+str(platform_list)
+# print "Detected Platforms: "+str(platform_list)
 
-methods.save_active_platforms(active_platforms,active_platform_ids)
+methods.save_active_platforms(active_platforms, active_platform_ids)
 
-custom_tools=['default']
+custom_tools = ['default']
 
 platform_arg = ARGUMENTS.get("platform", ARGUMENTS.get("p", False))
 
-if (os.name=="posix"):
+if (os.name == "posix"):
     pass
-elif (os.name=="nt"):
-    if (os.getenv("VSINSTALLDIR")==None or platform_arg=="android"):
-        custom_tools=['mingw']
+elif (os.name == "nt"):
+    if (os.getenv("VSINSTALLDIR") == None or platform_arg == "android"):
+        custom_tools = ['mingw']
 
-env_base=Environment(tools=custom_tools);
+env_base = Environment(tools=custom_tools);
 if 'TERM' in os.environ:
     env_base['ENV']['TERM'] = os.environ['TERM']
 env_base.AppendENVPath('PATH', os.getenv('PATH'))
 env_base.AppendENVPath('PKG_CONFIG_PATH', os.getenv('PKG_CONFIG_PATH'))
-env_base.global_defaults=global_defaults
-env_base.android_maven_repos=[]
-env_base.android_dependencies=[]
-env_base.android_java_dirs=[]
-env_base.android_res_dirs=[]
-env_base.android_aidl_dirs=[]
-env_base.android_jni_dirs=[]
-env_base.android_default_config=[]
-env_base.android_manifest_chunk=""
-env_base.android_permission_chunk=""
-env_base.android_appattributes_chunk=""
-env_base.disabled_modules=[]
-env_base.use_ptrcall=False
-env_base.split_drivers=False
-
-
-
-env_base.__class__.android_add_maven_repository=methods.android_add_maven_repository
-env_base.__class__.android_add_dependency=methods.android_add_dependency
-env_base.__class__.android_add_java_dir=methods.android_add_java_dir
-env_base.__class__.android_add_res_dir=methods.android_add_res_dir
-env_base.__class__.android_add_aidl_dir=methods.android_add_aidl_dir
-env_base.__class__.android_add_jni_dir=methods.android_add_jni_dir
-env_base.__class__.android_add_default_config=methods.android_add_default_config
+env_base.global_defaults = global_defaults
+env_base.android_maven_repos = []
+env_base.android_dependencies = []
+env_base.android_java_dirs = []
+env_base.android_res_dirs = []
+env_base.android_aidl_dirs = []
+env_base.android_jni_dirs = []
+env_base.android_default_config = []
+env_base.android_manifest_chunk = ""
+env_base.android_permission_chunk = ""
+env_base.android_appattributes_chunk = ""
+env_base.disabled_modules = []
+env_base.use_ptrcall = False
+env_base.split_drivers = False
+
+
+
+env_base.__class__.android_add_maven_repository = methods.android_add_maven_repository
+env_base.__class__.android_add_dependency = methods.android_add_dependency
+env_base.__class__.android_add_java_dir = methods.android_add_java_dir
+env_base.__class__.android_add_res_dir = methods.android_add_res_dir
+env_base.__class__.android_add_aidl_dir = methods.android_add_aidl_dir
+env_base.__class__.android_add_jni_dir = methods.android_add_jni_dir
+env_base.__class__.android_add_default_config = methods.android_add_default_config
 env_base.__class__.android_add_to_manifest = methods.android_add_to_manifest
 env_base.__class__.android_add_to_permissions = methods.android_add_to_permissions
 env_base.__class__.android_add_to_attributes = methods.android_add_to_attributes
@@ -103,8 +103,8 @@ env_base.__class__.add_source_files = methods.add_source_files
 env_base.__class__.use_windows_spawn_fix = methods.use_windows_spawn_fix
 env_base.__class__.split_lib = methods.split_lib
 
-env_base["x86_libtheora_opt_gcc"]=False
-env_base["x86_libtheora_opt_vc"]=False
+env_base["x86_libtheora_opt_gcc"] = False
+env_base["x86_libtheora_opt_vc"] = False
 
 customs = ['custom.py']
 
@@ -113,44 +113,44 @@ if profile:
     import os.path
     if os.path.isfile(profile):
         customs.append(profile)
-    elif os.path.isfile(profile+".py"):
-        customs.append(profile+".py")
+    elif os.path.isfile(profile + ".py"):
+        customs.append(profile + ".py")
 
-opts=Variables(customs, ARGUMENTS)
+opts = Variables(customs, ARGUMENTS)
 opts.Add('target', 'Compile Target (debug/release_debug/release).', "debug")
 opts.Add('arch', 'Platform dependent architecture (arm/arm64/x86/x64/mips/etc)', "")
 opts.Add('bits', 'Compile Target Bits (default/32/64/fat).', "default")
-opts.Add('platform','Platform: '+str(platform_list)+'.',"")
-opts.Add('p','Platform (same as platform=).',"")
-opts.Add('tools','Build Tools (Including Editor): (yes/no)','yes')
-opts.Add('gdscript','Build GDSCript support: (yes/no)','yes')
-opts.Add('libogg','Ogg library for ogg container support (system/builtin)','builtin')
-opts.Add('libvorbis','Ogg Vorbis library for vorbis support (system/builtin)','builtin')
-opts.Add('libtheora','Theora library for theora module (system/builtin)','builtin')
-opts.Add('opus','Opus and opusfile library for Opus format support: (system/builtin)','builtin')
-opts.Add('minizip','Build Minizip Archive Support: (yes/no)','yes')
-opts.Add('squish','Squish library for BC Texture Compression in editor (system/builtin)','builtin')
-opts.Add('freetype','Freetype library for TTF support via freetype module (system/builtin)','builtin')
+opts.Add('platform', 'Platform: ' + str(platform_list) + '.', "")
+opts.Add('p', 'Platform (same as platform=).', "")
+opts.Add('tools', 'Build Tools (Including Editor): (yes/no)', 'yes')
+opts.Add('gdscript', 'Build GDSCript support: (yes/no)', 'yes')
+opts.Add('libogg', 'Ogg library for ogg container support (system/builtin)', 'builtin')
+opts.Add('libvorbis', 'Ogg Vorbis library for vorbis support (system/builtin)', 'builtin')
+opts.Add('libtheora', 'Theora library for theora module (system/builtin)', 'builtin')
+opts.Add('opus', 'Opus and opusfile library for Opus format support: (system/builtin)', 'builtin')
+opts.Add('minizip', 'Build Minizip Archive Support: (yes/no)', 'yes')
+opts.Add('squish', 'Squish library for BC Texture Compression in editor (system/builtin)', 'builtin')
+opts.Add('freetype', 'Freetype library for TTF support via freetype module (system/builtin)', 'builtin')
 # (akien) Unbundling would require work in audio_stream_speex.{cpp,h}, but since speex was
 # removed in 3.0+ and this is only to preserve compatibility in 2.1, I haven't worked on it.
 # Patches welcome if anyone cares :)
-opts.Add('speex','Speex library for speex support','builtin')
-opts.Add('xml','XML Save/Load support (yes/no)','yes')
-opts.Add('libpng','libpng library for image loader support (system/builtin)','builtin')
-opts.Add('libwebp','libwebp library for webp module (system/builtin)','builtin')
-opts.Add('openssl','OpenSSL library for openssl module (system/builtin)','builtin')
-opts.Add('libmpcdec','libmpcdec library for mpc module (system/builtin)','builtin')
-opts.Add('glew','GLEW library for the gl_context (system/builtin)','builtin')
+opts.Add('speex', 'Speex library for speex support', 'builtin')
+opts.Add('xml', 'XML Save/Load support (yes/no)', 'yes')
+opts.Add('libpng', 'libpng library for image loader support (system/builtin)', 'builtin')
+opts.Add('libwebp', 'libwebp library for webp module (system/builtin)', 'builtin')
+opts.Add('openssl', 'OpenSSL library for openssl module (system/builtin)', 'builtin')
+opts.Add('libmpcdec', 'libmpcdec library for mpc module (system/builtin)', 'builtin')
+opts.Add('glew', 'GLEW library for the gl_context (system/builtin)', 'builtin')
 opts.Add("CXX", "C++ Compiler")
 opts.Add("CC", "C Compiler")
 opts.Add("CCFLAGS", "Custom flags for the C/C++ compiler");
 opts.Add("CFLAGS", "Custom flags for the C compiler");
 opts.Add("LINKFLAGS", "Custom flags for the linker");
-opts.Add('unix_global_settings_path', 'unix-specific path to system-wide settings. Currently only used by templates.','')
+opts.Add('unix_global_settings_path', 'unix-specific path to system-wide settings. Currently only used by templates.', '')
 opts.Add('disable_3d', 'Disable 3D nodes for smaller executable (yes/no)', "no")
 opts.Add('disable_advanced_gui', 'Disable advance 3D gui nodes and behaviors (yes/no)', "no")
 opts.Add('verbose', 'Enable verbose output for the compilation (yes/no)', 'yes')
-opts.Add('deprecated','Enable deprecated features (yes/no)','yes')
+opts.Add('deprecated', 'Enable deprecated features (yes/no)', 'yes')
 opts.Add('extra_suffix', 'Custom extra suffix added to the base filename of all generated binary files.', '')
 opts.Add('vsproj', 'Generate Visual Studio Project. (yes/no)', 'no')
 
@@ -159,20 +159,20 @@ opts.Add('vsproj', 'Generate Visual Studio Project. (yes/no)', 'no')
 for k in platform_opts.keys():
     opt_list = platform_opts[k]
     for o in opt_list:
-        opts.Add(o[0],o[1],o[2])
+        opts.Add(o[0], o[1], o[2])
 
 for x in module_list:
-    opts.Add('module_'+x+'_enabled', "Enable module '"+x+"' (yes/no)", "yes")
+    opts.Add('module_' + x + '_enabled', "Enable module '" + x + "' (yes/no)", "yes")
 
-opts.Update(env_base) # update environment
-Help(opts.GenerateHelpText(env_base)) # generate help
+opts.Update(env_base)  # update environment
+Help(opts.GenerateHelpText(env_base))  # generate help
 
 # add default include paths
 
-env_base.Append(CPPPATH=['#core','#core/math','#tools','#drivers','#'])
+env_base.Append(CPPPATH=['#core', '#core/math', '#tools', '#drivers', '#'])
 
 # configure ENV for platform
-env_base.platform_exporters=platform_exporters
+env_base.platform_exporters = platform_exporters
 
 """
 sys.path.append("./platform/"+env_base["platform"])
@@ -182,58 +182,58 @@ sys.path.remove("./platform/"+env_base["platform"])
 sys.modules.pop('detect')
 """
 
-if (env_base['target']=='debug'):
+if (env_base['target'] == 'debug'):
     env_base.Append(CPPFLAGS=['-DDEBUG_MEMORY_ALLOC']);
     env_base.Append(CPPFLAGS=['-DSCI_NAMESPACE'])
 
-if (env_base['deprecated']!='no'):
+if (env_base['deprecated'] != 'no'):
     env_base.Append(CPPFLAGS=['-DENABLE_DEPRECATED']);
 
 env_base.platforms = {}
 
 
-selected_platform =""
+selected_platform = ""
 
 if env_base['platform'] != "":
-    selected_platform=env_base['platform']
+    selected_platform = env_base['platform']
 elif env_base['p'] != "":
-    selected_platform=env_base['p']
-    env_base["platform"]=selected_platform
+    selected_platform = env_base['p']
+    env_base["platform"] = selected_platform
 
 
 
 if selected_platform in platform_list:
 
-    sys.path.append("./platform/"+selected_platform)
+    sys.path.append("./platform/" + selected_platform)
     import detect
     if "create" in dir(detect):
         env = detect.create(env_base)
     else:
         env = env_base.Clone()
 
-    if env['vsproj']=="yes":
+    if env['vsproj'] == "yes":
         env.vs_incs = []
         env.vs_srcs = []
 
-        def AddToVSProject( sources ):
+        def AddToVSProject(sources):
             for x in sources:
                 if type(x) == type(""):
                     fname = env.File(x).path
                 else:
                     fname = env.File(x)[0].path
-                pieces =  fname.split(".")
-                if len(pieces)>0:
+                pieces = fname.split(".")
+                if len(pieces) > 0:
                     basename = pieces[0]
-                    basename = basename.replace('\\\\','/')
+                    basename = basename.replace('\\\\', '/')
                     env.vs_srcs = env.vs_srcs + [basename + ".cpp"]
                     env.vs_incs = env.vs_incs + [basename + ".h"]
-                    #print basename
+                    # print basename
         env.AddToVSProject = AddToVSProject
 
-    env.extra_suffix=""
+    env.extra_suffix = ""
 
-    if env["extra_suffix"] != '' :
-        env.extra_suffix += '.'+env["extra_suffix"]
+    if env["extra_suffix"] != '':
+        env.extra_suffix += '.' + env["extra_suffix"]
 
     CCFLAGS = env.get('CCFLAGS', '')
     env['CCFLAGS'] = ''
@@ -252,63 +252,63 @@ if selected_platform in platform_list:
 
     flag_list = platform_flags[selected_platform]
     for f in flag_list:
-        if not (f[0] in ARGUMENTS): # allow command line to override platform flags
+        if not (f[0] in ARGUMENTS):  # allow command line to override platform flags
             env[f[0]] = f[1]
 
-    #must happen after the flags, so when flags are used by configure, stuff happens (ie, ssl on x11)
+    # must happen after the flags, so when flags are used by configure, stuff happens (ie, ssl on x11)
     detect.configure(env)
 
     #env['platform_libsuffix'] = env['LIBSUFFIX']
 
-    suffix="."+selected_platform
+    suffix = "." + selected_platform
 
-    if (env["target"]=="release"):
-        if (env["tools"]=="yes"):
+    if (env["target"] == "release"):
+        if (env["tools"] == "yes"):
             print("Tools can only be built with targets 'debug' and 'release_debug'.")
             sys.exit(255)
-        suffix+=".opt"
+        suffix += ".opt"
 
         env.Append(CCFLAGS=['-DNDEBUG']);
 
-    elif (env["target"]=="release_debug"):
-        if (env["tools"]=="yes"):
-            suffix+=".opt.tools"
+    elif (env["target"] == "release_debug"):
+        if (env["tools"] == "yes"):
+            suffix += ".opt.tools"
         else:
-            suffix+=".opt.debug"
+            suffix += ".opt.debug"
     else:
-        if (env["tools"]=="yes"):
-            suffix+=".tools"
+        if (env["tools"] == "yes"):
+            suffix += ".tools"
         else:
-            suffix+=".debug"
+            suffix += ".debug"
 
     if env["arch"] != "":
-        suffix += "."+env["arch"]
-    elif (env["bits"]=="32"):
-        suffix+=".32"
-    elif (env["bits"]=="64"):
-        suffix+=".64"
-    elif (env["bits"]=="fat"):
-        suffix+=".fat"
-
-    suffix+=env.extra_suffix
-
-    env["PROGSUFFIX"]=suffix+env["PROGSUFFIX"]
-    env["OBJSUFFIX"]=suffix+env["OBJSUFFIX"]
-    env["LIBSUFFIX"]=suffix+env["LIBSUFFIX"]
-    env["SHLIBSUFFIX"]=suffix+env["SHLIBSUFFIX"]
-
-    sys.path.remove("./platform/"+selected_platform)
+        suffix += "." + env["arch"]
+    elif (env["bits"] == "32"):
+        suffix += ".32"
+    elif (env["bits"] == "64"):
+        suffix += ".64"
+    elif (env["bits"] == "fat"):
+        suffix += ".fat"
+
+    suffix += env.extra_suffix
+
+    env["PROGSUFFIX"] = suffix + env["PROGSUFFIX"]
+    env["OBJSUFFIX"] = suffix + env["OBJSUFFIX"]
+    env["LIBSUFFIX"] = suffix + env["LIBSUFFIX"]
+    env["SHLIBSUFFIX"] = suffix + env["SHLIBSUFFIX"]
+
+    sys.path.remove("./platform/" + selected_platform)
     sys.modules.pop('detect')
 
 
-    env.module_list=[]
+    env.module_list = []
 
     for x in module_list:
-        if env['module_'+x+'_enabled'] != "yes":
+        if env['module_' + x + '_enabled'] != "yes":
             continue
-        tmppath="./modules/"+x
+        tmppath = "./modules/" + x
         sys.path.append(tmppath)
-        env.current_module=x
+        env.current_module = x
         import config
         if (config.can_build(selected_platform)):
             config.configure(env)
@@ -323,27 +323,27 @@ if selected_platform in platform_list:
     # to test 64 bits compiltion
     # env.Append(CPPFLAGS=['-m64'])
 
-    if (env['tools']=='yes'):
+    if (env['tools'] == 'yes'):
         env.Append(CPPFLAGS=['-DTOOLS_ENABLED'])
-    if (env['disable_3d']=='yes'):
+    if (env['disable_3d'] == 'yes'):
         env.Append(CPPFLAGS=['-D_3D_DISABLED'])
-    if (env['gdscript']=='yes'):
+    if (env['gdscript'] == 'yes'):
         env.Append(CPPFLAGS=['-DGDSCRIPT_ENABLED'])
-    if (env['disable_advanced_gui']=='yes'):
+    if (env['disable_advanced_gui'] == 'yes'):
         env.Append(CPPFLAGS=['-DADVANCED_GUI_DISABLED'])
 
     if (env['minizip'] == 'yes'):
         env.Append(CPPFLAGS=['-DMINIZIP_ENABLED'])
 
-    if (env['xml']=='yes'):
+    if (env['xml'] == 'yes'):
         env.Append(CPPFLAGS=['-DXML_ENABLED'])
 
-    if (env['verbose']=='no'):
-        methods.no_verbose(sys,env)
+    if (env['verbose'] == 'no'):
+        methods.no_verbose(sys, env)
 
     Export('env')
 
-    #build subdirs, the build order is dependent on link order.
+    # build subdirs, the build order is dependent on link order.
 
     SConscript("core/SCsub")
     SConscript("servers/SCsub")
@@ -355,10 +355,10 @@ if selected_platform in platform_list:
     SConscript("modules/SCsub")
     SConscript("main/SCsub")
 
-    SConscript("platform/"+selected_platform+"/SCsub"); # build selected platform
+    SConscript("platform/" + selected_platform + "/SCsub");  # build selected platform
 
     # Microsoft Visual Studio Project Generation
-    if (env['vsproj'])=="yes":
+    if (env['vsproj']) == "yes":
 
         AddToVSProject(env.core_sources)
         AddToVSProject(env.main_sources)
@@ -371,7 +371,7 @@ if selected_platform in platform_list:
         # Even then, SCons still seems to ignore it and builds with the latest MSVC...
         # That said, it's not needed to be set so far but I'm leaving it here so that this comment
         # has a purpose.
-        #env['MSVS_VERSION']='9.0'
+        # env['MSVS_VERSION']='9.0'
 
 
         # Calls a CMD with /C(lose) and /V(delayed environment variable expansion) options.
@@ -383,26 +383,26 @@ if selected_platform in platform_list:
         # This version information (Win32, x64, Debug, Release, Release_Debug seems to be
         # required for Visual Studio to understand that it needs to generate an NMAKE
         # project. Do not modify without knowing what you are doing.
-        debug_variants = ['debug|Win32']+['debug|x64']
-        release_variants = ['release|Win32']+['release|x64']
-        release_debug_variants = ['release_debug|Win32']+['release_debug|x64']
+        debug_variants = ['debug|Win32'] + ['debug|x64']
+        release_variants = ['release|Win32'] + ['release|x64']
+        release_debug_variants = ['release_debug|Win32'] + ['release_debug|x64']
         variants = debug_variants + release_variants + release_debug_variants
-        debug_targets = ['bin\\godot.windows.tools.32.exe']+['bin\\godot.windows.tools.64.exe']
-        release_targets = ['bin\\godot.windows.opt.32.exe']+['bin\\godot.windows.opt.64.exe']
-        release_debug_targets = ['bin\\godot.windows.opt.tools.32.exe']+['bin\\godot.windows.opt.tools.64.exe']
+        debug_targets = ['bin\\godot.windows.tools.32.exe'] + ['bin\\godot.windows.tools.64.exe']
+        release_targets = ['bin\\godot.windows.opt.32.exe'] + ['bin\\godot.windows.opt.64.exe']
+        release_debug_targets = ['bin\\godot.windows.opt.tools.32.exe'] + ['bin\\godot.windows.opt.tools.64.exe']
         targets = debug_targets + release_targets + release_debug_targets
-        msvproj = env.MSVSProject(target = ['#godot' + env['MSVSPROJECTSUFFIX'] ],
-                                  incs = env.vs_incs,
-                                  srcs = env.vs_srcs,
-                                  runfile = targets,
-                                  buildtarget = targets,
+        msvproj = env.MSVSProject(target=['#godot' + env['MSVSPROJECTSUFFIX']],
+                                  incs=env.vs_incs,
+                                  srcs=env.vs_srcs,
+                                  runfile=targets,
+                                  buildtarget=targets,
                                   auto_build_solution=1,
-                                  variant = variants)
+                                  variant=variants)
 
 else:
 
     print("No valid target platform selected.")
     print("The following were detected:")
     for x in platform_list:
-        print("\t"+x)
+        print("\t" + x)
     print("\nPlease run scons again with argument: platform=<string>")

bin/tests/SCsub

@@ -2,13 +2,13 @@
 
 Import('env')
 
-env.tests_sources=[]
-env.add_source_files(env.tests_sources,"*.cpp")
+env.tests_sources = []
+env.add_source_files(env.tests_sources, "*.cpp")
 
 Export('env')
 
-#SConscript('math/SCsub');
+# SConscript('math/SCsub');
 
-lib = env.Library("tests",env.tests_sources)
+lib = env.Library("tests", env.tests_sources)
 
 env.Prepend(LIBS=[lib])

core/SCsub

@@ -2,66 +2,66 @@
 
 Import('env')
 
-env.core_sources=[]
+env.core_sources = []
 
 
-gd_call=""
-gd_inc=""
+gd_call = ""
+gd_inc = ""
 
 for x in env.global_defaults:
-    env.core_sources.append("#platform/"+x+"/globals/global_defaults.cpp")
-    gd_inc+='#include "platform/'+x+'/globals/global_defaults.h"\n'
-    gd_call+="\tregister_"+x+"_global_defaults();\n"
+    env.core_sources.append("#platform/" + x + "/globals/global_defaults.cpp")
+    gd_inc += '#include "platform/' + x + '/globals/global_defaults.h"\n'
+    gd_call += "\tregister_" + x + "_global_defaults();\n"
 
-gd_cpp='#include "globals.h"\n'
-gd_cpp+=gd_inc
-gd_cpp+="void Globals::register_global_defaults() {\n"+gd_call+"\n}\n"
+gd_cpp = '#include "globals.h"\n'
+gd_cpp += gd_inc
+gd_cpp += "void Globals::register_global_defaults() {\n" + gd_call + "\n}\n"
 
-f = open("global_defaults.cpp","wb")
+f = open("global_defaults.cpp", "wb")
 f.write(gd_cpp)
 f.close()
 
 import os
 txt = "0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0"
 if ("SCRIPT_AES256_ENCRYPTION_KEY" in os.environ):
-    e=os.environ["SCRIPT_AES256_ENCRYPTION_KEY"]
+    e = os.environ["SCRIPT_AES256_ENCRYPTION_KEY"]
     txt = ""
-    ec_valid=True
-    if (len(e)!=64):
-        ec_valid=False
+    ec_valid = True
+    if (len(e) != 64):
+        ec_valid = False
     else:
 
-        for i in range(len(e)>>1):
-            if (i>0):
-                txt+=","
-            txts="0x"+e[i*2:i*2+2]
+        for i in range(len(e) >> 1):
+            if (i > 0):
+                txt += ","
+            txts = "0x" + e[i * 2:i * 2 + 2]
             try:
-                int(txts,16)
+                int(txts, 16)
             except:
-                ec_valid=False
-            txt+=txts
+                ec_valid = False
+            txt += txts
     if (not ec_valid):
         txt = "0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0"
-        print("Invalid AES256 encryption key, not 64 bits hex: "+e)
+        print("Invalid AES256 encryption key, not 64 bits hex: " + e)
 
 f = open("script_encryption_key.cpp", "wb")
 f.write("#include \"globals.h\"\nuint8_t script_encryption_key[32]={" + txt + "};\n")
 f.close()
 
 
-env.add_source_files(env.core_sources,"*.cpp")
+env.add_source_files(env.core_sources, "*.cpp")
 
 
 Export('env')
 
 import make_binders
-env.Command(['method_bind.inc','method_bind_ext.inc'], 'make_binders.py', make_binders.run)
+env.Command(['method_bind.inc', 'method_bind_ext.inc'], 'make_binders.py', make_binders.run)
 
 SConscript('os/SCsub');
 SConscript('math/SCsub');
 SConscript('io/SCsub');
 SConscript('bind/SCsub');
 
-lib = env.Library("core",env.core_sources)
+lib = env.Library("core", env.core_sources)
 
 env.Prepend(LIBS=[lib])

core/bind/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.core_sources,"*.cpp")
+env.add_source_files(env.core_sources, "*.cpp")
 
 Export('env')

core/io/SCsub

@@ -2,8 +2,8 @@
 
 Import('env')
 
-env.add_source_files(env.core_sources,"*.cpp")
-env.add_source_files(env.core_sources,"*.c")
-#env.core_sources.append("io/fastlz.c")
+env.add_source_files(env.core_sources, "*.cpp")
+env.add_source_files(env.core_sources, "*.c")
+# env.core_sources.append("io/fastlz.c")
 
 Export('env')

core/make_binders.py

@@ -1,7 +1,7 @@
 # -*- coding: ibm850 -*-
 
 
-template_typed="""
+template_typed = """
 #ifdef TYPED_METHOD_BIND
 template<class T $ifret ,class R$ $ifargs ,$ $arg, class P@$>
 class MethodBind$argc$$ifret R$$ifconst C$ : public MethodBind {
@@ -75,7 +75,7 @@ MethodBind* create_method_bind($ifret R$ $ifnoret void$ (T::*p_method)($arg, P@$
 #endif
 """
 
-template="""
+template = """
 #ifndef TYPED_METHOD_BIND
 $iftempl template<$ $ifret class R$ $ifretargs ,$ $arg, class P@$ $iftempl >$
 class MethodBind$argc$$ifret R$$ifconst C$ : public MethodBind {
@@ -161,96 +161,96 @@ MethodBind* create_method_bind($ifret R$ $ifnoret void$ (T::*p_method)($arg, P@$
 """
 
 
-def make_version(template,nargs,argmax,const,ret):
+def make_version(template, nargs, argmax, const, ret):
 
-    intext=template
-    from_pos=0
-    outtext=""
+    intext = template
+    from_pos = 0
+    outtext = ""
 
     while(True):
-        to_pos=intext.find("$",from_pos)
-        if (to_pos==-1):
-            outtext+=intext[from_pos:]
+        to_pos = intext.find("$", from_pos)
+        if (to_pos == -1):
+            outtext += intext[from_pos:]
             break
         else:
-            outtext+=intext[from_pos:to_pos]
-        end=intext.find("$",to_pos+1)
-        if (end==-1):
-            break # ignore
-        macro=intext[to_pos+1:end]
-        cmd=""
-        data=""
-
-        if (macro.find(" ")!=-1):
-            cmd=macro[0:macro.find(" ")]
-            data=macro[macro.find(" ")+1:]
+            outtext += intext[from_pos:to_pos]
+        end = intext.find("$", to_pos + 1)
+        if (end == -1):
+            break  # ignore
+        macro = intext[to_pos + 1:end]
+        cmd = ""
+        data = ""
+
+        if (macro.find(" ") != -1):
+            cmd = macro[0:macro.find(" ")]
+            data = macro[macro.find(" ") + 1:]
         else:
-            cmd=macro
-
-        if (cmd=="argc"):
-            outtext+=str(nargs)
-        if (cmd=="ifret" and ret):
-            outtext+=data
-        if (cmd=="ifargs" and nargs):
-            outtext+=data
-        if (cmd=="ifretargs" and nargs and ret):
-            outtext+=data
-        if (cmd=="ifconst" and const):
-            outtext+=data
-        elif (cmd=="ifnoconst" and not const):
-            outtext+=data
-        elif (cmd=="ifnoret" and not ret):
-            outtext+=data
-        elif (cmd=="iftempl" and (nargs>0 or ret)):
-            outtext+=data
-        elif (cmd=="arg,"):
-            for i in range(1,nargs+1):
-                if (i>1):
-                    outtext+=", "
-                outtext+=data.replace("@",str(i))
-        elif (cmd=="arg"):
-            for i in range(1,nargs+1):
-                outtext+=data.replace("@",str(i))
-        elif (cmd=="noarg"):
-            for i in range(nargs+1,argmax+1):
-                outtext+=data.replace("@",str(i))
-        elif (cmd=="noarg"):
-            for i in range(nargs+1,argmax+1):
-                outtext+=data.replace("@",str(i))
-
-        from_pos=end+1
+            cmd = macro
+
+        if (cmd == "argc"):
+            outtext += str(nargs)
+        if (cmd == "ifret" and ret):
+            outtext += data
+        if (cmd == "ifargs" and nargs):
+            outtext += data
+        if (cmd == "ifretargs" and nargs and ret):
+            outtext += data
+        if (cmd == "ifconst" and const):
+            outtext += data
+        elif (cmd == "ifnoconst" and not const):
+            outtext += data
+        elif (cmd == "ifnoret" and not ret):
+            outtext += data
+        elif (cmd == "iftempl" and (nargs > 0 or ret)):
+            outtext += data
+        elif (cmd == "arg,"):
+            for i in range(1, nargs + 1):
+                if (i > 1):
+                    outtext += ", "
+                outtext += data.replace("@", str(i))
+        elif (cmd == "arg"):
+            for i in range(1, nargs + 1):
+                outtext += data.replace("@", str(i))
+        elif (cmd == "noarg"):
+            for i in range(nargs + 1, argmax + 1):
+                outtext += data.replace("@", str(i))
+        elif (cmd == "noarg"):
+            for i in range(nargs + 1, argmax + 1):
+                outtext += data.replace("@", str(i))
+
+        from_pos = end + 1
 
     return outtext
 
 
 def run(target, source, env):
 
-    versions=10
-    versions_ext=6
-    text=""
-    text_ext=""
-
-    for i in range(0,versions+1):
-
-        t=""
-        t+=make_version(template,i,versions,False,False)
-        t+=make_version(template_typed,i,versions,False,False)
-        t+=make_version(template,i,versions,False,True)
-        t+=make_version(template_typed,i,versions,False,True)
-        t+=make_version(template,i,versions,True,False)
-        t+=make_version(template_typed,i,versions,True,False)
-        t+=make_version(template,i,versions,True,True)
-        t+=make_version(template_typed,i,versions,True,True)
-        if (i>=versions_ext):
-            text_ext+=t
+    versions = 10
+    versions_ext = 6
+    text = ""
+    text_ext = ""
+
+    for i in range(0, versions + 1):
+
+        t = ""
+        t += make_version(template, i, versions, False, False)
+        t += make_version(template_typed, i, versions, False, False)
+        t += make_version(template, i, versions, False, True)
+        t += make_version(template_typed, i, versions, False, True)
+        t += make_version(template, i, versions, True, False)
+        t += make_version(template_typed, i, versions, True, False)
+        t += make_version(template, i, versions, True, True)
+        t += make_version(template_typed, i, versions, True, True)
+        if (i >= versions_ext):
+            text_ext += t
         else:
-            text+=t
+            text += t
 
 
-    f=open(target[0].path,"w")
+    f = open(target[0].path, "w")
     f.write(text)
     f.close()
 
-    f=open(target[1].path,"w")
+    f = open(target[1].path, "w")
     f.write(text_ext)
     f.close()

core/math/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.core_sources,"*.cpp")
+env.add_source_files(env.core_sources, "*.cpp")
 
 Export('env')

core/os/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.core_sources,"*.cpp")
+env.add_source_files(env.core_sources, "*.cpp")
 
 Export('env')

doc/tools/doc_merge.py

@@ -6,17 +6,17 @@ import xml.etree.ElementTree as ET
 
 
 tree = ET.parse(sys.argv[1])
-old_doc=tree.getroot()
+old_doc = tree.getroot()
 
 tree = ET.parse(sys.argv[2])
-new_doc=tree.getroot()
+new_doc = tree.getroot()
 
-f = file(sys.argv[3],"wb")
-tab=0
+f = file(sys.argv[3], "wb")
+tab = 0
 
-old_classes={}
+old_classes = {}
 
-def write_string(_f, text,newline=True):
+def write_string(_f, text, newline=True):
     for t in range(tab):
         _f.write("\t")
     _f.write(text)
@@ -24,188 +24,188 @@ def write_string(_f, text,newline=True):
         _f.write("\n")
 
 def escape(ret):
-    ret=ret.replace("&","&");
-    ret=ret.replace("<","&gt;");
-    ret=ret.replace(">","&lt;");
-    ret=ret.replace("'","&apos;");
-    ret=ret.replace("\"","&quot;");
+    ret = ret.replace("&", "&amp;");
+    ret = ret.replace("<", "&gt;");
+    ret = ret.replace(">", "&lt;");
+    ret = ret.replace("'", "&apos;");
+    ret = ret.replace("\"", "&quot;");
     return ret
 
 
 def inc_tab():
     global tab
-    tab+=1
+    tab += 1
 
 def dec_tab():
     global tab
-    tab-=1
+    tab -= 1
 
-write_string(f,'<?xml version="1.0" encoding="UTF-8" ?>')
-write_string(f,'<doc version="'+new_doc.attrib["version"]+'">')
+write_string(f, '<?xml version="1.0" encoding="UTF-8" ?>')
+write_string(f, '<doc version="' + new_doc.attrib["version"] + '">')
 
-def get_tag(node,name):
-    tag=""
+def get_tag(node, name):
+    tag = ""
     if (name in node.attrib):
-        tag=' '+name+'="'+escape(node.attrib[name])+'" '
+        tag = ' ' + name + '="' + escape(node.attrib[name]) + '" '
     return tag
 
-def find_method_descr(old_class,name):
+def find_method_descr(old_class, name):
 
     methods = old_class.find("methods")
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
         for m in list(methods):
-            if (m.attrib["name"]==name):
-                description=m.find("description")
-                if (description!=None and description.text.strip()!=""):
+            if (m.attrib["name"] == name):
+                description = m.find("description")
+                if (description != None and description.text.strip() != ""):
                     return description.text
 
     return None
 
-def find_signal_descr(old_class,name):
+def find_signal_descr(old_class, name):
 
     signals = old_class.find("signals")
-    if(signals!=None and len(list(signals))>0):
+    if(signals != None and len(list(signals)) > 0):
         for m in list(signals):
-            if (m.attrib["name"]==name):
-                description=m.find("description")
-                if (description!=None and description.text.strip()!=""):
+            if (m.attrib["name"] == name):
+                description = m.find("description")
+                if (description != None and description.text.strip() != ""):
                     return description.text
 
     return None
 
-def find_constant_descr(old_class,name):
+def find_constant_descr(old_class, name):
 
-    if (old_class==None):
+    if (old_class == None):
         return None
     constants = old_class.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
         for m in list(constants):
-            if (m.attrib["name"]==name):
-                if (m.text.strip()!=""):
+            if (m.attrib["name"] == name):
+                if (m.text.strip() != ""):
                     return m.text
     return None
 
 def write_class(c):
     class_name = c.attrib["name"]
-    print("Parsing Class: "+class_name)
+    print("Parsing Class: " + class_name)
     if (class_name in old_classes):
-        old_class=old_classes[class_name]
+        old_class = old_classes[class_name]
     else:
-        old_class=None
+        old_class = None
 
 
-    category=get_tag(c,"category")
-    inherits=get_tag(c,"inherits")
-    write_string(f,'<class name="'+class_name+'" '+category+inherits+'>')
+    category = get_tag(c, "category")
+    inherits = get_tag(c, "inherits")
+    write_string(f, '<class name="' + class_name + '" ' + category + inherits + '>')
     inc_tab()
 
-    write_string(f,"<brief_description>")
+    write_string(f, "<brief_description>")
 
-    if (old_class!=None):
-        old_brief_descr=old_class.find("brief_description")
-        if (old_brief_descr!=None):
-            write_string(f,escape(old_brief_descr.text.strip()))
+    if (old_class != None):
+        old_brief_descr = old_class.find("brief_description")
+        if (old_brief_descr != None):
+            write_string(f, escape(old_brief_descr.text.strip()))
 
 
-    write_string(f,"</brief_description>")
+    write_string(f, "</brief_description>")
 
-    write_string(f,"<description>")
-    if (old_class!=None):
-        old_descr=old_class.find("description")
-        if (old_descr!=None):
-            write_string(f,escape(old_descr.text.strip()))
+    write_string(f, "<description>")
+    if (old_class != None):
+        old_descr = old_class.find("description")
+        if (old_descr != None):
+            write_string(f, escape(old_descr.text.strip()))
 
-    write_string(f,"</description>")
+    write_string(f, "</description>")
 
     methods = c.find("methods")
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
 
-        write_string(f,"<methods>")
+        write_string(f, "<methods>")
         inc_tab()
 
         for m in list(methods):
-            qualifiers=get_tag(m,"qualifiers")
+            qualifiers = get_tag(m, "qualifiers")
 
-            write_string(f,'<method name="'+escape(m.attrib["name"])+'" ' +qualifiers+'>')
+            write_string(f, '<method name="' + escape(m.attrib["name"]) + '" ' + qualifiers + '>')
             inc_tab()
 
             for a in list(m):
-                if (a.tag=="return"):
-                    typ=get_tag(a,"type")
-                    write_string(f,'<return'+typ+'>');
-                    write_string(f,'</return>');
-                elif (a.tag=="argument"):
+                if (a.tag == "return"):
+                    typ = get_tag(a, "type")
+                    write_string(f, '<return' + typ + '>');
+                    write_string(f, '</return>');
+                elif (a.tag == "argument"):
 
-                    default=get_tag(a,"default")
+                    default = get_tag(a, "default")
 
-                    write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'"' +default+'>');
-                    write_string(f,'</argument>');
+                    write_string(f, '<argument index="' + a.attrib["index"] + '" name="' + escape(a.attrib["name"]) + '" type="' + a.attrib["type"] + '"' + default + '>');
+                    write_string(f, '</argument>');
 
-            write_string(f,'<description>');
-            if (old_class!=None):
-                old_method_descr=find_method_descr(old_class,m.attrib["name"])
+            write_string(f, '<description>');
+            if (old_class != None):
+                old_method_descr = find_method_descr(old_class, m.attrib["name"])
                 if (old_method_descr):
-                    write_string(f,escape(escape(old_method_descr.strip())))
+                    write_string(f, escape(escape(old_method_descr.strip())))
 
-            write_string(f,'</description>');
+            write_string(f, '</description>');
             dec_tab()
-            write_string(f,"</method>")
+            write_string(f, "</method>")
         dec_tab()
-        write_string(f,"</methods>")
+        write_string(f, "</methods>")
 
     signals = c.find("signals")
-    if(signals!=None and len(list(signals))>0):
+    if(signals != None and len(list(signals)) > 0):
 
-        write_string(f,"<signals>")
+        write_string(f, "<signals>")
         inc_tab()
 
         for m in list(signals):
 
-            write_string(f,'<signal name="'+escape(m.attrib["name"])+'">')
+            write_string(f, '<signal name="' + escape(m.attrib["name"]) + '">')
             inc_tab()
 
             for a in list(m):
-                if (a.tag=="argument"):
+                if (a.tag == "argument"):
 
-                    write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'">');
-                    write_string(f,'</argument>');
+                    write_string(f, '<argument index="' + a.attrib["index"] + '" name="' + escape(a.attrib["name"]) + '" type="' + a.attrib["type"] + '">');
+                    write_string(f, '</argument>');
 
-            write_string(f,'<description>');
-            if (old_class!=None):
-                old_signal_descr=find_signal_descr(old_class,m.attrib["name"])
+            write_string(f, '<description>');
+            if (old_class != None):
+                old_signal_descr = find_signal_descr(old_class, m.attrib["name"])
                 if (old_signal_descr):
-                    write_string(f,escape(old_signal_descr.strip()))
-            write_string(f,'</description>');
+                    write_string(f, escape(old_signal_descr.strip()))
+            write_string(f, '</description>');
             dec_tab()
-            write_string(f,"</signal>")
+            write_string(f, "</signal>")
         dec_tab()
-        write_string(f,"</signals>")
+        write_string(f, "</signals>")
 
     constants = c.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
 
-        write_string(f,"<constants>")
+        write_string(f, "<constants>")
         inc_tab()
 
         for m in list(constants):
 
-            write_string(f,'<constant name="'+escape(m.attrib["name"])+'" value="'+m.attrib["value"]+'">')
-            old_constant_descr=find_constant_descr(old_class,m.attrib["name"])
+            write_string(f, '<constant name="' + escape(m.attrib["name"]) + '" value="' + m.attrib["value"] + '">')
+            old_constant_descr = find_constant_descr(old_class, m.attrib["name"])
             if (old_constant_descr):
-                write_string(f,escape(old_constant_descr.strip()))
-            write_string(f,"</constant>")
+                write_string(f, escape(old_constant_descr.strip()))
+            write_string(f, "</constant>")
 
         dec_tab()
-        write_string(f,"</constants>")
+        write_string(f, "</constants>")
 
     dec_tab()
-    write_string(f,"</class>")
+    write_string(f, "</class>")
 
 for c in list(old_doc):
-    old_classes[c.attrib["name"]]=c
+    old_classes[c.attrib["name"]] = c
 
 for c in list(new_doc):
     write_class(c)
-write_string(f,'</doc>\n')
+write_string(f, '</doc>\n')
 
 

doc/tools/doc_status.py

@@ -11,7 +11,7 @@ import xml.etree.ElementTree as ET
 ################################################################################
 
 flags = {
-    'c': platform.platform() != 'Windows', # Disable by default on windows, since we use ANSI escape codes
+    'c': platform.platform() != 'Windows',  # Disable by default on windows, since we use ANSI escape codes
     'b': False,
     'g': False,
     's': False,
@@ -62,15 +62,15 @@ long_flags = {
 table_columns = ['name', 'brief_description', 'description', 'methods', 'constants', 'members', 'signals']
 table_column_names = ['Name', 'Brief Desc.', 'Desc.', 'Methods', 'Constants', 'Members', 'Signals']
 colors = {
-    'name': [36], # cyan
-    'part_big_problem': [4, 31], # underline, red
-    'part_problem': [31], # red
-    'part_mostly_good': [33], # yellow
-    'part_good': [32], # green
-    'url': [4, 34], # underline, blue
-    'section': [1, 4], # bold, underline
-    'state_off': [36], # cyan
-    'state_on': [1, 35], # bold, magenta/plum
+    'name': [36],  # cyan
+    'part_big_problem': [4, 31],  # underline, red
+    'part_problem': [31],  # red
+    'part_mostly_good': [33],  # yellow
+    'part_good': [32],  # green
+    'url': [4, 34],  # underline, blue
+    'section': [1, 4],  # bold, underline
+    'state_off': [36],  # cyan
+    'state_on': [1, 35],  # bold, magenta/plum
 }
 overall_progress_description_weigth = 10
 
@@ -105,7 +105,7 @@ def nonescape_len(s):
 ################################################################################
 
 class ClassStatusProgress:
-    def __init__(self, described = 0, total = 0):
+    def __init__(self, described=0, total=0):
         self.described = described
         self.total = total
 
@@ -127,12 +127,12 @@ class ClassStatusProgress:
             return self.to_colored_string()
 
     def to_colored_string(self, format='{has}/{total}', pad_format='{pad_described}{s}{pad_total}'):
-        ratio = self.described/self.total if self.total != 0 else 1
-        percent = round(100*ratio)
-        s = format.format(has = str(self.described), total = str(self.total), percent = str(percent))
+        ratio = self.described / self.total if self.total != 0 else 1
+        percent = round(100 * ratio)
+        s = format.format(has=str(self.described), total=str(self.total), percent=str(percent))
         if self.described >= self.total:
             s = color('part_good', s)
-        elif self.described >= self.total/4*3:
+        elif self.described >= self.total / 4 * 3:
             s = color('part_mostly_good', s)
         elif self.described > 0:
             s = color('part_problem', s)
@@ -142,7 +142,7 @@ class ClassStatusProgress:
         pad_described = ''.ljust(pad_size - len(str(self.described)))
         pad_percent = ''.ljust(3 - len(str(percent)))
         pad_total = ''.ljust(pad_size - len(str(self.total)))
-        return pad_format.format(pad_described = pad_described, pad_total = pad_total, pad_percent = pad_percent, s = s)
+        return pad_format.format(pad_described=pad_described, pad_total=pad_total, pad_percent=pad_percent, s=s)
 
 
 class ClassStatus:
@@ -231,7 +231,7 @@ class ClassStatus:
                     status.progresses[tag.tag].increment(len(sub_tag.text.strip()) > 0)
 
             elif tag.tag in ['theme_items']:
-                pass #Ignore those tags, since they seem to lack description at all
+                pass  # Ignore those tags, since they seem to lack description at all
 
             else:
                 print(tag.tag, tag.attrib)
@@ -296,10 +296,10 @@ if len(input_file_list) < 1 or flags['h']:
             if long_flags[synonym] == flag:
                 synonyms.append(color('name', '--' + synonym))
 
-        print(('{synonyms} (Currently '+color('state_'+('on' if flags[flag] else 'off'), '{value}')+')\n\t{description}').format(
-            synonyms = ', '.join(synonyms),
-            value = ('on' if flags[flag] else 'off'),
-            description = flag_descriptions[flag]
+        print(('{synonyms} (Currently ' + color('state_' + ('on' if flags[flag] else 'off'), '{value}') + ')\n\t{description}').format(
+            synonyms=', '.join(synonyms),
+            value=('on' if flags[flag] else 'off'),
+            description=flag_descriptions[flag]
         ))
     sys.exit(0)
 
@@ -413,9 +413,9 @@ for row_i, row in enumerate(table):
     for cell_i, cell in enumerate(row):
         padding_needed = table_column_sizes[cell_i] - nonescape_len(cell) + 2
         if cell_i == 0:
-            row_string += table_row_chars[2] + cell + table_row_chars[2]*(padding_needed-1)
+            row_string += table_row_chars[2] + cell + table_row_chars[2] * (padding_needed - 1)
         else:
-            row_string += table_row_chars[2]*math.floor(padding_needed/2) + cell + table_row_chars[2]*math.ceil((padding_needed/2))
+            row_string += table_row_chars[2] * math.floor(padding_needed / 2) + cell + table_row_chars[2] * math.ceil((padding_needed / 2))
         row_string += table_column_chars
 
     print(row_string)

doc/tools/makedoku.py

@@ -15,68 +15,68 @@ if len(input_list) < 1:
     sys.exit(0)
 
 
-def validate_tag(elem,tag):
+def validate_tag(elem, tag):
     if (elem.tag != tag):
-        print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
+        print("Tag mismatch, expected '" + tag + "', got " + elem.tag);
         sys.exit(255)
 
 
-class_names=[]
-classes={}
+class_names = []
+classes = {}
 
 
-def make_class_list(class_list,columns):
+def make_class_list(class_list, columns):
 
-    f=open("class_list.txt","wb")
-    prev=0
+    f = open("class_list.txt", "wb")
+    prev = 0
     col_max = len(class_list) / columns + 1
     print("col max is ", col_max)
     col_count = 0
     row_count = 0
     last_initial = ""
-    fit_columns=[]
+    fit_columns = []
 
-    for n in range(0,columns):
-        fit_columns+=[[]]
+    for n in range(0, columns):
+        fit_columns += [[]]
 
-    indexers=[]
-    last_initial=""
+    indexers = []
+    last_initial = ""
 
-    idx=0
+    idx = 0
     for n in class_list:
-        col = idx/col_max
-        if (col>=columns):
-            col=columns-1
-        fit_columns[col]+=[n]
-        idx+=1
-        if (n[:1]!=last_initial):
-            indexers+=[n]
-        last_initial=n[:1]
+        col = idx / col_max
+        if (col >= columns):
+            col = columns - 1
+        fit_columns[col] += [n]
+        idx += 1
+        if (n[:1] != last_initial):
+            indexers += [n]
+        last_initial = n[:1]
 
 
-    row_max=0
+    row_max = 0
 
-    for n in range(0,columns):
-        if (len(fit_columns[n])>row_max):
-            row_max=len(fit_columns[n])
+    for n in range(0, columns):
+        if (len(fit_columns[n]) > row_max):
+            row_max = len(fit_columns[n])
 
 
-    for r in range(0,row_max):
-        s="|"
-        for c in range(0,columns):
-            if (r>=len(fit_columns[c])):
+    for r in range(0, row_max):
+        s = "|"
+        for c in range(0, columns):
+            if (r >= len(fit_columns[c])):
                 continue
 
             classname = fit_columns[c][r]
-            initial=classname[0]
+            initial = classname[0]
             if (classname in indexers):
-                s+="**"+initial+"**|"
+                s += "**" + initial + "**|"
             else:
-                s+=" |"
+                s += " |"
 
-            s+="[["+classname.lower()+"|"+classname+"]]|"
+            s += "[[" + classname.lower() + "|" + classname + "]]|"
 
-        s+="\n"
+        s += "\n"
         f.write(s)
 
 
@@ -86,221 +86,221 @@ def dokuize_text(txt):
 
 
 def dokuize_text(text):
-    pos=0
+    pos = 0
     while(True):
-        pos = text.find("[",pos)
-        if (pos==-1):
+        pos = text.find("[", pos)
+        if (pos == -1):
             break
 
-        endq_pos=text.find("]",pos+1)
-        if (endq_pos==-1):
+        endq_pos = text.find("]", pos + 1)
+        if (endq_pos == -1):
             break
 
-        pre_text=text[:pos]
-        post_text=text[endq_pos+1:]
-        tag_text=text[pos+1:endq_pos]
+        pre_text = text[:pos]
+        post_text = text[endq_pos + 1:]
+        tag_text = text[pos + 1:endq_pos]
 
         if (tag_text in class_names):
-            tag_text="[["+tag_text.lower()+"|"+tag_text+"]]"
-        else: #command
-            cmd=tag_text
-            space_pos=tag_text.find(" ")
-            if (cmd.find("html")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-                tag_text="<"+param+">"
-            elif(cmd.find("method")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-
-                if (param.find(".")!=-1):
-                    class_param,method_param=param.split(".")
-                    tag_text="[["+class_param.lower()+"#"+method_param+"|"+class_param+'.'+method_param+"]]"
+            tag_text = "[[" + tag_text.lower() + "|" + tag_text + "]]"
+        else:  # command
+            cmd = tag_text
+            space_pos = tag_text.find(" ")
+            if (cmd.find("html") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+                tag_text = "<" + param + ">"
+            elif(cmd.find("method") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+
+                if (param.find(".") != -1):
+                    class_param, method_param = param.split(".")
+                    tag_text = "[[" + class_param.lower() + "#" + method_param + "|" + class_param + '.' + method_param + "]]"
                 else:
-                    tag_text="[[#"+param+"|"+param+"]]"
-            elif (cmd.find("image=")==0):
-                tag_text="{{"+cmd[6:]+"}}"
-            elif (cmd.find("url=")==0):
-                tag_text="[["+cmd[4:]+"|"
-            elif (cmd=="/url"):
-                tag_text="]]>"
-            elif (cmd=="center"):
-                tag_text=""
-            elif (cmd=="/center"):
-                tag_text=""
-            elif (cmd=="br"):
-                tag_text="\\\\\n"
-            elif (cmd=="i" or cmd=="/i"):
-                tag_text="//"
-            elif (cmd=="b" or cmd=="/b"):
-                tag_text="**"
-            elif (cmd=="u" or cmd=="/u"):
-                tag_text="__"
+                    tag_text = "[[#" + param + "|" + param + "]]"
+            elif (cmd.find("image=") == 0):
+                tag_text = "{{" + cmd[6:] + "}}"
+            elif (cmd.find("url=") == 0):
+                tag_text = "[[" + cmd[4:] + "|"
+            elif (cmd == "/url"):
+                tag_text = "]]>"
+            elif (cmd == "center"):
+                tag_text = ""
+            elif (cmd == "/center"):
+                tag_text = ""
+            elif (cmd == "br"):
+                tag_text = "\\\\\n"
+            elif (cmd == "i" or cmd == "/i"):
+                tag_text = "//"
+            elif (cmd == "b" or cmd == "/b"):
+                tag_text = "**"
+            elif (cmd == "u" or cmd == "/u"):
+                tag_text = "__"
             else:
-                tag_text="["+tag_text+"]"
+                tag_text = "[" + tag_text + "]"
 
 
-        text=pre_text+tag_text+post_text
-        pos=len(pre_text)+len(tag_text)
+        text = pre_text + tag_text + post_text
+        pos = len(pre_text) + len(tag_text)
 
     #tnode = ET.SubElement(parent,"div")
-    #tnode.text=text
+    # tnode.text=text
     return text
 
 
 def make_type(t):
     global class_names
     if (t in class_names):
-        return "[["+t.lower()+"|"+t+"]]"
+        return "[[" + t.lower() + "|" + t + "]]"
     return t
 
 
-def make_method(f,name,m,declare,event=False):
+def make_method(f, name, m, declare, event=False):
 
-    s="  * "
-    ret_type="void"
-    args=list(m)
-    mdata={}
-    mdata["argidx"]=[]
+    s = "  * "
+    ret_type = "void"
+    args = list(m)
+    mdata = {}
+    mdata["argidx"] = []
     for a in args:
-        if (a.tag=="return"):
-            idx=-1
-        elif (a.tag=="argument"):
-            idx=int(a.attrib["index"])
+        if (a.tag == "return"):
+            idx = -1
+        elif (a.tag == "argument"):
+            idx = int(a.attrib["index"])
         else:
             continue
 
         mdata["argidx"].append(idx)
-        mdata[idx]=a
+        mdata[idx] = a
 
 
 
     if (not event):
         if (-1 in mdata["argidx"]):
-            s+=make_type(mdata[-1].attrib["type"])
+            s += make_type(mdata[-1].attrib["type"])
         else:
-            s+="void"
-        s+=" "
+            s += "void"
+        s += " "
 
     if (declare):
 
-        #span.attrib["class"]="funcdecl"
-        #a=ET.SubElement(span,"a")
-        #a.attrib["name"]=name+"_"+m.attrib["name"]
-        #a.text=name+"::"+m.attrib["name"]
-        s+="**"+m.attrib["name"]+"**"
+        # span.attrib["class"]="funcdecl"
+        # a=ET.SubElement(span,"a")
+        # a.attrib["name"]=name+"_"+m.attrib["name"]
+        # a.text=name+"::"+m.attrib["name"]
+        s += "**" + m.attrib["name"] + "**"
     else:
-        s+="[[#"+m.attrib["name"]+"|"+m.attrib["name"]+"]]"
+        s += "[[#" + m.attrib["name"] + "|" + m.attrib["name"] + "]]"
 
-    s+="**(**"
-    argfound=False
+    s += "**(**"
+    argfound = False
     for a in mdata["argidx"]:
-        arg=mdata[a]
-        if (a<0):
+        arg = mdata[a]
+        if (a < 0):
             continue
-        if (a>0):
-            s+=", "
+        if (a > 0):
+            s += ", "
         else:
-            s+=" "
+            s += " "
 
-        s+=make_type(arg.attrib["type"])
+        s += make_type(arg.attrib["type"])
         if ("name" in arg.attrib):
-            s+=" "+arg.attrib["name"]
+            s += " " + arg.attrib["name"]
         else:
-            s+=" arg"+str(a)
+            s += " arg" + str(a)
 
         if ("default" in arg.attrib):
-            s+="="+arg.attrib["default"]
+            s += "=" + arg.attrib["default"]
 
 
-        argfound=True
+        argfound = True
 
     if (argfound):
-        s+=" "
-    s+="**)**"
+        s += " "
+    s += "**)**"
 
     if ("qualifiers" in m.attrib):
-        s+=" "+m.attrib["qualifiers"]
+        s += " " + m.attrib["qualifiers"]
 
-    f.write(s+"\n")
+    f.write(s + "\n")
 
 
 def make_doku_class(node):
 
     name = node.attrib["name"]
 
-    f=open(name.lower()+".txt","wb")
+    f = open(name.lower() + ".txt", "wb")
 
-    f.write("======  "+name+"  ======\n")
+    f.write("======  " + name + "  ======\n")
 
     if ("inherits" in node.attrib):
-        inh=node.attrib["inherits"].strip()
-        f.write("**Inherits:** [["+inh.lower()+"|"+inh+"]]\\\\\n")
+        inh = node.attrib["inherits"].strip()
+        f.write("**Inherits:** [[" + inh.lower() + "|" + inh + "]]\\\\\n")
     if ("category" in node.attrib):
-        f.write("**Category:** "+node.attrib["category"].strip()+"\\\\\n")
+        f.write("**Category:** " + node.attrib["category"].strip() + "\\\\\n")
 
     briefd = node.find("brief_description")
-    if (briefd!=None):
+    if (briefd != None):
         f.write("=====  Brief Description  ======\n")
-        f.write( dokuize_text(briefd.text.strip())+"\n" )
+        f.write(dokuize_text(briefd.text.strip()) + "\n")
 
     methods = node.find("methods")
 
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
         f.write("=====  Member Functions  ======\n")
         for m in list(methods):
-            make_method(f,node.attrib["name"],m,False)
+            make_method(f, node.attrib["name"], m, False)
 
     events = node.find("signals")
-    if(events!=None and len(list(events))>0):
+    if(events != None and len(list(events)) > 0):
         f.write("=====  Signals  ======\n")
         for m in list(events):
-            make_method(f,node.attrib["name"],m,True,True)
+            make_method(f, node.attrib["name"], m, True, True)
 
     members = node.find("members")
 
-    if(members!=None and len(list(members))>0):
+    if(members != None and len(list(members)) > 0):
         f.write("=====  Member Variables  ======\n")
 
         for c in list(members):
             s = "  * "
-            s+=make_type(c.attrib["type"])+" "
-            s+="**"+c.attrib["name"]+"**"
-            if (c.text.strip()!=""):
-                s+=" - "+c.text.strip()
-            f.write(s+"\n")
+            s += make_type(c.attrib["type"]) + " "
+            s += "**" + c.attrib["name"] + "**"
+            if (c.text.strip() != ""):
+                s += " - " + c.text.strip()
+            f.write(s + "\n")
 
 
 
     constants = node.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
         f.write("=====  Numeric Constants  ======\n")
         for c in list(constants):
             s = "  * "
-            s+="**"+c.attrib["name"]+"**"
+            s += "**" + c.attrib["name"] + "**"
             if ("value" in c.attrib):
-                s+=" = **"+c.attrib["value"]+"**"
-            if (c.text.strip()!=""):
-                s+=" - "+c.text.strip()
-            f.write(s+"\n")
+                s += " = **" + c.attrib["value"] + "**"
+            if (c.text.strip() != ""):
+                s += " - " + c.text.strip()
+            f.write(s + "\n")
 
 
-    descr=node.find("description")
-    if (descr!=None and descr.text.strip()!=""):
+    descr = node.find("description")
+    if (descr != None and descr.text.strip() != ""):
         f.write("=====  Description  ======\n")
-        f.write(dokuize_text(descr.text.strip())+"\n")
+        f.write(dokuize_text(descr.text.strip()) + "\n")
 
     methods = node.find("methods")
 
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
         f.write("=====  Member Function Description  ======\n")
         for m in list(methods):
 
-            d=m.find("description")
-            if (d==None or d.text.strip()==""):
+            d = m.find("description")
+            if (d == None or d.text.strip() == ""):
                 continue
-            f.write("==  "+m.attrib["name"]+"  ==\n")
-            make_method(f,node.attrib["name"],m,False)
+            f.write("==  " + m.attrib["name"] + "  ==\n")
+            make_method(f, node.attrib["name"], m, False)
             f.write("\\\\\n")
             f.write(dokuize_text(d.text.strip()))
             f.write("\n")
@@ -488,27 +488,27 @@ def make_doku_class(node):
 """
 for file in input_list:
     tree = ET.parse(file)
-    doc=tree.getroot()
+    doc = tree.getroot()
 
     if ("version" not in doc.attrib):
         print("Version missing from 'doc'")
         sys.exit(255)
 
-    version=doc.attrib["version"]
+    version = doc.attrib["version"]
 
     for c in list(doc):
         if (c.attrib["name"] in class_names):
             continue
         class_names.append(c.attrib["name"])
-        classes[c.attrib["name"]]=c
+        classes[c.attrib["name"]] = c
 
 
 class_names.sort()
 
-make_class_list(class_names,4)
+make_class_list(class_names, 4)
 
 for cn in class_names:
-    c=classes[cn]
+    c = classes[cn]
     make_doku_class(c)
 
 

doc/tools/makehtml.py

@@ -10,7 +10,7 @@ html_escape_table = {
     "'": "'"
 }
 
-html_unescape_table = {v:k for k, v in html_escape_table.items()}
+html_unescape_table = {v: k for k, v in html_escape_table.items()}
 
 def html_escape(text):
     return escape(text, html_escape_table)
@@ -20,7 +20,7 @@ def html_unescape(text):
 
 input_list = []
 
-single_page=True
+single_page = True
 
 for arg in sys.argv[1:]:
     if arg[:1] == "-":
@@ -36,106 +36,106 @@ if len(input_list) < 1:
     sys.exit(0)
 
 
-def validate_tag(elem,tag):
+def validate_tag(elem, tag):
     if (elem.tag != tag):
-        print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
+        print("Tag mismatch, expected '" + tag + "', got " + elem.tag);
         sys.exit(255)
 
 def make_html_bottom(body):
-    #make_html_top(body,True)
-    ET.SubElement(body,"hr")
-    copyright = ET.SubElement(body,"span")
+    # make_html_top(body,True)
+    ET.SubElement(body, "hr")
+    copyright = ET.SubElement(body, "span")
     copyright.text = "Copyright 2008-2010 Codenix SRL"
 
-def make_html_top(body,bottom=False):
+def make_html_top(body, bottom=False):
 
     if (bottom):
-        ET.SubElement(body,"hr")
-
-    table = ET.SubElement(body,"table")
-    table.attrib["class"]="top_table"
-    tr = ET.SubElement(table,"tr")
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-
-    img = ET.SubElement(td,"image")
-    img.attrib["src"]="images/logo.png"
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="index.html"
-    a.text="Index"
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="alphabetical.html"
-    a.text="Classes"
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="category.html"
-    a.text="Categories"
-    td = ET.SubElement(tr,"td")
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="inheritance.html"
-    a.text="Inheritance"
+        ET.SubElement(body, "hr")
+
+    table = ET.SubElement(body, "table")
+    table.attrib["class"] = "top_table"
+    tr = ET.SubElement(table, "tr")
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+
+    img = ET.SubElement(td, "image")
+    img.attrib["src"] = "images/logo.png"
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "index.html"
+    a.text = "Index"
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "alphabetical.html"
+    a.text = "Classes"
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "category.html"
+    a.text = "Categories"
+    td = ET.SubElement(tr, "td")
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "inheritance.html"
+    a.text = "Inheritance"
     if (not bottom):
-        ET.SubElement(body,"hr")
+        ET.SubElement(body, "hr")
 
 
 
 
-def make_html_class_list(class_list,columns):
+def make_html_class_list(class_list, columns):
 
-    div=ET.Element("div")
-    div.attrib["class"]="ClassList";
+    div = ET.Element("div")
+    div.attrib["class"] = "ClassList";
 
-    h1=ET.SubElement(div,"h2")
-    h1.text="Alphabetical Class List"
+    h1 = ET.SubElement(div, "h2")
+    h1.text = "Alphabetical Class List"
 
-    table=ET.SubElement(div,"table")
-    table.attrib["class"]="class_table"
-    table.attrib["width"]="100%"
-    prev=0
+    table = ET.SubElement(div, "table")
+    table.attrib["class"] = "class_table"
+    table.attrib["width"] = "100%"
+    prev = 0
 
     col_max = len(class_list) / columns + 1
     print("col max is ", col_max)
     col_count = 0
     row_count = 0
     last_initial = ""
-    fit_columns=[]
+    fit_columns = []
 
-    for n in range(0,columns):
-        fit_columns+=[[]]
+    for n in range(0, columns):
+        fit_columns += [[]]
 
-    indexers=[]
-    last_initial=""
+    indexers = []
+    last_initial = ""
 
-    idx=0
+    idx = 0
     for n in class_list:
-        col = int(idx/col_max)
-        if (col>=columns):
-            col=columns-1
-        fit_columns[col]+=[n]
-        idx+=1
-        if (n[:1]!=last_initial):
-            indexers+=[n]
-            last_initial=n[:1]
-
-    row_max=0
-
-    for n in range(0,columns):
-        if (len(fit_columns[n])>row_max):
-            row_max=len(fit_columns[n])
-
-
-    for r in range(0,row_max):
-        tr = ET.SubElement(table,"tr")
-        for c in range(0,columns):
-            tdi = ET.SubElement(tr,"td")
-            tdi.attrib["align"]="right"
-            td = ET.SubElement(tr,"td")
-            if (r>=len(fit_columns[c])):
+        col = int(idx / col_max)
+        if (col >= columns):
+            col = columns - 1
+        fit_columns[col] += [n]
+        idx += 1
+        if (n[:1] != last_initial):
+            indexers += [n]
+            last_initial = n[:1]
+
+    row_max = 0
+
+    for n in range(0, columns):
+        if (len(fit_columns[n]) > row_max):
+            row_max = len(fit_columns[n])
+
+
+    for r in range(0, row_max):
+        tr = ET.SubElement(table, "tr")
+        for c in range(0, columns):
+            tdi = ET.SubElement(tr, "td")
+            tdi.attrib["align"] = "right"
+            td = ET.SubElement(tr, "td")
+            if (r >= len(fit_columns[c])):
                 continue
 
             classname = fit_columns[c][r]
@@ -147,17 +147,17 @@ def make_html_class_list(class_list,columns):
                 span.text = classname[:1].upper()
 
             if (single_page):
-                link="#"+classname
+                link = "#" + classname
             else:
-                link=classname+".html"
+                link = classname + ".html"
 
-            a=ET.SubElement(td,"a")
-            a.attrib["href"]=link
-            a.text=classname
+            a = ET.SubElement(td, "a")
+            a.attrib["href"] = link
+            a.text = classname
 
 
     if (not single_page):
-        cat_class_list=ET.Element("html")
+        cat_class_list = ET.Element("html")
         csscc = ET.SubElement(cat_class_list, "link")
         csscc.attrib["href"] = "main.css"
         csscc.attrib["rel"] = "stylesheet"
@@ -165,62 +165,62 @@ def make_html_class_list(class_list,columns):
         bodycc = ET.SubElement(cat_class_list, "body")
         make_html_top(bodycc)
 
-        cat_class_parent=bodycc
+        cat_class_parent = bodycc
     else:
-        cat_class_parent=div
+        cat_class_parent = div
 
 
 
 
-    h1=ET.SubElement(cat_class_parent,"h2")
-    h1.text="Class List By Category"
+    h1 = ET.SubElement(cat_class_parent, "h2")
+    h1.text = "Class List By Category"
 
-    class_cat_table={}
-    class_cat_list=[]
+    class_cat_table = {}
+    class_cat_list = []
 
     for c in class_list:
         clss = classes[c]
         if ("category" in clss.attrib):
-            class_cat=clss.attrib["category"]
+            class_cat = clss.attrib["category"]
         else:
-            class_cat="Core"
-        if (class_cat.find("/")!=-1):
-            class_cat=class_cat[class_cat.rfind("/")+1:]
+            class_cat = "Core"
+        if (class_cat.find("/") != -1):
+            class_cat = class_cat[class_cat.rfind("/") + 1:]
         if (not class_cat in class_cat_list):
             class_cat_list.append(class_cat)
-            class_cat_table[class_cat]=[]
+            class_cat_table[class_cat] = []
         class_cat_table[class_cat].append(c)
 
     class_cat_list.sort()
 
-    ct = ET.SubElement(cat_class_parent,"table")
+    ct = ET.SubElement(cat_class_parent, "table")
     for cl in class_cat_list:
         l = class_cat_table[cl]
         l.sort()
-        tr = ET.SubElement(ct,"tr")
-        tr.attrib["class"]="category_title"
-        td = ET.SubElement(ct,"td")
-        td.attrib["class"]="category_title"
+        tr = ET.SubElement(ct, "tr")
+        tr.attrib["class"] = "category_title"
+        td = ET.SubElement(ct, "td")
+        td.attrib["class"] = "category_title"
 
-        a = ET.SubElement(td,"a")
-        a.attrib["class"]="category_title"
-        a.text=cl
-        a.attrib["name"]="CATEGORY_"+cl
+        a = ET.SubElement(td, "a")
+        a.attrib["class"] = "category_title"
+        a.text = cl
+        a.attrib["name"] = "CATEGORY_" + cl
 
-        td = ET.SubElement(ct,"td")
-        td.attrib["class"]="category_title"
+        td = ET.SubElement(ct, "td")
+        td.attrib["class"] = "category_title"
 
         for clt in l:
-            tr = ET.SubElement(ct,"tr")
-            td = ET.SubElement(ct,"td")
-            make_type(clt,td)
-            clss=classes[clt]
+            tr = ET.SubElement(ct, "tr")
+            td = ET.SubElement(ct, "td")
+            make_type(clt, td)
+            clss = classes[clt]
             bd = clss.find("brief_description")
-            bdtext=""
-            if (bd!=None):
-                bdtext=bd.text
-            td = ET.SubElement(ct,"td")
-            td.text=bdtext
+            bdtext = ""
+            if (bd != None):
+                bdtext = bd.text
+            td = ET.SubElement(ct, "td")
+            td.text = bdtext
 
     if (not single_page):
         make_html_bottom(bodycc)
@@ -229,31 +229,31 @@ def make_html_class_list(class_list,columns):
 
 
     if (not single_page):
-        inh_class_list=ET.Element("html")
+        inh_class_list = ET.Element("html")
         cssic = ET.SubElement(inh_class_list, "link")
         cssic.attrib["href"] = "main.css"
         cssic.attrib["rel"] = "stylesheet"
         cssic.attrib["type"] = "text/css"
         bodyic = ET.SubElement(inh_class_list, "body")
         make_html_top(bodyic)
-        inh_class_parent=bodyic
+        inh_class_parent = bodyic
     else:
-        inh_class_parent=div
+        inh_class_parent = div
 
 
 
 
-    h1=ET.SubElement(inh_class_parent,"h2")
-    h1.text="Class List By Inheritance"
+    h1 = ET.SubElement(inh_class_parent, "h2")
+    h1.text = "Class List By Inheritance"
 
-    itemlist = ET.SubElement(inh_class_parent,"list")
+    itemlist = ET.SubElement(inh_class_parent, "list")
 
-    class_inh_table={}
+    class_inh_table = {}
 
     def add_class(clss):
         if (clss.attrib["name"] in class_inh_table):
-            return #already added
-        parent_list=None
+            return  # already added
+        parent_list = None
 
         if ("inherits" in clss.attrib):
             inhc = clss.attrib["inherits"]
@@ -262,20 +262,20 @@ def make_html_class_list(class_list,columns):
 
             parent_list = class_inh_table[inhc].find("div")
             if (parent_list == None):
-                parent_div = ET.SubElement(class_inh_table[inhc],"div")
-                parent_list = ET.SubElement(parent_div,"list")
-                parent_div.attrib["class"]="inh_class_list"
+                parent_div = ET.SubElement(class_inh_table[inhc], "div")
+                parent_list = ET.SubElement(parent_div, "list")
+                parent_div.attrib["class"] = "inh_class_list"
             else:
                 parent_list = parent_list.find("list")
 
 
         else:
-            parent_list=itemlist
+            parent_list = itemlist
 
-        item = ET.SubElement(parent_list,"li")
+        item = ET.SubElement(parent_list, "li")
 #   item.attrib["class"]="inh_class_list"
-        class_inh_table[clss.attrib["name"]]=item
-        make_type(clss.attrib["name"],item)
+        class_inh_table[clss.attrib["name"]] = item
+        make_type(clss.attrib["name"], item)
 
 
     for c in class_list:
@@ -290,98 +290,98 @@ def make_html_class_list(class_list,columns):
 
 
 
-    #h1=ET.SubElement(div,"h2")
+    # h1=ET.SubElement(div,"h2")
     #h1.text="Class List By Inheritance"
 
     return div
 
 
-def make_type(p_type,p_parent):
-    if (p_type=="RefPtr"):
-        p_type="Resource"
+def make_type(p_type, p_parent):
+    if (p_type == "RefPtr"):
+        p_type = "Resource"
 
     if (p_type in class_names):
-        a=ET.SubElement(p_parent,"a")
-        a.attrib["class"]="datatype_existing"
-        a.text=p_type+" "
+        a = ET.SubElement(p_parent, "a")
+        a.attrib["class"] = "datatype_existing"
+        a.text = p_type + " "
         if (single_page):
-            a.attrib["href"]="#"+p_type
+            a.attrib["href"] = "#" + p_type
         else:
-            a.attrib["href"]=p_type+".html"
+            a.attrib["href"] = p_type + ".html"
     else:
-        span=ET.SubElement(p_parent,"span")
-        span.attrib["class"]="datatype"
-        span.text=p_type+" "
+        span = ET.SubElement(p_parent, "span")
+        span.attrib["class"] = "datatype"
+        span.text = p_type + " "
 
 
 
-def make_text_def(class_name,parent,text):
+def make_text_def(class_name, parent, text):
     text = html_escape(text)
-    pos=0
+    pos = 0
     while(True):
-        pos = text.find("[",pos)
-        if (pos==-1):
+        pos = text.find("[", pos)
+        if (pos == -1):
             break
 
-        endq_pos=text.find("]",pos+1)
-        if (endq_pos==-1):
+        endq_pos = text.find("]", pos + 1)
+        if (endq_pos == -1):
             break
 
-        pre_text=text[:pos]
-        post_text=text[endq_pos+1:]
-        tag_text=text[pos+1:endq_pos]
+        pre_text = text[:pos]
+        post_text = text[endq_pos + 1:]
+        tag_text = text[pos + 1:endq_pos]
 
         if (tag_text in class_names):
             if (single_page):
-                tag_text='<a href="#'+tag_text+'">'+tag_text+'</a>'
+                tag_text = '<a href="#' + tag_text + '">' + tag_text + '</a>'
             else:
-                tag_text='<a href="'+tag_text+'.html">'+tag_text+'</a>'
-        else: #command
-            cmd=tag_text
-            space_pos=tag_text.find(" ")
-            if (cmd.find("html")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-                tag_text="<"+param+">"
-            elif(cmd.find("method")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-
-                if (not single_page and param.find(".")!=-1):
-                    class_param,method_param=param.split(".")
-                    tag_text=tag_text='<a href="'+class_param+'.html#'+class_param+"_"+method_param+'">'+class_param+'.'+method_param+'()</a>'
+                tag_text = '<a href="' + tag_text + '.html">' + tag_text + '</a>'
+        else:  # command
+            cmd = tag_text
+            space_pos = tag_text.find(" ")
+            if (cmd.find("html") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+                tag_text = "<" + param + ">"
+            elif(cmd.find("method") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+
+                if (not single_page and param.find(".") != -1):
+                    class_param, method_param = param.split(".")
+                    tag_text = tag_text = '<a href="' + class_param + '.html#' + class_param + "_" + method_param + '">' + class_param + '.' + method_param + '()</a>'
                 else:
-                    tag_text=tag_text='<a href="#'+class_name+"_"+param+'">'+class_name+'.'+param+'()</a>'
-            elif (cmd.find("image=")==0):
-                print("found image: "+cmd)
-                tag_text="<img src="+cmd[6:]+"/>"
-            elif (cmd.find("url=")==0):
-                tag_text="<a href="+cmd[4:]+">"
-            elif (cmd=="/url"):
-                tag_text="</a>"
-            elif (cmd=="center"):
-                tag_text="<div align=\"center\">"
-            elif (cmd=="/center"):
-                tag_text="</div>"
-            elif (cmd=="br"):
-                tag_text="<br/>"
-            elif (cmd=="i" or cmd=="/i" or cmd=="b" or cmd=="/b" or cmd=="u" or cmd=="/u"):
-                tag_text="<"+tag_text+">" #html direct mapping
+                    tag_text = tag_text = '<a href="#' + class_name + "_" + param + '">' + class_name + '.' + param + '()</a>'
+            elif (cmd.find("image=") == 0):
+                print("found image: " + cmd)
+                tag_text = "<img src=" + cmd[6:] + "/>"
+            elif (cmd.find("url=") == 0):
+                tag_text = "<a href=" + cmd[4:] + ">"
+            elif (cmd == "/url"):
+                tag_text = "</a>"
+            elif (cmd == "center"):
+                tag_text = "<div align=\"center\">"
+            elif (cmd == "/center"):
+                tag_text = "</div>"
+            elif (cmd == "br"):
+                tag_text = "<br/>"
+            elif (cmd == "i" or cmd == "/i" or cmd == "b" or cmd == "/b" or cmd == "u" or cmd == "/u"):
+                tag_text = "<" + tag_text + ">"  # html direct mapping
             else:
-                tag_text="["+tag_text+"]"
+                tag_text = "[" + tag_text + "]"
 
 
-        text=pre_text+tag_text+post_text
-        pos=len(pre_text)+len(tag_text)
+        text = pre_text + tag_text + post_text
+        pos = len(pre_text) + len(tag_text)
 
     #tnode = ET.SubElement(parent,"div")
-    #tnode.text=text
-    text="<div class=\"description\">"+text+"</div>"
+    # tnode.text=text
+    text = "<div class=\"description\">" + text + "</div>"
     try:
-        tnode=ET.XML(text)
+        tnode = ET.XML(text)
         parent.append(tnode)
     except:
-        print("Error parsing description text: '"+text+"'")
+        print("Error parsing description text: '" + text + "'")
         sys.exit(255)
 
 
@@ -390,292 +390,292 @@ def make_text_def(class_name,parent,text):
 
 
 
-def make_method_def(name,m,declare,event=False):
+def make_method_def(name, m, declare, event=False):
 
-    mdata={}
+    mdata = {}
 
 
     if (not declare):
-        div=ET.Element("tr")
-        div.attrib["class"]="method"
-        ret_parent=ET.SubElement(div,"td")
-        ret_parent.attrib["align"]="right"
-        func_parent=ET.SubElement(div,"td")
+        div = ET.Element("tr")
+        div.attrib["class"] = "method"
+        ret_parent = ET.SubElement(div, "td")
+        ret_parent.attrib["align"] = "right"
+        func_parent = ET.SubElement(div, "td")
     else:
-        div=ET.Element("div")
-        div.attrib["class"]="method"
-        ret_parent=div
-        func_parent=div
-
-    mdata["argidx"]=[]
-    mdata["name"]=m.attrib["name"]
-    qualifiers=""
+        div = ET.Element("div")
+        div.attrib["class"] = "method"
+        ret_parent = div
+        func_parent = div
+
+    mdata["argidx"] = []
+    mdata["name"] = m.attrib["name"]
+    qualifiers = ""
     if ("qualifiers" in m.attrib):
-        qualifiers=m.attrib["qualifiers"]
+        qualifiers = m.attrib["qualifiers"]
 
-    args=list(m)
+    args = list(m)
     for a in args:
-        if (a.tag=="return"):
-            idx=-1
-        elif (a.tag=="argument"):
-            idx=int(a.attrib["index"])
+        if (a.tag == "return"):
+            idx = -1
+        elif (a.tag == "argument"):
+            idx = int(a.attrib["index"])
         else:
             continue
 
         mdata["argidx"].append(idx)
-        mdata[idx]=a
+        mdata[idx] = a
 
     if (not event):
         if (-1 in mdata["argidx"]):
-            make_type(mdata[-1].attrib["type"],ret_parent)
+            make_type(mdata[-1].attrib["type"], ret_parent)
             mdata["argidx"].remove(-1)
         else:
-            make_type("void",ret_parent)
+            make_type("void", ret_parent)
 
-    span=ET.SubElement(func_parent,"span")
+    span = ET.SubElement(func_parent, "span")
     if (declare):
-        span.attrib["class"]="funcdecl"
-        a=ET.SubElement(span,"a")
-        a.attrib["name"]=name+"_"+m.attrib["name"]
-        a.text=name+"::"+m.attrib["name"]
+        span.attrib["class"] = "funcdecl"
+        a = ET.SubElement(span, "a")
+        a.attrib["name"] = name + "_" + m.attrib["name"]
+        a.text = name + "::" + m.attrib["name"]
     else:
-        span.attrib["class"]="identifier funcdef"
-        a=ET.SubElement(span,"a")
-        a.attrib["href"]="#"+name+"_"+m.attrib["name"]
-        a.text=m.attrib["name"]
+        span.attrib["class"] = "identifier funcdef"
+        a = ET.SubElement(span, "a")
+        a.attrib["href"] = "#" + name + "_" + m.attrib["name"]
+        a.text = m.attrib["name"]
 
-    span=ET.SubElement(func_parent,"span")
-    span.attrib["class"]="symbol"
-    span.text=" ("
+    span = ET.SubElement(func_parent, "span")
+    span.attrib["class"] = "symbol"
+    span.text = " ("
 
     for a in mdata["argidx"]:
-        arg=mdata[a]
-        if (a>0):
-            span=ET.SubElement(func_parent,"span")
-            span.text=", "
+        arg = mdata[a]
+        if (a > 0):
+            span = ET.SubElement(func_parent, "span")
+            span.text = ", "
         else:
-            span=ET.SubElement(func_parent,"span")
-            span.text=" "
+            span = ET.SubElement(func_parent, "span")
+            span.text = " "
 
 
-        make_type(arg.attrib["type"],func_parent)
+        make_type(arg.attrib["type"], func_parent)
 
-        span=ET.SubElement(func_parent,"span")
-        span.text=arg.attrib["name"]
+        span = ET.SubElement(func_parent, "span")
+        span.text = arg.attrib["name"]
         if ("default" in arg.attrib):
-            span.text=span.text+"="+arg.attrib["default"]
+            span.text = span.text + "=" + arg.attrib["default"]
 
 
-    span=ET.SubElement(func_parent,"span")
-    span.attrib["class"]="symbol"
+    span = ET.SubElement(func_parent, "span")
+    span.attrib["class"] = "symbol"
     if (len(mdata["argidx"])):
-        span.text=" )"
+        span.text = " )"
     else:
-        span.text=")"
+        span.text = ")"
 
     if (qualifiers):
-        span=ET.SubElement(func_parent,"span")
-        span.attrib["class"]="qualifier"
-        span.text=" "+qualifiers
+        span = ET.SubElement(func_parent, "span")
+        span.attrib["class"] = "qualifier"
+        span.text = " " + qualifiers
 
     return div
 
 
 def make_html_class(node):
 
-    div=ET.Element("div")
-    div.attrib["class"]="class";
+    div = ET.Element("div")
+    div.attrib["class"] = "class";
 
-    a=ET.SubElement(div,"a")
-    a.attrib["name"]=node.attrib["name"]
+    a = ET.SubElement(div, "a")
+    a.attrib["name"] = node.attrib["name"]
 
-    h3=ET.SubElement(a,"h3")
-    h3.attrib["class"]="title class_title"
-    h3.text=node.attrib["name"]
+    h3 = ET.SubElement(a, "h3")
+    h3.attrib["class"] = "title class_title"
+    h3.text = node.attrib["name"]
 
     briefd = node.find("brief_description")
-    if (briefd!=None):
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="description class_description"
-        div2.text=briefd.text
+    if (briefd != None):
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "description class_description"
+        div2.text = briefd.text
 
     if ("inherits" in node.attrib):
-        ET.SubElement(div,"br")
+        ET.SubElement(div, "br")
 
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="inheritance";
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "inheritance";
 
-        span=ET.SubElement(div2,"span")
-        span.text="Inherits: "
+        span = ET.SubElement(div2, "span")
+        span.text = "Inherits: "
 
-        make_type(node.attrib["inherits"],div2)
+        make_type(node.attrib["inherits"], div2)
 
     if ("category" in node.attrib):
-        ET.SubElement(div,"br")
+        ET.SubElement(div, "br")
 
-        div3=ET.SubElement(div,"div")
-        div3.attrib["class"]="category";
+        div3 = ET.SubElement(div, "div")
+        div3.attrib["class"] = "category";
 
-        span=ET.SubElement(div3,"span")
-        span.attrib["class"]="category"
-        span.text="Category: "
+        span = ET.SubElement(div3, "span")
+        span.attrib["class"] = "category"
+        span.text = "Category: "
 
-        a = ET.SubElement(div3,"a")
-        a.attrib["class"]="category_ref"
-        a.text=node.attrib["category"]
-        catname=a.text
-        if (catname.rfind("/")!=-1):
-            catname=catname[catname.rfind("/"):]
-        catname="CATEGORY_"+catname
+        a = ET.SubElement(div3, "a")
+        a.attrib["class"] = "category_ref"
+        a.text = node.attrib["category"]
+        catname = a.text
+        if (catname.rfind("/") != -1):
+            catname = catname[catname.rfind("/"):]
+        catname = "CATEGORY_" + catname
 
         if (single_page):
-            a.attrib["href"]="#"+catname
+            a.attrib["href"] = "#" + catname
         else:
-            a.attrib["href"]="category.html#"+catname
+            a.attrib["href"] = "category.html#" + catname
 
 
     methods = node.find("methods")
 
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Public Methods:"
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Public Methods:"
 
-        method_table=ET.SubElement(div,"table")
-        method_table.attrib["class"]="method_list";
+        method_table = ET.SubElement(div, "table")
+        method_table.attrib["class"] = "method_list";
 
         for m in list(methods):
             #    li = ET.SubElement(div2, "li")
-            method_table.append( make_method_def(node.attrib["name"],m,False) )
+            method_table.append(make_method_def(node.attrib["name"], m, False))
 
     events = node.find("signals")
 
-    if(events!=None and len(list(events))>0):
-        h4=ET.SubElement(div,"h4")
-        h4.text="Events:"
+    if(events != None and len(list(events)) > 0):
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Events:"
 
-        event_table=ET.SubElement(div,"table")
-        event_table.attrib["class"]="method_list";
+        event_table = ET.SubElement(div, "table")
+        event_table.attrib["class"] = "method_list";
 
         for m in list(events):
             #    li = ET.SubElement(div2, "li")
-            event_table.append( make_method_def(node.attrib["name"],m,False,True) )
+            event_table.append(make_method_def(node.attrib["name"], m, False, True))
 
 
     members = node.find("members")
-    if(members!=None and len(list(members))>0):
+    if(members != None and len(list(members)) > 0):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Public Variables:"
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="member_list";
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Public Variables:"
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "member_list";
 
         for c in list(members):
 
             li = ET.SubElement(div2, "li")
-            div3=ET.SubElement(li,"div")
-            div3.attrib["class"]="member";
-            make_type(c.attrib["type"],div3)
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="identifier member_name"
-            span.text=" "+c.attrib["name"]+" "
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="member_description"
-            span.text=c.text
+            div3 = ET.SubElement(li, "div")
+            div3.attrib["class"] = "member";
+            make_type(c.attrib["type"], div3)
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "identifier member_name"
+            span.text = " " + c.attrib["name"] + " "
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "member_description"
+            span.text = c.text
 
 
     constants = node.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Constants:"
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="constant_list";
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Constants:"
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "constant_list";
 
         for c in list(constants):
             li = ET.SubElement(div2, "li")
-            div3=ET.SubElement(li,"div")
-            div3.attrib["class"]="constant";
+            div3 = ET.SubElement(li, "div")
+            div3.attrib["class"] = "constant";
 
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="identifier constant_name"
-            span.text=c.attrib["name"]+" "
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "identifier constant_name"
+            span.text = c.attrib["name"] + " "
             if ("value" in c.attrib):
-                span=ET.SubElement(div3,"span")
-                span.attrib["class"]="symbol"
-                span.text="= "
-                span=ET.SubElement(div3,"span")
-                span.attrib["class"]="constant_value"
-                span.text=c.attrib["value"]+" "
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="constant_description"
-            span.text=c.text
+                span = ET.SubElement(div3, "span")
+                span.attrib["class"] = "symbol"
+                span.text = "= "
+                span = ET.SubElement(div3, "span")
+                span.attrib["class"] = "constant_value"
+                span.text = c.attrib["value"] + " "
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "constant_description"
+            span.text = c.text
 
 #  ET.SubElement(div,"br")
 
 
-    descr=node.find("description")
-    if (descr!=None and descr.text.strip()!=""):
-        h4=ET.SubElement(div,"h4")
-        h4.text="Description:"
+    descr = node.find("description")
+    if (descr != None and descr.text.strip() != ""):
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Description:"
 
-        make_text_def(node.attrib["name"],div,descr.text)
+        make_text_def(node.attrib["name"], div, descr.text)
 #   div2=ET.SubElement(div,"div")
 #   div2.attrib["class"]="description";
 #   div2.text=descr.text
 
 
 
-    if(methods!=None or events!=None):
+    if(methods != None or events != None):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Method Documentation:"
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Method Documentation:"
         iter_list = []
-        if (methods!=None):
-            iter_list+=list(methods)
-        if (events!=None):
-            iter_list+=list(events)
+        if (methods != None):
+            iter_list += list(methods)
+        if (events != None):
+            iter_list += list(events)
 
         for m in iter_list:
 
-            descr=m.find("description")
+            descr = m.find("description")
 
-            if (descr==None or descr.text.strip()==""):
+            if (descr == None or descr.text.strip() == ""):
                 continue;
 
-            div2=ET.SubElement(div,"div")
-            div2.attrib["class"]="method_doc";
+            div2 = ET.SubElement(div, "div")
+            div2.attrib["class"] = "method_doc";
 
 
-            div2.append( make_method_def(node.attrib["name"],m,True) )
+            div2.append(make_method_def(node.attrib["name"], m, True))
             #anchor = ET.SubElement(div2, "a")
-            #anchor.attrib["name"] =
-            make_text_def(node.attrib["name"],div2,descr.text)
-            #div3=ET.SubElement(div2,"div")
-            #div3.attrib["class"]="description";
-            #div3.text=descr.text
+            # anchor.attrib["name"] =
+            make_text_def(node.attrib["name"], div2, descr.text)
+            # div3=ET.SubElement(div2,"div")
+            # div3.attrib["class"]="description";
+            # div3.text=descr.text
 
 
     return div
 
-class_names=[]
-classes={}
+class_names = []
+classes = {}
 
 for file in input_list:
     tree = ET.parse(file)
-    doc=tree.getroot()
+    doc = tree.getroot()
 
     if ("version" not in doc.attrib):
         print("Version missing from 'doc'")
         sys.exit(255)
 
-        version=doc.attrib["version"]
+        version = doc.attrib["version"]
 
     for c in list(doc):
         if (c.attrib["name"] in class_names):
             continue
         class_names.append(c.attrib["name"])
-        classes[c.attrib["name"]]=c
+        classes[c.attrib["name"]] = c
 
 html = ET.Element("html")
 css = ET.SubElement(html, "link")
@@ -691,24 +691,24 @@ if (not single_page):
 
 class_names.sort()
 
-body.append( make_html_class_list(class_names,5) )
+body.append(make_html_class_list(class_names, 5))
 
 for cn in class_names:
-    c=classes[cn]
+    c = classes[cn]
     if (single_page):
-        body.append( make_html_class(c))
+        body.append(make_html_class(c))
     else:
         html2 = ET.Element("html")
         css = ET.SubElement(html2, "link")
         css.attrib["href"] = "main.css"
         css.attrib["rel"] = "stylesheet"
         css.attrib["type"] = "text/css"
-        body2 = ET.SubElement(html2, "body" )
+        body2 = ET.SubElement(html2, "body")
         make_html_top(body2)
-        body2.append( make_html_class(c) );
+        body2.append(make_html_class(c));
         make_html_bottom(body2)
         et_out = ET.ElementTree(html2)
-        et_out.write(c.attrib["name"]+".html")
+        et_out.write(c.attrib["name"] + ".html")
 
 
 et_out = ET.ElementTree(html)

doc/tools/makemd.py

@@ -82,7 +82,7 @@ def make_class_list(class_list, columns):
             else:
                 s += ' | '
 
-            s += '[' + classname + '](class_'+ classname.lower()+') | '
+            s += '[' + classname + '](class_' + classname.lower() + ') | '
 
         s += '\n'
         f.write(s)
@@ -126,14 +126,14 @@ def dokuize_text(text):
 
                 if param.find('.') != -1:
                     (class_param, method_param) = param.split('.')
-                    tag_text = '['+class_param+'.'+method_param.replace("_","_")+'](' + class_param.lower() + '#' \
+                    tag_text = '[' + class_param + '.' + method_param.replace("_", "_") + '](' + class_param.lower() + '#' \
                         + method_param + ')'
                 else:
-                    tag_text = '[' + param.replace("_","_") + '](#' + param + ')'
+                    tag_text = '[' + param.replace("_", "_") + '](#' + param + ')'
             elif cmd.find('image=') == 0:
                 tag_text = '![](' + cmd[6:] + ')'
             elif cmd.find('url=') == 0:
-                tag_text = '[' + cmd[4:] + ']('+cmd[4:]
+                tag_text = '[' + cmd[4:] + '](' + cmd[4:]
             elif cmd == '/url':
                 tag_text = ')'
             elif cmd == 'center':
@@ -205,9 +205,9 @@ def make_method(
         # a.attrib["name"]=name+"_"+m.attrib["name"]
         # a.text=name+"::"+m.attrib["name"]
 
-        s += ' **'+m.attrib['name'].replace("_","_")+'** '
+        s += ' **' + m.attrib['name'].replace("_", "_") + '** '
     else:
-        s += ' **['+ m.attrib['name'].replace("_","_")+'](#' + m.attrib['name'] + ')** '
+        s += ' **[' + m.attrib['name'].replace("_", "_") + '](#' + m.attrib['name'] + ')** '
 
     s += ' **(**'
     argfound = False
@@ -245,13 +245,13 @@ def make_doku_class(node):
 
     name = node.attrib['name']
 
-    f = open("class_"+name.lower() + '.md', 'wb')
+    f = open("class_" + name.lower() + '.md', 'wb')
 
     f.write('#  ' + name + '  \n')
 
     if 'inherits' in node.attrib:
         inh = node.attrib['inherits'].strip()
-        f.write('####**Inherits:** '+make_type(inh)+'\n')
+        f.write('####**Inherits:** ' + make_type(inh) + '\n')
     if 'category' in node.attrib:
         f.write('####**Category:** ' + node.attrib['category'].strip()
                 + '\n')
@@ -313,7 +313,7 @@ def make_doku_class(node):
             d = m.find('description')
             if d == None or d.text.strip() == '':
                 continue
-            f.write('\n#### <a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n')
+            f.write('\n#### <a name="' + m.attrib['name'] + '">' + m.attrib['name'] + '</a>\n')
             make_method(f, node.attrib['name'], m, True)
             f.write('\n')
             f.write(dokuize_text(d.text.strip()))

doc/tools/makerst.py

@@ -24,11 +24,11 @@ def validate_tag(elem, tag):
 class_names = []
 classes = {}
 
-def ul_string(str,ul):
-    str+="\n"
-    for i in range(len(str)-1):
-        str+=ul
-    str+="\n"
+def ul_string(str, ul):
+    str += "\n"
+    for i in range(len(str) - 1):
+        str += ul
+    str += "\n"
     return str
 
 def make_class_list(class_list, columns):
@@ -89,7 +89,7 @@ def make_class_list(class_list, columns):
             else:
                 s += ' | '
 
-            s += '[' + classname + '](class_'+ classname.lower()+') | '
+            s += '[' + classname + '](class_' + classname.lower() + ') | '
 
         s += '\n'
         f.write(s)
@@ -99,7 +99,7 @@ def make_class_list(class_list, columns):
     f.write("\n")
 
 
-def rstize_text(text,cclass):
+def rstize_text(text, cclass):
 
     # Linebreak + tabs in the XML should become two line breaks unless in a "codeblock"
     pos = 0
@@ -109,9 +109,9 @@ def rstize_text(text,cclass):
             break
 
         pre_text = text[:pos]
-        while text[pos+1] == '\t':
+        while text[pos + 1] == '\t':
             pos += 1
-        post_text = text[pos+1:]
+        post_text = text[pos + 1:]
 
         # Handle codeblocks
         if post_text.startswith("[codeblock]"):
@@ -130,14 +130,14 @@ def rstize_text(text,cclass):
                     break
 
                 to_skip = 0
-                while code_pos+to_skip+1 < len(code_text) and code_text[code_pos+to_skip+1] == '\t':
+                while code_pos + to_skip + 1 < len(code_text) and code_text[code_pos + to_skip + 1] == '\t':
                     to_skip += 1
 
-                if len(code_text[code_pos+to_skip+1:])==0:
+                if len(code_text[code_pos + to_skip + 1:]) == 0:
                     code_text = code_text[:code_pos] + "\n"
                     code_pos += 1
                 else:
-                    code_text = code_text[:code_pos] + "\n    " + code_text[code_pos+to_skip+1:]
+                    code_text = code_text[:code_pos] + "\n    " + code_text[code_pos + to_skip + 1:]
                     code_pos += 5 - to_skip
 
             text = pre_text + "\n[codeblock]" + code_text + post_text
@@ -163,7 +163,7 @@ def rstize_text(text,cclass):
         pos = text.find('_', pos)
         if pos == -1:
             break
-        if not text[pos + 1].isalnum(): # don't escape within a snake_case word
+        if not text[pos + 1].isalnum():  # don't escape within a snake_case word
             text = text[:pos] + "\_" + text[pos + 1:]
             pos += 2
         else:
@@ -186,7 +186,7 @@ def rstize_text(text,cclass):
 
         if tag_text in class_names:
             tag_text = make_type(tag_text)
-        else: # command
+        else:  # command
             cmd = tag_text
             space_pos = tag_text.find(' ')
             if cmd.find('html') == 0:
@@ -199,13 +199,13 @@ def rstize_text(text,cclass):
 
                 if param.find('.') != -1:
                     (class_param, method_param) = param.split('.')
-                    tag_text = ':ref:`'+class_param+'.'+method_param+'<class_' + class_param + '_' + method_param + '>`'
+                    tag_text = ':ref:`' + class_param + '.' + method_param + '<class_' + class_param + '_' + method_param + '>`'
                 else:
-                    tag_text = ':ref:`' + param + '<class_' + cclass +"_"+ param + '>`'
+                    tag_text = ':ref:`' + param + '<class_' + cclass + "_" + param + '>`'
             elif cmd.find('image=') == 0:
-                tag_text = "" #'![](' + cmd[6:] + ')'
+                tag_text = ""  # '![](' + cmd[6:] + ')'
             elif cmd.find('url=') == 0:
-                tag_text = ':ref:`' + cmd[4:] + '<'+cmd[4:]+">`"
+                tag_text = ':ref:`' + cmd[4:] + '<' + cmd[4:] + ">`"
             elif cmd == '/url':
                 tag_text = ')'
             elif cmd == 'center':
@@ -234,7 +234,7 @@ def rstize_text(text,cclass):
             elif cmd == 'code' or cmd == '/code':
                 tag_text = '``'
             else:
-                tag_text = ':ref:`' + tag_text + '<class_'+tag_text.lower()+'>`'
+                tag_text = ':ref:`' + tag_text + '<class_' + tag_text.lower() + '>`'
 
         text = pre_text + tag_text + post_text
         pos = len(pre_text) + len(tag_text)
@@ -248,7 +248,7 @@ def rstize_text(text,cclass):
 def make_type(t):
     global class_names
     if t in class_names:
-        return ':ref:`'+t+'<class_' + t.lower()+'>`'
+        return ':ref:`' + t + '<class_' + t.lower() + '>`'
     return t
 
 
@@ -262,7 +262,7 @@ def make_method(
         pp=None
 ):
 
-    if (declare or pp==None):
+    if (declare or pp == None):
         t = '- '
     else:
         t = ""
@@ -289,16 +289,16 @@ def make_method(
             t += 'void'
         t += ' '
 
-    if declare or pp==None:
+    if declare or pp == None:
 
         # span.attrib["class"]="funcdecl"
         # a=ET.SubElement(span,"a")
         # a.attrib["name"]=name+"_"+m.attrib["name"]
         # a.text=name+"::"+m.attrib["name"]
 
-        s = ' **'+m.attrib['name']+'** '
+        s = ' **' + m.attrib['name'] + '** '
     else:
-        s = ':ref:`'+ m.attrib['name']+'<class_' + cname+"_"+m.attrib['name'] + '>` '
+        s = ':ref:`' + m.attrib['name'] + '<class_' + cname + "_" + m.attrib['name'] + '>` '
 
     s += ' **(**'
     argfound = False
@@ -331,16 +331,16 @@ def make_method(
 
 #	f.write(s)
     if (not declare):
-        if (pp!=None):
-            pp.append( (t,s) )
+        if (pp != None):
+            pp.append((t, s))
         else:
-            f.write("- "+t+" "+s+"\n")
+            f.write("- " + t + " " + s + "\n")
     else:
-        f.write(t+s+"\n")
+        f.write(t + s + "\n")
 
 
 def make_heading(title, underline):
-    return title + '\n' + underline*len(title) + "\n\n"
+    return title + '\n' + underline * len(title) + "\n\n"
 
 
 
@@ -348,47 +348,47 @@ def make_rst_class(node):
 
     name = node.attrib['name']
 
-    f = codecs.open("class_"+name.lower() + '.rst', 'wb', 'utf-8')
+    f = codecs.open("class_" + name.lower() + '.rst', 'wb', 'utf-8')
 
     # Warn contributors not to edit this file directly
     f.write(".. Generated automatically by doc/tools/makerst.py in Godot's source tree.\n")
     f.write(".. DO NOT EDIT THIS FILE, but the doc/base/classes.xml source instead.\n\n")
 
-    f.write(".. _class_"+name+":\n\n")
+    f.write(".. _class_" + name + ":\n\n")
     f.write(make_heading(name, '='))
 
     if 'inherits' in node.attrib:
         inh = node.attrib['inherits'].strip()
 #		whle inh in classes[cn]
         f.write('**Inherits:** ')
-        first=True
+        first = True
         while(inh in classes):
             if (not first):
                 f.write(" **<** ")
             else:
-                first=False
+                first = False
 
             f.write(make_type(inh))
             inode = classes[inh]
             if ('inherits' in inode.attrib):
-                inh=inode.attrib['inherits'].strip()
+                inh = inode.attrib['inherits'].strip()
             else:
-                inh=None
+                inh = None
 
 
         f.write("\n\n")
 
-    inherited=[]
+    inherited = []
     for cn in classes:
-        c=classes[cn]
+        c = classes[cn]
         if 'inherits' in c.attrib:
-            if (c.attrib['inherits'].strip()==name):
+            if (c.attrib['inherits'].strip() == name):
                 inherited.append(c.attrib['name'])
 
     if (len(inherited)):
         f.write('**Inherited By:** ')
         for i in range(len(inherited)):
-            if (i>0):
+            if (i > 0):
                 f.write(", ")
             f.write(make_type(inherited[i]))
         f.write("\n\n")
@@ -398,41 +398,41 @@ def make_rst_class(node):
     f.write(make_heading('Brief Description', '-'))
     briefd = node.find('brief_description')
     if briefd != None:
-        f.write(rstize_text(briefd.text.strip(),name) + "\n\n")
+        f.write(rstize_text(briefd.text.strip(), name) + "\n\n")
 
     methods = node.find('methods')
 
     if methods != None and len(list(methods)) > 0:
         f.write(make_heading('Member Functions', '-'))
-        ml=[]
+        ml = []
         for m in list(methods):
-            make_method(f, node.attrib['name'], m, False,name,False,ml)
+            make_method(f, node.attrib['name'], m, False, name, False, ml)
         longest_t = 0
         longest_s = 0
         for s in ml:
             sl = len(s[0])
-            if (sl>longest_s):
-                longest_s=sl
+            if (sl > longest_s):
+                longest_s = sl
             tl = len(s[1])
-            if (tl>longest_t):
-                longest_t=tl
-
-        sep="+"
-        for i in range(longest_s+2):
-            sep+="-"
-        sep+="+"
-        for i in range(longest_t+2):
-            sep+="-"
-        sep+="+\n"
+            if (tl > longest_t):
+                longest_t = tl
+
+        sep = "+"
+        for i in range(longest_s + 2):
+            sep += "-"
+        sep += "+"
+        for i in range(longest_t + 2):
+            sep += "-"
+        sep += "+\n"
         f.write(sep)
         for s in ml:
             rt = s[0]
-            while( len(rt) < longest_s ):
-                rt+=" "
+            while(len(rt) < longest_s):
+                rt += " "
             st = s[1]
-            while( len(st) < longest_t ):
-                st+=" "
-            f.write("| "+rt+" | "+st+" |\n")
+            while(len(st) < longest_t):
+                st += " "
+            f.write("| " + rt + " | " + st + " |\n")
             f.write(sep)
         f.write('\n')
 
@@ -441,7 +441,7 @@ def make_rst_class(node):
     if events != None and len(list(events)) > 0:
         f.write(make_heading('Signals', '-'))
         for m in list(events):
-            make_method(f, node.attrib['name'], m, True,name, True)
+            make_method(f, node.attrib['name'], m, True, name, True)
         f.write('\n')
 
     members = node.find('members')
@@ -466,28 +466,28 @@ def make_rst_class(node):
             if 'value' in c.attrib:
                 s += ' = **' + c.attrib['value'] + '**'
             if c.text.strip() != '':
-                s += ' --- ' + rstize_text(c.text.strip(),name)
+                s += ' --- ' + rstize_text(c.text.strip(), name)
             f.write(s + '\n')
         f.write('\n')
 
     descr = node.find('description')
     if descr != None and descr.text.strip() != '':
         f.write(make_heading('Description', '-'))
-        f.write(rstize_text(descr.text.strip(),name) + "\n\n")
+        f.write(rstize_text(descr.text.strip(), name) + "\n\n")
 
     methods = node.find('methods')
     if methods != None and len(list(methods)) > 0:
         f.write(make_heading('Member Function Description', '-'))
         for m in list(methods):
-            f.write(".. _class_"+name+"_"+m.attrib['name']+":\n\n")
+            f.write(".. _class_" + name + "_" + m.attrib['name'] + ":\n\n")
 #			f.write(ul_string(m.attrib['name'],"^"))
             #f.write('\n<a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n------\n')
-            make_method(f, node.attrib['name'], m, True,name)
+            make_method(f, node.attrib['name'], m, True, name)
             f.write('\n')
             d = m.find('description')
             if d == None or d.text.strip() == '':
                 continue
-            f.write(rstize_text(d.text.strip(),name))
+            f.write(rstize_text(d.text.strip(), name))
             f.write("\n\n")
         f.write('\n')
 
@@ -510,7 +510,7 @@ for file in input_list:
 
 class_names.sort()
 
-#Don't make class list for Sphinx, :toctree: handles it
+# Don't make class list for Sphinx, :toctree: handles it
 #make_class_list(class_names, 2)
 
 for cn in class_names:

drivers/SCsub

@@ -2,7 +2,7 @@
 
 Import('env')
 
-env.drivers_sources=[]
+env.drivers_sources = []
 
 if ("builtin_zlib" in env and env["builtin_zlib"] == "yes"):
     SConscript("zlib/SCsub");
@@ -27,15 +27,15 @@ SConscript("nrex/SCsub");
 
 # Tools override
 # FIXME: Should likely be integrated in the tools/ codebase
-if (env["tools"]=="yes"):
+if (env["tools"] == "yes"):
     SConscript("convex_decomp/SCsub");
 
-if env['vsproj']=="yes":
+if env['vsproj'] == "yes":
     env.AddToVSProject(env.drivers_sources)
 
 if env.split_drivers:
     env.split_lib("drivers")
 else:
-    env.add_source_files(env.drivers_sources,"*.cpp")
-    lib = env.Library("drivers",env.drivers_sources)
+    env.add_source_files(env.drivers_sources, "*.cpp")
+    lib = env.Library("drivers", env.drivers_sources)
     env.Prepend(LIBS=[lib])

drivers/builtin_openssl2/SCsub

@@ -640,19 +640,19 @@ openssl_sources = [
     "crypto/bn/bn_asm.c",
 ]
 
-#env.drivers_sources+=openssl_sources
+# env.drivers_sources+=openssl_sources
 
 env_drivers.Append(CPPPATH=["#drivers/builtin_openssl2/crypto"])
 env_drivers.Append(CPPPATH=["#drivers/builtin_openssl2/openssl"])
 env_drivers.Append(CPPPATH=["#drivers/builtin_openssl2/crypto/evp"])
 env_drivers.Append(CPPPATH=["#drivers/builtin_openssl2/crypto/asn1"])
 env_drivers.Append(CPPPATH=["#drivers/builtin_openssl2/crypto/modes"])
-#env_ssl.Append(CPPPATH=["#drivers/builtin_openssl2/crypto/store"])
-env_drivers.Append(CPPFLAGS=["-DOPENSSL_NO_ASM","-DOPENSSL_THREADS","-DL_ENDIAN"])
+# env_ssl.Append(CPPPATH=["#drivers/builtin_openssl2/crypto/store"])
+env_drivers.Append(CPPFLAGS=["-DOPENSSL_NO_ASM", "-DOPENSSL_THREADS", "-DL_ENDIAN"])
 
 # Workaround for compilation error with GCC/Clang when -Werror is too greedy (GH-4517)
 import os
-if not (os.name=="nt" and os.getenv("VSINSTALLDIR")!=None): # not Windows and not MSVC
+if not (os.name == "nt" and os.getenv("VSINSTALLDIR") != None):  # not Windows and not MSVC
     env_drivers.Append(CFLAGS=["-Wno-error=implicit-function-declaration"])
 
-env_drivers.add_source_files(env.drivers_sources,openssl_sources)
+env_drivers.add_source_files(env.drivers_sources, openssl_sources)

drivers/gl_context/SCsub

@@ -2,9 +2,9 @@
 
 Import('env')
 
-if (env["platform"] in ["haiku","osx","windows","x11"]):
+if (env["platform"] in ["haiku", "osx", "windows", "x11"]):
     # Thirdparty source files
-    if (env["glew"] != "system"): # builtin
+    if (env["glew"] != "system"):  # builtin
         thirdparty_dir = "#thirdparty/glew/"
         thirdparty_sources = [
             "glew.c",
@@ -12,10 +12,10 @@ if (env["platform"] in ["haiku","osx","windows","x11"]):
         thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
         env.add_source_files(env.drivers_sources, thirdparty_sources)
-        env.Append(CPPFLAGS = ['-DGLEW_STATIC'])
-        env.Append(CPPPATH = [thirdparty_dir])
+        env.Append(CPPFLAGS=['-DGLEW_STATIC'])
+        env.Append(CPPPATH=[thirdparty_dir])
 
-    env.Append(CPPFLAGS = ['-DGLEW_ENABLED'])
+    env.Append(CPPFLAGS=['-DGLEW_ENABLED'])
 
 # Godot source files
 env.add_source_files(env.drivers_sources, "*.cpp")

drivers/png/SCsub

@@ -27,12 +27,12 @@ if (env["libpng"] == "builtin"):
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_png.add_source_files(env.drivers_sources, thirdparty_sources)
-    env_png.Append(CPPPATH = [thirdparty_dir])
+    env_png.Append(CPPPATH=[thirdparty_dir])
 
     # Currently .ASM filter_neon.S does not compile on NT.
     import os
-    if ("neon_enabled" in env and env["neon_enabled"]) and os.name!="nt":
-        env_png.Append(CPPFLAGS = ["-DPNG_ARM_NEON_OPT=2"])
+    if ("neon_enabled" in env and env["neon_enabled"]) and os.name != "nt":
+        env_png.Append(CPPFLAGS=["-DPNG_ARM_NEON_OPT=2"])
         env_neon = env_png.Clone();
         if "S_compiler" in env:
             env_neon['CC'] = env['S_compiler']
@@ -42,7 +42,7 @@ if (env["libpng"] == "builtin"):
         neon_sources.append(env_neon.Object(thirdparty_dir + "/arm/filter_neon.S"))
         env.drivers_sources += neon_sources
     else:
-        env_png.Append(CPPFLAGS = ["-DPNG_ARM_NEON_OPT=0"])
+        env_png.Append(CPPFLAGS=["-DPNG_ARM_NEON_OPT=0"])
 
 # Godot source files
 env_png.add_source_files(env.drivers_sources, "*.cpp")

drivers/rtaudio/SCsub

@@ -12,7 +12,7 @@ thirdparty_sources = [
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
 env.add_source_files(env.drivers_sources, thirdparty_sources)
-env.Append(CPPPATH = [thirdparty_dir])
+env.Append(CPPPATH=[thirdparty_dir])
 
 # Driver source files
 env.add_source_files(env.drivers_sources, "*.cpp")

drivers/unix/SCsub

@@ -2,13 +2,13 @@
 
 Import('env')
 
-g_set_p='#ifdef UNIX_ENABLED\n'
-g_set_p+='#include "os_unix.h"\n'
-g_set_p+='String OS_Unix::get_global_settings_path() const {\n'
-g_set_p+='\treturn "' + env["unix_global_settings_path"]+'";\n'
-g_set_p+='}\n'
-g_set_p+='#endif'
-f = open("os_unix_global_settings_path.cpp","wb")
+g_set_p = '#ifdef UNIX_ENABLED\n'
+g_set_p += '#include "os_unix.h"\n'
+g_set_p += 'String OS_Unix::get_global_settings_path() const {\n'
+g_set_p += '\treturn "' + env["unix_global_settings_path"] + '";\n'
+g_set_p += '}\n'
+g_set_p += '#endif'
+f = open("os_unix_global_settings_path.cpp", "wb")
 f.write(g_set_p)
 f.close()
 

drivers/zlib/SCsub

@@ -23,4 +23,4 @@ thirdparty_sources = [
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
 env.add_source_files(env.drivers_sources, thirdparty_sources)
-env.Append(CPPPATH = [thirdparty_dir])
+env.Append(CPPPATH=[thirdparty_dir])

main/SCsub

@@ -2,11 +2,11 @@
 
 Import('env')
 
-env.main_sources=[]
-env.add_source_files(env.main_sources,"*.cpp")
+env.main_sources = []
+env.add_source_files(env.main_sources, "*.cpp")
 
 Export('env')
 
-lib = env.Library("main",env.main_sources)
+lib = env.Library("main", env.main_sources)
 
 env.Prepend(LIBS=[lib])

modules/SCsub

@@ -6,18 +6,18 @@ env_modules = env.Clone()
 
 Export('env_modules')
 
-env.modules_sources=[
+env.modules_sources = [
     "register_module_types.cpp",
 ]
-#env.add_source_files(env.modules_sources,"*.cpp")
+# env.add_source_files(env.modules_sources,"*.cpp")
 Export('env')
 
 for x in env.module_list:
     if (x in env.disabled_modules):
         continue
-    env_modules.Append(CPPFLAGS=["-DMODULE_"+x.upper()+"_ENABLED"])
-    SConscript(x+"/SCsub")
+    env_modules.Append(CPPFLAGS=["-DMODULE_" + x.upper() + "_ENABLED"])
+    SConscript(x + "/SCsub")
 
-lib = env_modules.Library("modules",env.modules_sources)
+lib = env_modules.Library("modules", env.modules_sources)
 
 env.Prepend(LIBS=[lib])

modules/etc1/SCsub

@@ -14,7 +14,7 @@ thirdparty_sources = [
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
 env_etc1.add_source_files(env.modules_sources, thirdparty_sources)
-env_etc1.Append(CPPPATH = [thirdparty_dir])
+env_etc1.Append(CPPPATH=[thirdparty_dir])
 
 # Godot source files
 env_etc1.add_source_files(env.modules_sources, "*.cpp")

modules/freetype/SCsub

@@ -5,7 +5,7 @@ Import('env')
 # Not building in a separate env as core needs it
 
 # Thirdparty source files
-if (env["freetype"] != "system"): # builtin
+if (env["freetype"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/freetype/"
     thirdparty_sources = [
         "src/autofit/autofit.c",
@@ -56,13 +56,13 @@ if (env["freetype"] != "system"): # builtin
 
     # Include header for WinRT to fix build issues
     if "platform" in env and env["platform"] == "winrt":
-        env.Append(CCFLAGS = ['/FI', '"modules/freetype/winrtdef.h"'])
+        env.Append(CCFLAGS=['/FI', '"modules/freetype/winrtdef.h"'])
 
-    env.Append(CPPPATH = [thirdparty_dir, thirdparty_dir + "/include"])
+    env.Append(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"])
 
     # also requires libpng headers
-    if (env["libpng"] != "system"): # builtin
-        env.Append(CPPPATH = ["#thirdparty/libpng"])
+    if (env["libpng"] != "system"):  # builtin
+        env.Append(CPPPATH=["#thirdparty/libpng"])
 
     """ FIXME: Remove this commented code if Windows can handle the monolithic lib
 	# fix for Windows' shell miserably failing on long lines, split in two libraries
@@ -81,10 +81,10 @@ if (env["freetype"] != "system"): # builtin
 	"""
 
     lib = env.Library("freetype_builtin", thirdparty_sources)
-    env.Append(LIBS = [lib])
+    env.Append(LIBS=[lib])
 
 # Godot source files
 env.add_source_files(env.modules_sources, "*.cpp")
-env.Append(CCFLAGS = ['-DFREETYPE_ENABLED'])
+env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
 
 Export('env')

modules/jpg/SCsub

@@ -14,7 +14,7 @@ thirdparty_sources = [
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
 env_jpg.add_source_files(env.modules_sources, thirdparty_sources)
-env_jpg.Append(CPPPATH = [thirdparty_dir])
+env_jpg.Append(CPPPATH=[thirdparty_dir])
 
 # Godot's own source files
 env_jpg.add_source_files(env.modules_sources, "*.cpp")

modules/mpc/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_mpc = env_modules.Clone()
 
 # Thirdparty source files
-if (env["libmpcdec"] != "system"): # builtin
+if (env["libmpcdec"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/libmpcdec/"
     thirdparty_sources = [
         "huffman.c",
@@ -22,7 +22,7 @@ if (env["libmpcdec"] != "system"): # builtin
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_mpc.add_source_files(env.modules_sources, thirdparty_sources)
-    env_mpc.Append(CPPPATH = [thirdparty_dir])
+    env_mpc.Append(CPPPATH=[thirdparty_dir])
 
 # Godot source files
 env_mpc.add_source_files(env.modules_sources, "*.cpp")

modules/ogg/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_ogg = env_modules.Clone()
 
 # Thirdparty source files
-if (env["libogg"] != "system"): # builtin
+if (env["libogg"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/libogg/"
     thirdparty_sources = [
         "bitwise.c",
@@ -15,7 +15,7 @@ if (env["libogg"] != "system"): # builtin
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_ogg.add_source_files(env.modules_sources, thirdparty_sources)
-    env_ogg.Append(CPPPATH = [thirdparty_dir])
+    env_ogg.Append(CPPPATH=[thirdparty_dir])
 
 # Godot source files
 env_ogg.add_source_files(env.modules_sources, "*.cpp")

modules/openssl/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_openssl = env_modules.Clone()
 
 # Thirdparty source files
-if (env["openssl"] != "system"): # builtin
+if (env["openssl"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/openssl/"
 
     thirdparty_sources = [
@@ -661,15 +661,15 @@ if (env["openssl"] != "system"): # builtin
         "crypto/modes",
         "openssl",
     ]
-    env_openssl.Append(CPPPATH = [thirdparty_dir + "/" + dir for dir in thirdparty_include_paths])
+    env_openssl.Append(CPPPATH=[thirdparty_dir + "/" + dir for dir in thirdparty_include_paths])
 
-    env_openssl.Append(CPPFLAGS = ["-DOPENSSL_NO_ASM", "-DOPENSSL_THREADS", "-DL_ENDIAN"])
+    env_openssl.Append(CPPFLAGS=["-DOPENSSL_NO_ASM", "-DOPENSSL_THREADS", "-DL_ENDIAN"])
 
     # Workaround for compilation error with GCC/Clang when -Werror is too greedy (GH-4517)
     import os
     import methods
-    if not (os.name=="nt" and os.getenv("VSINSTALLDIR") != None): # not Windows and not MSVC
-        env_openssl.Append(CFLAGS = ["-Wno-error=implicit-function-declaration"])
+    if not (os.name == "nt" and os.getenv("VSINSTALLDIR") != None):  # not Windows and not MSVC
+        env_openssl.Append(CFLAGS=["-Wno-error=implicit-function-declaration"])
 
 
 # Module sources

modules/opus/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_opus = env_modules.Clone()
 
 # Thirdparty source files
-if (env["opus"] != "system"): # builtin
+if (env["opus"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/opus/"
 
     thirdparty_sources = [
@@ -129,8 +129,8 @@ if (env["opus"] != "system"): # builtin
 
     opus_sources_silk = []
 
-    if("opus_fixed_point" in env and env.opus_fixed_point=="yes"):
-        env_opus.Append(CFLAGS = ["-DFIXED_POINT"])
+    if("opus_fixed_point" in env and env.opus_fixed_point == "yes"):
+        env_opus.Append(CFLAGS=["-DFIXED_POINT"])
         opus_sources_silk = [
             "silk/fixed/schur64_FIX.c",
             "silk/fixed/residual_energy16_FIX.c",
@@ -205,11 +205,11 @@ if (env["opus"] != "system"): # builtin
         "silk/fixed",
         "silk/float",
     ]
-    env_opus.Append(CPPPATH = [thirdparty_dir + "/" + dir for dir in thirdparty_include_paths])
+    env_opus.Append(CPPPATH=[thirdparty_dir + "/" + dir for dir in thirdparty_include_paths])
 
     # also requires libogg
-    if (env["libogg"] != "system"): # builtin
-        env_opus.Append(CPPPATH = ["#thirdparty/libogg"])
+    if (env["libogg"] != "system"):  # builtin
+        env_opus.Append(CPPPATH=["#thirdparty/libogg"])
 
 # Module files
 env_opus.add_source_files(env.modules_sources, "*.cpp")

modules/pvr/SCsub

@@ -18,7 +18,7 @@ thirdparty_sources = [
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
 env_pvr.add_source_files(env.modules_sources, thirdparty_sources)
-env_pvr.Append(CPPPATH = [thirdparty_dir])
+env_pvr.Append(CPPPATH=[thirdparty_dir])
 
 # Godot source files
 env_pvr.add_source_files(env.modules_sources, "*.cpp")

modules/speex/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_speex = env_modules.Clone()
 
 # Thirdparty source files
-if (env["speex"] != "system"): # builtin
+if (env["speex"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/speex/"
 
     thirdparty_sources = [
@@ -56,11 +56,11 @@ if (env["speex"] != "system"): # builtin
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_speex.add_source_files(env.modules_sources, thirdparty_sources)
-    env_speex.Append(CPPPATH = [thirdparty_dir])
+    env_speex.Append(CPPPATH=[thirdparty_dir])
 
     # also requires libogg
-    if (env["libogg"] != "system"): # builtin
-        env_speex.Append(CPPPATH = ["#thirdparty/libogg"])
+    if (env["libogg"] != "system"):  # builtin
+        env_speex.Append(CPPPATH=["#thirdparty/libogg"])
 
 # Module files
 env_speex.add_source_files(env.modules_sources, "*.cpp")

modules/squish/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_squish = env_modules.Clone()
 
 # Thirdparty source files
-if (env["squish"] != "system"): # builtin
+if (env["squish"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/squish/"
     thirdparty_sources = [
         "alpha.cpp",
@@ -23,7 +23,7 @@ if (env["squish"] != "system"): # builtin
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_squish.add_source_files(env.modules_sources, thirdparty_sources)
-    env_squish.Append(CPPPATH = [thirdparty_dir])
+    env_squish.Append(CPPPATH=[thirdparty_dir])
 
 # Godot source files
 env_squish.add_source_files(env.modules_sources, "*.cpp")

modules/theora/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_theora = env_modules.Clone()
 
 # Thirdparty source files
-if (env["libtheora"] != "system"): # builtin
+if (env["libtheora"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/libtheora/"
     thirdparty_sources = [
         #"analyze.c",
@@ -66,18 +66,18 @@ if (env["libtheora"] != "system"): # builtin
         thirdparty_sources += thirdparty_sources_x86_vc
 
     if (env["x86_libtheora_opt_gcc"] or env["x86_libtheora_opt_vc"]):
-        env_theora.Append(CCFLAGS = ["-DOC_X86_ASM"])
+        env_theora.Append(CCFLAGS=["-DOC_X86_ASM"])
 
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_theora.add_source_files(env.modules_sources, thirdparty_sources)
-    env_theora.Append(CPPPATH = [thirdparty_dir])
+    env_theora.Append(CPPPATH=[thirdparty_dir])
 
     # also requires libogg and libvorbis
-    if (env["libogg"] != "system"): # builtin
-        env_theora.Append(CPPPATH = ["#thirdparty/libogg"])
-    if (env["libvorbis"] != "system"): # builtin
-        env_theora.Append(CPPPATH = ["#thirdparty/libvorbis"])
+    if (env["libogg"] != "system"):  # builtin
+        env_theora.Append(CPPPATH=["#thirdparty/libogg"])
+    if (env["libvorbis"] != "system"):  # builtin
+        env_theora.Append(CPPPATH=["#thirdparty/libvorbis"])
 
 # Godot source files
 env_theora.add_source_files(env.modules_sources, "*.cpp")

modules/vorbis/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_vorbis = env_modules.Clone()
 
 # Thirdparty source files
-if (env["libvorbis"] != "system"): # builtin
+if (env["libvorbis"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/libvorbis/"
     thirdparty_sources = [
         #"analysis.c",
@@ -39,11 +39,11 @@ if (env["libvorbis"] != "system"): # builtin
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_vorbis.add_source_files(env.modules_sources, thirdparty_sources)
-    env_vorbis.Append(CPPPATH = [thirdparty_dir])
+    env_vorbis.Append(CPPPATH=[thirdparty_dir])
 
     # also requires libogg
-    if (env["libogg"] != "system"): # builtin
-        env_vorbis.Append(CPPPATH = ["#thirdparty/libogg"])
+    if (env["libogg"] != "system"):  # builtin
+        env_vorbis.Append(CPPPATH=["#thirdparty/libogg"])
 
 # Godot source files
 env_vorbis.add_source_files(env.modules_sources, "*.cpp")

modules/webp/SCsub

@@ -6,7 +6,7 @@ Import('env_modules')
 env_webp = env_modules.Clone()
 
 # Thirdparty source files
-if (env["libwebp"] != "system"): # builtin
+if (env["libwebp"] != "system"):  # builtin
     thirdparty_dir = "#thirdparty/libwebp/"
     thirdparty_sources = [
         "enc/webpenc.c",
@@ -115,7 +115,7 @@ if (env["libwebp"] != "system"): # builtin
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_webp.add_source_files(env.modules_sources, thirdparty_sources)
-    env_webp.Append(CPPPATH = [thirdparty_dir])
+    env_webp.Append(CPPPATH=[thirdparty_dir])
 
 # Godot source files
 env_webp.add_source_files(env.modules_sources, "*.cpp")

platform/android/SCsub

@@ -22,7 +22,7 @@ android_files = [
     'java_class_wrapper.cpp'
 ]
 
-#env.Depends('#core/math/vector3.h', 'vector3_psp.h')
+# env.Depends('#core/math/vector3.h', 'vector3_psp.h')
 
 #obj = env.SharedObject('godot_android.cpp')
 
@@ -30,86 +30,86 @@ env_android = env.Clone()
 if env['target'] == "profile":
     env_android.Append(CPPFLAGS=['-DPROFILER_ENABLED'])
 
-android_objects=[]
+android_objects = []
 for x in android_files:
-    android_objects.append( env_android.SharedObject( x ) )
+    android_objects.append(env_android.SharedObject(x))
 
 prog = None
 
-abspath=env.Dir(".").abspath
+abspath = env.Dir(".").abspath
 
 
-gradle_basein = open(abspath+"/build.gradle.template","rb")
-gradle_baseout = open(abspath+"/java/build.gradle","wb")
+gradle_basein = open(abspath + "/build.gradle.template", "rb")
+gradle_baseout = open(abspath + "/java/build.gradle", "wb")
 
 gradle_text = gradle_basein.read()
 
 
-gradle_maven_repos_text=""
+gradle_maven_repos_text = ""
 
 if len(env.android_maven_repos) > 0:
-    gradle_maven_repos_text+="maven {\n"
+    gradle_maven_repos_text += "maven {\n"
     for x in env.android_maven_repos:
-        gradle_maven_repos_text+="\t\t"+x+"\n"
-    gradle_maven_repos_text+="\t}\n"
+        gradle_maven_repos_text += "\t\t" + x + "\n"
+    gradle_maven_repos_text += "\t}\n"
 
-gradle_maven_dependencies_text=""
+gradle_maven_dependencies_text = ""
 
 for x in env.android_dependencies:
-    gradle_maven_dependencies_text+=x+"\n"
+    gradle_maven_dependencies_text += x + "\n"
 
-gradle_java_dirs_text=""
+gradle_java_dirs_text = ""
 
 for x in env.android_java_dirs:
-    gradle_java_dirs_text+=",'"+x.replace("\\","/")+"'"
+    gradle_java_dirs_text += ",'" + x.replace("\\", "/") + "'"
 
 
-gradle_res_dirs_text=""
+gradle_res_dirs_text = ""
 
 for x in env.android_res_dirs:
-    gradle_res_dirs_text+=",'"+x.replace("\\","/")+"'"
+    gradle_res_dirs_text += ",'" + x.replace("\\", "/") + "'"
 
-gradle_aidl_dirs_text=""
+gradle_aidl_dirs_text = ""
 
 for x in env.android_aidl_dirs:
-    gradle_aidl_dirs_text+=",'"+x.replace("\\","/")+"'"
+    gradle_aidl_dirs_text += ",'" + x.replace("\\", "/") + "'"
 
-gradle_jni_dirs_text=""
+gradle_jni_dirs_text = ""
 
 for x in env.android_jni_dirs:
-    gradle_jni_dirs_text+=",'"+x.replace("\\","/")+"'"
+    gradle_jni_dirs_text += ",'" + x.replace("\\", "/") + "'"
 
-gradle_asset_dirs_text=""
+gradle_asset_dirs_text = ""
 
-gradle_default_config_text=""
+gradle_default_config_text = ""
 
 for x in env.android_default_config:
-    gradle_default_config_text+=x+"\n\t\t"
+    gradle_default_config_text += x + "\n\t\t"
 
-gradle_text = gradle_text.replace("$$GRADLE_REPOSITORY_URLS$$",gradle_maven_repos_text)
-gradle_text = gradle_text.replace("$$GRADLE_DEPENDENCIES$$",gradle_maven_dependencies_text)
-gradle_text = gradle_text.replace("$$GRADLE_JAVA_DIRS$$",gradle_java_dirs_text)
-gradle_text = gradle_text.replace("$$GRADLE_RES_DIRS$$",gradle_res_dirs_text)
-gradle_text = gradle_text.replace("$$GRADLE_ASSET_DIRS$$",gradle_asset_dirs_text)
-gradle_text = gradle_text.replace("$$GRADLE_AIDL_DIRS$$",gradle_aidl_dirs_text)
-gradle_text = gradle_text.replace("$$GRADLE_JNI_DIRS$$",gradle_jni_dirs_text)
-gradle_text = gradle_text.replace("$$GRADLE_DEFAULT_CONFIG$$",gradle_default_config_text)
+gradle_text = gradle_text.replace("$$GRADLE_REPOSITORY_URLS$$", gradle_maven_repos_text)
+gradle_text = gradle_text.replace("$$GRADLE_DEPENDENCIES$$", gradle_maven_dependencies_text)
+gradle_text = gradle_text.replace("$$GRADLE_JAVA_DIRS$$", gradle_java_dirs_text)
+gradle_text = gradle_text.replace("$$GRADLE_RES_DIRS$$", gradle_res_dirs_text)
+gradle_text = gradle_text.replace("$$GRADLE_ASSET_DIRS$$", gradle_asset_dirs_text)
+gradle_text = gradle_text.replace("$$GRADLE_AIDL_DIRS$$", gradle_aidl_dirs_text)
+gradle_text = gradle_text.replace("$$GRADLE_JNI_DIRS$$", gradle_jni_dirs_text)
+gradle_text = gradle_text.replace("$$GRADLE_DEFAULT_CONFIG$$", gradle_default_config_text)
 
 
-gradle_baseout.write( gradle_text )
+gradle_baseout.write(gradle_text)
 gradle_baseout.close()
 
 
-pp_basein = open(abspath+"/AndroidManifest.xml.template","rb")
-pp_baseout = open(abspath+"/java/AndroidManifest.xml","wb")
+pp_basein = open(abspath + "/AndroidManifest.xml.template", "rb")
+pp_baseout = open(abspath + "/java/AndroidManifest.xml", "wb")
 manifest = pp_basein.read()
-manifest = manifest.replace("$$ADD_APPLICATION_CHUNKS$$",env.android_manifest_chunk)
-manifest = manifest.replace("$$ADD_PERMISSION_CHUNKS$$",env.android_permission_chunk)
-manifest = manifest.replace("$$ADD_APPATTRIBUTE_CHUNKS$$",env.android_appattributes_chunk)
-pp_baseout.write( manifest )
+manifest = manifest.replace("$$ADD_APPLICATION_CHUNKS$$", env.android_manifest_chunk)
+manifest = manifest.replace("$$ADD_PERMISSION_CHUNKS$$", env.android_permission_chunk)
+manifest = manifest.replace("$$ADD_APPATTRIBUTE_CHUNKS$$", env.android_appattributes_chunk)
+pp_baseout.write(manifest)
 
 
-env_android.SharedLibrary("#bin/libgodot",[android_objects],SHLIBSUFFIX=env["SHLIBSUFFIX"])
+env_android.SharedLibrary("#bin/libgodot", [android_objects], SHLIBSUFFIX=env["SHLIBSUFFIX"])
 
 
 lib_arch_dir = ''
@@ -125,8 +125,8 @@ else:
 if lib_arch_dir != '':
     if env['target'] == 'release':
         lib_type_dir = 'release'
-    else: # release_debug, debug
+    else:  # release_debug, debug
         lib_type_dir = 'debug'
 
-    out_dir = '#platform/android/java/libs/'+lib_type_dir+'/'+lib_arch_dir
-    env_android.Command(out_dir+'/libgodot_android.so', '#bin/libgodot'+env['SHLIBSUFFIX'], Move("$TARGET", "$SOURCE"))
+    out_dir = '#platform/android/java/libs/' + lib_type_dir + '/' + lib_arch_dir
+    env_android.Command(out_dir + '/libgodot_android.so', '#bin/libgodot' + env['SHLIBSUFFIX'], Move("$TARGET", "$SOURCE"))

platform/android/detect.py

@@ -21,12 +21,12 @@ def get_opts():
 
     return [
         ('ANDROID_NDK_ROOT', 'the path to Android NDK', os.environ.get("ANDROID_NDK_ROOT", 0)),
-        ('NDK_TARGET', 'toolchain to use for the NDK',os.environ.get("NDK_TARGET", "arm-linux-androideabi-4.9")),
-        ('NDK_TARGET_X86', 'toolchain to use for the NDK x86',os.environ.get("NDK_TARGET_X86", "x86-4.9")),
-        ('ndk_platform', 'compile for platform: (android-<api> , example: android-14)',"android-14"),
-        ('android_arch', 'select compiler architecture: (armv7/armv6/x86)',"armv7"),
-        ('android_neon','enable neon (armv7 only)',"yes"),
-        ('android_stl','enable STL support in android port (for modules)',"no")
+        ('NDK_TARGET', 'toolchain to use for the NDK', os.environ.get("NDK_TARGET", "arm-linux-androideabi-4.9")),
+        ('NDK_TARGET_X86', 'toolchain to use for the NDK x86', os.environ.get("NDK_TARGET_X86", "x86-4.9")),
+        ('ndk_platform', 'compile for platform: (android-<api> , example: android-14)', "android-14"),
+        ('android_arch', 'select compiler architecture: (armv7/armv6/x86)', "armv7"),
+        ('android_neon', 'enable neon (armv7 only)', "yes"),
+        ('android_stl', 'enable STL support in android port (for modules)', "no")
     ]
 
 
@@ -34,7 +34,7 @@ def get_flags():
 
     return [
         ('tools', 'no'),
-        ('openssl', 'builtin'), #use builtin openssl
+        ('openssl', 'builtin'),  # use builtin openssl
     ]
 
 
@@ -52,16 +52,16 @@ def configure(env):
     # Workaround for MinGW. See:
     # http://www.scons.org/wiki/LongCmdLinesOnWin32
     import os
-    if (os.name=="nt"):
+    if (os.name == "nt"):
 
         import subprocess
 
-        def mySubProcess(cmdline,env):
-            #print "SPAWNED : " + cmdline
+        def mySubProcess(cmdline, env):
+            # print "SPAWNED : " + cmdline
             startupinfo = subprocess.STARTUPINFO()
             startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
             proc = subprocess.Popen(cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE, startupinfo=startupinfo, shell = False, env = env)
+                                    stderr=subprocess.PIPE, startupinfo=startupinfo, shell=False, env=env)
             data, err = proc.communicate()
             rv = proc.wait()
             if rv:
@@ -75,176 +75,176 @@ def configure(env):
             newargs = ' '.join(args[1:])
             cmdline = cmd + " " + newargs
 
-            rv=0
-            if len(cmdline) > 32000 and cmd.endswith("ar") :
+            rv = 0
+            if len(cmdline) > 32000 and cmd.endswith("ar"):
                 cmdline = cmd + " " + args[1] + " " + args[2] + " "
-                for i in range(3,len(args)) :
-                    rv = mySubProcess( cmdline + args[i], env )
-                    if rv :
+                for i in range(3, len(args)):
+                    rv = mySubProcess(cmdline + args[i], env)
+                    if rv:
                         break
             else:
-                rv = mySubProcess( cmdline, env )
+                rv = mySubProcess(cmdline, env)
 
             return rv
 
         env['SPAWN'] = mySpawn
 
-    ndk_platform=env['ndk_platform']
+    ndk_platform = env['ndk_platform']
 
-    if env['android_arch'] not in ['armv7','armv6','x86']:
-        env['android_arch']='armv7'
+    if env['android_arch'] not in ['armv7', 'armv6', 'x86']:
+        env['android_arch'] = 'armv7'
 
-    if env['android_arch']=='x86':
-        env['NDK_TARGET']=env['NDK_TARGET_X86']
-        env["x86_libtheora_opt_gcc"]=True
+    if env['android_arch'] == 'x86':
+        env['NDK_TARGET'] = env['NDK_TARGET_X86']
+        env["x86_libtheora_opt_gcc"] = True
 
     if env['PLATFORM'] == 'win32':
         env.Tool('gcc')
         env['SHLIBSUFFIX'] = '.so'
 
 
-    neon_text=""
-    if env["android_arch"]=="armv7" and env['android_neon']=='yes':
-        neon_text=" (with neon)"
-    print("Godot Android!!!!! ("+env['android_arch']+")"+neon_text)
+    neon_text = ""
+    if env["android_arch"] == "armv7" and env['android_neon'] == 'yes':
+        neon_text = " (with neon)"
+    print("Godot Android!!!!! (" + env['android_arch'] + ")" + neon_text)
 
     env.Append(CPPPATH=['#platform/android'])
 
-    if env['android_arch']=='x86':
-        env.extra_suffix=".x86"+env.extra_suffix
-    elif env['android_arch']=='armv6':
-        env.extra_suffix=".armv6"+env.extra_suffix
-    elif env["android_arch"]=="armv7":
-        if env['android_neon']=='yes':
-            env.extra_suffix=".armv7.neon"+env.extra_suffix
+    if env['android_arch'] == 'x86':
+        env.extra_suffix = ".x86" + env.extra_suffix
+    elif env['android_arch'] == 'armv6':
+        env.extra_suffix = ".armv6" + env.extra_suffix
+    elif env["android_arch"] == "armv7":
+        if env['android_neon'] == 'yes':
+            env.extra_suffix = ".armv7.neon" + env.extra_suffix
         else:
-            env.extra_suffix=".armv7"+env.extra_suffix
+            env.extra_suffix = ".armv7" + env.extra_suffix
 
-    gcc_path=env["ANDROID_NDK_ROOT"]+"/toolchains/"+env["NDK_TARGET"]+"/prebuilt/";
+    gcc_path = env["ANDROID_NDK_ROOT"] + "/toolchains/" + env["NDK_TARGET"] + "/prebuilt/";
 
     if (sys.platform.startswith("linux")):
         if (platform.machine().endswith('64')):
-            gcc_path=gcc_path+"/linux-x86_64/bin"
+            gcc_path = gcc_path + "/linux-x86_64/bin"
         else:
-            gcc_path=gcc_path+"/linux-x86/bin"
+            gcc_path = gcc_path + "/linux-x86/bin"
     elif (sys.platform.startswith("darwin")):
-        gcc_path=gcc_path+"/darwin-x86_64/bin"
+        gcc_path = gcc_path + "/darwin-x86_64/bin"
         env['SHLINKFLAGS'][1] = '-shared'
         env['SHLIBSUFFIX'] = '.so'
     elif (sys.platform.startswith('win')):
         if (platform.machine().endswith('64')):
-            gcc_path=gcc_path+"/windows-x86_64/bin"
+            gcc_path = gcc_path + "/windows-x86_64/bin"
         else:
-            gcc_path=gcc_path+"/windows-x86/bin"
-
-    env['ENV']['PATH'] = gcc_path+":"+env['ENV']['PATH']
-    if env['android_arch']=='x86':
-        env['CC'] = gcc_path+'/i686-linux-android-gcc'
-        env['CXX'] = gcc_path+'/i686-linux-android-g++'
-        env['AR'] = gcc_path+"/i686-linux-android-ar"
-        env['RANLIB'] = gcc_path+"/i686-linux-android-ranlib"
-        env['AS'] = gcc_path+"/i686-linux-android-as"
+            gcc_path = gcc_path + "/windows-x86/bin"
+
+    env['ENV']['PATH'] = gcc_path + ":" + env['ENV']['PATH']
+    if env['android_arch'] == 'x86':
+        env['CC'] = gcc_path + '/i686-linux-android-gcc'
+        env['CXX'] = gcc_path + '/i686-linux-android-g++'
+        env['AR'] = gcc_path + "/i686-linux-android-ar"
+        env['RANLIB'] = gcc_path + "/i686-linux-android-ranlib"
+        env['AS'] = gcc_path + "/i686-linux-android-as"
     else:
-        env['CC'] = gcc_path+'/arm-linux-androideabi-gcc'
-        env['CXX'] = gcc_path+'/arm-linux-androideabi-g++'
-        env['AR'] = gcc_path+"/arm-linux-androideabi-ar"
-        env['RANLIB'] = gcc_path+"/arm-linux-androideabi-ranlib"
-        env['AS'] = gcc_path+"/arm-linux-androideabi-as"
+        env['CC'] = gcc_path + '/arm-linux-androideabi-gcc'
+        env['CXX'] = gcc_path + '/arm-linux-androideabi-g++'
+        env['AR'] = gcc_path + "/arm-linux-androideabi-ar"
+        env['RANLIB'] = gcc_path + "/arm-linux-androideabi-ranlib"
+        env['AS'] = gcc_path + "/arm-linux-androideabi-as"
 
-    if env['android_arch']=='x86':
+    if env['android_arch'] == 'x86':
         env['ARCH'] = 'arch-x86'
     else:
         env['ARCH'] = 'arch-arm'
 
     import string
-    #include path
-    gcc_include=env["ANDROID_NDK_ROOT"]+"/platforms/"+ndk_platform+"/"+env['ARCH'] +"/usr/include"
-    ld_sysroot=env["ANDROID_NDK_ROOT"]+"/platforms/"+ndk_platform+"/"+env['ARCH']
-    #glue_include=env["ANDROID_NDK_ROOT"]+"/sources/android/native_app_glue"
-    ld_path=env["ANDROID_NDK_ROOT"]+"/platforms/"+ndk_platform+"/"+env['ARCH']+"/usr/lib"
+    # include path
+    gcc_include = env["ANDROID_NDK_ROOT"] + "/platforms/" + ndk_platform + "/" + env['ARCH'] + "/usr/include"
+    ld_sysroot = env["ANDROID_NDK_ROOT"] + "/platforms/" + ndk_platform + "/" + env['ARCH']
+    # glue_include=env["ANDROID_NDK_ROOT"]+"/sources/android/native_app_glue"
+    ld_path = env["ANDROID_NDK_ROOT"] + "/platforms/" + ndk_platform + "/" + env['ARCH'] + "/usr/lib"
     env.Append(CPPPATH=[gcc_include])
 #	env['CCFLAGS'] = string.split('-DNO_THREADS -MMD -MP -MF -fpic -ffunction-sections -funwind-tables -fstack-protector -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__  -Wno-psabi -march=armv5te -mtune=xscale -msoft-float  -fno-exceptions -mthumb -fno-strict-aliasing -DANDROID -Wa,--noexecstack -DGLES2_ENABLED ')
 
-    env['neon_enabled']=False
-    if env['android_arch']=='x86':
+    env['neon_enabled'] = False
+    if env['android_arch'] == 'x86':
         env.Append(CCFLAGS=string.split('-DNO_STATVFS -fpic -ffunction-sections -funwind-tables -fstack-protector -fvisibility=hidden -D__GLIBC__  -Wno-psabi -ftree-vectorize -funsafe-math-optimizations -fno-strict-aliasing -DANDROID -Wa,--noexecstack -DGLES2_ENABLED'))
-    elif env["android_arch"]=="armv6":
+    elif env["android_arch"] == "armv6":
         env.Append(CCFLAGS=string.split('-DNO_STATVFS -fpic -ffunction-sections -funwind-tables -fstack-protector -fvisibility=hidden -D__ARM_ARCH_6__ -D__GLIBC__  -Wno-psabi -march=armv6 -mfpu=vfp -mfloat-abi=softfp -funsafe-math-optimizations -fno-strict-aliasing -DANDROID -Wa,--noexecstack -DGLES2_ENABLED'))
-    elif env["android_arch"]=="armv7":
+    elif env["android_arch"] == "armv7":
         env.Append(CCFLAGS=string.split('-DNO_STATVFS -fpic -ffunction-sections -funwind-tables -fstack-protector -fvisibility=hidden -D__ARM_ARCH_7__ -D__ARM_ARCH_7A__ -D__GLIBC__  -Wno-psabi -march=armv7-a -mfloat-abi=softfp -ftree-vectorize -funsafe-math-optimizations -fno-strict-aliasing -DANDROID -Wa,--noexecstack -DGLES2_ENABLED'))
-        if env['android_neon']=='yes':
-            env['neon_enabled']=True
-            env.Append(CCFLAGS=['-mfpu=neon','-D__ARM_NEON__'])
+        if env['android_neon'] == 'yes':
+            env['neon_enabled'] = True
+            env.Append(CCFLAGS=['-mfpu=neon', '-D__ARM_NEON__'])
         else:
             env.Append(CCFLAGS=['-mfpu=vfpv3-d16'])
 
     env.Append(LDPATH=[ld_path])
     env.Append(LIBS=['OpenSLES'])
 #	env.Append(LIBS=['c','m','stdc++','log','EGL','GLESv1_CM','GLESv2','OpenSLES','supc++','android'])
-    env.Append(LIBS=['EGL','OpenSLES','android'])
-    env.Append(LIBS=['c','m','stdc++','log','GLESv1_CM','GLESv2', 'z'])
+    env.Append(LIBS=['EGL', 'OpenSLES', 'android'])
+    env.Append(LIBS=['c', 'm', 'stdc++', 'log', 'GLESv1_CM', 'GLESv2', 'z'])
 
-    env["LINKFLAGS"]= string.split(" -g --sysroot="+ld_sysroot+" -Wl,--no-undefined -Wl,-z,noexecstack ")
+    env["LINKFLAGS"] = string.split(" -g --sysroot=" + ld_sysroot + " -Wl,--no-undefined -Wl,-z,noexecstack ")
     env.Append(LINKFLAGS=["-Wl,-soname,libgodot_android.so"])
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
 
-        env.Append(CCFLAGS=['-O2', '-ffast-math','-fomit-frame-pointer'])
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-fomit-frame-pointer'])
 
-    elif (env["target"]=="release_debug"):
+    elif (env["target"] == "release_debug"):
 
-        env.Append(CCFLAGS=['-O2', '-ffast-math','-DDEBUG_ENABLED'])
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED'])
 
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "debug"):
 
         env.Append(CCFLAGS=['-D_DEBUG', '-g1', '-Wall', '-O0', '-DDEBUG_ENABLED'])
         env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ALLOC'])
 
-    env.Append(CPPFLAGS=['-DANDROID_ENABLED', '-DUNIX_ENABLED', '-DNO_FCNTL','-DMPC_FIXED_POINT'])
+    env.Append(CPPFLAGS=['-DANDROID_ENABLED', '-DUNIX_ENABLED', '-DNO_FCNTL', '-DMPC_FIXED_POINT'])
 #	env.Append(CPPFLAGS=['-DANDROID_ENABLED', '-DUNIX_ENABLED','-DMPC_FIXED_POINT'])
 
     # TODO: Move that to opus module's config
     if("module_opus_enabled" in env and env["module_opus_enabled"] != "no"):
-        if (env["android_arch"]=="armv6" or env["android_arch"]=="armv7"):
+        if (env["android_arch"] == "armv6" or env["android_arch"] == "armv7"):
             env.Append(CFLAGS=["-DOPUS_ARM_OPT"])
-        env.opus_fixed_point="yes"
-
-    if (env['android_stl']=='yes'):
-        #env.Append(CCFLAGS=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/system/include"])
-        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/include"])
-        if env['android_arch']=='x86':
-            env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/x86/include"])
-            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/x86"])
-        elif env['android_arch']=='armv6':
-            env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi/include"])
-            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi"])
-        elif env["android_arch"]=="armv7":
-            env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi-v7a/include"])
-            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi-v7a"])
-
-        env.Append(LIBS=["gnustl_static","supc++"])
-        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cpufeatures"])
-
-        #env.Append(CCFLAGS=["-I"+env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/stlport/stlport"])
-        #env.Append(CCFLAGS=["-I"+env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/libs/armeabi/include"])
-        #env.Append(LINKFLAGS=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/libs/armeabi/libstdc++.a"])
+        env.opus_fixed_point = "yes"
+
+    if (env['android_stl'] == 'yes'):
+        # env.Append(CCFLAGS=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/system/include"])
+        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/include"])
+        if env['android_arch'] == 'x86':
+            env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/x86/include"])
+            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/x86"])
+        elif env['android_arch'] == 'armv6':
+            env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi/include"])
+            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi"])
+        elif env["android_arch"] == "armv7":
+            env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi-v7a/include"])
+            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi-v7a"])
+
+        env.Append(LIBS=["gnustl_static", "supc++"])
+        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cpufeatures"])
+
+        # env.Append(CCFLAGS=["-I"+env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/stlport/stlport"])
+        # env.Append(CCFLAGS=["-I"+env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/libs/armeabi/include"])
+        # env.Append(LINKFLAGS=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/libs/armeabi/libstdc++.a"])
     else:
 
-        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/include"])
-        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cpufeatures"])
-        if env['android_arch']=='x86':
-            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/x86"])
-        elif env["android_arch"]=="armv6":
-            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi"])
-        elif env["android_arch"]=="armv7":
-            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"]+"/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi-v7a"])
+        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/include"])
+        env.Append(CPPPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cpufeatures"])
+        if env['android_arch'] == 'x86':
+            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/x86"])
+        elif env["android_arch"] == "armv6":
+            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi"])
+        elif env["android_arch"] == "armv7":
+            env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/gnu-libstdc++/4.9/libs/armeabi-v7a"])
         env.Append(LIBS=['gnustl_static'])
-        env.Append(CCFLAGS=["-fno-exceptions",'-DNO_SAFE_CAST'])
+        env.Append(CCFLAGS=["-fno-exceptions", '-DNO_SAFE_CAST'])
 
 
     import methods
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})
 
     env.use_windows_spawn_fix()

platform/bb10/detect.py

@@ -53,7 +53,7 @@ def configure(env):
     env['OBJSUFFIX'] = ".qnx.${qnx_target}.o"
     env['LIBSUFFIX'] = ".qnx.${qnx_target}.a"
     env['PROGSUFFIX'] = ".qnx.${qnx_target}"
-    print("PROGSUFFIX: "+env['PROGSUFFIX']+" target: "+env['qnx_target'])
+    print("PROGSUFFIX: " + env['PROGSUFFIX'] + " target: " + env['qnx_target'])
 
     env.PrependENVPath('PATH', env['QNX_CONFIGURATION'] + '/bin')
     env.PrependENVPath('PATH', env['QNX_CONFIGURATION'] + '/usr/bin')
@@ -66,23 +66,23 @@ def configure(env):
     env['AR'] = '$qnx_prefix-ar'
     env['RANLIB'] = '$qnx_prefix-ranlib'
 
-    env.Append(CPPPATH = ['#platform/bb10'])
-    env.Append(LIBPATH = ['#platform/bb10/lib/$qnx_target', '#platform/bb10/lib/$qnx_target_ver'])
-    env.Append(CCFLAGS = string.split('-DBB10_ENABLED -DUNIX_ENABLED -DGLES2_ENABLED -DGLES1_ENABLED -D_LITTLE_ENDIAN -DNO_THREADS -DNO_FCNTL'))
-    if env['bb10_exceptions']=="yes":
-        env.Append(CCFLAGS = ['-fexceptions'])
+    env.Append(CPPPATH=['#platform/bb10'])
+    env.Append(LIBPATH=['#platform/bb10/lib/$qnx_target', '#platform/bb10/lib/$qnx_target_ver'])
+    env.Append(CCFLAGS=string.split('-DBB10_ENABLED -DUNIX_ENABLED -DGLES2_ENABLED -DGLES1_ENABLED -D_LITTLE_ENDIAN -DNO_THREADS -DNO_FCNTL'))
+    if env['bb10_exceptions'] == "yes":
+        env.Append(CCFLAGS=['-fexceptions'])
     else:
-        env.Append(CCFLAGS = ['-fno-exceptions'])
+        env.Append(CCFLAGS=['-fno-exceptions'])
 
-    #env.Append(LINKFLAGS = string.split()
+    # env.Append(LINKFLAGS = string.split()
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
 
-        env.Append(CCFLAGS=['-O3','-DRELEASE_BUILD'])
+        env.Append(CCFLAGS=['-O3', '-DRELEASE_BUILD'])
 
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "debug"):
 
-        env.Append(CCFLAGS=['-g', '-O0','-DDEBUG_ENABLED', '-D_DEBUG'])
+        env.Append(CCFLAGS=['-g', '-O0', '-DDEBUG_ENABLED', '-D_DEBUG'])
         env.Append(LINKFLAGS=['-g'])
 
     env.Append(LIBS=['bps', 'pps', 'screen', 'socket', 'EGL', 'GLESv2', 'GLESv1_CM', 'm', 'asound'])

platform/haiku/SCsub

@@ -20,7 +20,7 @@ target = env.Program(
 command = env.Command('#bin/godot.rsrc', '#platform/haiku/godot.rdef',
                       ['rc -o $TARGET $SOURCE'])
 
-def addResourcesAction(target = None, source = None, env = None):
+def addResourcesAction(target=None, source=None, env=None):
     return env.Execute('xres -o ' + File(target)[0].path + ' bin/godot.rsrc')
 
 env.AddPostAction(target, addResourcesAction)

platform/haiku/detect.py

@@ -18,7 +18,7 @@ def can_build():
 
 def get_opts():
     return [
-        ('debug_release', 'Add debug symbols to release version','no')
+        ('debug_release', 'Add debug symbols to release version', 'no')
     ]
 
 def get_flags():
@@ -28,34 +28,34 @@ def get_flags():
 def configure(env):
     is64 = sys.maxsize > 2**32
 
-    if (env["bits"]=="default"):
+    if (env["bits"] == "default"):
         if (is64):
-            env["bits"]="64"
+            env["bits"] = "64"
         else:
-            env["bits"]="32"
+            env["bits"] = "32"
 
-    env.Append(CPPPATH = ['#platform/haiku'])
+    env.Append(CPPPATH=['#platform/haiku'])
 
     env["CC"] = "gcc-x86"
     env["CXX"] = "g++-x86"
 
-    if (env["target"]=="release"):
-        if (env["debug_release"]=="yes"):
+    if (env["target"] == "release"):
+        if (env["debug_release"] == "yes"):
             env.Append(CCFLAGS=['-g2'])
         else:
-            env.Append(CCFLAGS=['-O3','-ffast-math'])
-    elif (env["target"]=="release_debug"):
-        env.Append(CCFLAGS=['-O2','-ffast-math','-DDEBUG_ENABLED'])
-    elif (env["target"]=="debug"):
-        env.Append(CCFLAGS=['-g2', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
-
-    #env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
-    env.Append(CPPFLAGS = ['-DPTHREAD_NO_RENAME']) # TODO: enable when we have pthread_setname_np
-    env.Append(CPPFLAGS = ['-DOPENGL_ENABLED', '-DMEDIA_KIT_ENABLED'])
-    env.Append(CPPFLAGS = ['-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DGLES_OVER_GL'])
-    env.Append(LIBS = ['be', 'game', 'media', 'network', 'bnetapi', 'z', 'GL'])
+            env.Append(CCFLAGS=['-O3', '-ffast-math'])
+    elif (env["target"] == "release_debug"):
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED'])
+    elif (env["target"] == "debug"):
+        env.Append(CCFLAGS=['-g2', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED'])
+
+    # env.Append(CCFLAGS=['-DFREETYPE_ENABLED'])
+    env.Append(CPPFLAGS=['-DPTHREAD_NO_RENAME'])  # TODO: enable when we have pthread_setname_np
+    env.Append(CPPFLAGS=['-DOPENGL_ENABLED', '-DMEDIA_KIT_ENABLED'])
+    env.Append(CPPFLAGS=['-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DGLES_OVER_GL'])
+    env.Append(LIBS=['be', 'game', 'media', 'network', 'bnetapi', 'z', 'GL'])
 
     import methods
-    env.Append(BUILDERS = {'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl')})
-    env.Append(BUILDERS = {'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl')})
-    env.Append(BUILDERS = {'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl')})
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})

platform/iphone/SCsub

@@ -19,7 +19,7 @@ iphone_lib = [
     'ios.mm',
 ]
 
-#env.Depends('#core/math/vector3.h', 'vector3_psp.h')
+# env.Depends('#core/math/vector3.h', 'vector3_psp.h')
 
 #iphone_lib = env.Library('iphone', iphone_lib)
 
@@ -30,7 +30,7 @@ if env['ios_gles22_override'] == "yes":
     env_ios.Append(CPPFLAGS=['-DGLES2_OVERRIDE'])
 
 
-#if env['ios_appirater'] == "yes":
+# if env['ios_appirater'] == "yes":
 #	env_ios.Append(CPPFLAGS=['-DAPPIRATER_ENABLED'])
 
 
@@ -38,5 +38,5 @@ obj = env_ios.Object('godot_iphone.cpp')
 
 prog = None
 prog = env_ios.Program('#bin/godot', [obj] + iphone_lib)
-action = "$IPHONEPATH/usr/bin/dsymutil "+File(prog)[0].path+" -o " + File(prog)[0].path + ".dSYM"
+action = "$IPHONEPATH/usr/bin/dsymutil " + File(prog)[0].path + " -o " + File(prog)[0].path + ".dSYM"
 env.AddPostAction(prog, action)

platform/iphone/detect.py

@@ -39,7 +39,7 @@ def get_flags():
         ('tools', 'no'),
         ('webp', 'yes'),
         ('builtin_zlib', 'yes'),
-        ('openssl','builtin'), #use builtin openssl
+        ('openssl', 'builtin'),  # use builtin openssl
     ]
 
 
@@ -48,7 +48,7 @@ def configure(env):
 
     env.Append(CPPPATH=['#platform/iphone'])
 
-    env['ENV']['PATH'] = env['IPHONEPATH']+"/Developer/usr/bin/:"+env['ENV']['PATH']
+    env['ENV']['PATH'] = env['IPHONEPATH'] + "/Developer/usr/bin/:" + env['ENV']['PATH']
 
     env['CC'] = '$IPHONEPATH/usr/bin/${ios_triple}clang'
     env['CXX'] = '$IPHONEPATH/usr/bin/${ios_triple}clang++'
@@ -56,21 +56,21 @@ def configure(env):
     env['RANLIB'] = '$IPHONEPATH/usr/bin/${ios_triple}ranlib'
 
     import string
-    if (env["ios_sim"]=="yes" or env["arch"] == "x86"): # i386, simulator
-        env["arch"]="x86"
-        env["bits"]="32"
+    if (env["ios_sim"] == "yes" or env["arch"] == "x86"):  # i386, simulator
+        env["arch"] = "x86"
+        env["bits"] = "32"
         env['CCFLAGS'] = string.split('-arch i386 -fobjc-abi-version=2 -fobjc-legacy-dispatch -fmessage-length=0 -fpascal-strings -fasm-blocks  -Wall -D__IPHONE_OS_VERSION_MIN_REQUIRED=40100 -isysroot $IPHONESDK -mios-simulator-version-min=4.3 -DCUSTOM_MATRIX_TRANSFORM_H=\\\"build/iphone/matrix4_iphone.h\\\" -DCUSTOM_VECTOR3_TRANSFORM_H=\\\"build/iphone/vector3_iphone.h\\\"')
-    elif (env["arch"]=="arm64"): # arm64
+    elif (env["arch"] == "arm64"):  # arm64
         env["bits"] = "64"
         env['CCFLAGS'] = string.split('-fno-objc-arc -arch arm64 -fmessage-length=0 -fno-strict-aliasing -fdiagnostics-print-source-range-info -fdiagnostics-show-category=id -fdiagnostics-parseable-fixits -Wno-trigraphs -fpascal-strings -Wmissing-prototypes -Wreturn-type -Wparentheses -Wswitch -Wno-unused-parameter -Wunused-variable -Wunused-value -Wno-shorten-64-to-32 -fvisibility=hidden -Wno-sign-conversion -MMD -MT dependencies -miphoneos-version-min=5.1.1 -isysroot $IPHONESDK')
         env.Append(CPPFLAGS=['-DNEED_LONG_INT'])
         env.Append(CPPFLAGS=['-DLIBYUV_DISABLE_NEON'])
-    else: # armv7
+    else:  # armv7
         env["arch"] = "arm"
         env["bits"] = "32"
         env['CCFLAGS'] = string.split('-fno-objc-arc -arch armv7 -fmessage-length=0 -fno-strict-aliasing -fdiagnostics-print-source-range-info -fdiagnostics-show-category=id -fdiagnostics-parseable-fixits -Wno-trigraphs -fpascal-strings -Wmissing-prototypes -Wreturn-type -Wparentheses -Wswitch -Wno-unused-parameter -Wunused-variable -Wunused-value -Wno-shorten-64-to-32 -isysroot /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS5.0.sdk -fvisibility=hidden -Wno-sign-conversion -mthumb "-DIBOutlet=__attribute__((iboutlet))" "-DIBOutletCollection(ClassName)=__attribute__((iboutletcollection(ClassName)))" "-DIBAction=void)__attribute__((ibaction)" -miphoneos-version-min=5.1.1 -MMD -MT dependencies -isysroot $IPHONESDK')
 
-    if (env["arch"]=="x86"):
+    if (env["arch"] == "x86"):
         env['IPHONEPLATFORM'] = 'iPhoneSimulator'
         env.Append(LINKFLAGS=['-arch', 'i386', '-mios-simulator-version-min=4.3',
                               '-isysroot', '$IPHONESDK',
@@ -92,7 +92,7 @@ def configure(env):
                               '-framework', 'SystemConfiguration',
                               '-F$IPHONESDK',
                               ])
-    elif (env["arch"]=="arm64"):
+    elif (env["arch"] == "arm64"):
         env.Append(LINKFLAGS=['-arch', 'arm64', '-Wl,-dead_strip', '-miphoneos-version-min=5.1.1',
                                                 '-isysroot', '$IPHONESDK',
                                                 #'-stdlib=libc++',
@@ -139,39 +139,39 @@ def configure(env):
     if env['icloud'] == 'yes':
         env.Append(CPPFLAGS=['-DICLOUD_ENABLED'])
 
-    env.Append(CPPPATH = ['$IPHONESDK/usr/include', '$IPHONESDK/System/Library/Frameworks/OpenGLES.framework/Headers', '$IPHONESDK/System/Library/Frameworks/AudioUnit.framework/Headers'])
+    env.Append(CPPPATH=['$IPHONESDK/usr/include', '$IPHONESDK/System/Library/Frameworks/OpenGLES.framework/Headers', '$IPHONESDK/System/Library/Frameworks/AudioUnit.framework/Headers'])
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
 
-        env.Append(CCFLAGS=['-O3', '-DNS_BLOCK_ASSERTIONS=1','-Wall', '-gdwarf-2']) # removed -ffast-math
-        env.Append(LINKFLAGS=['-O3']) #
+        env.Append(CCFLAGS=['-O3', '-DNS_BLOCK_ASSERTIONS=1', '-Wall', '-gdwarf-2'])  # removed -ffast-math
+        env.Append(LINKFLAGS=['-O3'])
 
     elif env["target"] == "release_debug":
-        env.Append(CCFLAGS=['-Os', '-DNS_BLOCK_ASSERTIONS=1','-Wall','-DDEBUG_ENABLED'])
+        env.Append(CCFLAGS=['-Os', '-DNS_BLOCK_ASSERTIONS=1', '-Wall', '-DDEBUG_ENABLED'])
         env.Append(LINKFLAGS=['-Os'])
         env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ENABLED'])
 
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "debug"):
 
         env.Append(CCFLAGS=['-D_DEBUG', '-DDEBUG=1', '-gdwarf-2', '-Wall', '-O0', '-DDEBUG_ENABLED'])
         env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ENABLED'])
 
-    elif (env["target"]=="profile"):
+    elif (env["target"] == "profile"):
 
-        env.Append(CCFLAGS=['-g','-pg', '-Os'])
+        env.Append(CCFLAGS=['-g', '-pg', '-Os'])
         env.Append(LINKFLAGS=['-pg'])
 
-    if (env["ios_sim"]=="yes"): #TODO: Check if needed?
+    if (env["ios_sim"] == "yes"):  # TODO: Check if needed?
         env['ENV']['MACOSX_DEPLOYMENT_TARGET'] = '10.6'
     env['ENV']['CODESIGN_ALLOCATE'] = '/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/codesign_allocate'
     env.Append(CPPFLAGS=['-DIPHONE_ENABLED', '-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DMPC_FIXED_POINT'])
 
     # TODO: Move that to opus module's config
     if("module_opus_enabled" in env and env["module_opus_enabled"] != "no"):
-        env.opus_fixed_point="yes"
-        if env["arch"]=="x86":
+        env.opus_fixed_point = "yes"
+        if env["arch"] == "x86":
             pass
-        elif(env["arch"]=="arm64"):
+        elif(env["arch"] == "arm64"):
             env.Append(CFLAGS=["-DOPUS_ARM64_OPT"])
         else:
             env.Append(CFLAGS=["-DOPUS_ARM_OPT"])
@@ -180,10 +180,10 @@ def configure(env):
         env.Append(CPPFLAGS=['-fexceptions'])
     else:
         env.Append(CPPFLAGS=['-fno-exceptions'])
-    #env['neon_enabled']=True
+    # env['neon_enabled']=True
     env['S_compiler'] = '$IPHONEPATH/Developer/usr/bin/gcc'
 
     import methods
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})

platform/javascript/SCsub

@@ -15,14 +15,14 @@ env_javascript = env.Clone()
 if env['target'] == "profile":
     env_javascript.Append(CPPFLAGS=['-DPROFILER_ENABLED'])
 
-javascript_objects=[]
+javascript_objects = []
 for x in javascript_files:
-    javascript_objects.append( env_javascript.Object( x ) )
+    javascript_objects.append(env_javascript.Object(x))
 
-env.Append(LINKFLAGS=["-s","EXPORTED_FUNCTIONS=\"['_main','_audio_server_mix_function','_main_after_fs_sync']\""])
+env.Append(LINKFLAGS=["-s", "EXPORTED_FUNCTIONS=\"['_main','_audio_server_mix_function','_main_after_fs_sync']\""])
 
 prog = None
 
-#env_javascript.SharedLibrary("#platform/javascript/libgodot_javascript.so",[javascript_objects])
+# env_javascript.SharedLibrary("#platform/javascript/libgodot_javascript.so",[javascript_objects])
 
-env.Program('#bin/godot',javascript_objects,PROGSUFFIX=env["PROGSUFFIX"]+".html")
+env.Program('#bin/godot', javascript_objects, PROGSUFFIX=env["PROGSUFFIX"] + ".html")

platform/javascript/detect.py

@@ -18,7 +18,7 @@ def can_build():
 def get_opts():
 
     return [
-        ['compress','Compress JS Executable','no']
+        ['compress', 'Compress JS Executable', 'no']
     ]
 
 def get_flags():
@@ -40,14 +40,14 @@ def configure(env):
 
     env.Append(CPPPATH=['#platform/javascript'])
 
-    em_path=os.environ["EMSCRIPTEN_ROOT"]
+    em_path = os.environ["EMSCRIPTEN_ROOT"]
 
-    env['ENV']['PATH'] = em_path+":"+env['ENV']['PATH']
+    env['ENV']['PATH'] = em_path + ":" + env['ENV']['PATH']
 
-    env['CC'] = em_path+'/emcc'
-    env['CXX'] = em_path+'/emcc'
+    env['CC'] = em_path + '/emcc'
+    env['CXX'] = em_path + '/emcc'
     #env['AR'] = em_path+"/emar"
-    env['AR'] = em_path+"/emcc"
+    env['AR'] = em_path + "/emcc"
     env['ARFLAGS'] = "-o"
 
 #	env['RANLIB'] = em_path+"/emranlib"
@@ -61,11 +61,11 @@ def configure(env):
 
 #	env["LINKFLAGS"]= string.split(" -g --sysroot="+ld_sysroot+" -Wl,--no-undefined -Wl,-z,noexecstack ")
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
         env.Append(CCFLAGS=['-O2'])
-    elif (env["target"]=="release_debug"):
-        env.Append(CCFLAGS=['-O2','-DDEBUG_ENABLED'])
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "release_debug"):
+        env.Append(CCFLAGS=['-O2', '-DDEBUG_ENABLED'])
+    elif (env["target"] == "debug"):
         env.Append(CCFLAGS=['-D_DEBUG', '-Wall', '-O2', '-DDEBUG_ENABLED'])
         #env.Append(CCFLAGS=['-D_DEBUG', '-Wall', '-g4', '-DDEBUG_ENABLED'])
         env.Append(CPPFLAGS=['-DDEBUG_MEMORY_ALLOC'])
@@ -74,29 +74,29 @@ def configure(env):
     if("module_opus_enabled" in env and env["module_opus_enabled"] != "no"):
         env.opus_fixed_point = "yes"
 
-    env.Append(CPPFLAGS=["-fno-exceptions",'-DNO_SAFE_CAST','-fno-rtti'])
-    env.Append(CPPFLAGS=['-DJAVASCRIPT_ENABLED', '-DUNIX_ENABLED', '-DPTHREAD_NO_RENAME', '-DNO_FCNTL','-DMPC_FIXED_POINT','-DTYPED_METHOD_BIND','-DNO_THREADS'])
+    env.Append(CPPFLAGS=["-fno-exceptions", '-DNO_SAFE_CAST', '-fno-rtti'])
+    env.Append(CPPFLAGS=['-DJAVASCRIPT_ENABLED', '-DUNIX_ENABLED', '-DPTHREAD_NO_RENAME', '-DNO_FCNTL', '-DMPC_FIXED_POINT', '-DTYPED_METHOD_BIND', '-DNO_THREADS'])
     env.Append(CPPFLAGS=['-DGLES2_ENABLED'])
     env.Append(CPPFLAGS=['-DGLES_NO_CLIENT_ARRAYS'])
-    env.Append(CPPFLAGS=['-s','ASM_JS=1'])
-    env.Append(CPPFLAGS=['-s','FULL_ES2=1'])
+    env.Append(CPPFLAGS=['-s', 'ASM_JS=1'])
+    env.Append(CPPFLAGS=['-s', 'FULL_ES2=1'])
 #	env.Append(CPPFLAGS=['-DANDROID_ENABLED', '-DUNIX_ENABLED','-DMPC_FIXED_POINT'])
-    if (env["compress"]=="yes"):
-        lzma_binpath = em_path+"/third_party/lzma.js/lzma-native"
-        lzma_decoder = em_path+"/third_party/lzma.js/lzma-decoder.js"
+    if (env["compress"] == "yes"):
+        lzma_binpath = em_path + "/third_party/lzma.js/lzma-native"
+        lzma_decoder = em_path + "/third_party/lzma.js/lzma-decoder.js"
         lzma_dec = "LZMA.decompress"
-        env.Append(LINKFLAGS=['--compression',lzma_binpath+","+lzma_decoder+","+lzma_dec])
+        env.Append(LINKFLAGS=['--compression', lzma_binpath + "," + lzma_decoder + "," + lzma_dec])
 
-    env.Append(LINKFLAGS=['-s','ASM_JS=1'])
+    env.Append(LINKFLAGS=['-s', 'ASM_JS=1'])
     env.Append(LINKFLAGS=['-O2'])
-    #env.Append(LINKFLAGS=['-g4'])
+    # env.Append(LINKFLAGS=['-g4'])
 
-    #print "CCCOM is:", env.subst('$CCCOM')
-    #print "P: ", env['p'], " Platofrm: ", env['platform']
+    # print "CCCOM is:", env.subst('$CCCOM')
+    # print "P: ", env['p'], " Platofrm: ", env['platform']
 
     import methods
 
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})
     #env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } )

platform/osx/SCsub

@@ -12,4 +12,4 @@ files = [
     'joystick_osx.cpp',
 ]
 
-env.Program('#bin/godot',files)
+env.Program('#bin/godot', files)

platform/osx/detect.py

@@ -20,8 +20,8 @@ def can_build():
 def get_opts():
 
     return [
-        ('force_64_bits','Force 64 bits binary','no'),
-        ('osxcross_sdk','OSXCross SDK version','darwin14'),
+        ('force_64_bits', 'Force 64 bits binary', 'no'),
+        ('osxcross_sdk', 'OSXCross SDK version', 'darwin14'),
 
     ]
 
@@ -36,67 +36,67 @@ def configure(env):
 
     env.Append(CPPPATH=['#platform/osx'])
 
-    if (env["bits"]=="default"):
-        env["bits"]="32"
+    if (env["bits"] == "default"):
+        env["bits"] = "32"
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
 
-        env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer','-ftree-vectorize','-msse2'])
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-fomit-frame-pointer', '-ftree-vectorize', '-msse2'])
 
-    elif (env["target"]=="release_debug"):
+    elif (env["target"] == "release_debug"):
 
-        env.Append(CCFLAGS=['-O2','-DDEBUG_ENABLED'])
+        env.Append(CCFLAGS=['-O2', '-DDEBUG_ENABLED'])
 
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "debug"):
 
-        env.Append(CCFLAGS=['-g3', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
+        env.Append(CCFLAGS=['-g3', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED'])
 
 
 
     if (not os.environ.has_key("OSXCROSS_ROOT")):
-        #regular native build
-        if (env["bits"]=="64"):
+        # regular native build
+        if (env["bits"] == "64"):
             env.Append(CCFLAGS=['-arch', 'x86_64'])
             env.Append(LINKFLAGS=['-arch', 'x86_64'])
-        elif (env["bits"]=="32"):
+        elif (env["bits"] == "32"):
             env.Append(CCFLAGS=['-arch', 'i386'])
             env.Append(LINKFLAGS=['-arch', 'i386'])
         else:
             env.Append(CCFLAGS=['-arch', 'i386', '-arch', 'x86_64'])
             env.Append(LINKFLAGS=['-arch', 'i386', '-arch', 'x86_64'])
     else:
-        #osxcross build
-        root=os.environ.get("OSXCROSS_ROOT",0)
-        if env["bits"]=="64":
-            basecmd=root+"/target/bin/x86_64-apple-"+env["osxcross_sdk"]+"-"
+        # osxcross build
+        root = os.environ.get("OSXCROSS_ROOT", 0)
+        if env["bits"] == "64":
+            basecmd = root + "/target/bin/x86_64-apple-" + env["osxcross_sdk"] + "-"
         else:
-            basecmd=root+"/target/bin/i386-apple-"+env["osxcross_sdk"]+"-"
+            basecmd = root + "/target/bin/i386-apple-" + env["osxcross_sdk"] + "-"
 
 
-        env['CC'] = basecmd+"cc"
-        env['CXX'] = basecmd+"c++"
-        env['AR'] = basecmd+"ar"
-        env['RANLIB'] = basecmd+"ranlib"
-        env['AS'] = basecmd+"as"
+        env['CC'] = basecmd + "cc"
+        env['CXX'] = basecmd + "c++"
+        env['AR'] = basecmd + "ar"
+        env['RANLIB'] = basecmd + "ranlib"
+        env['AS'] = basecmd + "as"
 
 
     env.Append(CPPFLAGS=["-DAPPLE_STYLE_KEYS"])
-    env.Append(CPPFLAGS=['-DUNIX_ENABLED','-DGLES2_ENABLED','-DOSX_ENABLED'])
+    env.Append(CPPFLAGS=['-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DOSX_ENABLED'])
     env.Append(LIBS=['pthread'])
     #env.Append(CPPFLAGS=['-F/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks', '-isysroot', '/Developer/SDKs/MacOSX10.4u.sdk', '-mmacosx-version-min=10.4'])
     #env.Append(LINKFLAGS=['-mmacosx-version-min=10.4', '-isysroot', '/Developer/SDKs/MacOSX10.4u.sdk', '-Wl,-syslibroot,/Developer/SDKs/MacOSX10.4u.sdk'])
-    env.Append(LINKFLAGS=['-framework', 'Cocoa', '-framework', 'Carbon', '-framework', 'OpenGL', '-framework', 'AGL', '-framework', 'AudioUnit','-lz', '-framework', 'IOKit', '-framework', 'ForceFeedback'])
+    env.Append(LINKFLAGS=['-framework', 'Cocoa', '-framework', 'Carbon', '-framework', 'OpenGL', '-framework', 'AGL', '-framework', 'AudioUnit', '-lz', '-framework', 'IOKit', '-framework', 'ForceFeedback'])
 
-    if (env["CXX"]=="clang++"):
+    if (env["CXX"] == "clang++"):
         env.Append(CPPFLAGS=['-DTYPED_METHOD_BIND'])
-        env["CC"]="clang"
-        env["LD"]="clang++"
+        env["CC"] = "clang"
+        env["LD"] = "clang++"
 
     import methods
 
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})
     #env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } )
 
-    env["x86_libtheora_opt_gcc"]=True
+    env["x86_libtheora_opt_gcc"] = True

platform/server/SCsub

@@ -3,8 +3,8 @@
 Import('env')
 
 
-common_server=[\
+common_server = [\
     "os_server.cpp",\
 ]
 
-env.Program('#bin/godot_server',['godot_server.cpp']+common_server)
+env.Program('#bin/godot_server', ['godot_server.cpp'] + common_server)

platform/server/detect.py

@@ -12,16 +12,16 @@ def get_name():
 
 def can_build():
 
-    if (os.name!="posix"):
+    if (os.name != "posix"):
         return False
 
-    return True # enabled
+    return True  # enabled
 
 def get_opts():
 
     return [
-        ('use_llvm','Use llvm compiler','no'),
-        ('force_32_bits','Force 32 bits binary','no')
+        ('use_llvm', 'Use llvm compiler', 'no'),
+        ('force_32_bits', 'Force 32 bits binary', 'no')
     ]
 
 def get_flags():
@@ -34,43 +34,43 @@ def get_flags():
 def configure(env):
 
     env.Append(CPPPATH=['#platform/server'])
-    if (env["use_llvm"]=="yes"):
-        env["CC"]="clang"
-        env["CXX"]="clang++"
-        env["LD"]="clang++"
+    if (env["use_llvm"] == "yes"):
+        env["CC"] = "clang"
+        env["CXX"] = "clang++"
+        env["LD"] = "clang++"
 
-    is64=sys.maxsize > 2**32
+    is64 = sys.maxsize > 2**32
 
-    if (env["bits"]=="default"):
+    if (env["bits"] == "default"):
         if (is64):
-            env["bits"]="64"
+            env["bits"] = "64"
         else:
-            env["bits"]="32"
+            env["bits"] = "32"
 
 
-    #if (env["tools"]=="no"):
+    # if (env["tools"]=="no"):
     #	#no tools suffix
     #	env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
     #	env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
 
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
 
-        env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer'])
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-fomit-frame-pointer'])
 
-    elif (env["target"]=="release_debug"):
+    elif (env["target"] == "release_debug"):
 
-        env.Append(CCFLAGS=['-O2','-ffast-math','-DDEBUG_ENABLED'])
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED'])
 
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "debug"):
 
-        env.Append(CCFLAGS=['-g2', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
+        env.Append(CCFLAGS=['-g2', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED'])
 
-    env.Append(CPPFLAGS=['-DSERVER_ENABLED','-DUNIX_ENABLED'])
-    env.Append(LIBS=['pthread','z']) #TODO detect linux/BSD!
+    env.Append(CPPFLAGS=['-DSERVER_ENABLED', '-DUNIX_ENABLED'])
+    env.Append(LIBS=['pthread', 'z'])  # TODO detect linux/BSD!
 
-    if (env["CXX"]=="clang++"):
+    if (env["CXX"] == "clang++"):
         env.Append(CPPFLAGS=['-DTYPED_METHOD_BIND'])
-        env["CC"]="clang"
-        env["LD"]="clang++"
+        env["CC"] = "clang"
+        env["LD"] = "clang++"
 

platform/windows/SCsub

@@ -3,7 +3,7 @@
 Import('env')
 
 
-common_win=[
+common_win = [
     "context_gl_win.cpp",
     "os_windows.cpp",
     "ctxgl_procaddr.cpp",
@@ -14,16 +14,16 @@ common_win=[
     "joystick.cpp",
 ]
 
-restarget="godot_res"+env["OBJSUFFIX"]
+restarget = "godot_res" + env["OBJSUFFIX"]
 
-obj = env.RES(restarget,'godot_res.rc')
+obj = env.RES(restarget, 'godot_res.rc')
 
 common_win.append(obj)
 
-env.Program('#bin/godot',['godot_win.cpp']+common_win,PROGSUFFIX=env["PROGSUFFIX"])
+env.Program('#bin/godot', ['godot_win.cpp'] + common_win, PROGSUFFIX=env["PROGSUFFIX"])
 
 # Microsoft Visual Studio Project Generation
-if (env['vsproj'])=="yes":
+if (env['vsproj']) == "yes":
     env.vs_srcs = env.vs_srcs + ["platform/windows/godot_win.cpp"]
     for x in common_win:
         env.vs_srcs = env.vs_srcs + ["platform/windows/" + str(x)]

platform/windows/detect.py

@@ -99,21 +99,21 @@ def get_name():
 
 def can_build():
 
-    if (os.name=="nt"):
-        #building natively on windows!
+    if (os.name == "nt"):
+        # building natively on windows!
         if (os.getenv("VSINSTALLDIR")):
             return True
         else:
             print("\nMSVC not detected, attempting Mingw.")
             mingw32 = ""
             mingw64 = ""
-            if ( os.getenv("MINGW32_PREFIX") ) :
+            if (os.getenv("MINGW32_PREFIX")):
                 mingw32 = os.getenv("MINGW32_PREFIX")
-            if ( os.getenv("MINGW64_PREFIX") ) :
+            if (os.getenv("MINGW64_PREFIX")):
                 mingw64 = os.getenv("MINGW64_PREFIX")
 
             test = "gcc --version > NUL 2>&1"
-            if os.system(test)!= 0 and os.system(mingw32+test)!=0 and os.system(mingw64+test)!=0 :
+            if os.system(test) != 0 and os.system(mingw32 + test) != 0 and os.system(mingw64 + test) != 0:
                 print("- could not detect gcc.")
                 print("Please, make sure a path to a Mingw /bin directory is accessible into the environment PATH.\n")
                 return False
@@ -122,57 +122,57 @@ def can_build():
 
             return True
 
-    if (os.name=="posix"):
+    if (os.name == "posix"):
 
         mingw = "i586-mingw32msvc-"
         mingw64 = "x86_64-w64-mingw32-"
         mingw32 = "i686-w64-mingw32-"
 
         if (os.getenv("MINGW32_PREFIX")):
-            mingw32=os.getenv("MINGW32_PREFIX")
+            mingw32 = os.getenv("MINGW32_PREFIX")
             mingw = mingw32
         if (os.getenv("MINGW64_PREFIX")):
-            mingw64=os.getenv("MINGW64_PREFIX")
+            mingw64 = os.getenv("MINGW64_PREFIX")
 
         test = "gcc --version &>/dev/null"
-        if (os.system(mingw+test) == 0 or os.system(mingw64+test) == 0 or os.system(mingw32+test) == 0):
+        if (os.system(mingw + test) == 0 or os.system(mingw64 + test) == 0 or os.system(mingw32 + test) == 0):
             return True
 
     return False
 
 def get_opts():
 
-    mingw=""
-    mingw32=""
-    mingw64=""
-    if ( os.name == "posix" ):
+    mingw = ""
+    mingw32 = ""
+    mingw64 = ""
+    if (os.name == "posix"):
         mingw = "i586-mingw32msvc-"
         mingw32 = "i686-w64-mingw32-"
         mingw64 = "x86_64-w64-mingw32-"
 
-        if os.system(mingw32+"gcc --version &>/dev/null") != 0 :
+        if os.system(mingw32 + "gcc --version &>/dev/null") != 0:
             mingw32 = mingw
 
     if (os.getenv("MINGW32_PREFIX")):
-        mingw32=os.getenv("MINGW32_PREFIX")
+        mingw32 = os.getenv("MINGW32_PREFIX")
         mingw = mingw32
     if (os.getenv("MINGW64_PREFIX")):
-        mingw64=os.getenv("MINGW64_PREFIX")
+        mingw64 = os.getenv("MINGW64_PREFIX")
 
 
     return [
-        ('mingw_prefix','Mingw Prefix',mingw32),
-        ('mingw_prefix_64','Mingw Prefix 64 bits',mingw64),
+        ('mingw_prefix', 'Mingw Prefix', mingw32),
+        ('mingw_prefix_64', 'Mingw Prefix 64 bits', mingw64),
     ]
 
 def get_flags():
 
     return [
         ('builtin_zlib', 'yes'),
-        ('openssl','builtin'), #use builtin openssl
+        ('openssl', 'builtin'),  # use builtin openssl
     ]
 
-def build_res_file( target, source, env ):
+def build_res_file(target, source, env):
 
     cmdbase = ""
     if (env["bits"] == "32"):
@@ -185,7 +185,7 @@ def build_res_file( target, source, env ):
     for x in range(len(source)):
         cmd = cmdbase + '-i ' + str(source[x]) + ' -o ' + str(target[x])
         try:
-            out = subprocess.Popen(cmd,shell = True,stderr = subprocess.PIPE).communicate()
+            out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate()
             if len(out[1]):
                 return 1
         except:
@@ -195,42 +195,42 @@ def build_res_file( target, source, env ):
 def configure(env):
 
     env.Append(CPPPATH=['#platform/windows'])
-    env['is_mingw']=False
-    if (os.name=="nt" and os.getenv("VSINSTALLDIR")!=None):
-        #build using visual studio
+    env['is_mingw'] = False
+    if (os.name == "nt" and os.getenv("VSINSTALLDIR") != None):
+        # build using visual studio
         env['ENV']['TMP'] = os.environ['TMP']
         env.Append(CPPPATH=['#platform/windows/include'])
         env.Append(LIBPATH=['#platform/windows/lib'])
 
 
-        if (env["target"]=="release"):
+        if (env["target"] == "release"):
 
             env.Append(CCFLAGS=['/O2'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
             env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup'])
 
-        elif (env["target"]=="release_debug"):
+        elif (env["target"] == "release_debug"):
 
-            env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED'])
+            env.Append(CCFLAGS=['/O2', '/DDEBUG_ENABLED'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
-        elif (env["target"]=="debug_release"):
+        elif (env["target"] == "debug_release"):
 
-            env.Append(CCFLAGS=['/Z7','/Od'])
+            env.Append(CCFLAGS=['/Z7', '/Od'])
             env.Append(LINKFLAGS=['/DEBUG'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
             env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup'])
 
-        elif (env["target"]=="debug"):
+        elif (env["target"] == "debug"):
 
-            env.Append(CCFLAGS=['/Z7','/DDEBUG_ENABLED','/DDEBUG_MEMORY_ENABLED','/DD3D_DEBUG_INFO','/Od'])
+            env.Append(CCFLAGS=['/Z7', '/DDEBUG_ENABLED', '/DDEBUG_MEMORY_ENABLED', '/DD3D_DEBUG_INFO', '/Od'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
             env.Append(LINKFLAGS=['/DEBUG'])
 
 
-        env.Append(CCFLAGS=['/MT','/Gd','/GR','/nologo'])
+        env.Append(CCFLAGS=['/MT', '/Gd', '/GR', '/nologo'])
         env.Append(CXXFLAGS=['/TP'])
         env.Append(CPPFLAGS=['/DMSVC', '/GR', ])
-        env.Append(CCFLAGS=['/I'+os.getenv("WindowsSdkDir")+"/Include"])
+        env.Append(CCFLAGS=['/I' + os.getenv("WindowsSdkDir") + "/Include"])
         env.Append(CCFLAGS=['/DWINDOWS_ENABLED'])
         env.Append(CCFLAGS=['/DRTAUDIO_ENABLED'])
         env.Append(CCFLAGS=['/DWIN32'])
@@ -238,24 +238,24 @@ def configure(env):
 
         env.Append(CCFLAGS=['/DGLES2_ENABLED'])
 
-        LIBS=['winmm','opengl32','dsound','kernel32','ole32','oleaut32','user32','gdi32', 'IPHLPAPI','Shlwapi', 'wsock32', 'shell32','advapi32','dinput8','dxguid']
-        env.Append(LINKFLAGS=[p+env["LIBSUFFIX"] for p in LIBS])
+        LIBS = ['winmm', 'opengl32', 'dsound', 'kernel32', 'ole32', 'oleaut32', 'user32', 'gdi32', 'IPHLPAPI', 'Shlwapi', 'wsock32', 'shell32', 'advapi32', 'dinput8', 'dxguid']
+        env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in LIBS])
 
-        env.Append(LIBPATH=[os.getenv("WindowsSdkDir")+"/Lib"])
+        env.Append(LIBPATH=[os.getenv("WindowsSdkDir") + "/Lib"])
         if (os.getenv("DXSDK_DIR")):
-            DIRECTX_PATH=os.getenv("DXSDK_DIR")
+            DIRECTX_PATH = os.getenv("DXSDK_DIR")
         else:
-            DIRECTX_PATH="C:/Program Files/Microsoft DirectX SDK (March 2009)"
+            DIRECTX_PATH = "C:/Program Files/Microsoft DirectX SDK (March 2009)"
 
         if (os.getenv("VCINSTALLDIR")):
-            VC_PATH=os.getenv("VCINSTALLDIR")
+            VC_PATH = os.getenv("VCINSTALLDIR")
         else:
-            VC_PATH=""
+            VC_PATH = ""
 
         env.Append(CCFLAGS=["/I" + p for p in os.getenv("INCLUDE").split(";")])
         env.Append(LIBPATH=[p for p in os.getenv("LIB").split(";")])
-        env.Append(CCFLAGS=["/I"+DIRECTX_PATH+"/Include"])
-        env.Append(LIBPATH=[DIRECTX_PATH+"/Lib/x86"])
+        env.Append(CCFLAGS=["/I" + DIRECTX_PATH + "/Include"])
+        env.Append(LIBPATH=[DIRECTX_PATH + "/Lib/x86"])
         env['ENV'] = os.environ;
 
         # This detection function needs the tools env (that is env['ENV'], not SCons's env), and that is why it's this far bellow in the code
@@ -265,26 +265,26 @@ def configure(env):
         if(env["bits"] != "default"):
             print "Error: bits argument is disabled for MSVC"
             print ("Bits argument is not supported for MSVC compilation. Architecture depends on the Native/Cross Compile Tools Prompt/Developer Console (or Visual Studio settings)"
-                   +" that is being used to run SCons. As a consequence, bits argument is disabled. Run scons again without bits argument (example: scons p=windows) and SCons will attempt to detect what MSVC compiler"
-                   +" will be executed and inform you.")
+                   + " that is being used to run SCons. As a consequence, bits argument is disabled. Run scons again without bits argument (example: scons p=windows) and SCons will attempt to detect what MSVC compiler"
+                   + " will be executed and inform you.")
             sys.exit()
 
         # Forcing bits argument because MSVC does not have a flag to set this through SCons... it's different compilers (cl.exe's) called from the propper command prompt
         # that decide the architecture that is build for. Scons can only detect the os.getenviron (because vsvarsall.bat sets a lot of stuff for cl.exe to work with)
-        env["bits"]="32"
-        env["x86_libtheora_opt_vc"]=True
+        env["bits"] = "32"
+        env["x86_libtheora_opt_vc"] = True
 
-        print "Detected MSVC compiler: "+compiler_version_str
+        print "Detected MSVC compiler: " + compiler_version_str
         # If building for 64bit architecture, disable assembly optimisations for 32 bit builds (theora as of writting)... vc compiler for 64bit can not compile _asm
         if(compiler_version_str == "amd64" or compiler_version_str == "x86_amd64"):
-            env["bits"]="64"
-            env["x86_libtheora_opt_vc"]=False
+            env["bits"] = "64"
+            env["x86_libtheora_opt_vc"] = False
             print "Compiled program architecture will be a 64 bit executable (forcing bits=64)."
-        elif (compiler_version_str=="x86" or compiler_version_str == "amd64_x86"):
+        elif (compiler_version_str == "x86" or compiler_version_str == "amd64_x86"):
             print "Compiled program architecture will be a 32 bit executable. (forcing bits=32)."
         else:
-            print "Failed to detect MSVC compiler architecture version... Defaulting to 32bit executable settings (forcing bits=32). Compilation attempt will continue, but SCons can not detect for what architecture this build is compiled for. You should check your settings/compilation setup."                        
-        if env["bits"]=="64":
+            print "Failed to detect MSVC compiler architecture version... Defaulting to 32bit executable settings (forcing bits=32). Compilation attempt will continue, but SCons can not detect for what architecture this build is compiled for. You should check your settings/compilation setup."
+        if env["bits"] == "64":
             env.Append(CCFLAGS=['/D_WIN64'])
     else:
 
@@ -292,32 +292,32 @@ def configure(env):
         # http://www.scons.org/wiki/LongCmdLinesOnWin32
         env.use_windows_spawn_fix()
 
-        #build using mingw
-        if (os.name=="nt"):
-            env['ENV']['TMP'] = os.environ['TMP'] #way to go scons, you can be so stupid sometimes
+        # build using mingw
+        if (os.name == "nt"):
+            env['ENV']['TMP'] = os.environ['TMP']  # way to go scons, you can be so stupid sometimes
         else:
-            env["PROGSUFFIX"]=env["PROGSUFFIX"]+".exe" # for linux cross-compilation
+            env["PROGSUFFIX"] = env["PROGSUFFIX"] + ".exe"  # for linux cross-compilation
 
-        mingw_prefix=""
+        mingw_prefix = ""
 
-        if (env["bits"]=="default"):
-            env["bits"]="32"
+        if (env["bits"] == "default"):
+            env["bits"] = "32"
 
-        if (env["bits"]=="32"):
+        if (env["bits"] == "32"):
             env.Append(LINKFLAGS=['-static'])
             env.Append(LINKFLAGS=['-static-libgcc'])
             env.Append(LINKFLAGS=['-static-libstdc++'])
-            mingw_prefix=env["mingw_prefix"];
+            mingw_prefix = env["mingw_prefix"];
         else:
             env.Append(LINKFLAGS=['-static'])
-            mingw_prefix=env["mingw_prefix_64"];
+            mingw_prefix = env["mingw_prefix_64"];
 
-        nulstr=""
+        nulstr = ""
 
-        if (os.name=="posix"):
-            nulstr=">/dev/null"
+        if (os.name == "posix"):
+            nulstr = ">/dev/null"
         else:
-            nulstr=">nul"
+            nulstr = ">nul"
 
 
 
@@ -326,42 +326,42 @@ def configure(env):
             # print("Can't find Windows compiler: "+mingw_prefix)
             # sys.exit(255)
 
-        if (env["target"]=="release"):
+        if (env["target"] == "release"):
 
             env.Append(CCFLAGS=['-msse2'])
 
-            if (env["bits"]=="64"):
+            if (env["bits"] == "64"):
                 env.Append(CCFLAGS=['-O3'])
             else:
                 env.Append(CCFLAGS=['-O2'])
 
             env.Append(LINKFLAGS=['-Wl,--subsystem,windows'])
 
-        elif (env["target"]=="release_debug"):
+        elif (env["target"] == "release_debug"):
 
-            env.Append(CCFLAGS=['-O2','-DDEBUG_ENABLED'])
+            env.Append(CCFLAGS=['-O2', '-DDEBUG_ENABLED'])
 
-        elif (env["target"]=="debug"):
+        elif (env["target"] == "debug"):
 
-            env.Append(CCFLAGS=['-g', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
+            env.Append(CCFLAGS=['-g', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED'])
 
 
 
-        env["CC"]=mingw_prefix+"gcc"
-        env['AS']=mingw_prefix+"as"
-        env['CXX'] = mingw_prefix+"g++"
-        env['AR'] = mingw_prefix+"ar"
-        env['RANLIB'] = mingw_prefix+"ranlib"
-        env['LD'] = mingw_prefix+"g++"
-        env["x86_libtheora_opt_gcc"]=True
+        env["CC"] = mingw_prefix + "gcc"
+        env['AS'] = mingw_prefix + "as"
+        env['CXX'] = mingw_prefix + "g++"
+        env['AR'] = mingw_prefix + "ar"
+        env['RANLIB'] = mingw_prefix + "ranlib"
+        env['LD'] = mingw_prefix + "g++"
+        env["x86_libtheora_opt_gcc"] = True
 
         #env['CC'] = "winegcc"
         #env['CXX'] = "wineg++"
 
-        env.Append(CCFLAGS=['-DWINDOWS_ENABLED','-mwindows'])
+        env.Append(CCFLAGS=['-DWINDOWS_ENABLED', '-mwindows'])
         env.Append(CPPFLAGS=['-DRTAUDIO_ENABLED'])
         env.Append(CCFLAGS=['-DGLES2_ENABLED'])
-        env.Append(LIBS=['mingw32','opengl32', 'dsound', 'ole32', 'd3d9','winmm','gdi32','iphlpapi','shlwapi','wsock32','kernel32', 'oleaut32', 'dinput8', 'dxguid'])
+        env.Append(LIBS=['mingw32', 'opengl32', 'dsound', 'ole32', 'd3d9', 'winmm', 'gdi32', 'iphlpapi', 'shlwapi', 'wsock32', 'kernel32', 'oleaut32', 'dinput8', 'dxguid'])
 
         # if (env["bits"]=="32"):
         # env.Append(LIBS=['gcc_s'])
@@ -374,17 +374,17 @@ def configure(env):
 
         #'d3dx9d'
         env.Append(CPPFLAGS=['-DMINGW_ENABLED'])
-        #env.Append(LINKFLAGS=['-g'])
+        # env.Append(LINKFLAGS=['-g'])
 
         # resrc
-        env['is_mingw']=True
-        env.Append( BUILDERS = { 'RES' : env.Builder(action = build_res_file, suffix = '.o',src_suffix = '.rc') } )
+        env['is_mingw'] = True
+        env.Append(BUILDERS={'RES': env.Builder(action=build_res_file, suffix='.o', src_suffix='.rc')})
 
     import methods
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'HLSL9': env.Builder(action=methods.build_hlsl_dx9_headers, suffix='hlsl.h', src_suffix='.hlsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})
 
 def detect_visual_c_compiler_version(tools_env):
     # tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...
@@ -414,12 +414,12 @@ def detect_visual_c_compiler_version(tools_env):
 
     # find() works with -1 so big ifs bellow are needed... the simplest solution, in fact
     # First test if amd64 and amd64_x86 compilers are present in the path
-    vc_amd64_compiler_detection_index =  tools_env["PATH"].find(tools_env["VCINSTALLDIR"]+"BIN\\amd64;")
+    vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;")
     if(vc_amd64_compiler_detection_index > -1):
         vc_chosen_compiler_index = vc_amd64_compiler_detection_index
         vc_chosen_compiler_str = "amd64"
 
-    vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"]+"BIN\\amd64_x86;")
+    vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;")
     if(vc_amd64_x86_compiler_detection_index > -1
        and (vc_chosen_compiler_index == -1
             or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index)):
@@ -428,14 +428,14 @@ def detect_visual_c_compiler_version(tools_env):
 
 
     # Now check the 32 bit compilers
-    vc_x86_compiler_detection_index =  tools_env["PATH"].find(tools_env["VCINSTALLDIR"]+"BIN;")
+    vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;")
     if(vc_x86_compiler_detection_index > -1
        and (vc_chosen_compiler_index == -1
             or vc_chosen_compiler_index > vc_x86_compiler_detection_index)):
         vc_chosen_compiler_index = vc_x86_compiler_detection_index
         vc_chosen_compiler_str = "x86"
 
-    vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env['VCINSTALLDIR']+"BIN\\x86_amd64;")
+    vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env['VCINSTALLDIR'] + "BIN\\x86_amd64;")
     if(vc_x86_amd64_compiler_detection_index > -1
        and (vc_chosen_compiler_index == -1
             or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index)):
@@ -443,10 +443,10 @@ def detect_visual_c_compiler_version(tools_env):
         vc_chosen_compiler_str = "x86_amd64"
 
     # debug help
-    #print vc_amd64_compiler_detection_index
-    #print vc_amd64_x86_compiler_detection_index
-    #print vc_x86_compiler_detection_index
-    #print vc_x86_amd64_compiler_detection_index
-    #print "chosen "+str(vc_chosen_compiler_index)+ " | "+str(vc_chosen_compiler_str)
+    # print vc_amd64_compiler_detection_index
+    # print vc_amd64_x86_compiler_detection_index
+    # print vc_x86_compiler_detection_index
+    # print vc_x86_amd64_compiler_detection_index
+    # print "chosen "+str(vc_chosen_compiler_index)+ " | "+str(vc_chosen_compiler_str)
 
     return vc_chosen_compiler_str

platform/winrt/detect.py

@@ -13,8 +13,8 @@ def get_name():
     return "WinRT"
 
 def can_build():
-    if (os.name=="nt"):
-        #building natively on windows!
+    if (os.name == "nt"):
+        # building natively on windows!
         if (os.getenv("VSINSTALLDIR")):
             return True
     return False
@@ -50,31 +50,31 @@ def configure(env):
         env.Append(CCFLAGS=string.split('/MP /GS /wd"4453" /wd"28204" /analyze- /Zc:wchar_t /Zi /Gm- /Od /fp:precise /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /DWINDOWSPHONE_ENABLED /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /RTC1 /Gd /EHsc /nologo'))
         env.Append(CXXFLAGS=string.split('/ZW'))
 
-        if (env["target"]=="release"):
+        if (env["target"] == "release"):
 
             env.Append(CCFLAGS=['/O2'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
 
-        elif (env["target"]=="test"):
+        elif (env["target"] == "test"):
 
-            env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
+            env.Append(CCFLAGS=['/O2', '/DDEBUG_ENABLED', '/DD3D_DEBUG_INFO'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
 
-        elif (env["target"]=="debug"):
+        elif (env["target"] == "debug"):
 
-            env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
+            env.Append(CCFLAGS=['/Zi', '/DDEBUG_ENABLED', '/DD3D_DEBUG_INFO'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
             env.Append(LINKFLAGS=['/DEBUG', '/D_DEBUG'])
 
-        elif (env["target"]=="profile"):
+        elif (env["target"] == "profile"):
 
-            env.Append(CCFLAGS=['-g','-pg'])
+            env.Append(CCFLAGS=['-g', '-pg'])
             env.Append(LINKFLAGS=['-pg'])
 
 
         env['ENV'] = os.environ;
         # fix environment for windows phone 8.1
-        env['ENV']['WINDOWSPHONEKITDIR'] = env['ENV']['WINDOWSPHONEKITDIR'].replace("8.0", "8.1") # wtf
+        env['ENV']['WINDOWSPHONEKITDIR'] = env['ENV']['WINDOWSPHONEKITDIR'].replace("8.0", "8.1")  # wtf
         env['ENV']['INCLUDE'] = env['ENV']['INCLUDE'].replace("8.0", "8.1")
         env['ENV']['LIB'] = env['ENV']['LIB'].replace("8.0", "8.1")
         env['ENV']['PATH'] = env['ENV']['PATH'].replace("8.0", "8.1")
@@ -88,69 +88,69 @@ def configure(env):
         env.Append(LIBPATH=['#platform/winrt/x64/lib'])
 
 
-        if (env["target"]=="release"):
+        if (env["target"] == "release"):
 
             env.Append(CCFLAGS=['/O2'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
             env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup'])
 
-        elif (env["target"]=="test"):
+        elif (env["target"] == "test"):
 
-            env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
+            env.Append(CCFLAGS=['/O2', '/DDEBUG_ENABLED', '/DD3D_DEBUG_INFO'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
 
-        elif (env["target"]=="debug"):
+        elif (env["target"] == "debug"):
 
-            env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
+            env.Append(CCFLAGS=['/Zi', '/DDEBUG_ENABLED', '/DD3D_DEBUG_INFO'])
             env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
             env.Append(LINKFLAGS=['/DEBUG', '/D_DEBUG'])
 
-        elif (env["target"]=="profile"):
+        elif (env["target"] == "profile"):
 
-            env.Append(CCFLAGS=['-g','-pg'])
+            env.Append(CCFLAGS=['-g', '-pg'])
             env.Append(LINKFLAGS=['-pg'])
 
 
         env.Append(CCFLAGS=string.split('/MP /GS /wd"4453" /wd"28204" /Zc:wchar_t /Gm- /Od /fp:precise /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP" /errorReport:prompt /WX- /Zc:forScope /RTC1 /Gd /MDd /EHsc /nologo'))
         env.Append(CXXFLAGS=string.split('/ZW'))
-        env.Append(CCFLAGS=['/AI', os.environ['VCINSTALLDIR']+'\\vcpackages', '/AI', os.environ['WINDOWSSDKDIR']+'\\References\\CommonConfiguration\\Neutral'])
+        env.Append(CCFLAGS=['/AI', os.environ['VCINSTALLDIR'] + '\\vcpackages', '/AI', os.environ['WINDOWSSDKDIR'] + '\\References\\CommonConfiguration\\Neutral'])
         env.Append(CCFLAGS=['/DWINAPI_FAMILY=WINAPI_FAMILY_APP', '/D_WIN32_WINNT=0x0603', '/DNTDDI_VERSION=0x06030000'])
 
         env['ENV'] = os.environ;
 
 
-    env["PROGSUFFIX"]="."+arch+env["PROGSUFFIX"]
-    env["OBJSUFFIX"]="."+arch+env["OBJSUFFIX"]
-    env["LIBSUFFIX"]="."+arch+env["LIBSUFFIX"]
+    env["PROGSUFFIX"] = "." + arch + env["PROGSUFFIX"]
+    env["OBJSUFFIX"] = "." + arch + env["OBJSUFFIX"]
+    env["LIBSUFFIX"] = "." + arch + env["LIBSUFFIX"]
 
 
     #env.Append(CCFLAGS=['/Gd','/GR','/nologo', '/EHsc'])
     #env.Append(CXXFLAGS=['/TP', '/ZW'])
     #env.Append(CPPFLAGS=['/DMSVC', '/GR', ])
-    ##env.Append(CCFLAGS=['/I'+os.getenv("WindowsSdkDir")+"/Include"])
+    # env.Append(CCFLAGS=['/I'+os.getenv("WindowsSdkDir")+"/Include"])
     env.Append(CCFLAGS=['/DWINRT_ENABLED'])
     env.Append(CCFLAGS=['/DWINDOWS_ENABLED'])
     env.Append(CCFLAGS=['/DRTAUDIO_ENABLED'])
-    #env.Append(CCFLAGS=['/DWIN32'])
+    # env.Append(CCFLAGS=['/DWIN32'])
     env.Append(CCFLAGS=['/DTYPED_METHOD_BIND'])
 
     env.Append(CCFLAGS=['/DGLES2_ENABLED'])
-    #env.Append(CCFLAGS=['/DGLES1_ENABLED'])
+    # env.Append(CCFLAGS=['/DGLES1_ENABLED'])
 
-    LIBS=[
+    LIBS = [
         #'winmm',
         'libEGL',
         'libGLESv2',
         'libANGLE',
         #'kernel32','ole32','user32', 'advapi32'
     ]
-    env.Append(LINKFLAGS=[p+".lib" for p in LIBS])
+    env.Append(LINKFLAGS=[p + ".lib" for p in LIBS])
 
     import methods
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'HLSL9': env.Builder(action=methods.build_hlsl_dx9_headers, suffix='hlsl.h', src_suffix='.hlsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})
 
 
 #/c/Program Files (x86)/Windows Phone Kits/8.1/lib/ARM/WindowsPhoneCore.lib

platform/x11/SCsub

@@ -3,11 +3,11 @@
 Import('env')
 
 
-common_x11=[\
+common_x11 = [\
     "context_gl_x11.cpp",\
     "os_x11.cpp",\
     "key_mapping_x11.cpp",\
     "joystick_linux.cpp",\
 ]
 
-env.Program('#bin/godot',['godot_x11.cpp']+common_x11)
+env.Program('#bin/godot', ['godot_x11.cpp'] + common_x11)

platform/x11/detect.py

@@ -13,56 +13,56 @@ def get_name():
 
 def can_build():
 
-    if (os.name!="posix"):
+    if (os.name != "posix"):
         return False
 
     if sys.platform == "darwin":
-        return False # no x11 on mac for now
+        return False  # no x11 on mac for now
 
-    errorval=os.system("pkg-config --version > /dev/null")
+    errorval = os.system("pkg-config --version > /dev/null")
 
     if (errorval):
         print("pkg-config not found.. x11 disabled.")
         return False
 
-    x11_error=os.system("pkg-config x11 --modversion > /dev/null ")
+    x11_error = os.system("pkg-config x11 --modversion > /dev/null ")
     if (x11_error):
         print("X11 not found.. x11 disabled.")
         return False
 
-    ssl_error=os.system("pkg-config openssl --modversion > /dev/null ")
+    ssl_error = os.system("pkg-config openssl --modversion > /dev/null ")
     if (ssl_error):
         print("OpenSSL not found.. x11 disabled.")
         return False
 
-    x11_error=os.system("pkg-config xcursor --modversion > /dev/null ")
+    x11_error = os.system("pkg-config xcursor --modversion > /dev/null ")
     if (x11_error):
         print("xcursor not found.. x11 disabled.")
         return False
 
-    x11_error=os.system("pkg-config xinerama --modversion > /dev/null ")
+    x11_error = os.system("pkg-config xinerama --modversion > /dev/null ")
     if (x11_error):
         print("xinerama not found.. x11 disabled.")
         return False
 
-    x11_error=os.system("pkg-config xrandr --modversion > /dev/null ")
+    x11_error = os.system("pkg-config xrandr --modversion > /dev/null ")
     if (x11_error):
         print("xrandr not found.. x11 disabled.")
         return False
 
 
-    return True # X11 enabled
+    return True  # X11 enabled
 
 def get_opts():
 
     return [
-        ('use_llvm','Use llvm compiler','no'),
-        ('use_static_cpp','link stdc++ statically','no'),
-        ('use_sanitizer','Use llvm compiler sanitize address','no'),
-        ('use_leak_sanitizer','Use llvm compiler sanitize memory leaks','no'),
-        ('pulseaudio','Detect & Use pulseaudio','yes'),
-        ('udev','Use udev for gamepad connection callbacks','no'),
-        ('debug_release', 'Add debug symbols to release version','no'),
+        ('use_llvm', 'Use llvm compiler', 'no'),
+        ('use_static_cpp', 'link stdc++ statically', 'no'),
+        ('use_sanitizer', 'Use llvm compiler sanitize address', 'no'),
+        ('use_leak_sanitizer', 'Use llvm compiler sanitize memory leaks', 'no'),
+        ('pulseaudio', 'Detect & Use pulseaudio', 'yes'),
+        ('udev', 'Use udev for gamepad connection callbacks', 'no'),
+        ('debug_release', 'Add debug symbols to release version', 'no'),
     ]
 
 def get_flags():
@@ -77,56 +77,56 @@ def get_flags():
 
 def configure(env):
 
-    is64=sys.maxsize > 2**32
+    is64 = sys.maxsize > 2**32
 
-    if (env["bits"]=="default"):
+    if (env["bits"] == "default"):
         if (is64):
-            env["bits"]="64"
+            env["bits"] = "64"
         else:
-            env["bits"]="32"
+            env["bits"] = "32"
 
     env.Append(CPPPATH=['#platform/x11'])
-    if (env["use_llvm"]=="yes"):
+    if (env["use_llvm"] == "yes"):
         if 'clang++' not in env['CXX']:
-            env["CC"]="clang"
-            env["CXX"]="clang++"
-            env["LD"]="clang++"
+            env["CC"] = "clang"
+            env["CXX"] = "clang++"
+            env["LD"] = "clang++"
         env.Append(CPPFLAGS=['-DTYPED_METHOD_BIND'])
-        env.extra_suffix=".llvm"
+        env.extra_suffix = ".llvm"
 
-    if (env["use_sanitizer"]=="yes"):
-        env.Append(CXXFLAGS=['-fsanitize=address','-fno-omit-frame-pointer'])
+    if (env["use_sanitizer"] == "yes"):
+        env.Append(CXXFLAGS=['-fsanitize=address', '-fno-omit-frame-pointer'])
         env.Append(LINKFLAGS=['-fsanitize=address'])
-        env.extra_suffix+="s"
+        env.extra_suffix += "s"
 
-    if (env["use_leak_sanitizer"]=="yes"):
-        env.Append(CXXFLAGS=['-fsanitize=address','-fno-omit-frame-pointer'])
+    if (env["use_leak_sanitizer"] == "yes"):
+        env.Append(CXXFLAGS=['-fsanitize=address', '-fno-omit-frame-pointer'])
         env.Append(LINKFLAGS=['-fsanitize=address'])
-        env.extra_suffix+="s"
+        env.extra_suffix += "s"
 
 
-    #if (env["tools"]=="no"):
+    # if (env["tools"]=="no"):
     #	#no tools suffix
     #	env['OBJSUFFIX'] = ".nt"+env['OBJSUFFIX']
     #	env['LIBSUFFIX'] = ".nt"+env['LIBSUFFIX']
 
 
-    if (env["target"]=="release"):
+    if (env["target"] == "release"):
 
-        if (env["debug_release"]=="yes"):
+        if (env["debug_release"] == "yes"):
             env.Append(CCFLAGS=['-g2'])
         else:
-            env.Append(CCFLAGS=['-O3','-ffast-math'])
+            env.Append(CCFLAGS=['-O3', '-ffast-math'])
 
-    elif (env["target"]=="release_debug"):
+    elif (env["target"] == "release_debug"):
 
-        env.Append(CCFLAGS=['-O2','-ffast-math','-DDEBUG_ENABLED'])
-        if (env["debug_release"]=="yes"):
+        env.Append(CCFLAGS=['-O2', '-ffast-math', '-DDEBUG_ENABLED'])
+        if (env["debug_release"] == "yes"):
             env.Append(CCFLAGS=['-g2'])
 
-    elif (env["target"]=="debug"):
+    elif (env["target"] == "debug"):
 
-        env.Append(CCFLAGS=['-g2', '-Wall','-DDEBUG_ENABLED','-DDEBUG_MEMORY_ENABLED'])
+        env.Append(CCFLAGS=['-g2', '-Wall', '-DDEBUG_ENABLED', '-DDEBUG_MEMORY_ENABLED'])
 
     env.ParseConfig('pkg-config x11 --cflags --libs')
     env.ParseConfig('pkg-config xinerama --cflags --libs')
@@ -174,7 +174,7 @@ def configure(env):
     if (env["glew"] == "system"):
         env.ParseConfig('pkg-config glew --cflags --libs')
 
-    if os.system("pkg-config --exists alsa")==0:
+    if os.system("pkg-config --exists alsa") == 0:
         print("Enabling ALSA")
         env.Append(CPPFLAGS=["-DALSA_ENABLED"])
         env.ParseConfig('pkg-config alsa --cflags --libs')
@@ -183,7 +183,7 @@ def configure(env):
 
     if (platform.system() == "Linux"):
         env.Append(CPPFLAGS=["-DJOYDEV_ENABLED"])
-    if (env["udev"]=="yes"):
+    if (env["udev"] == "yes"):
         # pkg-config returns 0 when the lib exists...
         found_udev = not os.system("pkg-config --exists libudev")
 
@@ -194,7 +194,7 @@ def configure(env):
         else:
             print("libudev development libraries not found, disabling udev support")
 
-    if (env["pulseaudio"]=="yes"):
+    if (env["pulseaudio"] == "yes"):
         if not os.system("pkg-config --exists libpulse-simple"):
             print("Enabling PulseAudio")
             env.Append(CPPFLAGS=["-DPULSEAUDIO_ENABLED"])
@@ -202,33 +202,33 @@ def configure(env):
         else:
             print("PulseAudio development libraries not found, disabling driver")
 
-    env.Append(CPPFLAGS=['-DX11_ENABLED','-DUNIX_ENABLED','-DGLES2_ENABLED','-DGLES_OVER_GL'])
+    env.Append(CPPFLAGS=['-DX11_ENABLED', '-DUNIX_ENABLED', '-DGLES2_ENABLED', '-DGLES_OVER_GL'])
     env.Append(LIBS=['GL', 'pthread', 'z'])
     if (platform.system() == "Linux"):
         env.Append(LIBS='dl')
-    #env.Append(CPPFLAGS=['-DMPC_FIXED_POINT'])
+    # env.Append(CPPFLAGS=['-DMPC_FIXED_POINT'])
 
-#host compiler is default..
+# host compiler is default..
 
-    if (is64 and env["bits"]=="32"):
+    if (is64 and env["bits"] == "32"):
         env.Append(CPPFLAGS=['-m32'])
-        env.Append(LINKFLAGS=['-m32','-L/usr/lib/i386-linux-gnu'])
-    elif (not is64 and env["bits"]=="64"):
+        env.Append(LINKFLAGS=['-m32', '-L/usr/lib/i386-linux-gnu'])
+    elif (not is64 and env["bits"] == "64"):
         env.Append(CPPFLAGS=['-m64'])
-        env.Append(LINKFLAGS=['-m64','-L/usr/lib/i686-linux-gnu'])
+        env.Append(LINKFLAGS=['-m64', '-L/usr/lib/i686-linux-gnu'])
 
 
     import methods
 
-    env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
-    env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
+    env.Append(BUILDERS={'GLSL120': env.Builder(action=methods.build_legacygl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL': env.Builder(action=methods.build_glsl_headers, suffix='glsl.h', src_suffix='.glsl')})
+    env.Append(BUILDERS={'GLSL120GLES': env.Builder(action=methods.build_gles2_headers, suffix='glsl.h', src_suffix='.glsl')})
     #env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } )
 
-    if (env["use_static_cpp"]=="yes"):
+    if (env["use_static_cpp"] == "yes"):
         env.Append(LINKFLAGS=['-static-libstdc++'])
 
     list_of_x86 = ['x86_64', 'x86', 'i386', 'i586']
     if any(platform.machine() in s for s in list_of_x86):
-        env["x86_libtheora_opt_gcc"]=True
+        env["x86_libtheora_opt_gcc"] = True
 

scene/2d/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/3d/SCsub

@@ -3,11 +3,11 @@
 Import('env')
 
 
-if (env["disable_3d"]=="yes"):
+if (env["disable_3d"] == "yes"):
 
     env.scene_sources.append("3d/spatial.cpp")
     env.scene_sources.append("3d/skeleton.cpp")
 else:
-    env.add_source_files(env.scene_sources,"*.cpp")
+    env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/SCsub

@@ -2,8 +2,8 @@
 
 Import('env')
 
-env.scene_sources=[]
-env.add_source_files(env.scene_sources,"*.cpp")
+env.scene_sources = []
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')
 
@@ -17,6 +17,6 @@ SConscript('resources/SCsub');
 SConscript('io/SCsub');
 
 
-lib = env.Library("scene",env.scene_sources)
+lib = env.Library("scene", env.scene_sources)
 
 env.Prepend(LIBS=[lib])

scene/animation/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/audio/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/gui/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/io/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/main/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/resources/SCsub

@@ -2,8 +2,8 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
-env.add_source_files(env.scene_sources,"*.c")
+env.add_source_files(env.scene_sources, "*.cpp")
+env.add_source_files(env.scene_sources, "*.c")
 
 Export('env')
 

scene/resources/default_theme/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.scene_sources,"*.cpp")
+env.add_source_files(env.scene_sources, "*.cpp")
 
 Export('env')

scene/resources/default_theme/make_header.py

@@ -4,15 +4,15 @@ import glob;
 import string;
 
 
-#Generate include files
+# Generate include files
 
-f=open("theme_data.h","wb")
+f = open("theme_data.h", "wb")
 
 f.write("// THIS FILE HAS BEEN AUTOGENERATED, DONT EDIT!!\n");
 
 f.write("\n\n");
 
-#Generate png image block
+# Generate png image block
 
 pixmaps = glob.glob("*.png");
 
@@ -22,23 +22,23 @@ f.write("\n\n\n");
 
 for x in pixmaps:
 
-    var_str=x[:-4]+"_png";
+    var_str = x[:-4] + "_png";
 
-    f.write("static const unsigned char "+ var_str +"[]={\n");
+    f.write("static const unsigned char " + var_str + "[]={\n");
 
-    pngf=open(x,"rb");
+    pngf = open(x, "rb");
 
-    b=pngf.read(1);
-    while(len(b)==1):
+    b = pngf.read(1);
+    while(len(b) == 1):
         f.write(hex(ord(b)))
-        b=pngf.read(1);
-        if (len(b)==1):
+        b = pngf.read(1);
+        if (len(b) == 1):
             f.write(",")
 
     f.write("\n};\n\n\n");
     pngf.close();
 
-#Generate shaders block
+# Generate shaders block
 
 shaders = glob.glob("*.gsl")
 
@@ -48,22 +48,22 @@ f.write("\n\n\n");
 
 for x in shaders:
 
-    var_str=x[:-4]+"_shader_code";
+    var_str = x[:-4] + "_shader_code";
 
-    f.write("static const char *"+ var_str +"=\n");
+    f.write("static const char *" + var_str + "=\n");
 
-    sf=open(x,"rb");
+    sf = open(x, "rb");
 
 
-    b=sf.readline();
-    while(b!=""):
+    b = sf.readline();
+    while(b != ""):
         if (b.endswith("\r\n")):
-            b=b[:-2]
+            b = b[:-2]
         if (b.endswith("\n")):
-            b=b[:-1]
-        f.write("			\""+b)
-        b=sf.readline();
-        if (b!=""):
+            b = b[:-1]
+        f.write("			\"" + b)
+        b = sf.readline();
+        if (b != ""):
             f.write("\"\n")
 
     f.write("\";\n\n\n");

servers/SCsub

@@ -2,8 +2,8 @@
 
 Import('env')
 
-env.servers_sources=[]
-env.add_source_files(env.servers_sources,"*.cpp")
+env.servers_sources = []
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')
 
@@ -14,6 +14,6 @@ SConscript('audio/SCsub');
 SConscript('spatial_sound/SCsub');
 SConscript('spatial_sound_2d/SCsub');
 
-lib = env.Library("servers",env.servers_sources)
+lib = env.Library("servers", env.servers_sources)
 
 env.Prepend(LIBS=[lib])

servers/audio/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')

servers/physics/SCsub

@@ -2,7 +2,7 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')
 

servers/physics/joints/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')

servers/physics_2d/SCsub

@@ -2,4 +2,4 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")

servers/spatial_sound/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')

servers/spatial_sound_2d/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')

servers/visual/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.servers_sources,"*.cpp")
+env.add_source_files(env.servers_sources, "*.cpp")
 
 Export('env')

tools/SCsub

@@ -2,18 +2,18 @@
 
 Import('env')
 
-env.tool_sources=[]
-env.add_source_files(env.tool_sources,"*.cpp")
+env.tool_sources = []
+env.add_source_files(env.tool_sources, "*.cpp")
 
 Export('env')
 
 
-def make_translations_header(target,source,env):
+def make_translations_header(target, source, env):
 
 
     dst = target[0].srcnode().abspath
 
-    g = open(dst,"wb")
+    g = open(dst, "wb")
 
 
     """"
@@ -29,24 +29,24 @@ def make_translations_header(target,source,env):
     paths = [node.srcnode().abspath for node in source]
     sorted_paths = sorted(paths, key=lambda path: os.path.splitext(os.path.basename(path))[0])
 
-    xl_names=[]
+    xl_names = []
     for i in range(len(sorted_paths)):
-        print("Appending translation: "+sorted_paths[i])
-        f = open(sorted_paths[i],"rb")
+        print("Appending translation: " + sorted_paths[i])
+        f = open(sorted_paths[i], "rb")
         buf = f.read()
         decomp_size = len(buf)
         buf = zlib.compress(buf)
-        name =  os.path.splitext(os.path.basename(sorted_paths[i]))[0]
+        name = os.path.splitext(os.path.basename(sorted_paths[i]))[0]
 
         #g.write("static const int _translation_"+name+"_compressed_size="+str(len(buf))+";\n")
         #g.write("static const int _translation_"+name+"_uncompressed_size="+str(decomp_size)+";\n")
-        g.write("static const unsigned char _translation_"+name+"_compressed[]={\n")
+        g.write("static const unsigned char _translation_" + name + "_compressed[]={\n")
         for i in range(len(buf)):
-            g.write(str(ord(buf[i]))+",\n")
+            g.write(str(ord(buf[i])) + ",\n")
 
         g.write("};\n")
 
-        xl_names.append([name,len(buf),str(decomp_size)])
+        xl_names.append([name, len(buf), str(decomp_size)])
 
     g.write("struct EditorTranslationList {\n")
     g.write("\tconst char* lang;\n");
@@ -56,19 +56,19 @@ def make_translations_header(target,source,env):
     g.write("};\n\n");
     g.write("static EditorTranslationList _editor_translations[]={\n")
     for x in xl_names:
-        g.write("\t{ \""+x[0]+"\", "+str(x[1])+", "+str(x[2])+",_translation_"+x[0]+"_compressed},\n")
+        g.write("\t{ \"" + x[0] + "\", " + str(x[1]) + ", " + str(x[2]) + ",_translation_" + x[0] + "_compressed},\n")
     g.write("\t{NULL,0,0,NULL}\n")
     g.write("};\n")
 
     g.write("#endif")
 
 
-def make_fonts_header(target,source,env):
+def make_fonts_header(target, source, env):
 
 
     dst = target[0].srcnode().abspath
 
-    g = open(dst,"wb")
+    g = open(dst, "wb")
 
 
     """"
@@ -78,48 +78,48 @@ def make_fonts_header(target,source,env):
     g.write("#ifndef _EDITOR_FONTS_H\n")
     g.write("#define _EDITOR_FONTS_H\n")
 
-    #saving uncompressed, since freetype will reference from memory pointer
-    xl_names=[]
+    # saving uncompressed, since freetype will reference from memory pointer
+    xl_names = []
     for i in range(len(source)):
-        print("Appending font: "+source[i].srcnode().abspath)
-        f = open(source[i].srcnode().abspath,"rb")
+        print("Appending font: " + source[i].srcnode().abspath)
+        f = open(source[i].srcnode().abspath, "rb")
         buf = f.read()
         import os.path
 
-        name =  os.path.splitext(os.path.basename(source[i].srcnode().abspath))[0]
+        name = os.path.splitext(os.path.basename(source[i].srcnode().abspath))[0]
 
-        g.write("static const int _font_"+name+"_size="+str(len(buf))+";\n")
-        g.write("static const unsigned char _font_"+name+"[]={\n")
+        g.write("static const int _font_" + name + "_size=" + str(len(buf)) + ";\n")
+        g.write("static const unsigned char _font_" + name + "[]={\n")
         for i in range(len(buf)):
-            g.write(str(ord(buf[i]))+",\n")
+            g.write(str(ord(buf[i])) + ",\n")
 
         g.write("};\n")
 
     g.write("#endif")
 
 
-if (env["tools"]!="no"):
+if (env["tools"] != "no"):
 
     import glob
 
     dir = env.Dir('.').abspath
     tlist = glob.glob(dir + "/translations/*.po")
 
-    print("translations: ",tlist)
-    env.Depends('#tools/editor/translations.h',tlist)
-    env.Command('#tools/editor/translations.h',tlist,make_translations_header)
+    print("translations: ", tlist)
+    env.Depends('#tools/editor/translations.h', tlist)
+    env.Command('#tools/editor/translations.h', tlist, make_translations_header)
 
     flist = glob.glob(dir + "/editor_fonts/*.ttf")
-    flist.append( glob.glob(dir + "/editor_fonts/*.otf") )
+    flist.append(glob.glob(dir + "/editor_fonts/*.otf"))
 
-    print("fonts: ",flist)
-    env.Depends('#tools/editor/builtin_fonts.h',flist)
-    env.Command('#tools/editor/builtin_fonts.h',flist,make_fonts_header)
+    print("fonts: ", flist)
+    env.Depends('#tools/editor/builtin_fonts.h', flist)
+    env.Command('#tools/editor/builtin_fonts.h', flist, make_fonts_header)
 
     SConscript('editor/SCsub');
     SConscript('collada/SCsub');
     SConscript('doc/SCsub')
 
-    lib = env.Library("tool",env.tool_sources)
+    lib = env.Library("tool", env.tool_sources)
 
     env.Prepend(LIBS=[lib])

tools/collada/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.tool_sources,"*.cpp")
+env.add_source_files(env.tool_sources, "*.cpp")
 
 Export('env')

tools/doc/SCsub

@@ -2,6 +2,6 @@
 
 Import('env')
 
-env.add_source_files(env.tool_sources,"*.cpp")
+env.add_source_files(env.tool_sources, "*.cpp")
 
 Export('env')

tools/editor/SCsub

@@ -3,12 +3,12 @@
 Import('env')
 
 
-def make_doc_header(target,source,env):
+def make_doc_header(target, source, env):
 
     src = source[0].srcnode().abspath
     dst = target[0].srcnode().abspath
-    f = open(src,"rb")
-    g = open(dst,"wb")
+    f = open(src, "rb")
+    g = open(dst, "wb")
     buf = f.read()
     decomp_size = len(buf)
     import zlib
@@ -18,22 +18,22 @@ def make_doc_header(target,source,env):
     g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
     g.write("#ifndef _DOC_DATA_RAW_H\n")
     g.write("#define _DOC_DATA_RAW_H\n")
-    g.write("static const int _doc_data_compressed_size="+str(len(buf))+";\n")
-    g.write("static const int _doc_data_uncompressed_size="+str(decomp_size)+";\n")
+    g.write("static const int _doc_data_compressed_size=" + str(len(buf)) + ";\n")
+    g.write("static const int _doc_data_uncompressed_size=" + str(decomp_size) + ";\n")
     g.write("static const unsigned char _doc_data_compressed[]={\n")
     for i in range(len(buf)):
-        g.write(str(ord(buf[i]))+",\n")
+        g.write(str(ord(buf[i])) + ",\n")
     g.write("};\n")
     g.write("#endif")
 
 
 
-def make_certs_header(target,source,env):
+def make_certs_header(target, source, env):
 
     src = source[0].srcnode().abspath
     dst = target[0].srcnode().abspath
-    f = open(src,"rb")
-    g = open(dst,"wb")
+    f = open(src, "rb")
+    g = open(dst, "wb")
     buf = f.read()
     decomp_size = len(buf)
     import zlib
@@ -43,11 +43,11 @@ def make_certs_header(target,source,env):
     g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
     g.write("#ifndef _CERTS_RAW_H\n")
     g.write("#define _CERTS_RAW_H\n")
-    g.write("static const int _certs_compressed_size="+str(len(buf))+";\n")
-    g.write("static const int _certs_uncompressed_size="+str(decomp_size)+";\n")
+    g.write("static const int _certs_compressed_size=" + str(len(buf)) + ";\n")
+    g.write("static const int _certs_uncompressed_size=" + str(decomp_size) + ";\n")
     g.write("static const unsigned char _certs_compressed[]={\n")
     for i in range(len(buf)):
-        g.write(str(ord(buf[i]))+",\n")
+        g.write(str(ord(buf[i])) + ",\n")
     g.write("};\n")
     g.write("#endif")
 
@@ -57,29 +57,29 @@ def make_certs_header(target,source,env):
 
 
 
-if (env["tools"]=="yes"):
+if (env["tools"] == "yes"):
 
-    reg_exporters_inc='#include "register_exporters.h"\n'
-    reg_exporters='void register_exporters() {\n'
+    reg_exporters_inc = '#include "register_exporters.h"\n'
+    reg_exporters = 'void register_exporters() {\n'
     for e in env.platform_exporters:
-        env.tool_sources.append("#platform/"+e+"/export/export.cpp")
-        reg_exporters+='\tregister_'+e+'_exporter();\n'
-        reg_exporters_inc+='#include "platform/'+e+'/export/export.h"\n'
-    reg_exporters+='}\n'
-    f = open("register_exporters.cpp","wb")
+        env.tool_sources.append("#platform/" + e + "/export/export.cpp")
+        reg_exporters += '\tregister_' + e + '_exporter();\n'
+        reg_exporters_inc += '#include "platform/' + e + '/export/export.h"\n'
+    reg_exporters += '}\n'
+    f = open("register_exporters.cpp", "wb")
     f.write(reg_exporters_inc)
     f.write(reg_exporters)
     f.close()
 
-    env.Depends("#tools/editor/doc_data_compressed.h","#doc/base/classes.xml")
-    env.Command("#tools/editor/doc_data_compressed.h","#doc/base/classes.xml",make_doc_header)
+    env.Depends("#tools/editor/doc_data_compressed.h", "#doc/base/classes.xml")
+    env.Command("#tools/editor/doc_data_compressed.h", "#doc/base/classes.xml", make_doc_header)
 
-    env.Depends("#tools/editor/certs_compressed.h","#tools/certs/ca-certificates.crt")
-    env.Command("#tools/editor/certs_compressed.h","#tools/certs/ca-certificates.crt",make_certs_header)
+    env.Depends("#tools/editor/certs_compressed.h", "#tools/certs/ca-certificates.crt")
+    env.Command("#tools/editor/certs_compressed.h", "#tools/certs/ca-certificates.crt", make_certs_header)
 
-    #make_doc_header(env.File("#tools/editor/doc_data_raw.h").srcnode().abspath,env.File("#doc/base/classes.xml").srcnode().abspath,env)
+    # make_doc_header(env.File("#tools/editor/doc_data_raw.h").srcnode().abspath,env.File("#doc/base/classes.xml").srcnode().abspath,env)
 
-    env.add_source_files(env.tool_sources,"*.cpp")
+    env.add_source_files(env.tool_sources, "*.cpp")
 
     Export('env')
     SConscript('icons/SCsub');

tools/editor/fileserver/SCsub

@@ -2,4 +2,4 @@
 
 Import('env')
 Export('env')
-env.add_source_files(env.tool_sources,"*.cpp")
+env.add_source_files(env.tool_sources, "*.cpp")

tools/editor/icons/SCsub

@@ -16,47 +16,47 @@ def make_editor_icons_action(target, source, env):
     s.write("#include \"editor_scale.h\"\n\n")
     s.write("#include \"scene/resources/theme.h\"\n\n")
 
-    hidpi_list=[]
+    hidpi_list = []
 
     for x in pixmaps:
 
-        x=str(x)
-        var_str=os.path.basename(x)[:-4]+"_png";
-        #print(var_str)
+        x = str(x)
+        var_str = os.path.basename(x)[:-4] + "_png";
+        # print(var_str)
 
-        s.write("static const unsigned char "+ var_str +"[]={\n");
+        s.write("static const unsigned char " + var_str + "[]={\n");
 
-        pngf=open(x,"rb");
+        pngf = open(x, "rb");
 
-        b=pngf.read(1);
-        while(len(b)==1):
+        b = pngf.read(1);
+        while(len(b) == 1):
             s.write(hex(ord(b)))
-            b=pngf.read(1);
-            if (len(b)==1):
+            b = pngf.read(1);
+            if (len(b) == 1):
                 s.write(",")
 
         s.write("\n};\n\n");
 
         pngf.close();
-        var_str=os.path.basename(x)[:-4]+"_hidpi_png";
+        var_str = os.path.basename(x)[:-4] + "_hidpi_png";
         try:
 
-            pngf = open(os.path.dirname(x)+"/2x/"+os.path.basename(x), "rb")
+            pngf = open(os.path.dirname(x) + "/2x/" + os.path.basename(x), "rb")
 
-            s.write("static const unsigned char "+ var_str +"[]={\n");
+            s.write("static const unsigned char " + var_str + "[]={\n");
 
-            b=pngf.read(1);
-            while(len(b)==1):
+            b = pngf.read(1);
+            while(len(b) == 1):
                 s.write(hex(ord(b)))
-                b=pngf.read(1);
-                if (len(b)==1):
+                b = pngf.read(1);
+                if (len(b) == 1):
                     s.write(",")
 
             s.write("\n};\n\n\n");
             hidpi_list.append(x)
 
         except:
-            s.write("static const unsigned char* "+ var_str +"=NULL;\n\n\n");
+            s.write("static const unsigned char* " + var_str + "=NULL;\n\n\n");
 
 
 
@@ -73,24 +73,24 @@ def make_editor_icons_action(target, source, env):
 
     for x in pixmaps:
 
-        x=os.path.basename(str(x))
-        type=x[5:-4].title().replace("_","");
-        var_str=x[:-4]+"_png";
-        var_str_hidpi=x[:-4]+"_hidpi_png";
-        s.write("\tp_theme->set_icon(\""+type+"\",\"EditorIcons\",make_icon("+var_str+","+var_str_hidpi+"));\n");
+        x = os.path.basename(str(x))
+        type = x[5:-4].title().replace("_", "");
+        var_str = x[:-4] + "_png";
+        var_str_hidpi = x[:-4] + "_hidpi_png";
+        s.write("\tp_theme->set_icon(\"" + type + "\",\"EditorIcons\",make_icon(" + var_str + "," + var_str_hidpi + "));\n");
 
     s.write("\n\n}\n\n");
 
-    f = open(dst,"wb")
+    f = open(dst, "wb")
     f.write(s.getvalue())
     f.close()
     s.close()
 
 make_editor_icons_builder = Builder(action=make_editor_icons_action,
-                                    suffix = '.cpp',
-                                    src_suffix = '.png')
-env['BUILDERS']['MakeEditorIconsBuilder']=make_editor_icons_builder
-env.Alias('editor_icons',[env.MakeEditorIconsBuilder('#tools/editor/editor_icons.cpp',Glob("*.png"))])
+                                    suffix='.cpp',
+                                    src_suffix='.png')
+env['BUILDERS']['MakeEditorIconsBuilder'] = make_editor_icons_builder
+env.Alias('editor_icons', [env.MakeEditorIconsBuilder('#tools/editor/editor_icons.cpp', Glob("*.png"))])
 
 env.tool_sources.append("#tools/editor/editor_icons.cpp")
 Export('env')

tools/editor/io_plugins/SCsub

@@ -2,4 +2,4 @@
 
 Import('env')
 Export('env')
-env.add_source_files(env.tool_sources,"*.cpp")
+env.add_source_files(env.tool_sources, "*.cpp")

tools/editor/plugins/SCsub

@@ -2,4 +2,4 @@
 
 Import('env')
 Export('env')
-env.add_source_files(env.tool_sources,"*.cpp")
+env.add_source_files(env.tool_sources, "*.cpp")

tools/scripts/addheader.py

@@ -1,4 +1,4 @@
-header="""\
+header = """\
 /*************************************************************************/
 /*  $filename                                                            */
 /*************************************************************************/
@@ -29,44 +29,44 @@ header="""\
 /*************************************************************************/
 """
 
-f = open("files","rb")
+f = open("files", "rb")
 
 fname = f.readline()
-while (fname!=""):
+while (fname != ""):
 
-    fr = open(fname.strip(),"rb")
+    fr = open(fname.strip(), "rb")
     l = fr.readline()
-    bc=False
+    bc = False
     fsingle = fname.strip()
 
-    if (fsingle.find("/")!=-1):
-        fsingle=fsingle[fsingle.rfind("/")+1:]
-    rep_fl="$filename"
-    rep_fi=fsingle
-    len_fl=len(rep_fl)
-    len_fi=len(rep_fi)
-    if (len_fi<len_fl):
-        for x in range(len_fl-len_fi):
-            rep_fi+=" "
-    elif (len_fl<len_fi):
-        for x in range(len_fi-len_fl):
-            rep_fl+=" "
-    if (header.find(rep_fl)!=-1):
-        text=header.replace(rep_fl,rep_fi)
+    if (fsingle.find("/") != -1):
+        fsingle = fsingle[fsingle.rfind("/") + 1:]
+    rep_fl = "$filename"
+    rep_fi = fsingle
+    len_fl = len(rep_fl)
+    len_fi = len(rep_fi)
+    if (len_fi < len_fl):
+        for x in range(len_fl - len_fi):
+            rep_fi += " "
+    elif (len_fl < len_fi):
+        for x in range(len_fi - len_fl):
+            rep_fl += " "
+    if (header.find(rep_fl) != -1):
+        text = header.replace(rep_fl, rep_fi)
     else:
-        text=header.replace("$filename",fsingle)
+        text = header.replace("$filename", fsingle)
 
 
-    while (l!=""):
-        if ((l.find("//")!=0 and  l.find("/*")!=0 and l.strip()!="") or bc):
-            text+=l
-            bc=True
-        l=fr.readline()
+    while (l != ""):
+        if ((l.find("//") != 0 and l.find("/*") != 0 and l.strip() != "") or bc):
+            text += l
+            bc = True
+        l = fr.readline()
 
     fr.close()
-    fr=open(fname.strip(),"wb")
+    fr = open(fname.strip(), "wb")
     fr.write(text)
     fr.close()
-    #print(text)
-    fname=f.readline()
+    # print(text)
+    fname = f.readline()
 

tools/scripts/file-hex-array.py

@@ -5,27 +5,27 @@ import sys
 def tof(filepath):
     with open(filepath, 'r') as f:
         content = f.read()
-    content = content.replace("0x","")
+    content = content.replace("0x", "")
     content = content.split(',')
     for i in range(len(content)):
         if len(content[i]) == 1: content[i] = "0" + content[i]
     content = "".join(content)
-    with open(filepath+".file", 'wb') as f:
+    with open(filepath + ".file", 'wb') as f:
         content = f.write(content.decode("hex"))
-    print(os.path.basename(filepath)+".file created.")
+    print(os.path.basename(filepath) + ".file created.")
     exit(0)
 
 def toa(filepath):
     with open(filepath, 'rb') as f:
         content = f.read()
     content = binascii.hexlify(content)
-    content = [content[i:i+2] for i in range(0, len(content), 2)]
+    content = [content[i:i + 2] for i in range(0, len(content), 2)]
     content = ",0x".join(content)
     content = "0x" + content
-    content = content.replace("0x00","0x0")
-    with open(filepath+".array", 'w') as f:
+    content = content.replace("0x00", "0x0")
+    with open(filepath + ".array", 'w') as f:
         content = f.write(content)
-    print(os.path.basename(filepath)+".array created.")
+    print(os.path.basename(filepath) + ".array created.")
     exit(0)
 
 def usage():

tools/scripts/make_bmfhdr.py

@@ -2,43 +2,43 @@
 
 import sys
 
-if (len(sys.argv)!=2):
+if (len(sys.argv) != 2):
     print("Pass me a .fnt argument!")
 
-f = open(sys.argv[1],"rb")
+f = open(sys.argv[1], "rb")
 
-name = sys.argv[1].lower().replace(".fnt","")
+name = sys.argv[1].lower().replace(".fnt", "")
 
 l = f.readline()
 
-font_height=0
-font_ascent=0
-font_charcount=0
-font_chars=[]
-font_cc=0
+font_height = 0
+font_ascent = 0
+font_charcount = 0
+font_chars = []
+font_cc = 0
 
-while(l!=""):
+while(l != ""):
 
     fs = l.strip().find(" ")
-    if (fs==-1):
-        l=f.readline()
+    if (fs == -1):
+        l = f.readline()
         continue
-    t  = l[0:fs]
+    t = l[0:fs]
 
-    dv = l[fs+1:].split(" ")
+    dv = l[fs + 1:].split(" ")
     d = {}
     for x in dv:
-        if (x.find("=")==-1):
+        if (x.find("=") == -1):
             continue
         s = x.split("=")
-        d[ s[0] ] = s[1]
+        d[s[0]] = s[1]
 
 
-    if (t=="common"):
-        font_height=d["lineHeight"]
-        font_ascent=d["base"]
+    if (t == "common"):
+        font_height = d["lineHeight"]
+        font_ascent = d["base"]
 
-    if (t=="char"):
+    if (t == "char"):
         font_chars.append(d["id"])
         font_chars.append(d["x"])
         font_chars.append(d["y"])
@@ -47,24 +47,24 @@ while(l!=""):
         font_chars.append(d["xoffset"])
         font_chars.append(d["yoffset"])
         font_chars.append(d["xadvance"])
-        font_cc+=1
+        font_cc += 1
 
 
 
     l = f.readline()
 
 
-print("static const int _bi_font_"+name+"_height="+str(font_height)+";")
-print("static const int _bi_font_"+name+"_ascent="+str(font_ascent)+";")
-print("static const int _bi_font_"+name+"_charcount="+str(font_cc)+";")
-cstr="static const int _bi_font_"+name+"_characters={"
+print("static const int _bi_font_" + name + "_height=" + str(font_height) + ";")
+print("static const int _bi_font_" + name + "_ascent=" + str(font_ascent) + ";")
+print("static const int _bi_font_" + name + "_charcount=" + str(font_cc) + ";")
+cstr = "static const int _bi_font_" + name + "_characters={"
 for i in range(len(font_chars)):
 
-    c=font_chars[i]
-    if (i>0):
-        cstr+=", "
-    cstr+=c
+    c = font_chars[i]
+    if (i > 0):
+        cstr += ", "
+    cstr += c
 
-cstr+=("};")
+cstr += ("};")
 
 print(cstr)

tools/scripts/make_glwrapper.py

@@ -1,31 +1,31 @@
 #! /usr/bin/env python
 import sys
 
-if (len(sys.argv)<2):
+if (len(sys.argv) < 2):
     print("usage: make_glwrapper.py <headers>")
     sys.exit(255)
 
 
-functions=[]
-types=[]
-constants=[]
+functions = []
+types = []
+constants = []
 
-READ_FUNCTIONS=0
-READ_TYPES=1
-READ_CONSTANTS=2
+READ_FUNCTIONS = 0
+READ_TYPES = 1
+READ_CONSTANTS = 2
 
-read_what=READ_TYPES
+read_what = READ_TYPES
 
-for x in (range(len(sys.argv)-1)):
-    f=open(sys.argv[x+1],"r")
+for x in (range(len(sys.argv) - 1)):
+    f = open(sys.argv[x + 1], "r")
 
     while(True):
 
-        line=f.readline()
-        if (line==""):
+        line = f.readline()
+        if (line == ""):
             break
 
-        line=line.replace("\n","").strip()
+        line = line.replace("\n", "").strip()
         """
     if (line.find("[types]")!=-1):
       read_what=READ_TYPES
@@ -38,67 +38,67 @@ for x in (range(len(sys.argv)-1)):
       continue
      """
 
-        if (line.find("#define")!=-1):
-            if (line.find("0x")==-1 and line.find("GL_VERSION")==-1):
+        if (line.find("#define") != -1):
+            if (line.find("0x") == -1 and line.find("GL_VERSION") == -1):
                 continue
             constants.append(line)
-        elif (line.find("typedef")!=-1):
-            if (line.find("(")!=-1 or line.find(")")!=-1 or line.find("ARB")!=-1 or line.find("EXT")!=-1 or line.find("GL")==-1):
+        elif (line.find("typedef") != -1):
+            if (line.find("(") != -1 or line.find(")") != -1 or line.find("ARB") != -1 or line.find("EXT") != -1 or line.find("GL") == -1):
                 continue
             types.append(line)
-        elif (line.find("APIENTRY")!=-1 and line.find("GLAPI")!=-1):
+        elif (line.find("APIENTRY") != -1 and line.find("GLAPI") != -1):
 
-            if (line.find("ARB")!=-1 or line.find("EXT")!=-1 or line.find("NV")!=-1):
+            if (line.find("ARB") != -1 or line.find("EXT") != -1 or line.find("NV") != -1):
                 continue
 
-            line=line.replace("APIENTRY","")
-            line=line.replace("GLAPI","")
+            line = line.replace("APIENTRY", "")
+            line = line.replace("GLAPI", "")
 
-            glpos=line.find(" gl")
-            if (glpos==-1):
+            glpos = line.find(" gl")
+            if (glpos == -1):
 
-                glpos=line.find("\tgl")
-                if (glpos==-1):
+                glpos = line.find("\tgl")
+                if (glpos == -1):
                     continue
 
-            ret=line[:glpos].strip();
+            ret = line[:glpos].strip();
 
-            line=line[glpos:].strip()
-            namepos=line.find("(")
+            line = line[glpos:].strip()
+            namepos = line.find("(")
 
-            if (namepos==-1):
+            if (namepos == -1):
                 continue
 
-            name=line[:namepos].strip()
-            line=line[namepos:]
+            name = line[:namepos].strip()
+            line = line[namepos:]
 
-            argpos=line.rfind(")")
-            if (argpos==-1):
+            argpos = line.rfind(")")
+            if (argpos == -1):
                 continue
 
-            args=line[1:argpos]
+            args = line[1:argpos]
 
-            funcdata={}
-            funcdata["ret"]=ret
-            funcdata["name"]=name
-            funcdata["args"]=args
+            funcdata = {}
+            funcdata["ret"] = ret
+            funcdata["name"] = name
+            funcdata["args"] = args
 
             functions.append(funcdata)
             print(funcdata)
 
 
 
-#print(types)
-#print(constants)
-#print(functions)
+# print(types)
+# print(constants)
+# print(functions)
 
 
-f=open("glwrapper.h","w")
+f = open("glwrapper.h", "w")
 
 f.write("#ifndef GL_WRAPPER\n")
 f.write("#define GL_WRAPPER\n\n\n")
 
-header_code="""\
+header_code = """\
 #if defined(__gl_h_) || defined(__GL_H__)
 #error gl.h included before glwrapper.h
 #endif
@@ -137,18 +137,18 @@ f.write("#else\n");
 f.write("#define GLWRP_APIENTRY \n")
 f.write("#endif\n\n");
 for x in types:
-    f.write(x+"\n")
+    f.write(x + "\n")
 
 f.write("\n\n")
 
 for x in constants:
-    f.write(x+"\n")
+    f.write(x + "\n")
 
 f.write("\n\n")
 
 for x in functions:
-    f.write("extern "+x["ret"]+" GLWRP_APIENTRY (*__wrapper_"+x["name"]+")("+x["args"]+");\n")
-    f.write("#define "+x["name"]+" __wrapper_"+x["name"]+"\n")
+    f.write("extern " + x["ret"] + " GLWRP_APIENTRY (*__wrapper_" + x["name"] + ")(" + x["args"] + ");\n")
+    f.write("#define " + x["name"] + " __wrapper_" + x["name"] + "\n")
 
 f.write("\n\n")
 f.write("typedef void (*GLWrapperFuncPtr)(void);\n\n");
@@ -158,21 +158,21 @@ f.write("#ifdef __cplusplus\n}\n#endif\n")
 
 f.write("#endif\n\n")
 
-f=open("glwrapper.c","w")
+f = open("glwrapper.c", "w")
 
 f.write("\n\n")
 f.write("#include \"glwrapper.h\"\n")
 f.write("\n\n")
 
 for x in functions:
-    f.write(x["ret"]+" GLWRP_APIENTRY (*__wrapper_"+x["name"]+")("+x["args"]+")=NULL;\n")
+    f.write(x["ret"] + " GLWRP_APIENTRY (*__wrapper_" + x["name"] + ")(" + x["args"] + ")=NULL;\n")
 
 f.write("\n\n")
 f.write("void glWrapperInit( GLWrapperFuncPtr (*wrapperFunc)(const char*) )  {\n")
 f.write("\n")
 
 for x in functions:
-    f.write("\t__wrapper_"+x["name"]+"=("+x["ret"]+" GLWRP_APIENTRY (*)("+x["args"]+"))wrapperFunc(\""+x["name"]+"\");\n")
+    f.write("\t__wrapper_" + x["name"] + "=(" + x["ret"] + " GLWRP_APIENTRY (*)(" + x["args"] + "))wrapperFunc(\"" + x["name"] + "\");\n")
 
 f.write("\n\n")
 f.write("}\n")

tools/scripts/makeargs.py

@@ -1,5 +1,5 @@
 
-text="""
+text = """
 #define FUNC$numR(m_r,m_func,$argt)\\
 	virtual m_r m_func($argtp) { \\
 		if (Thread::get_caller_ID()!=server_thread) {\\
@@ -65,21 +65,21 @@ text="""
 
 
 
-for i in range(1,8):
+for i in range(1, 8):
 
-    tp=""
-    p=""
-    t=""
+    tp = ""
+    p = ""
+    t = ""
     for j in range(i):
-        if (j>0):
-            tp+=", "
-            p+=", "
-            t+=", "
-        tp +=("m_arg"+str(j+1)+" p"+str(j+1))
-        p+=("p"+str(j+1))
-        t+=("m_arg"+str(j+1))
-
-    t = text.replace("$argtp",tp).replace("$argp",p).replace("$argt",t).replace("$num",str(i))
+        if (j > 0):
+            tp += ", "
+            p += ", "
+            t += ", "
+        tp += ("m_arg" + str(j + 1) + " p" + str(j + 1))
+        p += ("p" + str(j + 1))
+        t += ("m_arg" + str(j + 1))
+
+    t = text.replace("$argtp", tp).replace("$argp", p).replace("$argt", t).replace("$num", str(i))
     print(t)
 
 

tools/scripts/memsort.py

@@ -1,35 +1,35 @@
 
 import sys
 
-arg="memdump.txt"
+arg = "memdump.txt"
 
-if (len(sys.argv)>1):
-    arg=sys.argv[1]
+if (len(sys.argv) > 1):
+    arg = sys.argv[1]
 
-f = open(arg,"rb")
+f = open(arg, "rb")
 
 
-l=f.readline()
+l = f.readline()
 
 
 sum = {}
-cnt={}
+cnt = {}
 
 
-while(l!=""):
+while(l != ""):
 
-    s=l.split("-")
+    s = l.split("-")
     amount = int(s[1])
-    what=s[2]
+    what = s[2]
     if (what in sum):
-        sum[what]+=amount
-        cnt[what]+=1
+        sum[what] += amount
+        cnt[what] += 1
     else:
-        sum[what]=amount
-        cnt[what]=1
+        sum[what] = amount
+        cnt[what] = 1
 
-    l=f.readline()
+    l = f.readline()
 
 
 for x in sum:
-    print(x.strip()+"("+str(cnt[x])+"):\n: "+str(sum[x]))
+    print(x.strip() + "(" + str(cnt[x]) + "):\n: " + str(sum[x]))

tools/scripts/svgs_2_pngs.py

@@ -51,7 +51,7 @@ def export_icons():
         # name without extensions
         name_only = file_name.replace('.svg', '')
 
-        out_icon_names = [name_only] # export to a png with the same file name
+        out_icon_names = [name_only]  # export to a png with the same file name
         theme_out_icon_names = []
         # special cases
         if special_icons.has_key(name_only):
@@ -82,7 +82,7 @@ def export_theme():
         # name without extensions
         name_only = file_name.replace('.svg', '')
 
-        out_icon_names = [name_only] # export to a png with the same file name
+        out_icon_names = [name_only]  # export to a png with the same file name
         # special cases
         if theme_icons.has_key(name_only):
             special_icon = theme_icons[name_only]
@@ -102,30 +102,30 @@ special_icons = {
         output_names=['icon_add'],
         theme_output_names=['icon_add', 'icon_zoom_more']
     ),
-    'icon_new': dict( output_names=['icon_file'] ),
-    'icon_animation_tree_player': dict( output_names=['icon_animation_tree'] ),
+    'icon_new': dict(output_names=['icon_file']),
+    'icon_animation_tree_player': dict(output_names=['icon_animation_tree']),
     'icon_tool_rotate': dict(
         output_names=['icon_reload'],
-        theme_output_names= ['icon_reload']
+        theme_output_names=['icon_reload']
     ),
-    'icon_multi_edit': dict( output_names=['icon_multi_node_edit'] ),
+    'icon_multi_edit': dict(output_names=['icon_multi_node_edit']),
     'icon_folder': dict(
         output_names=['icon_load', 'icon_open'],
-        theme_output_names= ['icon_folder']
+        theme_output_names=['icon_folder']
     ),
-    'icon_file_list': dict( output_names=['icon_enum'] ),
-    'icon_collision_2d': dict( output_names=['icon_collision_polygon_2d', 'icon_polygon_2d'] ),
-    'icon_class_list': dict( output_names=['icon_filesystem'] ),
-    'icon_color_ramp': dict( output_names=['icon_graph_color_ramp'] ),
-    'icon_translation': dict( output_names=['icon_p_hash_translation'] ),
-    'icon_shader': dict( output_names=['icon_shader_material', 'icon_material_shader'] ),
-    'icon_canvas_item_shader_graph': dict( output_names=['icon_material_shader_graph'] ),
-
-    'icon_color_pick': dict( theme_output_names= ['icon_color_pick'], avoid_self=True ),
-    'icon_play': dict( theme_output_names= ['icon_play'] ),
-    'icon_stop': dict( theme_output_names= ['icon_stop'] ),
-    'icon_zoom_less': dict( theme_output_names= ['icon_zoom_less'], avoid_self=True ),
-    'icon_zoom_reset': dict( theme_output_names= ['icon_zoom_reset'], avoid_self=True )
+    'icon_file_list': dict(output_names=['icon_enum']),
+    'icon_collision_2d': dict(output_names=['icon_collision_polygon_2d', 'icon_polygon_2d']),
+    'icon_class_list': dict(output_names=['icon_filesystem']),
+    'icon_color_ramp': dict(output_names=['icon_graph_color_ramp']),
+    'icon_translation': dict(output_names=['icon_p_hash_translation']),
+    'icon_shader': dict(output_names=['icon_shader_material', 'icon_material_shader']),
+    'icon_canvas_item_shader_graph': dict(output_names=['icon_material_shader_graph']),
+
+    'icon_color_pick': dict(theme_output_names=['icon_color_pick'], avoid_self=True),
+    'icon_play': dict(theme_output_names=['icon_play']),
+    'icon_stop': dict(theme_output_names=['icon_stop']),
+    'icon_zoom_less': dict(theme_output_names=['icon_zoom_less'], avoid_self=True),
+    'icon_zoom_reset': dict(theme_output_names=['icon_zoom_reset'], avoid_self=True)
 }
 
 theme_icons = {

tools/translations/extract.py

@@ -78,7 +78,7 @@ for fname in matches:
                 msg += l[pos]
                 pos += 1
 
-            location = os.path.relpath(fname).replace('\\','/')
+            location = os.path.relpath(fname).replace('\\', '/')
             if (line_nb):
                 location += ":" + str(lc)
 
@@ -115,7 +115,7 @@ shutil.move("tools.pot", "tools/translations/tools.pot")
 
 # TODO: Make that in a portable way, if we care; if not, kudos to Unix users
 if (os.name == "posix"):
-    added = subprocess.check_output("git diff tools/translations/tools.pot | grep \+msgid | wc -l", shell = True)
-    removed = subprocess.check_output("git diff tools/translations/tools.pot | grep \\\-msgid | wc -l", shell = True)
+    added = subprocess.check_output("git diff tools/translations/tools.pot | grep \+msgid | wc -l", shell=True)
+    removed = subprocess.check_output("git diff tools/translations/tools.pot | grep \\\-msgid | wc -l", shell=True)
     print("\n# Template changes compared to the staged status:")
     print("#   Additions: %s msgids.\n#   Deletions: %s msgids." % (int(added), int(removed)))

version.py

@@ -1,5 +1,5 @@
-short_name="godot"
-name="Godot Engine"
-major=2
-minor=1
-status="stable"
+short_name = "godot"
+name = "Godot Engine"
+major = 2
+minor = 1
+status = "stable"