generate lua bytecode according architecture (#379)

* compile 64bit lua bytecode

* build lua bytecode according architecture

* fix compiling and remove debug codes

* remove unneeded codes

* handle default situation and use class instead of magic number

Author: minggo

plugins/plugin_compile/build_android.py

@@ -411,6 +411,58 @@ def gradle_build_apk(self, build_mode):
         cmd = '"%s" --parallel --info assemble%s' % (gradle_path, mode_str)
         self._run_cmd(cmd, cwd=self.app_android_root)
 
+    class LuaBuildType:
+        UNKNOWN = -1
+        ONLY_BUILD_64BIT = 1
+        ONLY_BUILD_32BIT = 2
+        BUILD_32BIT_AND_64BIT = 3
+
+    def _do_get_build_type(self, str):
+        # remove the '#' and the contents after it
+        str = str.split('#')[0]
+        build_64bit = str.find('arm64-v8a') != -1
+
+        # check if need to build other architecture
+        build_other_arch = False
+        other_archs = ('armeabi', 'armeabi-v7a', 'x86') # other arches are not supported
+        for arch in other_archs:
+            if str.find(arch) != -1:
+                build_other_arch = True
+                break
+
+        if build_64bit or build_other_arch:
+            if build_64bit:
+                if build_other_arch:
+                    print 'build 64bit and 32bit'
+                    return LuaBuildType.BUILD_32BIT_AND_64BIT
+                else:
+                    print 'only build 64bit'
+                    return LuaBuildType.ONLY_BUILD_64BIT
+            else:
+                print 'only build 32bit'
+                return LuaBuildType.ONLY_BUILD_32BIT
+
+        return LuaBuildType.UNKNOWN
+
+    # check if arm64-v8a is set in Application.mk
+    def _get_build_type(self, param_of_appabi):
+
+        # get build type from parameter
+        if param_of_appabi:
+            return self._do_get_build_type(param_of_appabi)
+        
+        # get build type from Application.mk
+        applicationmk_path = os.path.join(self.app_android_root, "jni/Application.mk")
+        with open(applicationmk_path) as f:
+            for line in f:
+                if line.find('APP_ABI') == -1:
+                    continue
+                build_type = self._do_get_build_type(line)
+                if build_type != LuaBuildType.UNKNOWN:
+                    return build_type
+
+        return LuaBuildType.UNKNOWN
+
     def do_build_apk(self, build_mode, no_apk, output_dir, custom_step_args, compile_obj):
         if self.use_studio:
             assets_dir = os.path.join(self.app_android_root, "app", "assets")
@@ -441,11 +493,37 @@ def do_build_apk(self, build_mode, no_apk, output_dir, custom_step_args, compile
 
         # copy resources
         self._copy_resources(custom_step_args, assets_dir)
-        
 
         # check the project config & compile the script files
         if self._project._is_lua_project():
-            compile_obj.compile_lua_scripts(assets_dir, assets_dir)
+            print "generate byte code ............"
+            src_dir = os.path.join(assets_dir, 'src')
+            build_type = self._get_build_type(compile_obj.app_abi)
+
+            # only build 64bit
+            if build_type == LuaBuildType.ONLY_BUILD_64BIT:
+                dst_dir = os.path.join(assets_dir, 'src/64bit')
+                compile_obj.compile_lua_scripts(src_dir, dst_dir, True)
+                # remove unneeded lua files
+                compile_obj._remove_file_with_ext(src_dir, '.lua')
+                shutil.rmtree(os.path.join(src_dir, 'cocos'))
+
+            # only build 32bit
+            if build_type == LuaBuildType.ONLY_BUILD_32BIT:
+                # build 32-bit bytecode
+                compile_obj.compile_lua_scripts(src_dir, src_dir, False)
+            
+            # build 32bit and 64bit
+            if build_type == LuaBuildType.BUILD_32BIT_AND_64BIT:
+                # build 64-bit bytecode
+                dst_dir = os.path.join(assets_dir, 'src/64bit')
+                compile_obj.compile_lua_scripts(src_dir, dst_dir, True)
+                # build 32-bit bytecode
+                compile_obj.compile_lua_scripts(src_dir, src_dir, False)
+
+            if build_type == LuaBuildType.UNKNOWN:
+                # haven't set APP_ABI in parameter and Application.mk, default build 32bit
+                compile_obj.compile_lua_scripts(src_dir, src_dir, False)
 
         if self._project._is_js_project():
             compile_obj.compile_js_scripts(assets_dir, assets_dir)

plugins/plugin_compile/project_compile.py

@@ -359,23 +359,23 @@ def _remove_file_with_ext(self, work_dir, ext):
                 if cur_ext == ext:
                     os.remove(full_path)
 
-    def compile_lua_scripts(self, src_dir, dst_dir, need_compile=None):
+    def compile_lua_scripts(self, src_dir, dst_dir, build_64):
         if not self._project._is_lua_project():
             return
 
-        if need_compile is None:
-            need_compile = self._compile_script
-
-        if not need_compile and not self._lua_encrypt:
+        if not self._compile_script and not self._lua_encrypt:
             return
 
         cocos_cmd_path = os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "cocos")
         rm_ext = ".lua"
         compile_cmd = "\"%s\" luacompile -s \"%s\" -d \"%s\"" % (cocos_cmd_path, src_dir, dst_dir)
 
-        if not need_compile:
+        if not self._compile_script:
             compile_cmd = "%s --disable-compile" % compile_cmd
 
+        if build_64:
+            compile_cmd = "%s --bytecode-64bit" % compile_cmd
+
         if self._lua_encrypt:
             add_para = ""
             if self._lua_encrypt_key is not None:
@@ -708,12 +708,15 @@ def build_ios(self):
                     self.compile_js_scripts(engine_js_dir, engine_js_dir)
                 need_reset_dir = True
 
-            if self._project._is_lua_project() and self._lua_encrypt:
-                # on iOS, only invoke luacompile when lua encrypt is specified
+            if self._project._is_lua_project():
                 self.backup_dir(script_src_dir)
+                # create 64-bit folder and build 64-bit bytecode
+                # should build 64-bit first because `script_src_dir` will be deleted when building 32-bit bytecode 
+                folder_64bit = os.path.join(script_src_dir, '64bit')
+                self.compile_lua_scripts(script_src_dir, folder_64bit, True)
+                # build 32-bit bytecode
                 self.compile_lua_scripts(script_src_dir, script_src_dir, False)
                 need_reset_dir = True
-
         try:
             cocos.Logging.info(MultiLanguage.get_string('COMPILE_INFO_BUILDING'))
 
@@ -845,10 +848,11 @@ def build_mac(self):
                     self.compile_js_scripts(engine_js_dir, engine_js_dir)
                 need_reset_dir = True
 
-            if self._project._is_lua_project() and (self._lua_encrypt or self._compile_script):
-                # on iOS, only invoke luacompile when lua encrypt is specified
+            if self._project._is_lua_project():
                 self.backup_dir(script_src_dir)
-                self.compile_lua_scripts(script_src_dir, script_src_dir)
+                # mac only support 64-bit bytecode
+                folder_64bit = os.path.join(script_src_dir, '64bit')
+                self.compile_lua_scripts(script_src_dir, folder_64bit, True)
                 need_reset_dir = True
 
         try:
@@ -1180,7 +1184,8 @@ def build_win32(self):
             self.compile_js_scripts(output_dir, output_dir)
 
         if self._project._is_lua_project():
-            self.compile_lua_scripts(output_dir, output_dir)
+            # windows only support 32-bit bytecode
+            self.compile_lua_scripts(output_dir, output_dir, False)
 
         self.run_root = output_dir