Grant privileges to create table to dbUser

.gitignore

@@ -15,3 +15,6 @@ tests/puppeteer/package.json
 tests/puppeteer/package-lock.json
 scripts/sdkjs_common/jsdoc/node_modules
 scripts/sdkjs_common/jsdoc/package-lock.json
+tools/linux/python3/
+tools/linux/python3.tar.gz
+tools/linux/sysroot/sysroot_ubuntu_1604

README.md

@@ -1,218 +1,221 @@
-<h1>ONLYOFFICE Build Tools</h1>
+# build_tools
 
-Welcome to the ```build_tools``` repository! This powerful toolkit simplifies the process of compiling [ONLYOFFICE](https://github.com/ONLYOFFICE) products from source on Linux.
+## Overview
 
-It automatically fetches all the required dependencies and source code to build the latest versions of:
+**build_tools** allow you to automatically get and install all the components
+necessary for the compilation process, all the dependencies required for the
+**ONLYOFFICE Document Server**, **Document Builder** and **Desktop Editors**
+ correct work, as well as to get the latest version of
+**ONLYOFFICE products** source code and build all their components.
 
-* [Docs (Document Server)](https://www.onlyoffice.com/docs?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools)  
-* [Desktop Editors](https://www.onlyoffice.com/desktop?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools)  
-* [Document Builder](https://www.onlyoffice.com/document-builder?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools)
+**Important!**  We can only guarantee the correct work of the products built
+from the `master` branch.
 
-**A quick note:** For the most stable and reliable builds, we strongly recommend compiling from the ```master``` branch of this repository.
+## How to use - Linux
 
-## **How do I use it on Linux? 🐧**
+**Note**: The solution has been tested on **Ubuntu 16.04**.
 
->This guide has been tested and verified on **Ubuntu 16.04**.
+### Installing dependencies
 
-### **Step 1: Install dependencies**
-
-First, let's make sure you have **Python** installed, as it's needed to run the build scripts.
+You might need to install **Python**, depending on your version of Ubuntu:
 
 ```bash
 sudo apt-get install -y python
 ```
 
-### **Step 2: Build the source code**
+### Building ONLYOFFICE products source code
 
-Now, you're ready to build the ONLYOFFICE products.
+1. Clone the build_tools repository:
 
-1. **Clone the build_tools repository:**  
-
-    This command downloads the build tools to your machine using Git:
-   ```bash
-   git clone https://github.com/ONLYOFFICE/build_tools.git
-   ```
-
-2. **Navigate to the scripts directory:**  
-   ```bash
-   cd build_tools/tools/linux
-   ```
-3. **Run the automation script:**  
-   
-   This is where the magic happens! Running the script without any options will build all three products: Document Server, Document Builder, and Desktop Editors.  
-
-   ```bash
-   ./automate.py
-   ```
-You can also build ONLYOFFICE products separately. Just run the script with the parameter corresponding to the necessary product. For example, to build *Desktop Editors* and *Document Server*
-  ```bash
-   ./automate.py desktop server
-   ```
-
-**Perfect!** Once the script finishes, you will find the compiled products in the ```./out``` directory.
-
-## **Advanced options & different workflows 🚀**
-
-### **How to use Docker**
-
-If you prefer using Docker, you can build all products inside a container. This is a great way to keep your local system clean.
-
-1. **Create an output directory:**  
-
-   ```bash
-   mkdir out
+    ```bash
+    git clone https://github.com/ONLYOFFICE/build_tools.git
     ```
 
-2. **Build the Docker image:**  
+2. Go to the `build_tools/tools/linux` directory:
 
-   ```bash
-   docker build --tag onlyoffice-document-editors-builder .
-   ```
-
-3. **Run the container to start the build:** 
-   
-   This command mounts your local out directory into the container, so the final build files will appear on your machine. 
-
-   ```bash 
-   docker run -v $PWD/out:/build_tools/out onlyoffice-document-editors-builder
+    ```bash
+    cd build_tools/tools/linux
     ```
 
-You've done it! The results will be in the ```./out``` directory you created.
+3. Run the `automate.py` script:
 
-## **How to build and run the products separately ▶️**
+    ```bash
+    ./automate.py
+    ```
 
-Don't need everything? You can save time by building only the products you need. Just add the product name as an argument to the script.
+If you run the script without any parameters this allows to build **ONLYOFFICE
+Document Server**, **Document Builder** and **Desktop Editors**.
 
-### Need just the [Document Builder](https://github.com/ONLYOFFICE/DocumentBuilder)❓
-* How to build
+The result will be available in the `./out` directory.
 
-  ```bash
-  ./automate.py builder
-  ```
-* How to run
-  ```bash
-  cd ../../out/linux_64/onlyoffice/documentbuilder
-  ./docbuilder
-  ```
+To build **ONLYOFFICE** products separately run the script with the parameter
+corresponding to the necessary product.
 
-### Need just the [Desktop Editors](https://github.com/ONLYOFFICE/DesktopEditors)❓
+It’s also possible to build several products at once as shown in the example
+below.
 
-* How to build
-  ```bash
-  ./automate.py desktop
-  ```
-* How to run
-  ```bash
-  cd ../../out/linux_64/onlyoffice/desktopeditors
-  LD_LIBRARY_PATH=./ ./DesktopEditors
-  ```
-
-### Need just the [Docs (Document Server)](https://github.com/ONLYOFFICE/DocumentServer)❓
-* How to build
-  ```bash
-  ./automate.py server
-  ```
-* How to run
-
-  Running the Document Server is a multi-step process because it relies on a few background services. Let's break it down step by step. 
-
-#### **Step 1. Set up dependencies**
-
-The Document Server needs a few things to run correctly:
-
-* **NGINX**: Acts as a web server to handle requests.  
-* **PostgreSQL**: Used as the database to store information.  
-* **RabbitMQ**: A message broker that helps different parts of the server communicate.
-
-Here are the commands to install and configure them.
-
-#### **Install and configure NGINX**
-
-1. Install NGINX  
-```bash
-sudo apt-get install nginx
-```
-2. Disable the default NGINX site
-```bash
-sudo rm -f /etc/nginx/sites-enabled/default
-```
-3. Set up the new website. To do that create the ```/etc/nginx/sites-available/onlyoffice-documentserver``` file with the following contents:
+**Example**: Building **Desktop Editors** and **Document Server**
 
 ```bash
-map $http_host $this_host {
-  "" $host;
-  default $http_host;
-}
-map $http_x_forwarded_proto $the_scheme {
-  default $http_x_forwarded_proto;
-  "" $scheme;
-}
-map $http_x_forwarded_host $the_host {
-  default $http_x_forwarded_host;
-  "" $this_host;
-}
-map $http_upgrade $proxy_connection {
-  default upgrade;
-  "" close;
-}
-proxy_set_header Host $http_host;
-proxy_set_header Upgrade $http_upgrade;
-proxy_set_header Connection $proxy_connection;
-proxy_set_header X-Forwarded-Host $the_host;
-proxy_set_header X-Forwarded-Proto $the_scheme;
-server {
-  listen 0.0.0.0:80;
-  listen [::]:80 default_server;
-  server_tokens off;
-  rewrite ^\/OfficeWeb(\/apps\/.*)$ /web-apps$1 redirect;
-  location / {
-    proxy_pass http://localhost:8000;
-    proxy_http_version 1.1;
-  }
-}
+./automate.py desktop server
 ```
 
-4. Enable the new site by creating a symbolic link  
-```bash
-sudo ln -s /etc/nginx/sites-available/onlyoffice-documentserver /etc/nginx/sites-enabled/onlyoffice-documentserver
-```
-5. Restart NGINX to apply the changes  
-```bash
-sudo nginx -s reload
-```
-#### **Install and configure PostgreSQL**
+### Using Docker
+
+You can also build all **ONLYOFFICE products** at once using Docker.
+Build the `onlyoffice-document-editors-builder` Docker image using the
+provided `Dockerfile` and run the corresponding Docker container.
+
+```bash
+mkdir out
+docker build --tag onlyoffice-document-editors-builder .
+docker run -v $PWD/out:/build_tools/out onlyoffice-document-editors-builder
+```
+
+The result will be available in the `./out` directory.
+
+### Building and running ONLYOFFICE products separately
+
+#### Document Builder
+
+##### Building Document Builder
+
+```bash
+./automate.py builder
+```
+
+##### Running Document Builder
+
+```bash
+cd ../../out/linux_64/onlyoffice/documentbuilder
+./docbuilder
+```
+
+#### Desktop Editors
+
+##### Building Desktop Editors
+
+```bash
+./automate.py desktop
+```
+
+##### Running Desktop Editors
+
+```bash
+cd ../../out/linux_64/onlyoffice/desktopeditors
+LD_LIBRARY_PATH=./ ./DesktopEditors
+```
+
+#### Document Server
+
+##### Building Document Server
+
+```bash
+./automate.py server
+```
+
+##### Installing and configuring Document Server dependencies
+
+**Document Server** uses **NGINX** as a web server and **PostgreSQL** as a database.
+**RabbitMQ** is also required for **Document Server** to work correctly.
+
+###### Installing and configuring NGINX
+
+1. Install NGINX:
+
+    ```bash
+    sudo apt-get install nginx
+    ```
+
+2. Disable the default website:
+
+    ```bash
+    sudo rm -f /etc/nginx/sites-enabled/default
+    ```
+
+3. Set up the new website. To do that create the `/etc/nginx/sites-available/onlyoffice-documentserver`
+   file with the following contents:
+
+    ```bash
+    map $http_host $this_host {
+      "" $host;
+      default $http_host;
+    }
+    map $http_x_forwarded_proto $the_scheme {
+      default $http_x_forwarded_proto;
+      "" $scheme;
+    }
+    map $http_x_forwarded_host $the_host {
+      default $http_x_forwarded_host;
+      "" $this_host;
+    }
+    map $http_upgrade $proxy_connection {
+      default upgrade;
+      "" close;
+    }
+    proxy_set_header Host $http_host;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection $proxy_connection;
+    proxy_set_header X-Forwarded-Host $the_host;
+    proxy_set_header X-Forwarded-Proto $the_scheme;
+    server {
+      listen 0.0.0.0:80;
+      listen [::]:80 default_server;
+      server_tokens off;
+      rewrite ^\/OfficeWeb(\/apps\/.*)$ /web-apps$1 redirect;
+      location / {
+        proxy_pass http://localhost:8000;
+        proxy_http_version 1.1;
+      }
+    }
+    ```
+
+4. Add the symlink to the newly created website to the
+   `/etc/nginx/sites-available` directory:
+
+    ```bash
+    sudo ln -s /etc/nginx/sites-available/onlyoffice-documentserver /etc/nginx/sites-enabled/onlyoffice-documentserver
+    ```
+
+5. Restart NGINX to apply the changes:
+
+    ```bash
+    sudo nginx -s reload
+    ```
+
+###### Installing and configuring PostgreSQL
+
+1. Install PostgreSQL:
 
-1. Install PostgreSQL  
     ```bash
     sudo apt-get install postgresql
     ```
 
-2. Create a database and user. 
+2. Create the PostgreSQL database and user:
+
+    **Note**: The created database must have **onlyoffice** both for user and password.
 
-    **Note**: The user and password must both be **'onlyoffice'.**  
     ```bash
     sudo -i -u postgres psql -c "CREATE USER onlyoffice WITH PASSWORD 'onlyoffice';"
     sudo -i -u postgres psql -c "CREATE DATABASE onlyoffice OWNER onlyoffice;"
     ```
 
-3. Configure the database:  
+3. Configure the database:
+
     ```bash
     psql -hlocalhost -Uonlyoffice -d onlyoffice -f ../../out/linux_64/onlyoffice/documentserver/server/schema/postgresql/createdb.sql
     ```
 
-Upon that, you will be asked to provide a password for the onlyoffice PostgreSQL user. Please enter the **onlyoffice** password.
+**Note**: Upon that, you will be asked to provide a password for the **onlyoffice**
+PostgreSQL user. Please enter the **onlyoffice** password.
+
+###### Installing RabbitMQ
 
-#### **Install RabbitMQ**
 ```bash
 sudo apt-get install rabbitmq-server
 ```
 
-Now that you have all the dependencies installed, it's time to generate server files. 
-#### **Step 2. Generate server files**
-
-Before running the server, you need to generate font and theme data.
-
-##### **Generate fonts data**
+###### Generate fonts data
 
 ```bash
 cd out/linux_64/onlyoffice/documentserver/
@@ -227,7 +230,8 @@ LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allfontsgen \
   --use-system="true"
 ```
 
-##### **Generate presentation themes**
+###### Generate presentation themes
+
 ```bash
 cd out/linux_64/onlyoffice/documentserver/
 LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allthemesgen \
@@ -236,39 +240,27 @@ LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allthemesgen \
   --output="${PWD}/sdkjs/common/Images"
 ```
 
-#### **Step 3. Run the Document Server services**
+##### Running Document Server
 
-All Document Server components run as foreground processes. Thus you need separate terminal consoles to run them or specific tools which will allow to run foreground processes in background mode.
+**Note**: All **Document Server** components run as foreground processes. Thus
+you need separate terminal consoles to run them or specific tools which will
+allow to run foreground processes in background mode.
 
-* **Start the FileConverter service:**  
-  ```bash
-  cd out/linux_64/onlyoffice/documentserver/server/FileConverter
-  LD_LIBRARY_PATH=$PWD/bin \
-  NODE_ENV=development-linux \
-  NODE_CONFIG_DIR=$PWD/../Common/config \
-  ./converter
-  ```
+1. Start the **FileConverter** service:
 
-* **Start the DocService service:**  
-  ```bash
-  cd out/linux_64/onlyoffice/documentserver/server/DocService
-  NODE_ENV=development-linux \
-  NODE_CONFIG_DIR=$PWD/../Common/config \
-  ./docservice
-  ```
+    ```bash
+    cd out/linux_64/onlyoffice/documentserver/server/FileConverter
+    LD_LIBRARY_PATH=$PWD/bin \
+    NODE_ENV=development-linux \
+    NODE_CONFIG_DIR=$PWD/../Common/config \
+    ./converter
+    ```
 
-## And it's a wrap!  🎉
-Congratulations! You have successfully used the ```build_tools``` to compile your desired ONLYOFFICE products from the latest source code. 
+2. Start the **DocService** service:
 
-Everything is now set up. You can go ahead and run your brand-new, self-compiled ONLYOFFICE applications. 
-
-## Need help or have an idea? 💡
-
-* **🐞 Found a bug?** Please report it by creating an [issue](https://github.com/ONLYOFFICE/build_tools/issues).
-* **❓ Have a question?** Ask our community and developers on the [ONLYOFFICE Forum](https://community.onlyoffice.com).
-* **💡 Want to suggest a feature?** Share your ideas on our [feedback platform](https://feedback.onlyoffice.com/forums/966080-your-voice-matters).
-* **🧑‍💻 Need help for developers?** Check our [API documentation](https://api.onlyoffice.com/?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools).
-
----
-
-<p align="center"> Made with ❤️ by the ONLYOFFICE Team </p>
+    ```bash
+    cd out/linux_64/onlyoffice/documentserver/server/DocService
+    NODE_ENV=development-linux \
+    NODE_CONFIG_DIR=$PWD/../Common/config \
+    ./docservice
+    ```

linux-start.sh

@@ -1,66 +0,0 @@
-sudo apt-get install git curl wget p7zip-full
-
-sudo apt-get install git-lfs
-# for old system (ubuntu 16)
-#curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
-#sudo apt-get install git-lfs
-
-# save login
-git config --global credential.helper store
-
-# clone build_tools
-git clone https://git.onlyoffice.com/ONLYOFFICE/build_tools.git
-
-# deps =========================================
-
-cd ./build_tools/tools/linux
-
-# python 3.10
-./python.sh
-
-# qt
-#./python3/bin/python3 ./qt_binary_fetch.py amd64
-#./python3/bin/python3 ./qt_binary_fetch.py arm64
-./python3/bin/python3 ./qt_binary_fetch.py all
-
-# deps
-./python3/bin/python3 ./deps.py
-
-# cmake 3.30
-sudo ./cmake.sh
-
-cd ../../
-
-# ==============================================
-
-# sysroots (IF NEEDED) =========================
-
-cd ./build_tools/tools/linux/sysroot
-#./python3/bin/python3 ./fetch.py amd64
-#./python3/bin/python3 ./fetch.py arm64
-./../python3/bin/python3 ./fetch.py all
-cd ../../../
-
-# ==============================================
-
-
-# configure ====================================
-
-./tools/linux/python3/bin/python3 ./configure.py --clean "0" --update-light "1" --update "1" --branch "hotfix/v9.2.1" --module "desktop" --qt-dir "$(pwd)/tools/linux/qt_build/Qt-5.9.9"
-
-# with sysroot: sysroot "1"
-
-# ==============================================
-
-# cross build linux_arm64
-sudo apt install qemu-user qemu-user-static binfmt-support
-sudo update-binfmts --enable qemu-aarch64
-
-# 1) without sysroot
-#sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
-#sudo dpkg --add-architecture arm64
-#sudo apt update
-#... install all dev packages ...
-
-# 2) official supported: with sysroot
-./tools/linux/python3/bin/python3 ./configure.py sysroot "1" #...

scripts/base.py

@@ -37,11 +37,9 @@ def is_os_64bit():
   return platform.machine().endswith('64')
 
 def is_os_arm():
-  if -1 != platform.machine().lower().find('arm'):
-    return True
-  if -1 != platform.machine().lower().find('aarch64'):
-    return True
-  return False
+  if -1 == platform.machine().find('arm'):
+    return False
+  return True
 
 def get_platform():
   return platform.machine().lower()
@@ -256,10 +254,7 @@ def delete_dir(path):
     shutil.rmtree(get_path(path), ignore_errors=True)
   return
 
-def copy_lib(src_folder, dst, name, subdir=""):
-  src = src_folder
-  if subdir != "":
-    src += ("/" + subdir)
+def copy_lib(src, dst, name):
   if (config.check_option("config", "bundle_dylibs")) and is_dir(src + "/" + name + ".framework"):
     copy_dir(src + "/" + name + ".framework", dst + "/" + name + ".framework", symlinks=True)
 
@@ -436,46 +431,11 @@ def cmd_in_dir(directory, prog, args=[], is_no_errors=False):
   return ret
 
 def cmd_in_dir_qemu(platform, directory, prog, args=[], is_no_errors=False):
-  platform_config = {
-    "linux_arm64": {
-      "qemu": "qemu-aarch64",
-      "default_libs": "/usr/aarch64-linux-gnu"
-    },
-    "linux_arm32": {
-      "qemu": "qemu-arm",
-      "default_libs": "/usr/arm-linux-gnueabi"
-    }
-  }
-
-  if platform not in platform_config:
-    return 0
-
-  libs_path = platform_config[platform]["default_libs"]
-  if config.option("sysroot") != "":
-    libs_path = config.option("sysroot_" + platform)
-
-  return cmd_in_dir(directory, platform_config[platform]["qemu"], ["-L", libs_path, prog] + args, is_no_errors)
-
-def create_qemu_wrapper(binary_path, platform):
-  binary_dir = os.path.dirname(binary_path)
-  binary_name = os.path.basename(binary_path)
-  binary_bin = binary_path + '.bin'
-  sysroot = config.option("sysroot_" + platform)
-
-  if os.path.exists(binary_path):
-    os.rename(binary_path, binary_bin)
-
-  wrapper_content = f'''#!/bin/bash
-DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
-export QEMU_LD_PREFIX={sysroot}
-exec qemu-aarch64 -L {sysroot} "$DIR/{binary_name}.bin" "$@"
-'''
-
-  with open(binary_path, 'w') as f:
-    f.write(wrapper_content)
-
-  os.chmod(binary_path, 0o755)
-  return binary_bin
+  if (platform == "linux_arm64"):
+    return cmd_in_dir(directory, "qemu-aarch64", ["-L", "/usr/aarch64-linux-gnu", prog] + args, is_no_errors)
+  if (platform == "linux_arm32"):
+    return cmd_in_dir(directory, "qemu-arm", ["-L", "/usr/arm-linux-gnueabi", prog] + args, is_no_errors)
+  return 0
 
 def cmd_and_return_cwd(prog, args=[], is_no_errors=False):
   cur_dir = os.getcwd()
@@ -659,7 +619,6 @@ def get_repositories():
     result.update(get_server_addons())
     result["document-server-integration"] = [False, False]
     result["document-templates"] = [False, False]
-    result["document-formats"] = [False, False]
 
   get_branding_repositories(result)
   return result
@@ -730,25 +689,18 @@ def git_dir():
   if ("windows" == host_platform()):
     return run_command("git --info-path")['stdout'] + "/../../.."
 
-def get_compiler_gcc_prefix(platform):
-  directory = "/usr/bin"
-
-  if config.option("sysroot") != "":
-    use_platform = platform
-    if ("linux_arm64" == platform and not is_os_arm()):
-      use_platform = "linux_64"
-    directory = config.option("sysroot_" + use_platform) + "/usr/bin"
-
-  if ("linux_arm64" == platform and not is_os_arm()):
-    return directory + "/aarch64-linux-gnu-"
-
-  return directory + "/"
+def get_prefix_cross_compiler_arm64():
+  cross_compiler_arm64 = config.option("arm64-toolchain-bin")
+  if is_file(cross_compiler_arm64 + "/aarch64-linux-gnu-g++") and is_file(cross_compiler_arm64 + "/aarch64-linux-gnu-gcc"):
+    return "aarch64-linux-gnu-"
+  if is_file(cross_compiler_arm64 + "/aarch64-unknown-linux-gnu-g++") and is_file(cross_compiler_arm64 + "/aarch64-unknown-linux-gnu-gcc"):
+    return "aarch64-unknown-linux-gnu-"
+  return ""
 
 def get_gcc_version():
-  # if use sysroot - fix gcc version
-  if config.option("sysroot") != "":
-    return 5004
   gcc_path = "gcc"
+  if config.option("sysroot") != "":
+    gcc_path = config.option("sysroot") + "/usr/bin/gcc"
   gcc_version_major = 4
   gcc_version_minor = 0
   gcc_version_str = run_command(gcc_path + " -dumpfullversion -dumpversion")['stdout']
@@ -798,6 +750,13 @@ def qt_setup(platform):
       set_env("QT_QMAKE_ADDON", "-spec win32-arm64-msvc2017")
 
   set_env("QT_DEPLOY", qt_dir + "/bin")
+
+  if ("linux_arm64" == platform):
+    cross_compiler_arm64 = config.option("arm64-toolchain-bin")
+    if ("" != cross_compiler_arm64):
+      set_env("ARM64_TOOLCHAIN_BIN", cross_compiler_arm64)
+      set_env("ARM64_TOOLCHAIN_BIN_PREFIX", get_prefix_cross_compiler_arm64())
+
   return qt_dir
 
 def qt_version():
@@ -938,34 +897,29 @@ def qt_copy_lib(lib, dir):
 def _check_icu_common(dir, out):
   isExist = False
   for file in glob.glob(dir + "/libicu*"):
-    # Skip static libraries
-    if not file.endswith('.a'):
-      isExist = True
-      break
+    isExist = True
+    break
+
   if isExist:
-    # Copy only shared libraries (skip .a files)
-    for pattern in ["/libicui18n*", "/libicuuc*", "/libicudata*"]:
-      for file in glob.glob(dir + pattern):
-        if not file.endswith('.a'):
-          copy_file(file, out)
+    copy_files(dir + "/libicui18n*", out)
+    copy_files(dir + "/libicuuc*", out)
+    copy_files(dir + "/libicudata*", out)
+
   return isExist
 
-def qt_copy_icu(out, platform):
+def qt_copy_icu(out):
   tests = [get_env("QT_DEPLOY") + "/../lib"]
   prefix = ""
   postfixes = [""]
 
-  if config.option("sysroot_" + platform) != "":
-    prefix = config.option("sysroot_" + platform)
+  # TODO add for linux arm desktop build
+  if config.option("sysroot") != "":
+    prefix = config.option("sysroot")
   else:
     prefix = ""
-
-  if ("linux_64" == platform):
-    postfixes += ["/x86_64-linux-gnu"]
-  elif ("linux_arm64" == platform):
-    postfixes += ["/aarch64-linux-gnu"]
-  elif ("linux_32" == platform):
-    postfixes += ["/i386-linux-gnu"]
+    
+  postfixes += ["/x86_64-linux-gnu"]
+  postfixes += ["/i386-linux-gnu"]
 
   for postfix in postfixes:
     tests += [prefix + "/lib" + postfix]
@@ -1365,10 +1319,7 @@ def mac_change_rpath_library(lib_name, old, new):
 
 def mac_correct_rpath_binary(path, libs):
   # if framework are built, instead of correcting lib paths add `@loader_path` to rpaths with `mac_add_loader_path_to_rpath()`
-  try:
-    if config.check_option("config", "bundle_dylibs"):
-      return
-  except:
+  if config.check_option("config", "bundle_dylibs"):
     return
 
   for lib in libs:
@@ -1398,9 +1349,7 @@ def mac_correct_rpath_x2t(dir):
   mac_correct_rpath_library("OFDFile", ["UnicodeConverter", "kernel", "graphics", "PdfFile"])
   mac_correct_rpath_library("DocxRenderer", ["UnicodeConverter", "kernel", "graphics"])
   mac_correct_rpath_library("IWorkFile", ["UnicodeConverter", "kernel"])
-  mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics", "StarMathConverter"])
-  mac_correct_rpath_library("StarMathConverter", ["kernel"])
-  mac_correct_rpath_library("ooxmlsignature", ["kernel"])
+  mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics"])
 
   def correct_core_executable(name, libs):
     cmd("chmod", ["-v", "+x", name])
@@ -1408,7 +1357,7 @@ def mac_correct_rpath_x2t(dir):
     mac_correct_rpath_binary(name, mac_icu_libs + libs)
     return
 
-  correct_core_executable("x2t", ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile", "StarMathConverter", "ooxmlsignature"])
+  correct_core_executable("x2t", ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile"])
   if is_file("./allfontsgen"):
     correct_core_executable("allfontsgen", ["UnicodeConverter", "kernel", "graphics"])
   if is_file("./allthemesgen"):
@@ -1641,12 +1590,6 @@ def hack_xcode_ios():
     file.write(filedata)
   return
 
-def find_ios_sdk(sdk_name):
-  return run_command("xcrun --sdk " + sdk_name + " --show-sdk-path")['stdout']
-
-def find_xcode_toolchain(sdk_name):
-  return run_command("xcrun --sdk " + sdk_name + " --show-toolchain-path")['stdout']
-
 def find_mac_sdk_version():
   sdk_dir = run_command("xcode-select -print-path")['stdout']
   sdk_dir = os.path.join(sdk_dir, "Platforms/MacOSX.platform/Developer/SDKs")
@@ -1721,9 +1664,6 @@ def replaceFileLicence(path, license):
 def copy_v8_files(core_dir, deploy_dir, platform, is_xp=False):
   if (-1 != config.option("config").find("use_javascript_core")):
     return
-  if (0 == platform.find("mac")) and not (config.check_option("config", "use_v8")):
-    return
-
   directory_v8 = core_dir + "/Common/3dParty"
 
   if is_xp:
@@ -1947,38 +1887,25 @@ def check_module_version(actual_version, clear_func):
   clear_func()
   return
 
-def set_sysroot_env(platform):
+
+def set_sysroot_env():
   global ENV_BEFORE_SYSROOT
   ENV_BEFORE_SYSROOT = dict(os.environ)
-
-  if "linux" != host_platform():
-    return
-  if config.option("sysroot") == "":
-    return
-
-  path = config.option("sysroot_" + platform)
-  sysroot_path_bin = config.get_custom_sysroot_bin(platform)
-  compiler_gcc_prefix = get_compiler_gcc_prefix(platform)
-
-  os.environ['PATH'] = sysroot_path_bin + ":" + get_env("PATH")
-  os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib(platform)
-
-  os.environ['CC'] = compiler_gcc_prefix + "gcc"
-  os.environ['CXX'] = compiler_gcc_prefix + "g++"
-  os.environ['AR'] = compiler_gcc_prefix + "ar"
-  os.environ['RANLIB'] = compiler_gcc_prefix + "ranlib"
-
-  os.environ['CFLAGS'] = "--sysroot=" + path
-  os.environ['CXXFLAGS'] = "--sysroot=" + path
-  os.environ['LDFLAGS'] = "--sysroot=" + path
-
-  check_python()
-  return
-
+  if "linux" == host_platform() and config.option("sysroot") != "":
+    os.environ['PATH'] = config.option("sysroot") + "/usr/bin:" + get_env("PATH")
+    os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
+    os.environ['QMAKE_CUSTOM_SYSROOT'] = config.option("sysroot")
+    os.environ['PKG_CONFIG_PATH'] = config.get_custom_sysroot_lib() + "/pkgconfig"
+    os.environ['CC'] = config.get_custom_sysroot_bin() + "/gcc"
+    os.environ['CXX'] = config.get_custom_sysroot_bin() + "/g++"
+    os.environ['CFLAGS'] = "--sysroot=" + config.option("sysroot")
+    os.environ['CXXFLAGS'] = "--sysroot=" + config.option("sysroot")
+    check_python()
+    
 def restore_sysroot_env():
   os.environ.clear()
   os.environ.update(ENV_BEFORE_SYSROOT)
-
+    
 def check_python():
   if ("linux" != host_platform()):
     return
@@ -1987,9 +1914,8 @@ def check_python():
 
   if not is_dir(directory + "/python3"):
     download('https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/python3.tar.gz', directory + "/python3.tar.gz")
-    download('https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/extract.sh', directory + "/extract.sh")
-    cmd_in_dir(directory, "chmod", ["+x", "./extract.sh"])
-    cmd_in_dir(directory, "./extract.sh")
+    cmd("tar", ["xfz", directory + "/python3.tar.gz", "-C", directory])
+    cmd("ln", ["-s", directory_bin + "/python3", directory_bin + "/python"])
   directory_bin = directory_bin.replace(" ", "\\ ")
   os.environ["PATH"] = directory_bin + os.pathsep + os.environ["PATH"]
   return
@@ -2067,7 +1993,7 @@ def create_artifacts_qemu_win_arm():
   if config.option("qemu-win-arm64-dir") == "":
     print("For deploying win_arm64 on non arm host you should provide qemu-win-arm64-dir. More info in tools/win/qemu/README.md")
     return
-
+    
   old_curr_dir = os.path.abspath(os.curdir)
   qemu_dir = os.path.abspath(config.option("qemu-win-arm64-dir"))
 
@@ -2082,7 +2008,7 @@ def create_x2t_js_cache(dir, product, platform):
     doctrenderer_lib = "libdoctrenderer.dylib" if is_file(dir + "/libdoctrenderer.dylib") else "doctrenderer.framework/doctrenderer"
     if os.path.getsize(dir + "/" + doctrenderer_lib) < 5*1024*1024:
       return
-
+  
   if ((platform == "linux_arm64") and not is_os_arm()):
     cmd_in_dir_qemu(platform, dir, "./x2t", ["-create-js-snapshots"], True)
     return

scripts/build_server.py

@@ -11,7 +11,6 @@ def make():
 
   git_dir = base.get_script_dir() + "/../.."
   server_dir = base.get_script_dir() + "/../../server"
-  server_admin_panel_dir = base.get_script_dir() + "/../../server-admin-panel"
   branding_dir = server_dir + "/branding"
 
   if("" != config.option("branding")):
@@ -50,11 +49,10 @@ def make():
   if ("windows" == base.host_platform()):
     pkg_target += "-win"
 
-  base.cmd_in_dir(server_dir + "/DocService", "pkg", [".", "-t", pkg_target, "--options", "max_old_space_size=6144", "-o", "docservice"])
+  base.cmd_in_dir(server_dir + "/DocService", "pkg", [".", "-t", pkg_target, "--options", "max_old_space_size=4096", "-o", "docservice"])
   base.cmd_in_dir(server_dir + "/FileConverter", "pkg", [".", "-t", pkg_target, "-o", "converter"])
   base.cmd_in_dir(server_dir + "/Metrics", "pkg", [".", "-t", pkg_target, "-o", "metrics"])
-  if "server-admin-panel" in base.get_server_addons() and base.is_exist(server_admin_panel_dir):
-    base.cmd_in_dir(server_admin_panel_dir + "/server", "pkg", [".", "-t", pkg_target, "-o", "adminpanel"])
+  base.cmd_in_dir(server_dir + "/AdminPanel/server", "pkg", [".", "-t", pkg_target, "-o", "adminpanel"])
 
   example_dir = base.get_script_dir() + "/../../document-server-integration/web/documentserver-example/nodejs"
   base.delete_dir(example_dir  + "/node_modules")

scripts/config.py

@@ -63,6 +63,12 @@ def parse():
       if not check_option("platform", "win_64"):
         options["platform"] = "win_64 " + options["platform"]
 
+  if ("linux" == host_platform) and check_option("platform", "linux_arm64") and not base.is_os_arm():
+    if not check_option("platform", "linux_64"):
+      # linux_64 binaries need only for desktop
+      if check_option("module", "desktop"):
+        options["platform"] = "linux_64 " + options["platform"]
+
   if check_option("platform", "xp") and ("windows" == host_platform):
     options["platform"] += " win_64_xp win_32_xp"
 
@@ -87,17 +93,17 @@ def parse():
       options["sysroot"] = ""
     elif options["sysroot"] == "1":
       dst_dir = os.path.abspath(base.get_script_dir(__file__) + '/../tools/linux/sysroot')
-      dst_dir_amd64 = dst_dir + "/ubuntu16-amd64-sysroot"
-      dst_dir_arm64 = dst_dir + "/ubuntu16-arm64-sysroot"
-      if not base.is_dir(dst_dir_amd64) or not base.is_dir(dst_dir_arm64):
-        base.cmd_in_dir(dst_dir, "python3", ["./fetch.py", "all"])
-      options["sysroot_linux_64"] = dst_dir_amd64
-      options["sysroot_linux_arm64"] = dst_dir_arm64
-    else:
-      # specific sysroot => one platform for build!
-      options["sysroot"] = "1"
-      options["sysroot_linux_64"] = options["sysroot"]
-      options["sysroot_linux_arm64"] = options["sysroot"]
+      custom_sysroot = dst_dir + '/sysroot_ubuntu_1604'
+      options["sysroot"] = custom_sysroot
+      if not os.path.isdir(custom_sysroot):
+        print("Sysroot is not found, downloading...")
+        sysroot_url = 'https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/sysroot/sysroot_ubuntu_1604.tar.xz'
+        base.download(sysroot_url, dst_dir + '/sysroot_ubuntu_1604.tar.xz')
+        os.mkdir(custom_sysroot)
+        print("Unpacking...")
+        base.cmd2('tar', ['-xf', dst_dir + '/sysroot_ubuntu_1604.tar.xz', '-C', dst_dir])
+        if os.path.exists(dst_dir + '/sysroot_ubuntu_1604.tar.xz'):
+          os.remove(dst_dir + '/sysroot_ubuntu_1604.tar.xz')
 
   if is_cef_107():
     extend_option("config", "cef_version_107")
@@ -125,6 +131,12 @@ def parse():
   if not "sdkjs-plugin-server" in options:
     options["sdkjs-plugin-server"] = "default"
 
+  if not "arm64-toolchain-bin" in options:
+    if not "sysroot" in options:
+      options["arm64-toolchain-bin"] = "/usr/bin"
+    else:
+      options["arm64-toolchain-bin"] = get_custom_sysroot_bin()
+
   if check_option("platform", "ios"):
     if not check_option("config", "no_bundle_xcframeworks"):
       if not check_option("config", "bundle_xcframeworks"):
@@ -224,25 +236,13 @@ def is_mobile_platform():
     return True
   return False
 
-def get_custom_sysroot_bin(platform):
-  use_platform = platform
-  if "linux_arm64" == platform and not base.is_os_arm():
-    # use cross compiler
-    use_platform = "linux_64"
+def get_custom_sysroot_bin():
+  return option("sysroot") + "/usr/bin"
 
-  return option("sysroot_" + use_platform) + "/usr/bin"
-
-def get_custom_sysroot_lib(platform, isNatural=False):
-  use_platform = platform
-  if "linux_arm64" == platform and not base.is_os_arm() and not isNatural:
-    # use cross compiler
-    use_platform = "linux_64"
-
-  if ("linux_64" == use_platform):
-    return option("sysroot_linux_64") + "/usr/lib/x86_64-linux-gnu"
-  if ("linux_arm64" == use_platform):
-    return option("sysroot_linux_arm64") + "/usr/lib/aarch64-linux-gnu"
-  return ""
+# todo 32bit support?
+def get_custom_sysroot_lib():
+  if base.is_os_64bit():
+    return option("sysroot") + "/usr/lib/x86_64-linux-gnu"
 
 def parse_defaults():
   defaults_path = base.get_script_dir() + "/../defaults"

scripts/core_common/modules/boost.py

@@ -138,14 +138,14 @@ def make():
   if (-1 != config.option("platform").find("android")) and not base.is_dir("../build/android"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"])
 
-  if config.check_option("platform", "mac_64") and not base.is_dir("../build/mac_64"):
+  if (-1 != config.option("platform").find("mac")) and not base.is_dir("../build/mac_64"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"], "mac_64")
     directory_build = base_dir + "/build/mac_64/lib"
     base.delete_file(directory_build + "/libboost_system.a")
     base.delete_file(directory_build + "/libboost_system.dylib")
     base.copy_files(directory_build + "/mac_64/*.a", directory_build)
 
-  if config.check_option("platform", "mac_arm64") and not base.is_dir("../build/mac_arm64"):
+  if (-1 != config.option("platform").find("mac_arm64")) and not base.is_dir("../build/mac_arm64"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"], "mac_arm64")
     directory_build = base_dir + "/build/mac_arm64/lib"
     base.delete_file(directory_build + "/libboost_system.a")

scripts/core_common/modules/boost_qt.py

@@ -14,8 +14,18 @@ def make(src_dir, modules, build_platform="android", qmake_addon=""):
 
   print("boost-headers...")
   
-  base.cmd("./bootstrap.sh", ["--with-libraries=system"]) 
-  base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install"])
+  # for b2 checks
+  if config.option("sysroot") != "":
+    base.set_sysroot_env()
+    b2_addon = "cflags=\"--sysroot=" + config.option("sysroot") + "\""
+    b2_addon = "cxxflags=\"--sysroot=" + config.option("sysroot") + "\""
+    b2_addon = "linkflags=\"--sysroot=" + config.option("sysroot") + "\""
+    
+  base.cmd("./bootstrap.sh", ["--with-libraries=system"])   
+  base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install", b2_addon])
+  
+  if config.option("sysroot") != "":
+    base.restore_sysroot_env()
   
   for module in modules:
     print("boost-module: " + module + " ...")

scripts/core_common/modules/cef.py

@@ -21,7 +21,7 @@ def make():
   os.chdir(base_dir)
 
   base.check_module_version("2", clear_module)
-  platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64", "linux_arm64"]
+  platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64"]
 
   for platform in platforms:
     if not config.check_option("platform", platform):

scripts/core_common/modules/heif.py

@@ -21,11 +21,31 @@ IOS_CMAKE_TOOLCHAIN_FILE = base.get_script_dir() + "/../../core/Common/3dParty/h
 ANDROID_CMAKE_TOOLCHAIN_FILE = base.get_env("ANDROID_NDK_ROOT") + "/build/cmake/android.toolchain.cmake"
 
 # linux arm64 cmake toolchain
-LINUX_SYSTEM_AARCH64_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/sysroot/system-aarch64.toolchain.cmake"
+LINUX_ARM64_CMAKE_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/arm/cross_arm64/linux-arm64.toolchain.cmake"
+
 LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/sysroot/custom-sysroot.toolchain.cmake"
 
 OLD_ENV = dict()
 
+# get custom sysroot vars as str
+def setup_custom_sysroot_env() -> str:
+  env_vars = []
+  env_vars += ['LD_LIBRARY_PATH=\"' + config.get_custom_sysroot_lib() + "\""]
+  env_vars += ['PATH=\"' + config.option("sysroot") + "/usr/bin:" + base.get_env("PATH") + "\""]
+  env_vars += ['CC=\"' + config.get_custom_sysroot_bin() + "/gcc\""]
+  env_vars += ['CXX=\"' + config.get_custom_sysroot_bin() + "/g++\""]
+  env_vars += ['AR=\"' + config.get_custom_sysroot_bin() + "/ar\""]
+  env_vars += ['RABLIB=\"' + config.get_custom_sysroot_bin() + "/ranlib\""]
+  env_vars += ['CFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+  env_vars += ['CXXFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+  env_vars += ['LDFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+
+  env_str = ""
+  for env_var in env_vars:
+    env_str += env_var + " "
+
+  return env_str
+
 def get_vs_version():
   vs_version = "14 2015"
   if config.option("vs-version") == "2019":
@@ -70,14 +90,10 @@ def build_with_cmake(platform, cmake_args, build_type):
       cmake_args_ext += ["-DCMAKE_OSX_DEPLOYMENT_TARGET=10.11", "-DCMAKE_OSX_ARCHITECTURES=x86_64"]
     elif platform == "mac_arm64":
       cmake_args_ext += ["-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0", "-DCMAKE_OSX_ARCHITECTURES=arm64"]
+    elif platform == "linux_arm64":
+      cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_ARM64_CMAKE_TOOLCHAIN_FILE]
     elif config.option("sysroot") != "":
-      # force use custom CXXFLAGS with Release/Debug build
-      if (platform == "linux_64"):
-        cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE]
-      else:
-        cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_SYSTEM_AARCH64_TOOLCHAIN_FILE]
-    elif platform == "linux_arm64" and not base.is_os_arm():
-      cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_SYSTEM_AARCH64_TOOLCHAIN_FILE]
+      cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE] # force use custom CXXFLAGS with Release/Debug build
   # IOS
   elif "ios" in platform:
     cmake_args_ext = [
@@ -111,20 +127,16 @@ def build_with_cmake(platform, cmake_args, build_type):
       cmake_args_ext += get_cmake_args_android("x86_64", "21")
 
   # env setup for custom sysroot
-  if config.option("sysroot") != "":
-    base.set_sysroot_env(platform)
+  env_str = setup_custom_sysroot_env() if config.option("sysroot") != "" else ""
 
   # run cmake
-  base.cmd("cmake", cmake_args + cmake_args_ext)
+  base.cmd(env_str + "cmake", cmake_args + cmake_args_ext)
 
   # build
   if "Unix Makefiles" in cmake_args_ext:
-    base.cmd("make", ["-j4"])
+    base.cmd(env_str + "make", ["-j4"])
   else:
     base.cmd("cmake", ["--build", ".", "--config", build_type])
-
-  if config.option("sysroot") != "":
-    base.restore_sysroot_env()
   return
 
 # general make function that calls `build_func` callback for configured platform(s) with specified cmake arguments

scripts/core_common/modules/icu.py

@@ -35,7 +35,7 @@ def make():
   old_cur = os.getcwd()
   os.chdir(base_dir)
 
-  base.check_module_version("8", clear_module)
+  base.check_module_version("7", clear_module)
 
   if (-1 != config.option("platform").find("android")):
     icu_android.make()
@@ -136,15 +136,13 @@ def make():
         base.cmd(command_configure, ["Linux", "--prefix=" + base_dir + "/icu/cross_build_install"])
         base.replaceInFile("./../source/icudefs.mk.in", "LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS)", "LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS) " + command_compile_addon)
       else:
-        base.set_sysroot_env("linux_64") 
-        sysroot_path = config.option("sysroot_linux_64")
-        sysroot_path_bin = config.get_custom_sysroot_bin("linux_64")
+        base.set_sysroot_env()     
         base.cmd_exe("./../source/configure", ["--prefix=" + base_dir + "/icu/cross_build_install",
-                                           "CC=" + sysroot_path_bin + "/gcc", "CXX=" + sysroot_path_bin + "/g++",
-                                           "AR=" + sysroot_path_bin + "/ar", "RANLIB=" + sysroot_path_bin + "/ranlib",
-                                           "CFLAGS=--sysroot=" + sysroot_path,
-                                           "CXXFLAGS=--sysroot=" + sysroot_path + " " + command_compile_addon,
-                                           "LDFLAGS=--sysroot=" + sysroot_path])
+                                           "CC=" + config.get_custom_sysroot_bin() + "/gcc", "CXX=" + config.get_custom_sysroot_bin() + "/g++",
+                                           "AR=" + config.get_custom_sysroot_bin() + "/ar", "RANLIB=" + config.get_custom_sysroot_bin() + "/ranlib",
+                                           "CFLAGS=--sysroot=" + config.option("sysroot"),
+                                           "CXXFLAGS=--sysroot=" + config.option("sysroot") + " " + command_compile_addon,
+                                           "LDFLAGS=--sysroot=" + config.option("sysroot")])
 
       if "" == config.option("sysroot"):
         base.cmd("make", ["-j4"])
@@ -163,11 +161,9 @@ def make():
     if config.check_option("platform", "linux_arm64") and not base.is_dir(base_dir + "/linux_arm64") and not base.is_os_arm():
       base.create_dir(base_dir + "/icu/linux_arm64")
       os.chdir(base_dir + "/icu/linux_arm64")
-      compiler_gcc_prefix = base.get_compiler_gcc_prefix("linux_arm64")
-      if config.option("sysroot") != "":
-        base.set_sysroot_env("linux_arm64")
+      base_arm_tool_dir = config.option('arm64-toolchain-bin') + '/' + base.get_prefix_cross_compiler_arm64()
       base.cmd("./../source/configure", ["--host=arm-linux", "--prefix=" + base_dir + "/icu/linux_arm64_install", "--with-cross-build=" + base_dir + "/icu/cross_build",
-        "CC=" + compiler_gcc_prefix + "gcc", "CXX=" + compiler_gcc_prefix + "g++", "AR=" + compiler_gcc_prefix + "ar", "RANLIB=" + compiler_gcc_prefix + "ranlib"])
+        "CC=" + base_arm_tool_dir + "gcc", "CXX=" + base_arm_tool_dir + "g++", "AR=" + base_arm_tool_dir + "ar", "RANLIB=" + base_arm_tool_dir + "ranlib"])
       base.cmd("make", ["-j4"])
       base.cmd("make", ["install"], True)
       base.create_dir(base_dir + "/linux_arm64")
@@ -175,8 +171,6 @@ def make():
       base.copy_file(base_dir + "/icu/linux_arm64_install/lib/libicudata.so." + icu_major + "." + icu_minor, base_dir + "/linux_arm64/build/libicudata.so." + icu_major)
       base.copy_file(base_dir + "/icu/linux_arm64_install/lib/libicuuc.so." + icu_major + "." + icu_minor, base_dir + "/linux_arm64/build/libicuuc.so." + icu_major)
       base.copy_dir(base_dir + "/icu/linux_arm64_install/include", base_dir + "/linux_arm64/build/include")
-      if config.option("sysroot") != "":
-        base.restore_sysroot_env()
 
       os.chdir("../..")
 

scripts/core_common/modules/icu_mac.py

@@ -41,7 +41,7 @@ if not base.is_dir(current_dir + "/mac_cross_64"):
   old_env = change_icu_defs("x86_64")
 
   base.cmd("../icu/source/runConfigureICU", ["MacOSX",
-    "--prefix=" + current_dir + "/mac_64_install", "--enable-static"])
+    "--prefix=" + current_dir + "/mac_cross_64", "--enable-static"])
 
   base.cmd("make", ["-j4"])
   base.cmd("make", ["install"], True)
@@ -58,7 +58,7 @@ addon = []
 if not base.is_os_arm():
   addon = ["--host=aarch64-apple-darwin"]
 
-base.cmd("./configure", ["--prefix=" + current_dir + "/mac_arm64_install",
+base.cmd("./configure", ["--prefix=" + current_dir + "/mac_arm_64",
   "--with-cross-build=" + current_dir + "/mac_cross_64", "--enable-static", "VERBOSE=1"] + addon)
 
 base.cmd("make", ["-j4"])
@@ -80,26 +80,25 @@ base.create_dir(current_dir + "/mac_64/build")
 base.create_dir(current_dir + "/mac_arm64")
 base.create_dir(current_dir + "/mac_arm64/build")
 
-base.copy_dir(current_dir + "/mac_64_install/include", current_dir + "/mac_64/build/include")
+base.copy_dir(current_dir + "/mac_cross_64/include", current_dir + "/mac_64/build/include")
 # copy shared libs
-base.copy_file(current_dir + "/mac_64_install/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicudata." + icu_major + ".dylib")
-base.copy_file(current_dir + "/mac_64_install/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicuuc." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicudata." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicuuc." + icu_major + ".dylib")
 # copy static libs
-base.copy_file(current_dir + "/mac_64_install/lib/libicudata.a", current_dir + "/mac_64/build")
-base.copy_file(current_dir + "/mac_64_install/lib/libicui18n.a", current_dir + "/mac_64/build")
-base.copy_file(current_dir + "/mac_64_install/lib/libicuuc.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicudata.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicui18n.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicuuc.a", current_dir + "/mac_64/build")
 
-base.copy_dir(current_dir + "/mac_arm64_install/include", current_dir + "/mac_arm64/build/include")
+base.copy_dir(current_dir + "/mac_arm_64/include", current_dir + "/mac_arm64/build/include")
 # copy shared libs
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicudata." + icu_major + ".dylib")
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicuuc." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicudata." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicuuc." + icu_major + ".dylib")
 # copy static libs
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicudata.a", current_dir + "/mac_arm64/build")
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicui18n.a", current_dir + "/mac_arm64/build")
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicuuc.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicudata.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicui18n.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicuuc.a", current_dir + "/mac_arm64/build")
 
 base.delete_dir(current_dir + "/mac_cross_64")
-base.delete_dir(current_dir + "/mac_64_install")
-base.delete_dir(current_dir + "/mac_arm64_install")
+base.delete_dir(current_dir + "/mac_arm_64")
 
 os.chdir(current_dir_old)

scripts/core_common/modules/iwork.py

@@ -22,7 +22,7 @@ def make(use_gperf = True):
   base_dir = base.get_script_dir() + "/../../core/Common/3dParty/apple"
   
   os.chdir(base_dir)
-  base.check_module_version("4", clear_module)
+  base.check_module_version("3", clear_module)
   os.chdir(old_cur_dir)
 
   cmd_args = ["fetch.py"]
@@ -35,5 +35,4 @@ def make(use_gperf = True):
 
 if __name__ == '__main__':
   # manual compile
-  make(False)
-
+  make(False)

scripts/core_common/modules/openssl.py

@@ -99,35 +99,34 @@ def make():
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden")
     else:
-      base.replaceInFile("./Makefile", "CROSS_COMPILE=", "CROSS_COMPILE=" + config.get_custom_sysroot_bin("linux_64") + "/")
-      base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot_linux_64"))
-      base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot_linux_64"))
+      base.replaceInFile("./Makefile", "CROSS_COMPILE=", "CROSS_COMPILE=" + config.get_custom_sysroot_bin() + "/")
+      base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot"))
+      base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot"))
 
     if config.option("sysroot") == "":
       base.cmd("make", [])
       base.cmd("make", ["install"])
       base.cmd("make", ["clean"], True)
     else:
-      base.set_sysroot_env("linux_64")
+      base.set_sysroot_env()
       base.cmd_exe("make", [])
       base.cmd_exe("make", ["install"])
       base.cmd_exe("make", ["clean"], True)
       base.restore_sysroot_env()
 
   if (-1 != config.option("platform").find("linux_arm64")) and not base.is_dir("../build/linux_arm64"):
-    if (base.is_os_arm()):
+    if ("x86_64" != platform.machine()):
       base.copy_dir("../build/linux_64", "../build/linux_arm64")
     else:
-      if config.option("sysroot") != "":
-        base.set_sysroot_env("linux_arm64")
-      base.cmd("/usr/bin/perl", ["./Configure", "linux-aarch64", "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
-      #base.cmd("./Configure", ["linux-aarch64", "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
+      cross_compiler_arm64 = config.option("arm64-toolchain-bin")
+      if ("" == cross_compiler_arm64):
+        cross_compiler_arm64 = "/usr/bin"
+      cross_compiler_arm64_prefix = cross_compiler_arm64 + "/" + base.get_prefix_cross_compiler_arm64()
+      base.cmd("./Configure", ["linux-aarch64", "--cross-compile-prefix=" + cross_compiler_arm64_prefix, "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden")
       base.cmd("make", [], True)
       base.cmd("make", ["install"], True)
-      if config.option("sysroot") != "":
-        base.restore_sysroot_env()
 
   if (-1 != config.option("platform").find("mac")) and not base.is_dir("../build/mac_64"):
     base.cmd("./Configure", ["enable-md2", "no-shared", "no-asm", "darwin64-x86_64-cc", "--prefix=" + old_cur_dir + "/build/mac_64", "--openssldir=" + old_cur_dir + "/build/mac_64", "-mmacosx-version-min=10.11"])

scripts/core_common/modules/v8.py

@@ -44,9 +44,14 @@ def is_xp_platform():
   return False
 
 def is_use_clang():
-  if config.option("sysroot") == "" and "1" == config.option("use-clang"):
-    return "true"
-  return "false"
+  gcc_version = base.get_gcc_version()  
+    
+  is_clang = "false"
+  if config.option("sysroot") == "" and (gcc_version >= 6000 or "1" == config.option("use-clang")):
+    is_clang = "true"
+
+  print("gcc version: " + str(gcc_version) + ", use clang:" + is_clang)
+  return is_clang
 
 def make():
   if not is_main_platform():
@@ -230,7 +235,8 @@ def make_xp():
         base.replaceInFile("depot_tools/cipd.ps1", "windows-386", "windows-amd64")
   
   # old variant
-  path_to_python2 = "/depot_tools/bootstrap-2@3_11_8_chromium_35_bin/python/bin"
+  #path_to_python2 = "/depot_tools/win_tools-2_7_13_chromium7_bin/python/bin"
+  path_to_python2 = "/depot_tools/bootstrap-2@3_8_10_chromium_23_bin/python/bin"
   os.environ["PATH"] = os.pathsep.join([base_dir + "/depot_tools", 
     base_dir + path_to_python2, 
     config.option("vs-path") + "/../Common7/IDE",

scripts/core_common/modules/v8_89.py

@@ -7,25 +7,6 @@ import base
 import os
 import subprocess
 
-def clean():
-  if base.is_dir("depot_tools"):
-    base.delete_dir_with_access_error("depot_tools")
-    base.delete_dir("depot_tools")
-  if base.is_dir("v8"):
-    base.delete_dir_with_access_error("v8")
-    base.delete_dir("v8")
-  if base.is_exist("./.gclient"):
-    base.delete_file("./.gclient")
-  if base.is_exist("./.gclient_entries"):
-    base.delete_file("./.gclient_entries")
-  if base.is_exist("./.gclient_previous_sync_commits"):
-    base.delete_file("./.gclient_previous_sync_commits")
-  if base.is_exist("./.gcs_entries"):
-    base.delete_file("./.gcs_entries")
-  if base.is_exist("./.cipd"):
-    base.delete_dir("./.cipd")
-  return
-
 def change_bootstrap():
   base.move_file("./depot_tools/bootstrap/manifest.txt", "./depot_tools/bootstrap/manifest.txt.bak")
   content = "# changed by build_tools\n\n"
@@ -53,31 +34,6 @@ def change_bootstrap():
   base.writeFile("./depot_tools/bootstrap/manifest.txt", content)
   return
 
-def is_ubuntu_24_or_higher():
-  try:
-    with open('/etc/os-release') as f:
-      for line in f:
-        if line.startswith('VERSION_ID='):
-          version = line.split('=')[1].strip().strip('"')
-          return float(version) >= 24
-  except:
-      pass
-  return False
-
-def fix_ubuntu24():
-  #if not is_ubuntu_24_or_higher():
-  #  return
-
-  if "" == config.option("sysroot"):
-    return
-
-  old_cur = os.getcwd()
-  os.chdir("third_party/llvm-build/Release+Asserts/lib")
-  base.cmd("mv", ["libstdc++.so.6", "libstdc++.so.6.old"])
-  base.cmd("ln", ["-s", "/usr/lib/x86_64-linux-gnu/libstdc++.so.6", "libstdc++.so.6"])
-  os.chdir(old_cur)
-  return
-
 def make_args(args, platform, is_64=True, is_debug=False):
   args_copy = args[:]
   if is_64:
@@ -91,6 +47,7 @@ def make_args(args, platform, is_64=True, is_debug=False):
     args_copy = args[:]
     args_copy.append("target_cpu=\\\"arm64\\\"")
     args_copy.append("v8_target_cpu=\\\"arm64\\\"")
+    args_copy.append("use_sysroot=true")
     
   if (platform == "win_arm64"):
     args_copy = args[:]
@@ -108,26 +65,8 @@ def make_args(args, platform, is_64=True, is_debug=False):
   linux_clang = False
   if platform == "linux":
     if "" != config.option("sysroot"):
-      args_copy.append("use_sysroot=true")
+      args_copy.append("use_sysroot=false")
       args_copy.append("is_clang=false")
-      if is_ubuntu_24_or_higher():
-        args_copy.append("use_gold=false")
-      args_copy.append("sysroot=\\\"" + config.option("sysroot_linux_64") + "\\\"")
-      args_copy.append("target_sysroot=\\\"" + config.option("sysroot_linux_64") + "\\\"")
-    else:
-      args_copy.append("is_clang=true")
-      if "1" == config.option("use-clang"):
-        linux_clang = True
-      else:
-        args_copy.append("use_sysroot=false")
-
-  if platform == "linux_arm64":
-    if "" != config.option("sysroot"):
-      args_copy.append("use_sysroot=true")
-      if is_ubuntu_24_or_higher():
-        args_copy.append("use_gold=false")
-      #args_copy.append("sysroot=\\\"" + config.option("sysroot_linux_64") + "\\\"")
-      args_copy.append("target_sysroot=\\\"" + config.option("sysroot_linux_arm64") + "\\\"")
     else:
       args_copy.append("is_clang=true")
       if "1" == config.option("use-clang"):
@@ -214,8 +153,6 @@ def make():
     base.cmd("git", ["config", "--global", "http.postBuffer", "157286400"], True)
 
   os.chdir(base_dir)
-  base.common_check_version("v8", "1", clean)
-    
   if not base.is_dir("depot_tools"):
     base.cmd("git", ["clone", "https://chromium.googlesource.com/chromium/tools/depot_tools.git"])
     change_bootstrap()
@@ -239,9 +176,6 @@ def make():
     base.cmd("./depot_tools/gclient", ["sync", "-r", v8_branch_version], True)
     base.cmd("gclient", ["sync", "--force"], True)
     base.copy_dir("./v8/third_party_new/ninja", "./v8/third_party/ninja")
-    if ("linux" == base.host_platform()):
-      if not base.is_file("./depot_tools/python3_bin_reldir.txt"):
-        base.cmd_in_dir("./depot_tools", "./ensure_bootstrap", [], True)
 
   if ("windows" == base.host_platform()):
     base.replaceInFile("v8/build/config/win/BUILD.gn", ":static_crt", ":dynamic_crt")
@@ -271,9 +205,6 @@ def make():
     base.replaceInFile("v8/third_party/jinja2/tests.py", "from collections import Mapping", "try:\n    from collections.abc import Mapping\nexcept ImportError:\n    from collections import Mapping")
 
   os.chdir("v8")
-
-  is_ubuntu24 = is_ubuntu_24_or_higher()
-  fix_ubuntu24()
   
   gn_args = ["v8_static_library=true",
              "is_component_build=false",
@@ -283,17 +214,17 @@ def make():
 
   if config.check_option("platform", "linux_64"):
     if config.option("sysroot") != "":
-      sysroot_path = config.option("sysroot_linux_64")
-      sysroot_path_bin = config.get_custom_sysroot_bin("linux_64")
+      src_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = []\n  cflags_c = []\n  cflags_cc = []\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = []"
+      dst_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = [\"--sysroot=" + config.option("sysroot") + "\"]" + "\n  cflags_c = []\n  cflags_cc = [\"--sysroot=" + config.option("sysroot") + "\"]" + "\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = [\"--sysroot=" + config.option("sysroot") + "\"]"
+      base.replaceInFile("build/config/compiler/BUILD.gn", src_replace, dst_replace)
 
+      src_replace = "gcc_toolchain(\"x64\") {\n  cc = \"gcc\"\n  cxx = \"g++\""
+      dst_replace = "gcc_toolchain(\"x64\") {\n  cc = \""+ config.get_custom_sysroot_bin() + "/gcc\"\n  cxx = \"" + config.get_custom_sysroot_bin() + "/g++\""
+      base.replaceInFile("build/toolchain/linux/BUILD.gn", src_replace, dst_replace)
+      
       old_env = dict(os.environ)
-      base.set_sysroot_env("linux_64")
-
-      pkg_old = os.environ.get("PKG_CONFIG_PATH", "")
-      os.environ["PKG_CONFIG_PATH"] = sysroot_path + "/usr/lib/x86_64-linux-gnu/pkgconfig:" + sysroot_path + "/usr/lib/pkgconfig:" + sysroot_path + "/usr/share/pkgconfig"
+      base.set_sysroot_env()
       base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
-      os.environ["PKG_CONFIG_PATH"] = pkg_old
-
       base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
       base.restore_sysroot_env()
     else:
@@ -307,13 +238,7 @@ def make():
 
   if config.check_option("platform", "linux_arm64"):
     base.cmd("build/linux/sysroot_scripts/install-sysroot.py", ["--arch=arm64"], False)
-    
-    sysroot_path = config.option("sysroot_linux_64")
-    pkg_old = os.environ.get("PKG_CONFIG_PATH", "")
-    os.environ["PKG_CONFIG_PATH"] = sysroot_path + "/usr/lib/x86_64-linux-gnu/pkgconfig:" + sysroot_path + "/usr/lib/pkgconfig:" + sysroot_path + "/usr/share/pkgconfig"
     base.cmd2("gn", ["gen", "out.gn/linux_arm64", make_args(gn_args, "linux_arm64", False)])
-    os.environ["PKG_CONFIG_PATH"] = pkg_old
-
     base.cmd("ninja", ["-C", "out.gn/linux_arm64"])
 
   if config.check_option("platform", "mac_64"):

scripts/deploy_builder.py

@@ -47,8 +47,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "DocxRenderer")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "ooxmlsignature", "xp" if isWindowsXP else "")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", root_dir + "/cmap.bin")
 
     if ("ios" == platform):

scripts/deploy_core.py

@@ -25,7 +25,6 @@ def make():
 
     platform = native_platform
     platform_postfix = platform + base.qt_dst_postfix()
-    isWindowsXP = False if (-1 == native_platform.find("_xp")) else True
 
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "kernel")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "kernel_network")
@@ -43,8 +42,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "DocxRenderer")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "hunspell")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "ooxmlsignature", "xp" if isWindowsXP else "")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", archive_dir + "/cmap.bin")
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, archive_dir, "x2t")
 

scripts/deploy_desktop.py

@@ -72,8 +72,6 @@ def make():
     base.copy_lib(build_libraries_path, root_dir + "/converter", "IWorkFile")
     base.copy_lib(build_libraries_path, root_dir + "/converter", "HWPFile")
     base.copy_lib(build_libraries_path, root_dir + "/converter", "DocxRenderer")
-    base.copy_lib(build_libraries_path, root_dir + "/converter", "StarMathConverter")
-    base.copy_lib(build_libraries_path, root_dir + "/converter", "ooxmlsignature", "xp" if isWindowsXP else "")
 
     if ("ios" == platform):
       base.copy_lib(build_libraries_path, root_dir + "/converter", "x2t")
@@ -139,6 +137,7 @@ def make():
 
     # libraries
     base.copy_lib(build_libraries_path, root_dir, "hunspell")
+    base.copy_lib(build_libraries_path + ("/xp" if isWindowsXP else ""), root_dir, "ooxmlsignature")
     base.copy_lib(build_libraries_path + ("/xp" if isWindowsXP else ""), root_dir, "ascdocumentscore")
     if (0 != platform.find("mac")):
       base.copy_lib(build_libraries_path + ("/xp" if isWindowsXP else ""), root_dir, "qtascdocumentscore")
@@ -179,7 +178,7 @@ def make():
         base.qt_copy_lib("Qt5DBus", root_dir)
         base.qt_copy_lib("Qt5X11Extras", root_dir)
         base.qt_copy_lib("Qt5XcbQpa", root_dir)
-        base.qt_copy_icu(root_dir, platform)
+        base.qt_copy_icu(root_dir)
         if not base.check_congig_option_with_platfom(platform, "libvlc"):
           base.copy_files(base.get_env("QT_DEPLOY") + "/../lib/libqgsttools_p.so*", root_dir)
 
@@ -243,11 +242,9 @@ def make():
     #base.copy_dir(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins/encrypt/ui/engine/database/{9AB4BBA8-A7E5-48D5-B683-ECE76A020BB1}", root_dir + "/editors/sdkjs-plugins/{9AB4BBA8-A7E5-48D5-B683-ECE76A020BB1}")
     base.copy_sdkjs_plugin(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins", root_dir + "/editors/sdkjs-plugins", "sendto", True)
 
-    isUseAgent = True
+    isUseAgent = False
     if isWindowsXP:
       isUseAgent = False
-    if (0 == platform.find("mac")) and (config.check_option("config", "use_v8")):
-      isUseAgent = False
 
     if (isUseAgent):
       agent_plugin_dir = git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins/ai-agent"
@@ -316,24 +313,8 @@ def make():
       themes_params = []
       if ("" != config.option("themesparams")):
         themes_params = ["--params=\"" + config.option("themesparams") + "\""]
-
-      params_allfontsgen = ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""]
-      params_allthemesgen = ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params
-      if (0 == platform.find("linux_arm") and not base.is_os_arm()):
-        x2t_origin = ""
-        if (config.option("sysroot") != ""):
-          x2t_origin = base.create_qemu_wrapper(root_dir + "/converter/x2t", platform)
- 
-        base.cmd_in_dir_qemu(platform, root_dir + "/converter", "./allfontsgen", params_allfontsgen, True)
-        base.cmd_in_dir_qemu(platform, root_dir + "/converter", "./allthemesgen", params_allthemesgen, True)
-
-        if "" != x2t_origin:
-          base.delete_file(root_dir + "/converter/x2t")
-          base.move_file(x2t_origin, root_dir + "/converter/x2t")
-      else:        
-        base.cmd_exe(root_dir + "/converter/allfontsgen", params_allfontsgen, True)
-        base.cmd_exe(root_dir + "/converter/allthemesgen", params_allthemesgen, True)
-
+      base.cmd_exe(root_dir + "/converter/allfontsgen", ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""], True)
+      base.cmd_exe(root_dir + "/converter/allthemesgen", ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params, True)
       base.delete_file(root_dir + "/converter/AllFonts.js")
       base.delete_file(root_dir + "/converter/font_selection.bin")
       base.delete_file(root_dir + "/converter/fonts.log")
@@ -345,4 +326,4 @@ def make():
     if not isUseJSC:
       base.delete_file(root_dir + "/editors/sdkjs/slide/sdk-all.cache")
 
-  return
+  return

scripts/deploy_mobile.py

@@ -65,8 +65,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "DocxRenderer")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "ooxmlsignature")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", root_dir + "/cmap.bin")
 
     if (0 == platform.find("win") or 0 == platform.find("linux") or 0 == platform.find("mac")):

scripts/deploy_server.py

@@ -41,7 +41,6 @@ def make():
 
     build_server_dir = root_dir + '/server'
     server_dir = base.get_script_dir() + "/../../server"
-    server_admin_panel_dir = base.get_script_dir() + "/../../server-admin-panel"
 
     base.create_dir(build_server_dir + '/DocService')
 
@@ -59,14 +58,13 @@ def make():
     base.create_dir(build_server_dir + '/Metrics/node_modules/modern-syslog/build/Release')
     base.copy_file(server_dir + "/Metrics/node_modules/modern-syslog/build/Release/core.node", build_server_dir + "/Metrics/node_modules/modern-syslog/build/Release/core.node")
 
-    if "server-admin-panel" in base.get_server_addons() and base.is_exist(server_admin_panel_dir):
-      # AdminPanel server part
-      base.create_dir(build_server_dir + '/AdminPanel/server')
-      base.copy_exe(server_admin_panel_dir + "/server", build_server_dir + '/AdminPanel/server', "adminpanel")
+    # AdminPanel server part
+    base.create_dir(build_server_dir + '/AdminPanel/server')
+    base.copy_exe(server_dir + "/AdminPanel/server", build_server_dir + '/AdminPanel/server', "adminpanel")
 
-      # AdminPanel client part
-      base.create_dir(build_server_dir + '/AdminPanel/client/build')
-      base.copy_dir(server_admin_panel_dir + '/client/build', build_server_dir + '/AdminPanel/client/build')
+    # AdminPanel client part
+    base.create_dir(build_server_dir + '/AdminPanel/client/build')
+    base.copy_dir(server_dir + '/AdminPanel/client/build', build_server_dir + '/AdminPanel/client/build')
 
     qt_dir = base.qt_setup(native_platform)
     platform = native_platform
@@ -95,8 +93,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "DocxRenderer")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "ooxmlsignature")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", converter_dir + "/cmap.bin")
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, converter_dir, "x2t")
 
@@ -183,12 +179,6 @@ def make():
     base.copy_dir(document_templates_files + '/new', document_templates + '/new')
     base.copy_dir(document_templates_files + '/sample', document_templates + '/sample')
 
-    #document-formats
-    document_formats_files = server_dir + '/../document-formats'
-    document_formats = build_server_dir + '/../document-formats'
-    base.create_dir(document_formats)
-    base.copy_file(document_formats_files + '/onlyoffice-docs-formats.json', document_formats + '/onlyoffice-docs-formats.json')
-
     #license
     license_file1 = server_dir + '/LICENSE.txt'
     license_file2 = server_dir + '/3rd-Party.txt'

scripts/develop/dependence.py

@@ -111,10 +111,20 @@ def check_dependencies():
   if (host_platform == 'windows'):
     checksResult.append(check_nodejs())
 
+  print('\n=== Database Check ===')
   sql_type = config.option("sql-type")
+  print('SQL type: ' + sql_type)
+  print('Host platform: ' + host_platform)
+  print('DB host: ' + config.option("db-host"))
+  print('DB port: ' + config.option("db-port"))
+  print('DB name: ' + config.option("db-name"))
+  print('DB user: ' + config.option("db-user"))
+  
   if (sql_type == 'mysql' and host_platform == 'windows'):
+    print('\nCalling check_mysqlServer()...')
     checksResult.append(check_mysqlServer())
   else:
+    print('\nCalling check_postgreSQL()...')
     checksResult.append(check_postgreSQL())
 
   server_addons = []
@@ -301,21 +311,88 @@ def check_rabbitmq():
       print('RabbitMQ is installed')
       return dependence
   elif (host_platform == 'linux'):
-    result = ''
+    # Try service command first
+    command_result = base.run_command('service rabbitmq-server status')
+    result = command_result['stdout']
     
-    # Prefer systemctl for systemd
-    systemctl_result = base.run_command('systemctl status rabbitmq-server')
-    if systemctl_result['returncode'] == 0 and systemctl_result['stdout']:
-      result = systemctl_result['stdout']
+    # Log command results
+    print('Checking RabbitMQ with service command...')
+    print('Command: service rabbitmq-server status')
+    print('stdout: ' + (result if result else '[EMPTY]'))
+    if command_result['stderr']:
+      print('stderr: ' + command_result['stderr'])
+    print('Return code: ' + str(command_result['returncode']))
     
-    # Fallback to service for SysV
-    if result == '':
-      command_result = base.run_command('service rabbitmq-server status')
-      if command_result['returncode'] == 0 and command_result['stdout']:
-        result = command_result['stdout']
+    # If service command failed or returned empty, try systemctl
+    if (result == '' or command_result['returncode'] != 0):
+      print('\nTrying systemctl command...')
+      systemctl_result = base.run_command('systemctl status rabbitmq-server')
+      print('Command: systemctl status rabbitmq-server')
+      print('stdout: ' + (systemctl_result['stdout'] if systemctl_result['stdout'] else '[EMPTY]'))
+      if systemctl_result['stderr']:
+        print('stderr: ' + systemctl_result['stderr'])
+      print('Return code: ' + str(systemctl_result['returncode']))
+      
+      # Update result if systemctl worked
+      if systemctl_result['stdout']:
+        result = systemctl_result['stdout']
+        command_result = systemctl_result
     
-    if result != '':
-      print('RabbitMQ is installed')
+    # If still no result, try direct process check
+    if (result == ''):
+      print('\nTrying direct process check...')
+      ps_result = base.run_command('ps aux | grep -i rabbitmq | grep -v grep')
+      print('Command: ps aux | grep -i rabbitmq | grep -v grep')
+      print('stdout: ' + (ps_result['stdout'] if ps_result['stdout'] else '[EMPTY]'))
+      print('Return code: ' + str(ps_result['returncode']))
+      
+      # Check if rabbitmq process is running
+      if ps_result['stdout']:
+        result = ps_result['stdout']
+        print('RabbitMQ process found: ' + result[:100] + '...' if len(result) > 100 else result)
+    
+    # Additional diagnostic checks
+    if (result == ''):
+      print('\nPerforming additional diagnostic checks...')
+      
+      # Check current user
+      whoami_result = base.run_command('whoami')
+      print('Current user: ' + whoami_result['stdout'])
+      
+      # Check for RabbitMQ binaries
+      which_result = base.run_command('which rabbitmqctl')
+      if which_result['stdout']:
+        print('RabbitMQ binary found at: ' + which_result['stdout'])
+        
+        # Try rabbitmqctl status
+        rabbitmqctl_result = base.run_command('rabbitmqctl status')
+        print('\nTrying rabbitmqctl status...')
+        print('stdout: ' + (rabbitmqctl_result['stdout'][:200] + '...' if len(rabbitmqctl_result['stdout']) > 200 else rabbitmqctl_result['stdout']))
+        if rabbitmqctl_result['stderr']:
+          print('stderr: ' + rabbitmqctl_result['stderr'])
+      else:
+        print('RabbitMQ binary (rabbitmqctl) not found in PATH')
+      
+      # Check for permission issues
+      if (command_result['returncode'] == 126):
+        print('\nPermission denied error (code 126).')
+        print('You may need to run this script with elevated privileges (sudo).')
+      elif (command_result['returncode'] == 127):
+        print('\nCommand not found error (code 127).')
+        print('The service command may not be available or RabbitMQ may not be installed.')
+      elif (command_result['returncode'] == 1):
+        print('\nService command failed (code 1).')
+        print('This could mean RabbitMQ service is not installed or not running.')
+      
+      # Check common RabbitMQ installation paths
+      print('\nChecking common RabbitMQ paths...')
+      common_paths = ['/usr/lib/rabbitmq', '/opt/rabbitmq', '/etc/rabbitmq', '/var/lib/rabbitmq']
+      for path in common_paths:
+        if base.is_dir(path):
+          print('Found RabbitMQ directory: ' + path)
+    
+    if (result != ''):
+      print('\nInstalled RabbitMQ is valid')
       return dependence
 
   print('RabbitMQ not found')
@@ -525,37 +602,61 @@ def check_mysqlServer():
   base.print_info('Check MySQL Server')
   dependence = CDependencies()
   mysqlLoginSrt = get_mysqlLoginString()
+  print('MySQL login string: ' + mysqlLoginSrt)
   connectionString = mysqlLoginSrt + ' -e "SHOW GLOBAL VARIABLES LIKE ' + r"'PORT';" + '"'
+  print('Connection string: ' + connectionString)
 
   if (host_platform != 'windows'):
+    print('\nTesting MySQL connection...')
     result = os.system(mysqlLoginSrt + ' -e "exit"')
+    print('Connection test result code: ' + str(result))
+    
     if (result == 0):
       connectionResult = base.run_command(connectionString)
+      print('Port check stdout: ' + connectionResult['stdout'])
+      if connectionResult['stderr']:
+        print('Port check stderr: ' + connectionResult['stderr'])
+      
       expected_port = config.option("db-port")
+      print('Expected port: ' + expected_port)
+      
       if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
         print('MySQL configuration is valid')
         dependence.sqlPath = 'mysql'
         return dependence
+      else:
+        print('Port not found or does not match. Found: ' + connectionResult['stdout'])
+    else:
+      print('MySQL connection failed with code: ' + str(result))
     print('Valid MySQL Server not found')
     dependence.append_install('MySQLServer')
     dependence.append_uninstall('mysql-server')
     return dependence
 
   arrInfo = get_mysqlServersInfo()
+  print('\nFound MySQL installations: ' + str(len(arrInfo)))
   for info in arrInfo:
+    print('\nChecking MySQL at: ' + info['Location'])
     if (base.is_dir(info['Location']) == False):
+      print('Directory does not exist, skipping...')
       continue
 
     mysql_full_name = 'MySQL Server ' + info['Version'] + ' '
     mysql_bin_path = get_mysql_path_to_bin(info['Location'])
+    print('MySQL bin path: ' + mysql_bin_path)
+
     connectionResult = base.run_command_in_dir(mysql_bin_path, connectionString)
+    print('Connection result stdout: ' + connectionResult['stdout'])
+    if connectionResult['stderr']:
+      print('Connection result stderr: ' + connectionResult['stderr'])
+    print('Return code: ' + str(connectionResult['returncode']))
     
     expected_port = config.option("db-port")
     if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
       print(mysql_full_name + 'configuration is valid')
       dependence.sqlPath = info['Location']
       return dependence
-    print(mysql_full_name + 'configuration is not valid')
+    print(mysql_full_name + 'configuration is not valid. Expected port: ' + expected_port)
     # if path exists, then further removal and installation fails(according to startup statistics). it is better to fix issue manually.
     return dependence
 
@@ -648,6 +749,7 @@ def get_postrgre_path_to_bin(postgrePath = ''):
   return postgrePath
 def get_postgreLoginSrting(userName):
   if (host_platform == 'windows'):
+    # Note: PGPASSWORD should be set as environment variable on Windows
     return 'psql -U ' + userName + ' -h localhost '
   return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U ' + userName + ' -h localhost '
 def get_postgreSQLInfoByFlag(flag):
@@ -679,12 +781,23 @@ def check_postgreSQL():
   dependence = CDependencies()
   
   postgreLoginSrt = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
+  print('PostgreSQL login string: ' + postgreLoginSrt)
   connectionString = postgreLoginSrt + ' -c "SELECT setting FROM pg_settings WHERE name = ' + "'port'" + ';"'
+  print('Connection string: ' + connectionString)
 
   if (host_platform == 'linux'):
+    print('\nTesting PostgreSQL connection...')
     result = os.system(postgreLoginSrt + ' -c "\q"')
+    print('Connection test result code: ' + str(result))
+    
     connectionResult = base.run_command(connectionString)
+    print('Port check stdout: ' + connectionResult['stdout'])
+    if connectionResult['stderr']:
+      print('Port check stderr: ' + connectionResult['stderr'])
+    print('Port check return code: ' + str(connectionResult['returncode']))
+    
     expected_port = config.option("db-port")
+    print('Expected port: ' + expected_port)
 
     if (result != 0 or connectionResult['stdout'].find(expected_port) == -1):
       print('Valid PostgreSQL not found!')
@@ -696,21 +809,33 @@ def check_postgreSQL():
     return dependence
 
   arrInfo = get_postgreSQLInfo()
-  base.set_env('PGPASSWORD', config.option("db-pass"))
+  print('\nFound PostgreSQL installations: ' + str(len(arrInfo)))
+  db_pass = config.option("db-pass")
+  print('Setting PGPASSWORD environment variable')
+  base.set_env('PGPASSWORD', db_pass)
   
   for info in arrInfo:
+    print('\nChecking PostgreSQL at: ' + info['Location'])
     if (base.is_dir(info['Location']) == False):
+      print('Directory does not exist, skipping...')
       continue
     
     postgre_full_name = 'PostgreSQL ' + info['Version'][:2] + ' '
     postgre_bin_path = get_postrgre_path_to_bin(info['Location'])
+    print('PostgreSQL bin path: ' + postgre_bin_path)
+    
     connectionResult = base.run_command_in_dir(postgre_bin_path, connectionString)
+    print('Connection result stdout: ' + connectionResult['stdout'])
+    if connectionResult['stderr']:
+      print('Connection result stderr: ' + connectionResult['stderr'])
+    print('Return code: ' + str(connectionResult['returncode']))
     
     expected_port = config.option("db-port")
     if (connectionResult['stdout'].find(expected_port) != -1):
       print(postgre_full_name + 'configuration is valid')
       dependence.sqlPath = info['Location']
       return dependence
+    print(postgre_full_name + 'configuration is not valid. Expected port: ' + expected_port)
 
   print('Valid PostgreSQL not found')
 
@@ -726,6 +851,7 @@ def check_postgreConfig(postgrePath = ''):
   base.print_info('Checking PostgreSQL configuration')
   
   if (host_platform == 'windows'):
+    print('Setting PGPASSWORD for Windows')
     base.set_env('PGPASSWORD', config.option("db-pass"))
 
   rootUser = install_params['PostgreSQL']['root']
@@ -733,78 +859,185 @@ def check_postgreConfig(postgrePath = ''):
   dbName = config.option("db-name")
   dbPass = config.option("db-pass")
   
+  print('Configuration:')
+  print('  Root user: ' + rootUser)
+  print('  DB user: ' + dbUser)
+  print('  DB name: ' + dbName)
+  print('  PostgreSQL path: ' + postgrePath)
+  
   postgre_path_to_bin = get_postrgre_path_to_bin(postgrePath)
+  print('  Bin path: ' + postgre_path_to_bin)
+  
   postgreLoginRoot = get_postgreLoginSrting(rootUser)
   postgreLoginDbUser = get_postgreLoginSrting(dbUser)
+  print('  Root login string: ' + postgreLoginRoot)
+  print('  User login string: ' + postgreLoginDbUser)
+  
   creatdb_path = base.get_script_dir() + "/../../server/schema/postgresql/createdb.sql"
+  print('  CreateDB script path: ' + creatdb_path)
+  if base.is_file(creatdb_path):
+    print('  CreateDB script exists: YES')
+  else:
+    print('  CreateDB script exists: NO - THIS IS A PROBLEM!')
 
-  # Check if user exists
-  user_check_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "\du ' + dbUser + '"')
+  print('\nChecking if user exists...')
+  check_user_cmd = postgreLoginRoot + ' -c "\du ' + dbUser + '"'
+  user_check_result = base.run_command_in_dir(postgre_path_to_bin, check_user_cmd)
+  print('User check command: ' + check_user_cmd)
+  print('User check stdout: ' + user_check_result['stdout'])
+  if user_check_result['stderr']:
+    print('User check stderr: ' + user_check_result['stderr'])
   
   if (user_check_result['stdout'].find(dbUser) != -1):
-    # User exists, check password
-    if (os.system(postgreLoginDbUser + '-c "\q"') != 0):
-      print('Invalid user password, changing...')
+    print('User ' + dbUser + ' exists')
+    print('\nTesting user password...')
+    password_test_result = os.system(postgreLoginDbUser + '-c "\q"')
+    print('Password test result code: ' + str(password_test_result))
+    
+    if (password_test_result != 0):
+      print('Invalid user password!')
+      base.print_info('Changing password...')
       result = change_userPass(dbUser, dbPass, postgre_path_to_bin) and result
+      print('Password change result: ' + str(result))
   else:
-    print('Creating user ' + dbUser + '...')
+    print('User ' + dbUser + ' not exist!')
+    base.print_info('Creating ' + dbName + ' user...')
     result = create_postgreUser(dbUser, dbPass, postgre_path_to_bin) and result
 
-  # Check if database exists
-  db_check_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"')
+  print('\nChecking if database exists...')
+  db_check_cmd = postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"'
+  db_check_result = base.run_command_in_dir(postgre_path_to_bin, db_check_cmd)
+  print('Database check command: ' + db_check_cmd)
+  print('Database check stdout: ' + db_check_result['stdout'])
+  if db_check_result['stderr']:
+    print('Database check stderr: ' + db_check_result['stderr'])
   
-  if (db_check_result['stdout'].find(dbName) == -1):
-    print('Creating database ' + dbName + '...')
+  if (db_check_result['stdout'].find(config.option("db-name")) == -1):
+    print('Database ' + dbName + ' not found')
+    base.print_info('Creating ' + dbName + ' database...')
     create_result = create_postgreDb(dbName, postgre_path_to_bin)
+    print('Database creation result: ' + str(create_result))
     
     if create_result:
-      # Grant privileges to user on database and schema
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"')
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"')
+      # Give user rights to database and schema
+      print('\nGranting database privileges to user ' + dbUser + '...')
+      db_grant_cmd = postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"'
+      db_grant_result = base.run_command_in_dir(postgre_path_to_bin, db_grant_cmd)
+      print('Database grant result: ' + str(db_grant_result['returncode']))
       
+      print('Granting schema privileges to user ' + dbUser + '...')
+      schema_cmd = postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"'
+      schema_result = base.run_command_in_dir(postgre_path_to_bin, schema_cmd)
+      print('Schema grant result: ' + str(schema_result['returncode']))
+      
+      print('\nConfiguring database with createdb.sql...')
       configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
+      print('Database configuration result: ' + str(configure_result))
       result = create_result and configure_result
     else:
       result = False
   else:
-    # Database exists - check if tables need to be created
+    print('Database ' + dbName + ' exists')
+    # Simple check: if 0 tables, configure database
+    print('Checking tables in database...')
     table_count_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT count(*) FROM information_schema.tables WHERE table_schema = \'public\';"')
-    
-    needs_configure = False
+    print('Table count result: ' + table_count_result['stdout'].strip())
     
     if table_count_result['stdout'].find(' 0') != -1:
-      # No tables - need to configure
-      needs_configure = True
+      print('Database ' + dbName + ' has no tables - configuring...')
+    else:
+      print('Database ' + dbName + ' has tables - checking ownership...')
+      # Check if tables belong to postgres instead of onlyoffice user
+      owner_check = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "\dt"')
+      if owner_check['stdout'].find('postgres') != -1 and owner_check['stdout'].find(dbUser) == -1:
+        print('Tables belong to postgres, not ' + dbUser + ' - need to recreate')
+        print('Dropping existing tables...')
+        drop_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"')
+        print('Schema recreation result: ' + str(drop_result['returncode']))
+        print('Will proceed to recreate tables with correct owner...')
+      else:
+        print('Database ' + dbUser + ' already has correct tables - skipping configuration')
+        return result
+
+    # Configure database (either empty or after recreation)
+    print('Granting database privileges to user ' + dbUser + '...')
+    db_grant_cmd = postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"'
+    db_grant_result = base.run_command_in_dir(postgre_path_to_bin, db_grant_cmd)
+    print('Database grant result: ' + str(db_grant_result['returncode']))
     
-    if needs_configure:
-      # Grant privileges and configure
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"')
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"')
-      
-      configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
-      result = configure_result and result
+    print('Granting schema privileges to user ' + dbUser + '...')
+    schema_cmd = postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"'
+    schema_result = base.run_command_in_dir(postgre_path_to_bin, schema_cmd)
+    print('Schema grant result: ' + str(schema_result['returncode']))
+    
+    base.print_info('Configuring ' + dbName + ' database...')
+    configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
+    print('Configuration completed: ' + ('SUCCESS' if configure_result else 'FAILED'))
+    result = configure_result and result
+
+  # User privileges are set above when configuring database
+
+  print('\n=== PostgreSQL Configuration Summary ===')
+  print('Database: ' + dbName + ' - ' + ('READY' if result else 'FAILED'))
+  print('User: ' + dbUser + ' - configured')
   
   return result
 def create_postgreDb(dbName, postgre_path_to_bin = ''):
+  print('\nCreating database: ' + dbName)
   postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"')
+  create_cmd = postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"'
+  print('Create database command: ' + create_cmd)
+  
+  result = base.run_command_in_dir(postgre_path_to_bin, create_cmd)
+  print('Create database return code: ' + str(result['returncode']))
+  if result['stdout']:
+    print('Create database stdout: ' + result['stdout'])
+  if result['stderr']:
+    print('Create database stderr: ' + result['stderr'])
+  
   if (result['returncode'] != 0):
-    print('Database creation failed!')
+    print('Database creation FAILED!')
     return False
+  
+  print('Database created successfully')
   return True
 def set_dbPrivilegesForUser(userName, dbName, postgre_path_to_bin = ''):
+  print('\nSetting database privileges for user: ' + userName)
   postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"')
+  grant_cmd = postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"'
+  print('Grant command: ' + grant_cmd)
+  
+  result = base.run_command_in_dir(postgre_path_to_bin, grant_cmd)
+  print('Grant return code: ' + str(result['returncode']))
+  if result['stdout']:
+    print('Grant stdout: ' + result['stdout'])
+  if result['stderr']:
+    print('Grant stderr: ' + result['stderr'])
+  
   if (result['returncode'] != 0):
-    print('Grant privileges failed!')
+    print('Grant privileges FAILED!')
     return False
+  
+  print('Privileges granted successfully')
   return True
 def create_postgreUser(userName, userPass, postgre_path_to_bin = ''):
+  print('\nCreating user: ' + userName)
   postgreLoginRoot = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"')
+  create_cmd = postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"'
+  print('Create user command: ' + create_cmd[:50] + '... [password hidden]')
+  
+  result = base.run_command_in_dir(postgre_path_to_bin, create_cmd)
+  print('Create user return code: ' + str(result['returncode']))
+  if result['stdout']:
+    print('Create user stdout: ' + result['stdout'])
+  if result['stderr']:
+    print('Create user stderr: ' + result['stderr'])
+  
   if (result['returncode'] != 0):
-    print('User creation failed!')
+    print('User creation FAILED!')
     return False
+  
+  print('User created successfully')
   return True
 def change_userPass(userName, userPass, postgre_path_to_bin = ''):
   postgreLoginRoot = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
@@ -812,25 +1045,68 @@ def change_userPass(userName, userPass, postgre_path_to_bin = ''):
     return False
   return True
 def configureDb(userName, dbName, scriptPath, postgre_path_to_bin = ''):
-  print('Executing ' + scriptPath)
+  print('\n=== Configuring Database ===')
+  print('Script path: ' + scriptPath)
+  print('User: ' + userName)
+  print('Database: ' + dbName)
+  print('Bin path: ' + postgre_path_to_bin)
   
+  # Check if script exists
   if not base.is_file(scriptPath):
-    print('ERROR: Script file does not exist!')
+    print('ERROR: Script file does not exist: ' + scriptPath)
     return False
   
+  print('Script file size: ' + str(os.path.getsize(scriptPath)) + ' bytes')
+  
   postgreLoginSrt = get_postgreLoginSrting(userName)
+  print('Login string: ' + postgreLoginSrt)
+  
   full_command = postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"'
+  print('Full command: ' + full_command)
   
-  # Use run_command_in_dir to capture output
+  print('\nExecuting createdb.sql script...')
+  
+  # Use run_command_in_dir instead of exec_command_in_dir to capture output
   result = base.run_command_in_dir(postgre_path_to_bin, full_command)
+  code = result['returncode']
   
-  if (result['returncode'] != 0):
-    print('Execution failed!')
-    if result['stderr']:
-      print('Error: ' + result['stderr'])
+  print('Execution return code: ' + str(code))
+  if result['stdout']:
+    print('Script output:\n' + result['stdout'])
+  if result['stderr']:
+    print('Script errors:\n' + result['stderr'])
+  
+  if (code != 0):
+    print('Execution FAILED! Return code: ' + str(code))
+    
+    # Try to get more info about the failure
+    print('\nTrying to connect and check database...')
+    test_cmd = postgreLoginSrt + ' -d ' + dbName + ' -c "SELECT version();"'
+    test_result = base.run_command_in_dir(postgre_path_to_bin, test_cmd)
+    print('Connection test stdout: ' + test_result['stdout'])
+    if test_result['stderr']:
+      print('Connection test stderr: ' + test_result['stderr'])
+    
     return False
   
-  print('Execution completed')
+  print('Execution completed successfully!')
+  
+  # Verify tables were created
+  print('\nVerifying table creation...')
+  verify_cmd = postgreLoginSrt + ' -d ' + dbName + ' -c "\dt;"'
+  verify_result = base.run_command_in_dir(postgre_path_to_bin, verify_cmd)
+  
+  # Count lines with table names (skip header)
+  table_lines = [line for line in verify_result['stdout'].split('\n') if '|' in line and 'table' in line.lower()]
+  table_count = len(table_lines)
+  
+  if table_count > 0:
+    print('SUCCESS: Created ' + str(table_count) + ' tables')
+    print('Database is ready for use!')
+  else:
+    print('WARNING: No tables found after script execution')
+    print(verify_result['stdout'])
+  
   return True
 def uninstall_postgresql():
   code = os.system('sudo DEBIAN_FRONTEND=noninteractive apt-get purge --auto-remove postgresql* -y')

scripts/package_builder.py

@@ -131,8 +131,6 @@ def make_tar():
   make_args = ["tar"]
   if common.platform == "darwin_arm64":
     make_args += ["-e", "UNAME_M=arm64"]
-  if common.platform == "darwin_x86_64":
-    make_args += ["-e", "UNAME_M=x86_64"]
   if common.platform == "linux_aarch64":
     make_args += ["-e", "UNAME_M=aarch64"]
   if not branding.onlyoffice:
@@ -170,7 +168,7 @@ def make_wheel():
 
   utils.delete_dir("python")
   utils.copy_dir("../onlyoffice/build_tools/packaging/docbuilder/resources", "python")
-  utils.copy_dir(builder_dir, "python/docbuilder/lib", True, True)
+  utils.copy_dir(builder_dir, "python/docbuilder/lib")
 
   desktop_dir = "../desktop-apps/macos/build/ONLYOFFICE.app/Contents/Resources/converter"
   if utils.is_macos() and "desktop" in common.targets and utils.is_exist(desktop_dir):
@@ -204,11 +202,7 @@ def make_wheel():
     utils.delete_file("docbuilder.net.dll")
     utils.delete_file("docbuilder.jni.dll")
   elif utils.is_macos():
-    if (utils.is_file("libdocbuilder.jni.dylib")):
-      utils.delete_file("libdocbuilder.jni.dylib")
-    if (utils.is_dir("docbuilder.jni.framework")):
-      utils.delete_file("docbuilder.jni.framework")
-    utils.remove_all_symlinks(".")
+    utils.delete_file("libdocbuilder.jni.dylib")
   elif utils.is_linux():
     utils.delete_file("libdocbuilder.jni.so")
 

scripts/package_common.py

@@ -3,14 +3,14 @@
 platformPrefixes = {
   "windows_x64":      "win_64",
   "windows_x86":      "win_32",
-  "windows_arm64":    "win_arm64",
   "windows_x64_xp":   "win_64_xp",
   "windows_x86_xp":   "win_32_xp",
-  "darwin_arm64":     "mac_arm64",
   "darwin_x86_64":    "mac_64",
+  "darwin_arm64":     "mac_arm64",
   "darwin_x86_64_v8": "mac_64",
   "linux_x86_64":     "linux_64",
   "linux_aarch64":    "linux_arm64",
+  "linux_x86_64_cef": "linux_64",
 }
 
 out_dir = "build_tools/out"

scripts/package_desktop.py

@@ -36,7 +36,7 @@ def s3_upload(files, dst):
 
 def make_windows():
   global package_name, package_version, arch, xp
-  utils.set_cwd("desktop-apps\\package")
+  utils.set_cwd("desktop-apps\\win-linux\\package\\windows")
 
   package_name = branding.desktop_package_name
   package_version = common.version + "." + common.build
@@ -44,34 +44,33 @@ def make_windows():
     "windows_x64":    "x64",
     "windows_x64_xp": "x64",
     "windows_x86":    "x86",
-    "windows_x86_xp": "x86",
-    "windows_arm64":  "arm64"
+    "windows_x86_xp": "x86"
   }[common.platform]
   xp = common.platform.endswith("_xp")
 
   if common.clean:
     utils.log_h2("desktop clean")
-    utils.delete_dir("build")
-    utils.delete_files("inno\\package.config")
-    utils.delete_files("inno\\*.exe")
-    utils.delete_dir("advinst\\DesktopEditors-cache")
-    utils.delete_files("advinst\\package.config")
-    utils.delete_files("advinst\\*.msi")
-    utils.delete_files("advinst\\*.aic")
-    utils.delete_dir("zip")
+    utils.delete_dir("DesktopEditors-cache")
+    utils.delete_files("*.exe")
+    utils.delete_files("*.msi")
+    utils.delete_files("*.aic")
+    utils.delete_files("*.tmp")
+    utils.delete_files("*.zip")
+    utils.delete_files("data\\*.exe")
 
   if not xp:
     make_prepare()
     make_zip()
+    make_inno()
     if branding.onlyoffice:
-      make_inno()
       make_inno("standalone")
-      make_advinst()
+      make_inno("update")
+    make_advinst()
 
-      make_prepare("commercial")
-      make_zip("commercial")
-      make_inno("commercial")
-      make_advinst("commercial")
+    make_prepare("commercial")
+    make_zip("commercial")
+    make_inno("commercial")
+    make_advinst("commercial")
   else:
     make_prepare("xp")
     make_zip("xp")
@@ -84,8 +83,7 @@ def make_prepare(edition = "opensource"):
   args = [
     "-Version", package_version,
     "-Arch", arch,
-    "-Target", edition,
-    "-CompanyName", branding.company_name
+    "-Target", edition
   ]
   if common.sign:
     args += ["-Sign"]
@@ -99,12 +97,11 @@ def make_zip(edition = "opensource"):
   if   edition == "commercial": zip_file = "%s-Enterprise-%s-%s.zip"
   elif edition == "xp":         zip_file = "%s-XP-%s-%s.zip"
   else:                         zip_file = "%s-%s-%s.zip"
-  zip_file = "zip\\" + zip_file % (package_name, package_version, arch)
+  zip_file = zip_file % (package_name, package_version, arch)
   args = [
     "-Version", package_version,
     "-Arch", arch,
-    "-Target", edition,
-    "-CompanyName", branding.company_name
+    "-Target", edition
   ]
   # if common.sign:
   #   args += ["-Sign"]
@@ -125,7 +122,7 @@ def make_inno(edition = "opensource"):
   elif edition == "update":     inno_file = "%s-Update-%s-%s.exe"
   elif edition == "xp":         inno_file = "%s-XP-%s-%s.exe"
   else:                         inno_file = "%s-%s-%s.exe"
-  inno_file = "inno\\" + inno_file % (package_name, package_version, arch)
+  inno_file = inno_file % (package_name, package_version, arch)
   args = [
     "-Version", package_version,
     "-Arch", arch,
@@ -150,7 +147,7 @@ def make_inno(edition = "opensource"):
 def make_advinst(edition = "opensource"):
   if edition == "commercial": advinst_file = "%s-Enterprise-%s-%s.msi"
   else:                       advinst_file = "%s-%s-%s.msi"
-  advinst_file = "advinst\\" + advinst_file % (package_name, package_version, arch)
+  advinst_file = advinst_file % (package_name, package_version, arch)
   args = [
     "-Version", package_version,
     "-Arch", arch,
@@ -315,7 +312,7 @@ def make_sparkle_updates():
 #
 
 def make_linux():
-  utils.set_cwd("desktop-apps/package")
+  utils.set_cwd("desktop-apps/win-linux/package/linux")
 
   for edition in ["opensource", "commercial"]:
     utils.log_h2("desktop " + edition + " build")
@@ -325,19 +322,14 @@ def make_linux():
     if common.platform == "linux_aarch64":
       make_args += ["-e", "UNAME_M=aarch64"]
     if not branding.onlyoffice:
-      make_args += ["-e", "BRANDING_DIR=../../" + common.branding + "/desktop-apps/package"]
+      make_args += ["-e", "BRANDING_DIR=../../../../" + common.branding + "/desktop-apps/win-linux/package/linux"]
     ret = utils.sh("make clean && make " + " ".join(make_args), verbose=True)
     utils.set_summary("desktop " + edition + " build", ret)
 
     if common.deploy:
       for t in branding.desktop_make_targets:
         utils.log_h2("desktop " + edition + " " + t["make"] + " deploy")
-        uploads = []
-        for f in utils.glob_path(t["src"]):
-          if "help" in f and not \
-            ("x86_64" in common.platform and edition == "opensource"): continue
-          uploads.append(f)
-        ret = s3_upload(uploads, t["dst"])
+        ret = s3_upload(utils.glob_path(t["src"]), t["dst"])
         utils.set_summary("desktop " + edition + " " + t["make"] + " deploy", ret)
 
   utils.set_cwd(common.workspace_dir)

scripts/package_utils.py

@@ -201,12 +201,12 @@ def copy_files(src, dst, override=True, verbose=True):
       copy_files(file + "/*", dst + "/" + file_name, override)
   return
 
-def copy_dir(src, dst, verbose=True, symlinks=False):
+def copy_dir(src, dst, verbose=True):
   if verbose:
     log("- copy_dir:")
     log("    src: " + src)
     log("    dst: " + dst)
-  shutil.copytree(src, dst, symlinks=symlinks)
+  shutil.copytree(src, dst)
   return
 
 def copy_dir_content(src, dst, filter_include = "", filter_exclude = "", verbose=True):
@@ -262,20 +262,6 @@ def delete_files(src, verbose=True):
       shutil.rmtree(path, ignore_errors=True)
   return
 
-def remove_all_symlinks(dir):
-  for root, dirs, files in os.walk(dir, topdown=True, followlinks=False):
-    for name in files:
-      path = os.path.join(root, name)
-      if os.path.islink(path):
-        os.unlink(path)
-    
-    for name in list(dirs):
-      path = os.path.join(root, name)
-      if os.path.islink(path):
-        os.unlink(path)
-        dirs.remove(name)
-  return
-
 def set_summary(target, status):
   common.summary.append({target: status})
   return

scripts/qmake.py

@@ -36,7 +36,7 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
     return
 
   old_env = dict(os.environ)
-
+  
   # qt
   qt_dir = base.qt_setup(platform)
   base.set_env("OS_DEPLOY", platform)
@@ -50,7 +50,7 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
   if (pro_dir.endswith("/")):
     pro_dir = pro_dir[:-1]
 
-  makefile_name = "Makefile." + get_make_file_suffix(platform)
+  makefile_name = "Makefile." + get_make_file_suffix(platform) 
   makefile = pro_dir + "/" + makefile_name
   stash_file = pro_dir + "/.qmake.stash"
 
@@ -73,11 +73,6 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
   # setup ios env
   if (-1 != platform.find("ios")):
     base.hack_xcode_ios()
-    sdk_name = "iphoneos"
-    if qmake_config_addon.find("ios_simulator") != -1:
-      sdk_name = "iphonesimulator"
-    base.set_env("SDK_PATH", base.find_ios_sdk(sdk_name))
-    base.set_env("XCODE_TOOLCHAIN_PATH", base.find_xcode_toolchain(sdk_name))
 
   if base.is_file(makefile):
     base.delete_file(makefile)
@@ -105,35 +100,19 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
     if "1" == config.option("use-clang"):
       build_params.append("-spec")
       build_params.append("linux-clang-libc++")
-
     if "" != config.option("sysroot"):
-      sysroot_path = config.option("sysroot_" + platform)
-      os.environ['QMAKE_CUSTOM_SYSROOT'] = sysroot_path
-      os.environ['QMAKE_CUSTOM_SYSROOT_BIN'] = config.get_custom_sysroot_bin(platform)
-      os.environ['PKG_CONFIG_PATH'] = config.get_custom_sysroot_lib(platform, True) + "/pkgconfig"
-      os.environ['PKG_CONFIG_SYSROOT_DIR'] = sysroot_path
-
-    base.cmd_exe(qmake_app, build_params)
-
-    if "" != config.option("sysroot"):
-      base.set_sysroot_env(platform)
+      base.set_sysroot_env()
+      base.cmd_exe(qmake_app, build_params) # calls cmd_exe to pass os.env
+    else:
+      base.cmd(qmake_app, build_params)
 
     base.correct_makefile_after_qmake(platform, makefile)
     if ("1" == config.option("clean")):
       base.cmd_and_return_cwd("make", clean_params, True)
       base.cmd_and_return_cwd("make", distclean_params, True)
-      
-      if "" != config.option("sysroot"):
-        base.restore_sysroot_env()
-      base.cmd(qmake_app, build_params)   
-      if "" != config.option("sysroot"):
-        base.set_sysroot_env(platform)
-      
+      base.cmd(qmake_app, build_params)
       base.correct_makefile_after_qmake(platform, makefile)
     base.cmd_and_return_cwd("make", ["-f", makefile] + get_j_num(), is_no_errors)
-
-    if "" != config.option("sysroot"):
-      base.restore_sysroot_env()
   else:
     config_params_array = base.qt_config_as_param(config_param)
     config_params_string = ""

scripts/sdkjs_common/jsdoc/office-api/config/correct_doclets.js

@@ -66,21 +66,11 @@ exports.handlers = {
             const isMethod = doclet.kind === 'function' || doclet.kind === 'method';
             const hasTypeofEditorsTag = isMethod && doclet.tags && doclet.tags.some(tag => tag.title === 'typeofeditors' && tag.value.includes(process.env.EDITOR));
 
-            let shouldAddMethod = 
+            const shouldAddMethod = 
                 doclet.kind !== 'member' &&
                 (!doclet.longname || doclet.longname.search('private') === -1) &&
                 doclet.scope !== 'inner' && hasTypeofEditorsTag;
 
-			// class names may be the same between editors, we check against the inheritance tree
-			if (doclet.inherits) {
-				const parentClass = doclet.inherits.split('#')[0];
-				const curClass = cleanName(doclet.memberof);
-
-				if (!classesDocletsMap[curClass].augments || !classesDocletsMap[curClass].augments.includes(parentClass)) {
-					shouldAddMethod = false;
-				}
-			}
-
             if (shouldAddMethod) {
                 // if the class is not in our map, then we deleted it ourselves -> not available in the editor
                 if (false == passedClasses.includes(cleanName(doclet.memberof))) {

scripts/sdkjs_common/jsdoc/office-api/config/pdf.json

@@ -1,6 +1,6 @@
 {
   "source": {
-    "include": ["../../../../../sdkjs/word/apiBuilder.js", "../../../../../sdkjs/pdf/apiBuilder.js"]
+    "include": ["../../../../../sdkjs/pdf/apiBuilder.js"]
   },
   "plugins": ["./correct_doclets.js"],
   "opts": {
@@ -13,4 +13,4 @@
       "pretty": true
     }
   }
-}
+}

scripts/sdkjs_common/jsdoc/office-api/generate_docs_json.py

@@ -13,16 +13,14 @@ configs = [
     "./config/word.json",
     "./config/cell.json",
     "./config/slide.json",
-    "./config/forms.json",
-    "./config/pdf.json"
+    "./config/forms.json"
 ]
 
 editors_maps = {
     "word":     "CDE",
     "cell":     "CSE",
     "slide":    "CPE",
-    "forms":    "CFE",
-    "pdf":		"PDFE"
+    "forms":    "CFE"
 }
 
 def generate(output_dir, md=False):
@@ -79,7 +77,10 @@ def generate(output_dir, md=False):
                             doclet['example'] = remove_js_comments(comment) + "```js\n" + code_content + "\n```"
                         
                         if md == False:
-                            doclet['description'] = doclet['description'] + f'\n\n## Try it\n\n ```js document-builder={{"documentType": "{editor_name}"}}\n{code_content}\n```'
+                            document_type = editor_name
+                            if "forms" == document_type:
+                                document_type = "pdf"
+                            doclet['description'] = doclet['description'] + f'\n\n## Try it\n\n ```js document-builder={{"documentType": "{document_type}"}}\n{code_content}\n```'
         
         # Write the modified JSON file back
         with open(output_file, 'w', encoding='utf-8') as f:

scripts/sdkjs_common/jsdoc/office-api/generate_docs_md.py

@@ -10,8 +10,7 @@ editors = {
     "word": "text-document-api",
     "cell": "spreadsheet-api",
     "slide": "presentation-api",
-    "forms": "form-api",
-    "pdf": "pdf-api",
+    "forms": "form-api"
 }
 
 
@@ -483,13 +482,11 @@ def process_doclets(data, output_dir, editor_name):
     if editor_name == 'word':
         example_editor_name += 'docx'
     elif editor_name == 'forms':
-        example_editor_name += 'forms'
+        example_editor_name += 'pdf'
     elif editor_name == 'slide':
         example_editor_name += 'pptx'
     elif editor_name == 'cell':
         example_editor_name += 'xlsx'
-    elif editor_name == 'pdf':
-        example_editor_name += 'pdf'
 
     for doclet in data:
         if doclet['kind'] == 'class':

scripts/sdkjs_common/jsdoc/office-api/generate_jsonl_dataset.py

@@ -11,16 +11,14 @@ editors = [
     "word",
     "cell",
     "slide",
-    "forms",
-    "pdf"
+    "forms"
 ]
 
 editors_names = {
     "word": "Word",
     "cell": "Spreadsheet",
     "slide": "Presentation",
-    "forms": "Forms",
-    "pdf": "PDF"
+    "forms": "Forms"
 }
 
 script_path = os.path.abspath(__file__)

scripts/sdkjs_common/jsdoc/plugins/config/events/pdf.json

@@ -1,16 +0,0 @@
-{
-  "source": {
-    "include": ["../../../../../sdkjs/pdf/plugin-events.js"]
-  },
-  "plugins": ["../correct_doclets.js"],
-  "opts": {
-    "destination": "./out",
-    "recurse": true,
-    "encoding": "utf8"
-  },
-  "templates": {
-    "json": {
-      "pretty": true
-    }
-  }
-}

scripts/sdkjs_common/jsdoc/plugins/config/methods/pdf.json

@@ -1,16 +0,0 @@
-{
-  "source": {
-    "include": ["../../../../../sdkjs/pdf/api_plugins.js"]
-  },
-  "plugins": ["../correct_doclets.js"],
-  "opts": {
-    "destination": "./out",
-    "recurse": true,
-    "encoding": "utf8"
-  },
-  "templates": {
-    "json": {
-      "pretty": true
-    }
-  }
-}

scripts/sdkjs_common/jsdoc/plugins/generate_docs_events_json.py

@@ -10,8 +10,7 @@ configs = [
     "./config/events/word.json",
     "./config/events/cell.json",
     "./config/events/slide.json",
-    "./config/events/forms.json",
-    "./config/events/pdf.json"
+    "./config/events/forms.json"
 ]
 
 script_path = os.path.abspath(__file__)

scripts/sdkjs_common/jsdoc/plugins/generate_docs_events_md.py

@@ -11,8 +11,7 @@ editors = {
     "word": "text-document-api",
     "cell": "spreadsheet-api",
     "slide": "presentation-api",
-    "forms": "form-api",
-    "pdf": "pdf-api"
+    "forms": "form-api"
 }
 
 script_path = os.path.abspath(__file__)

scripts/sdkjs_common/jsdoc/plugins/generate_docs_methods_json.py

@@ -10,8 +10,7 @@ configs = [
     "./config/methods/word.json",
     "./config/methods/cell.json",
     "./config/methods/slide.json",
-    "./config/methods/forms.json",
-    "./config/methods/pdf.json"
+    "./config/methods/forms.json"
 ]
 
 script_path = os.path.abspath(__file__)

scripts/sdkjs_common/jsdoc/plugins/generate_docs_methods_md.py

@@ -10,8 +10,7 @@ editors = {
     "word": "text-document-api",
     "cell": "spreadsheet-api",
     "slide": "presentation-api",
-    "forms": "form-api",
-    "pdf": "pdf-api"
+    "forms": "form-api"
 }
 
 script_path = os.path.abspath(__file__)

sln.json

@@ -13,11 +13,9 @@
     "core/UnicodeConverter/UnicodeConverter.pro",
     "core/Common/kernel.pro",
     "core/Common/Network/network.pro",
-
-    "core/OdfFile/Reader/Converter/StarMath2OOXML/StarMath2OOXML.pro",
-
+    
     "core/DesktopEditor/graphics/pro/graphics.pro",
-
+    
     "core/PdfFile/PdfFile.pro",
     "core/DjVuFile/DjVuFile.pro",
     "core/XpsFile/XpsFile.pro",
@@ -29,12 +27,10 @@
 
     "core/Apple/IWork.pro",
 
-    "core/DocxRenderer/DocxRenderer.pro",
+    "core/DocxRenderer/DocxRenderer.pro",   
 
     "core/DesktopEditor/doctrenderer/doctrenderer.pro",
 
-    "core/DesktopEditor/xmlsec/src/ooxmlsignature.pro",
-
     "[!no_x2t]core/OOXML/Projects/Linux/DocxFormatLib/DocxFormatLib.pro",
     "[!no_x2t]core/OOXML/Projects/Linux/PPTXFormatLib/PPTXFormatLib.pro",
     "[!no_x2t]core/OOXML/Projects/Linux/XlsbFormatLib/XlsbFormatLib.pro",
@@ -83,17 +79,19 @@
   "multimedia" : [
     "[win,linux]desktop-sdk/ChromiumBasedEditors/videoplayerlib/videoplayerlib.pro"
   ],
-
+  
   "desktop" : [
     "core",
     "multimedia",
+    
+    "core/DesktopEditor/xmlsec/src/ooxmlsignature.pro",
 
     "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore.pro",
     "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore_helper.pro",
 
     "[win,linux]desktop-sdk/ChromiumBasedEditors/lib/qt_wrapper/qtascdocumentscore.pro",
     "[win,linux]desktop-apps/win-linux/ASCDocumentEditor.pro",
-
+    
     "[win]desktop-apps/win-linux/extras/projicons/ProjIcons.pro",
     "[win,!win_xp]desktop-apps/win-linux/extras/update-daemon/UpdateDaemon.pro"
   ],

tools/linux/.gitignore

@@ -1,5 +0,0 @@
-qt_build
-packages_complete
-python3
-python3.tar.gz
-extract.sh

tools/linux/automate.py

@@ -6,7 +6,6 @@ import base
 import os
 import subprocess
 import deps
-import qt_binary_build
 
 def get_branch_name(directory):
   cur_dir = os.getcwd()
@@ -58,7 +57,12 @@ def install_qt():
   return
   
 def install_qt_prebuild():
-  base.cmd("python3", ["qt_binary_fetch.py", "all"])
+  url_amd64 = "https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/qt/qt_binary_linux_amd64.7z"
+  base.download(url_amd64, "./qt_amd64.7z")
+  base.extract("./qt_amd64.7z", "./qt_build")
+  base.create_dir("./qt_build/Qt-5.9.9")
+  base.cmd("mv", ["./qt_build/qt_amd64", "./qt_build/Qt-5.9.9/gcc_64"])
+  base.setup_local_qmake("./qt_build/Qt-5.9.9/gcc_64/bin")
   return
 
 if not base.is_file("./node_js_setup_14.x"):
@@ -68,7 +72,7 @@ if not base.is_file("./node_js_setup_14.x"):
 if not base.is_dir("./qt_build"):
   print("install qt...")
   if base.get_env("DO_NOT_USE_PREBUILD_QT") == "1":
-    qt_binary_build.install_qt()
+    install_qt()
   else:
     install_qt_prebuild()
 

tools/linux/cmake.sh

@@ -1,5 +0,0 @@
-wget https://github.com/Kitware/CMake/releases/download/v3.30.0/cmake-3.30.0-linux-x86_64.tar.gz
-tar -xzf cmake-3.30.0-linux-x86_64.tar.gz -C /opt
-ln -s /opt/cmake-3.30.0-linux-x86_64/bin/cmake /usr/local/bin/cmake
-ln -s /opt/cmake-3.30.0-linux-x86_64/bin/ctest /usr/local/bin/ctest
-rm cmake-3.30.0-linux-x86_64.tar.gz

tools/linux/deps.py

@@ -16,7 +16,6 @@ def install_deps():
               "build-essential",
               "ca-certificates",
               "cmake",
-              "perl",
               "curl",
               "git",
               "glib-2.0-dev",
@@ -69,7 +68,7 @@ def install_deps():
     print("OK")
     base.cmd("sudo", ["apt-get", "-y", "install", "npm", "yarn"], True)
   base.cmd("sudo", ["npm", "install", "-g", "grunt-cli"])
-  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg@6.11.0"])
+  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg"])
 
   # java
   java_error = base.cmd("sudo", ["apt-get", "-y", "install", "openjdk-11-jdk"], True)

tools/linux/python.sh

@@ -1,16 +0,0 @@
-#!/bin/bash
-
-wget https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/python3.tar.gz
-wget https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/extract.sh
-
-chmod +x ./extract.sh
-./extract.sh
-
-cd ./python3/bin
-ln -s python3 python
-cd ../../
-
-rm ./extract.sh
-rm ./python3.tar.gz
-
-

tools/linux/qt_binary_build.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../../scripts')
-import base
-import os
-import subprocess
-import deps
-
-def install_qt():
-  # qt
-  if not base.is_file("./qt_source_5.9.9.tar.xz"):
-    base.download("https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/qt/qt-everywhere-opensource-src-5.9.9.tar.xz", "./qt_source_5.9.9.tar.xz")
-
-  if not base.is_dir("./qt-everywhere-opensource-src-5.9.9"):
-    base.cmd("tar", ["-xf", "./qt_source_5.9.9.tar.xz"])
-
-  qt_params = ["-opensource",
-               "-confirm-license",
-               "-release",
-               "-shared",
-               "-accessibility",
-               "-prefix",
-               "./../qt_build/Qt-5.9.9/gcc_64",
-               "-qt-zlib",
-               "-qt-libpng",
-               "-qt-libjpeg",
-               "-qt-xcb",
-               "-qt-pcre",
-               "-no-sql-sqlite",
-               "-no-qml-debug",
-               "-gstreamer", "1.0",
-               "-nomake", "examples",
-               "-nomake", "tests",
-               "-skip", "qtenginio",
-               "-skip", "qtlocation",
-               "-skip", "qtserialport",
-               "-skip", "qtsensors",
-               "-skip", "qtxmlpatterns",
-               "-skip", "qt3d",
-               "-skip", "qtwebview",
-               "-skip", "qtwebengine"]
-
-  base.cmd_in_dir("./qt-everywhere-opensource-src-5.9.9", "./configure", qt_params)
-  base.cmd_in_dir("./qt-everywhere-opensource-src-5.9.9", "make", ["-j", "4"])
-  base.cmd_in_dir("./qt-everywhere-opensource-src-5.9.9", "make", ["install"])
-  return

tools/linux/qt_binary_fetch.py

@@ -1,67 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import os
-sys.path.append('../../scripts')
-
-import base
-
-URL = "https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/qt/"
-
-SYSROOTS = {
-  "amd64": "qt_binary_5.9.9_gcc_64.7z",
-  "arm64": "qt_binary_5.9.9_gcc_arm64.7z",
-}
-
-COMPILERS = {
-  "amd64": "gcc_64",
-  "arm64": "gcc_arm64",
-}
-
-def download_and_extract(name):
-  cur_dir = os.getcwd()
-  os.chdir("./qt_build/Qt-5.9.9")
-  archive = SYSROOTS[name]
-  folder = "./" + COMPILERS[name]
-  if (base.is_dir(folder)):
-    base.delete_dir(folder)
-  archive_file = "./" + archive
-  base.download(URL + archive, archive_file)
-  base.extract(archive_file, "./")
-  os.chdir(cur_dir)
-  base.setup_local_qmake("./qt_build/Qt-5.9.9/" + COMPILERS[name] + "/bin")
-
-def main():
-  if len(sys.argv) != 2:
-    print("Usage: fetch.py [amd64|arm64|all]")
-    sys.exit(1)
-
-  target = sys.argv[1]
-
-  if not base.is_dir("./qt_build/Qt-5.9.9"):
-    base.create_dir("./qt_build/Qt-5.9.9")
-
-  targets = []
-  if ("all" == target):
-    targets.append("amd64")
-    targets.append("arm64")
-  elif ("arm64" == target) and not base.is_os_arm():
-    targets.append("amd64")
-    targets.append(target)
-  else:
-    targets.append(target)
-
-  if (0 == len(targets)):
-    print(f"Unknown target: {target}")
-    print("Valid values: amd64, arm64, all")
-    sys.exit(1)
-
-  for name in targets:
-    download_and_extract(name)
-
-  if "arm64" in targets and not base.is_os_arm():
-    base.move_dir("./qt_build/Qt-5.9.9/gcc_arm64/bin", "./qt_build/Qt-5.9.9/gcc_arm64/_bin")
-    base.copy_dir("./qt_build/Qt-5.9.9/gcc_64/bin", "./qt_build/Qt-5.9.9/gcc_arm64/bin")
-
-if __name__ == "__main__":
-    main()

tools/linux/sysroot/.gitignore

@@ -1,2 +0,0 @@
-*sysroot*
-

tools/linux/sysroot/build_sysroot.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../scripts')
+import base
+import os
+import shutil
+import fix_symlinks
+
+def bash_chroot(command, sysroot):
+    base.cmd2('sudo -S chroot', [sysroot, '/bin/bash -c', '\"' + command + ' \"'])
+
+
+def download_sysroot():
+    curr_dir = base.get_script_dir(__file__)
+    tmp_sysroot_ubuntu_dir = curr_dir + '/sysroot_ubuntu_1604'
+
+    if os.path.isdir(tmp_sysroot_ubuntu_dir):
+       shutil.rmtree(tmp_sysroot_ubuntu_dir)
+
+    # debootstrap for downloading sysroot
+    base.cmd2('sudo -S apt-get', ['install', 'debootstrap'])
+
+    archive_ubuntu_url = 'http://archive.ubuntu.com/ubuntu/'
+    base.cmd2('sudo -S debootstrap', ['--arch=amd64', 'xenial', tmp_sysroot_ubuntu_dir, archive_ubuntu_url])
+
+    # setup a new sources
+    base.cmd2('sudo -S cp', [curr_dir + '/sources.list', tmp_sysroot_ubuntu_dir + '/etc/apt/sources.list'])
+
+    bash_chroot('apt update -y', tmp_sysroot_ubuntu_dir)
+    bash_chroot('apt upgrade -y', tmp_sysroot_ubuntu_dir)
+    
+    apt_libs = ["build-essential"]
+    apt_libs += ["libpthread-stubs0-dev"]
+    apt_libs += ["zlib1g-dev"]
+    apt_libs += ["curl"]
+    apt_libs += ["libc6-dev"]
+    apt_libs += ["glib-2.0-dev"]
+    apt_libs += ["libglu1-mesa-dev"]
+    apt_libs += ["libgtk-3-dev"]
+    apt_libs += ["libpulse-dev"]
+    apt_libs += ["libasound2-dev"]
+    apt_libs += ["libatspi2.0-dev"]
+    apt_libs += ["libcups2-dev"]
+    apt_libs += ["libdbus-1-dev"]
+    apt_libs += ["libicu-dev"]
+    apt_libs += ["libgstreamer1.0-dev"]
+    apt_libs += ["libgstreamer-plugins-base1.0-dev"]
+    apt_libs += ["libx11-xcb-dev"]
+    apt_libs += ["libxcb*"]
+    apt_libs += ["libxi-dev"]
+    apt_libs += ["libxrender-dev"]
+    apt_libs += ["libxss-dev"]
+    apt_libs += ["libxkbcommon-dev"]
+    apt_libs += ["libxkbcommon-x11-dev"]
+    apt_libs += ["libnotify-dev"]
+    apt_libs += ["gtk+-3.0-dev"]
+    
+    apt_libs_str = ""
+    for apt_lib in apt_libs:
+        apt_libs_str += apt_lib + " "
+    bash_chroot('apt install -y ' + apt_libs_str, tmp_sysroot_ubuntu_dir)
+
+    # # downloading arm toolchain
+    arm_toolchain_url = 'https://releases.linaro.org/components/toolchain/binaries/5.4-2017.05/aarch64-linux-gnu/'
+    arm_toolchain_tar_filename = 'gcc-linaro-5.4.1-2017.05-x86_64_aarch64-linux-gnu.tar.xz'
+    arm_toolchain_output_dir = 'gcc-linaro-5.4.1-2017.05-x86_64_aarch64-linux-gnu'
+    base.cmd2('wget', [arm_toolchain_url + arm_toolchain_tar_filename])
+    base.cmd2('tar', ['-xf', arm_toolchain_tar_filename])
+    base.cmd2('sudo -S rsync', ['-avh', '--progress', curr_dir + '/' + arm_toolchain_output_dir + '/', tmp_sysroot_ubuntu_dir + '/usr/'])
+    shutil.rmtree(arm_toolchain_output_dir)
+    os.remove(arm_toolchain_tar_filename)
+
+    base.cmd2('sudo -S chmod', ['-R', 'o+rwx', tmp_sysroot_ubuntu_dir])
+
+    # fix symlinks
+    fix_symlinks.fix_symlinks(tmp_sysroot_ubuntu_dir)
+
+    return
+
+if __name__ == '__main__':
+    download_sysroot()

tools/linux/sysroot/custom-sysroot.toolchain.cmake

@@ -1,19 +1,4 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_MAKE_PROGRAM "/usr/bin/make" CACHE FILEPATH "" FORCE)
-
-set(CMAKE_C_COMPILER $ENV{CC})
-set(CMAKE_CXX_COMPILER $ENV{CXX})
-set(CMAKE_AR $ENV{AR})
-set(CMAKE_RANLIB $ENV{RANLIB})
-
-set(CMAKE_C_FLAGS "$ENV{CFLAGS}" CACHE STRING "" FORCE)
-set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS}" CACHE STRING "" FORCE)
-set(CMAKE_EXE_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "" FORCE)
-set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "" FORCE)
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+set(CMAKE_C_FLAGS $ENV{CFLAGS})
+set(CMAKE_CXX_FLAGS $ENV{CXXFLAGS})
+set(CMAKE_C_LINKER_FLAGS $ENV{LDFLAGS})
+set(CMAKE_CXX_LINKER_FLAGS $ENV{LDFLAGS})

tools/linux/sysroot/fetch.py

@@ -1,224 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import os
-sys.path.append('../../../scripts')
-
-import base
-
-URL = "https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/sysroot/"
-
-SYSROOTS = {
-  "amd64": "ubuntu16-amd64-sysroot.tar.gz",
-  "arm64": "ubuntu16-arm64-sysroot.tar.gz",
-}
-
-def patch_linker_scripts(sysroot_path, arch):
-  """Fix absolute paths in linker scripts to use sysroot-relative paths"""
-  
-  # Determine directories to patch
-  lib_dirs = []
-  
-  if arch == "arm64":
-    lib_dirs = [
-      os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
-    ]
-  elif arch == "amd64":
-    lib_dirs = [
-      os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu"),
-      os.path.join(sysroot_path, "usr/aarch64-linux-gnu/lib")
-    ]
-  else:
-    return
-  
-  total_patched = 0
-  
-  for lib_dir in lib_dirs:
-    if not os.path.exists(lib_dir):
-      print(f"Warning: {lib_dir} not found, skipping")
-      continue
-    
-    print(f"Patching linker scripts in {lib_dir}...")
-    patched_count = 0
-    
-    for filename in os.listdir(lib_dir):
-      if not filename.endswith(".so"):
-        continue
-      
-      filepath = os.path.join(lib_dir, filename)
-      if not os.path.isfile(filepath):
-        continue
-      
-      # Check if it's a text file (linker script)
-      try:
-        with open(filepath, 'r') as f:
-          content = f.read()
-        
-        # Skip if not a linker script
-        if "GROUP" not in content and "INPUT" not in content:
-          continue
-          
-        original_content = content
-        
-        # STEP 1: Normalize all /usr/lib paths to /lib
-        # ORDER MATTERS - do longest paths first to avoid partial matches
-        
-        # For aarch64
-        content = content.replace("/usr/aarch64-linux-gnu/lib/", "/lib/aarch64-linux-gnu/")
-        content = content.replace("/usr/lib/aarch64-linux-gnu/", "/lib/aarch64-linux-gnu/")
-        
-        # For x86_64  
-        content = content.replace("/usr/x86_64-linux-gnu/lib/", "/lib/x86_64-linux-gnu/")
-        content = content.replace("/usr/lib/x86_64-linux-gnu/", "/lib/x86_64-linux-gnu/")
-        
-        # STEP 2: Add = prefix for sysroot-relative paths
-        content = content.replace("/lib/aarch64-linux-gnu/", "=/lib/aarch64-linux-gnu/")
-        content = content.replace("/lib/x86_64-linux-gnu/", "=/lib/x86_64-linux-gnu/")
-        
-        # Write back only if changed
-        if content != original_content:
-          with open(filepath, 'w') as f:
-            f.write(content)
-          
-          print(f"  Patched: {filename}")
-          patched_count += 1
-      except Exception as e:
-        # Not a text file or other error, skip
-        pass
-    
-    total_patched += patched_count
-    print(f"Patched {patched_count} linker scripts in {lib_dir}")
-  
-  print(f"Total patched: {total_patched} linker scripts")
-  
-  # Create symlinks from /lib to /usr/lib for library resolution
-  create_lib_symlinks(sysroot_path, arch)
-  
-  # Fix absolute symlinks to relative ones
-  fix_absolute_symlinks(sysroot_path, arch)
-
-
-def create_lib_symlinks(sysroot_path, arch):
-  """Create symlinks from /lib to /usr/lib for library resolution"""
-  print(f"Creating library symlinks in {sysroot_path}...")
-  
-  if arch == "arm64":
-    lib_symlink_dir = os.path.join(sysroot_path, "lib/aarch64-linux-gnu")
-    lib_target_dir = os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
-  elif arch == "amd64":
-    lib_symlink_dir = os.path.join(sysroot_path, "lib/x86_64-linux-gnu")
-    lib_target_dir = os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu")
-  else:
-    return
-  
-  # Create /lib/{arch} directory
-  os.makedirs(lib_symlink_dir, exist_ok=True)
-  
-  if not os.path.exists(lib_target_dir):
-    print(f"  Warning: Target directory {lib_target_dir} does not exist")
-    return
-  
-  symlink_count = 0
-  
-  # Create symlinks for all files in /usr/lib/{arch}
-  for filename in os.listdir(lib_target_dir):
-    target = os.path.join(lib_target_dir, filename)
-    link = os.path.join(lib_symlink_dir, filename)
-    
-    # Skip if symlink already exists
-    if os.path.exists(link) or os.path.islink(link):
-      continue
-    
-    # Create relative symlink
-    rel_target = os.path.relpath(target, lib_symlink_dir)
-    try:
-      os.symlink(rel_target, link)
-      symlink_count += 1
-    except OSError as e:
-      print(f"  Warning: Could not create symlink {link}: {e}")
-  
-  print(f"Created {symlink_count} symlinks in {lib_symlink_dir}")
-
-
-def fix_absolute_symlinks(sysroot_path, arch):
-  """Fix absolute symlinks in /usr/lib to use relative paths"""
-  print(f"Fixing absolute symlinks in {sysroot_path}...")
-  
-  if arch == "arm64":
-    lib_dir = os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
-    target_lib_dir = "aarch64-linux-gnu"
-  elif arch == "amd64":
-    lib_dir = os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu")
-    target_lib_dir = "x86_64-linux-gnu"
-  else:
-    return
-  
-  if not os.path.exists(lib_dir):
-    print(f"  Warning: {lib_dir} not found")
-    return
-  
-  fixed_count = 0
-  
-  # Find all .so symlinks pointing to /lib/
-  for filename in os.listdir(lib_dir):
-    if not filename.endswith(".so"):
-      continue
-    
-    filepath = os.path.join(lib_dir, filename)
-    
-    # Check if it's a symlink
-    if not os.path.islink(filepath):
-      continue
-    
-    # Get symlink target
-    target = os.readlink(filepath)
-    
-    # Check if it's an absolute path starting with /lib/
-    if target.startswith("/lib/"):
-      # Convert to relative path: /lib/... -> ../../../lib/...
-      relative_target = os.path.join("../../..", target[1:])  # Remove leading /
-      
-      # Remove old symlink and create new one
-      os.unlink(filepath)
-      os.symlink(relative_target, filepath)
-      
-      print(f"  Fixed: {filename} -> {relative_target}")
-      fixed_count += 1
-      
-  libgcc_usr_symlink = os.path.join(lib_dir, "libgcc_s.so")
-  libgcc_target = os.path.join(sysroot_path, "lib", target_lib_dir, "libgcc_s.so.1")
-  
-  if os.path.exists(libgcc_target) and not os.path.exists(libgcc_usr_symlink):
-    absolute_libgcc = os.path.abspath(libgcc_target)
-    os.symlink(absolute_libgcc, libgcc_usr_symlink)
-    fixed_count += 1
-  
-  print(f"Fixed {fixed_count} absolute symlinks")
-
-def download_and_extract(name):
-  archive = SYSROOTS[name]
-  base.download(URL + archive, "./" + archive)
-  base.cmd("tar", ["-xzf", "./" + archive])
-
-  sysroot_name = archive.replace(".tar.gz", "")
-  patch_linker_scripts(sysroot_name, name)
-
-def main():
-  if len(sys.argv) != 2:
-    print("Usage: fetch.py [amd64|arm64|all]")
-    sys.exit(1)
-
-  target = sys.argv[1]
-
-  if target == "all":
-    for name in SYSROOTS:
-      download_and_extract(name)
-  elif target in SYSROOTS:
-    download_and_extract(target)
-  else:
-    print(f"Unknown target: {target}")
-    print("Valid values: amd64, arm64, all")
-    sys.exit(1)
-
-if __name__ == "__main__":
-    main()

tools/linux/sysroot/fix_symlinks.py

@@ -0,0 +1,45 @@
+import os
+import sys
+import uuid
+
+# change symbolic link to relative paths
+def fix_symlinks(top_dir='./sysroot_ubuntu_1604'):
+    for root, dirs, files in os.walk(top_dir):
+        for name in files:
+            path = os.path.join(root, name)
+            if not os.path.islink(path):
+                continue
+            try:
+                target = os.readlink(path)
+            except OSError as e:
+                print(f"Error reading link '{path}': {e}", file=sys.stderr)
+                continue
+            
+            if not target.startswith('/'):
+                continue
+            
+            new_target = top_dir + target
+            new_target_rel = os.path.relpath(new_target, os.path.dirname(path))
+            temp_name = f".tmp.{uuid.uuid4().hex}"
+            temp_path = os.path.join(root, temp_name)
+            try:
+                os.symlink(new_target_rel, temp_path)
+            except OSError as e:
+                print(f"Failed to create temporary symlink for '{path}': {e}", file=sys.stderr)
+                continue
+            try:
+                os.replace(temp_path, path)
+                print(f"Updated: {path} -> {new_target_rel}")
+            except OSError as e:
+                print(f"Failed to replace symlink '{path}': {e}", file=sys.stderr)
+                try:
+                    os.unlink(temp_path)
+                except OSError:
+                    pass
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        directory = sys.argv[1]
+    else:
+        directory = './sysroot_ubuntu_1604'
+    fix_symlinks(directory)

tools/linux/sysroot/sources.list

@@ -0,0 +1,51 @@
+#deb cdrom:[Ubuntu 16.04.2 LTS _Xenial Xerus_ - Release amd64 (20170215.2)]/ xenial main restricted
+
+# See http://help.ubuntu.com/community/UpgradeNotes for how to upgrade to
+# newer versions of the distribution.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial main restricted
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial main restricted
+
+## Major bug fix updates produced after the final release of the
+## distribution.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates main restricted
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates main restricted
+
+## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
+## team. Also, please note that software in universe WILL NOT receive any
+## review or updates from the Ubuntu security team.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial universe
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial universe
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates universe
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates universe
+
+## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu 
+## team, and may not be under a free licence. Please satisfy yourself as to 
+## your rights to use the software. Also, please note that software in 
+## multiverse WILL NOT receive any review or updates from the Ubuntu
+## security team.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial multiverse
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial multiverse
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates multiverse
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates multiverse
+
+## N.B. software from this repository may not have been tested as
+## extensively as that contained in the main release, although it includes
+## newer versions of some applications which may provide useful features.
+## Also, please note that software in backports WILL NOT receive any review
+## or updates from the Ubuntu security team.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse
+
+## Uncomment the following two lines to add software from Canonical's
+## 'partner' repository.
+## This software is not part of Ubuntu, but is offered by Canonical and the
+## respective vendors as a service to Ubuntu users.
+# deb http://archive.canonical.com/ubuntu xenial partner
+# deb-src http://archive.canonical.com/ubuntu xenial partner
+
+deb http://security.ubuntu.com/ubuntu xenial-security main restricted
+# deb-src http://security.ubuntu.com/ubuntu xenial-security main restricted
+deb http://security.ubuntu.com/ubuntu xenial-security universe
+# deb-src http://security.ubuntu.com/ubuntu xenial-security universe
+deb http://security.ubuntu.com/ubuntu xenial-security multiverse
+# deb-src http://security.ubuntu.com/ubuntu xenial-security multiverse

tools/linux/sysroot/system-aarch64.toolchain.cmake

@@ -1,17 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
-set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
-
-set(CMAKE_C_LINKER aarch64-linux-gnu-ld)
-set(CMAKE_CXX_LINKER aarch64-linux-gnu-ld)
-
-set(CMAKE_AR aarch64-linux-gnu-ar)
-set(CMAKE_RANLIB aarch64-linux-gnu-ranlib)
-set(CMAKE_STRIP aarch64-linux-gnu-strip)
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

version

@@ -1 +1 @@
-9.3.0
+9.1.0