Merge branch 'espressif:master' into master

Author: DogushC

.github/ISSUE_TEMPLATE/Issue-report.yml

@@ -43,6 +43,7 @@ body:
         - latest stable Release (if not listed below)
         - latest development Release Candidate (RC-X)
         - latest master (checkout manually)
+        - v3.3.1
         - v3.3.0
         - v3.2.1
         - v3.2.0

.github/scripts/get_affected.py

@@ -222,6 +222,123 @@ def detect_universal_ctags() -> bool:
     except Exception:
         return False
 
+def normalize_function_signature(signature: str) -> str:
+    """
+    Normalize a function signature by removing parameter names, keeping only types.
+
+    This handles cases where header declarations and implementations have different parameter names.
+    Uses a simple heuristic: the last word in each parameter is typically the parameter name.
+
+    For example:
+    - "ltoa(long val, char *s, int radix)" -> "ltoa(long,char *,int)"
+    - "ltoa(long value, char *result, int base)" -> "ltoa(long,char *,int)"
+
+    Args:
+        signature: The function signature string, e.g., "(long val, char *s, int radix)"
+
+    Returns:
+        Normalized signature with parameter names removed, e.g., "(long,char *,int)"
+    """
+    if not signature:
+        return signature
+
+    # Normalize signatures: treat (void) and () as equivalent (both mean no parameters)
+    if signature == "(void)":
+        return "()"
+
+    if not (signature.startswith("(") and signature.endswith(")")):
+        return signature
+
+    # Handle const qualifier at the end (e.g., "(int i) const")
+    const_qualifier = ""
+    if signature.endswith(" const"):
+        signature = signature[:-6]  # Remove " const"
+        const_qualifier = " const"
+
+    # Extract parameter list without parentheses
+    param_list = signature[1:-1]
+    if not param_list.strip():
+        return "()" + const_qualifier
+
+    # Split by comma and process each parameter
+    params = []
+    for param in param_list.split(","):
+        param = param.strip()
+        if not param:
+            continue
+
+        # Handle default parameters (e.g., "int x = 5")
+        if "=" in param:
+            param = param.split("=")[0].strip()
+
+        # Try simple approach first: remove the last word
+        # This works for most cases: "int x" -> "int", "MyStruct s" -> "MyStruct"
+        import re
+
+        # Handle arrays first: "int arr[10]" -> "int [10]", "char *argv[]" -> "char *[]"
+        array_match = re.match(r'^(.+?)\s+(\w+)((?:\[\d*\])+)$', param)
+        if array_match:
+            type_part = array_match.group(1).strip()
+            array_brackets = array_match.group(3)
+            params.append(type_part + array_brackets)
+        else:
+            # Handle function pointers: "int (*func)(int, char)" -> "int (*)(int, char)"
+            func_ptr_match = re.match(r'^(.+?)\s*\(\s*\*\s*(\w+)\s*\)\s*\((.+?)\)\s*$', param)
+            if func_ptr_match:
+                return_type = func_ptr_match.group(1).strip()
+                inner_params = func_ptr_match.group(3).strip()
+                # Recursively normalize the inner parameters
+                if inner_params:
+                    inner_normalized = normalize_function_signature(f"({inner_params})")
+                    inner_normalized = inner_normalized[1:-1]  # Remove outer parentheses
+                else:
+                    inner_normalized = ""
+                params.append(f"{return_type} (*)({inner_normalized})")
+            else:
+                # Try simple approach: remove the last word
+                simple_match = re.match(r'^(.+)\s+(\w+)$', param)
+                if simple_match:
+                    # Simple case worked - just remove the last word
+                    type_part = simple_match.group(1).strip()
+                    params.append(type_part)
+                else:
+                    # Fallback to complex regex for edge cases with pointers
+                    # First, try to match cases with pointers/references (including multiple *)
+                    # Pattern: (everything before) (one or more * or &) (space) (parameter name)
+                    m = re.match(r'^(.+?)(\s*[*&]+\s+)(\w+)$', param)
+                    if m:
+                        # Keep everything before the pointers, plus the pointers (without the space before param name)
+                        type_part = m.group(1) + m.group(2).rstrip()
+                        params.append(type_part.strip())
+                    else:
+                        # Try to match cases without space between type and pointer: "char*ptr", "char**ptr"
+                        m = re.match(r'^(.+?)([*&]+)(\w+)$', param)
+                        if m:
+                            # Keep everything before the pointers, plus the pointers
+                            type_part = m.group(1) + m.group(2)
+                            params.append(type_part.strip())
+                        else:
+                            # Single word - assume it's a type
+                            params.append(param.strip())
+
+        # Normalize spacing around pointers to ensure consistent output
+        # This ensures "char *" and "char*" both become "char *"
+        if params:
+            last_param = params[-1]
+            # Normalize spacing around * and & symbols
+            # Replace multiple spaces with single space, ensure space before * and &
+            normalized = re.sub(r'\s+', ' ', last_param)  # Collapse multiple spaces
+            normalized = re.sub(r'\s*([*&]+)', r' \1', normalized)  # Ensure space before * and &
+            normalized = re.sub(r'([*&]+)\s*', r'\1 ', normalized)  # Ensure space after * and &
+            normalized = re.sub(r'\s+', ' ', normalized).strip()  # Clean up extra spaces
+            params[-1] = normalized
+
+    result = "(" + ",".join(params) + ")"
+    if const_qualifier:
+        result += const_qualifier
+
+    return result
+
 def build_qname_from_tag(tag: dict) -> str:
     """
     Compose a qualified name for a function/method using scope + name + signature.
@@ -231,9 +348,8 @@ def build_qname_from_tag(tag: dict) -> str:
     name = tag.get("name") or ""
     signature = tag.get("signature") or ""
 
-    # Normalize signatures: treat (void) and () as equivalent (both mean no parameters)
-    if signature == "(void)":
-        signature = "()"
+    # Normalize the signature to remove parameter names
+    signature = normalize_function_signature(signature)
 
     qparts = []
     if scope:

.github/scripts/update-version.sh

@@ -24,16 +24,20 @@ ESP_ARDUINO_VERSION_MINOR="$2"
 ESP_ARDUINO_VERSION_PATCH="$3"
 ESP_ARDUINO_VERSION="$ESP_ARDUINO_VERSION_MAJOR.$ESP_ARDUINO_VERSION_MINOR.$ESP_ARDUINO_VERSION_PATCH"
 
-# Get ESP-IDF version from push.yml (this way we can ensure that the version is correct even if the local libs are not up to date)
-ESP_IDF_VERSION=$(grep "idf_ver:" .github/workflows/push.yml | sed 's/.*release-v\([^"]*\).*/\1/')
+# Get ESP-IDF version from build_component.yml (this way we can ensure that the version is correct even if the local libs are not up to date)
+ESP_IDF_VERSION=$(grep -m 1 "default:" .github/workflows/build_component.yml | sed 's/.*release-v\([^"]*\).*/\1/')
 if [ -z "$ESP_IDF_VERSION" ]; then
-    echo "Error: ESP-IDF version not found in push.yml" >&2
+    echo "Error: ESP-IDF version not found in build_component.yml" >&2
     exit 1
 fi
 
 echo "New Arduino Version: $ESP_ARDUINO_VERSION"
 echo "ESP-IDF Version: $ESP_IDF_VERSION"
 
+echo "Updating issue template..."
+cat .github/ISSUE_TEMPLATE/Issue-report.yml | \
+sed "s/.*\- latest master .*/        - latest master \(checkout manually\)\\n        - v$ESP_ARDUINO_VERSION/g" > __issue-report.yml && mv __issue-report.yml .github/ISSUE_TEMPLATE/Issue-report.yml
+
 echo "Updating platform.txt..."
 cat platform.txt | sed "s/version=.*/version=$ESP_ARDUINO_VERSION/g" > __platform.txt && mv __platform.txt platform.txt
 

.github/scripts/update_esptool.py

@@ -33,6 +33,7 @@
 import os
 import shutil
 import stat
+import subprocess
 import tarfile
 import zipfile
 import hashlib
@@ -201,10 +202,34 @@ def get_release_info(version):
     response.raise_for_status()
     return response.json()
 
+def create_branch_and_commit(version, json_path):
+    """Create a new branch and commit the changes to it."""
+    branch_name = f"update-esptool-{version}"
+    commit_message = f"change(esptool): Upgrade to version {version}"
+
+    try:
+        # Create and checkout new branch
+        subprocess.run(["git", "checkout", "-b", branch_name], check=True, capture_output=True, text=True)
+        print(f"Created and switched to new branch: {branch_name}")
+
+        # Stage the JSON file
+        subprocess.run(["git", "add", str(json_path)], check=True, capture_output=True, text=True)
+        print(f"Staged file: {json_path}")
+
+        # Commit the changes
+        subprocess.run(["git", "commit", "-m", commit_message], check=True, capture_output=True, text=True)
+        print(f"Committed changes with message: {commit_message}")
+
+    except subprocess.CalledProcessError as e:
+        print(f"Git operation failed: {e}")
+        print(f"Command output: {e.stderr if e.stderr else e.stdout}")
+        raise
+
 def main():
     parser = argparse.ArgumentParser(description="Repack esptool and update JSON metadata.")
     parser.add_argument("version", help="Version of the esptool (e.g. 5.0.dev1)")
     parser.add_argument("-l", "--local", dest="base_folder", help="Enable local build mode and set the base folder with unpacked artifacts")
+    parser.add_argument("-c", "--commit", action="store_true", help="Automatically create a new branch and commit the JSON file changes")
     args = parser.parse_args()
 
     script_dir = Path(__file__).resolve().parent
@@ -232,5 +257,10 @@ def main():
     shutil.move(tmp_json_path, json_path)
     print(f"Done. JSON updated at {json_path}")
 
+    # Auto-commit if requested
+    if args.commit:
+        print("Auto-commit enabled. Creating branch and committing changes...")
+        create_branch_and_commit(args.version, json_path)
+
 if __name__ == "__main__":
     main()

.github/workflows/pre-commit-status.yml

@@ -131,3 +131,24 @@ jobs:
           gh pr edit ${{ steps.pr-info.outputs.pr_number }} --repo ${{ github.repository }} --remove-label 'Status: Pre-commit fixes required ⚠️'
         env:
           GH_TOKEN: ${{ github.token }}
+
+      - name: Comment on PR about pre-commit failures
+        if: |
+          steps.pr-info.outputs.artifacts_found == 'true' &&
+          steps.pr-info.outputs.pre_commit_outcome == 'failure' &&
+          steps.pr-info.outputs.pending_commit == '0'
+        uses: thollander/actions-comment-pull-request@24bffb9b452ba05a4f3f77933840a6a841d1b32b # v3.0.1
+        with:
+          pr-number: ${{ steps.pr-info.outputs.pr_number }}
+          message: |
+            ## ⚠️ Pre-commit Hooks Failed
+
+            Some pre-commit hooks failed and require manual fixes. Please see the detailed error report below.
+
+            **What to do:**
+            1. 📋 [**View the detailed error report**](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.event.workflow_run.id }}) to see which hooks failed
+            2. 🔧 Fix the issues locally in your code
+            3. 💾 Commit and push your changes
+            4. 🔄 The hooks will run again automatically
+
+            **Need help?** Ask in the comments below.

.gitlab/workflows/common.yml

@@ -10,7 +10,7 @@ stages:
 
 variables:
   ESP_IDF_VERSION: "5.5"
-  ESP_ARDUINO_VERSION: "3.3.0"
+  ESP_ARDUINO_VERSION: "3.3.1"
 
 #############
 # `default` #

CMakeLists.txt

@@ -32,6 +32,7 @@ set(CORE_SRCS
   cores/esp32/esp32-hal-cpu.c
   cores/esp32/esp32-hal-dac.c
   cores/esp32/esp32-hal-gpio.c
+  cores/esp32/esp32-hal-hosted.c
   cores/esp32/esp32-hal-i2c.c
   cores/esp32/esp32-hal-i2c-ng.c
   cores/esp32/esp32-hal-i2c-slave.c

Kconfig.projbuild

@@ -341,9 +341,15 @@ config ARDUINO_SELECTIVE_PPP
     depends on ARDUINO_SELECTIVE_COMPILATION
     default y
 
+config ARDUINO_SELECTIVE_Hash
+    bool "Enable Hash"
+    depends on ARDUINO_SELECTIVE_COMPILATION
+    default y
+
 config ARDUINO_SELECTIVE_ArduinoOTA
     bool "Enable ArduinoOTA"
     depends on ARDUINO_SELECTIVE_COMPILATION && ARDUINO_SELECTIVE_Network
+    select ARDUINO_SELECTIVE_Hash
     select ARDUINO_SELECTIVE_ESPmDNS
     default y
 
@@ -383,6 +389,7 @@ config ARDUINO_SELECTIVE_WebServer
     depends on ARDUINO_SELECTIVE_COMPILATION && ARDUINO_SELECTIVE_Network
     default y
     select ARDUINO_SELECTIVE_FS
+    select ARDUINO_SELECTIVE_Hash
 
 config ARDUINO_SELECTIVE_WiFi
     bool "Enable WiFi"