Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2026-02-07 21:42:56 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
Files
bcddaa59a9050f3ae0e030f61ba4d965769103a2
nuttx/tools/process_config.py
xuxin19 e9e9c76a76 cmake(enhance):include-style defconfig can modified via menuconfig 
1. enhanced process_config.py script: supports both preprocess and postprocess modes

2. in preprocess mode: handles include formats and recursively records the include config tree structure to prepare for postprocess

3. In postprocess mode: compares the original file with menuconfig to identify non-#include items that should be written back

4. olddefconfig stores the original compressed include defconfig file at the very beginning

5. savedefconfig saves both the original file and the written back include defconfig

Signed-off-by: xuxin19 <xuxin19@xiaomi.com>
2026-01-15 15:42:17 -03:00

532 lines
19 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python3
# tools/process_config.py
#
# SPDX-License-Identifier: Apache-2.0
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership. The
# ASF licenses this file to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance with the
# License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
import json
import os
import re
import shutil
import sys
from collections import OrderedDict
from pathlib import Path
def parse_config_line(line):
"""
Parse a configuration line and return the key and value.
Args:
line (str): A line from a configuration file
Returns:
tuple: (key, value) if the line contains a configuration, (None, None) otherwise
Handles two formats:
1. "# CONFIG_XXX is not set" -> returns (CONFIG_XXX, 'n')
2. "CONFIG_XXX=value" -> returns (CONFIG_XXX, value)
"""
line = line.strip()
if not line:
return None, None
# Handle "# CONFIG_XXX is not set" format
if line.startswith("# ") and line.endswith(" is not set"):
config_name = line.split()[1]
return config_name, "n"
# Handle "CONFIG_XXX=value" format
if "=" in line:
key, value = line.split("=", 1)
return key, value
return None, None
def opposite(value):
if value == "n":
return "y"
else:
return "n"
def expand_file(input_path, include_paths, processed=None, tree_node=None):
"""
Recursively expand a configuration file with #include directives.
Args:
input_path (str): Path to the input configuration file
include_paths (list): List of directories to search for included files
processed (set, optional): Set of already processed files to avoid circular includes
tree_node (dict, optional): Node in the configuration tree being built
Returns:
tuple: (list of expanded lines, tree structure node)
This function:
1. Reads the input file line by line
2. Processes #include directives by recursively expanding included files
3. Parses configuration lines to build a configuration dictionary
4. Builds a tree structure representing the file inclusion hierarchy
5. Returns the expanded content and the tree structure
"""
if processed is None:
processed = set()
if tree_node is None:
tree_node = {
"file": str(input_path),
"includes": [],
"configs": OrderedDict(),
"include_lines": [],
"raw_content": [], # Store original content for postprocessing
}
input_path = Path(input_path).resolve()
if input_path in processed:
return [], tree_node
processed.add(input_path)
expanded_lines = []
current_configs = OrderedDict()
with input_path.open("r", encoding="utf-8") as f:
lines = f.readlines()
# Save original content for postprocessing
tree_node["raw_content"] = [line.rstrip("\n") for line in lines]
for line in lines:
line_strip = line.strip()
match = re.match(r"#include\s*[<\"]([^\">]+)[\">]", line_strip)
if match:
include_file = match.group(1)
found = False
# Record original include line for postprocessing
tree_node["include_lines"].append(line.rstrip("\n"))
# Check current directory first
direct_path = input_path.parent / include_file
if direct_path.exists():
include_node = {
"file": str(direct_path),
"includes": [],
"configs": OrderedDict(),
"include_lines": [],
"raw_content": [],
}
tree_node["includes"].append(include_node)
# Recursively expand the included file
included_lines, include_node = expand_file(
direct_path, include_paths, processed, include_node
)
expanded_lines.extend(included_lines)
# Merge configurations (later configurations override earlier ones)
for key, value in include_node["configs"].items():
current_configs[key] = value
tree_node["configs"][key] = value
found = True
else:
# Check include paths
for path in include_paths:
candidate = Path(path) / include_file
if candidate.exists():
include_node = {
"file": str(candidate),
"includes": [],
"configs": OrderedDict(),
"include_lines": [],
"raw_content": [],
}
tree_node["includes"].append(include_node)
# Recursively expand the included file
included_lines, include_node = expand_file(
candidate, include_paths, processed, include_node
)
expanded_lines.extend(included_lines)
# Merge configurations
for key, value in include_node["configs"].items():
current_configs[key] = value
tree_node["configs"][key] = value
found = True
break
if not found:
print(
f'ERROR: Cannot find "{include_file}" from {input_path}',
file=sys.stderr,
)
sys.exit(1)
else:
# Parse configuration line
key, value = parse_config_line(line)
if key is not None:
current_configs[key] = value
tree_node["configs"][key] = value
expanded_lines.append(line)
expanded_lines.append("\n") # Maintain separation between files
return expanded_lines, tree_node
def preprocess(output_path, input_path, include_paths, tree_output_path=None):
"""
Process a configuration file with #include directives.
Args:
output_path (str): Path to write the expanded configuration
input_path (str): Path to the input configuration file
include_paths (list): List of directories to search for included files
tree_output_path (str, optional): Path to write the tree structure
This function:
1. Expands the input file by processing #include directives
2. Writes the expanded configuration to output_path
3. Optionally writes the tree structure to tree_output_path for postprocessing
"""
lines, tree = expand_file(input_path, include_paths)
# Write expanded configuration
with open(output_path, "w", encoding="utf-8") as out:
out.writelines(lines)
# Write tree structure if requested
if tree_output_path and tree["includes"]:
with open(tree_output_path, "w", encoding="utf-8") as f:
json.dump(tree, f, indent=2, ensure_ascii=False)
def get_all_included_configs(tree):
"""
Extract all configuration options from included files.
Args:
tree (dict): The configuration tree structure
Returns:
OrderedDict: Dictionary of configuration options from all included files
This function recursively traverses the tree to collect all configurations
from files included via #include directives.
"""
included_configs = OrderedDict()
def collect_configs(node):
for include in node.get("includes", []):
collect_configs(include)
for key, value in node.get("configs", {}).items():
included_configs[key] = value
# Collect configurations from included files only (not the main file)
for include in tree.get("includes", []):
collect_configs(include)
return included_configs
def get_main_configs(tree):
"""
Extract configuration options from the main file (excluding #include directives).
Args:
tree (dict): The configuration tree structure
Returns:
OrderedDict: Dictionary of configuration options from the main file
"""
main_configs = OrderedDict()
for line in tree["raw_content"]:
key, value = parse_config_line(line)
if key is not None:
main_configs[key] = value
return main_configs
def get_current_configs(config_path):
"""
Parse the current full configuration file.
Args:
config_path (str): Path to the current configuration file
Returns:
OrderedDict: Dictionary of configuration options from the current file
"""
configs = OrderedDict()
with open(config_path, "r", encoding="utf-8") as f:
for line in f:
key, value = parse_config_line(line)
if key is not None:
configs[key] = value
return configs
def postprocess_inner(tree_path, added, changed, removed, output_path):
"""
Postprocess configuration changes to generate a defconfig with #include directives.
This function takes the specific changes (added, changed, removed) calculated
by postprocess and applies them to the original defconfig structure
represented by the tree, producing a new defconfig file.
Args:
tree_path (str): Path to the config_tree.json generated during preprocessing of the ORIGINAL defconfig.
added (dict): {key: value} - Configurations added by the user.
changed (dict): {key: (old_value, new_value)} - Configurations changed by the user.
removed (dict): {key: old_value} - Configurations removed by the user.
output_path (str): Path where the new defconfig should be written.
"""
# 1. Load the original tree structure (this represents the structure of the ORIGINAL defconfig)
with open(tree_path, "r", encoding="utf-8") as f:
original_tree = json.load(f, object_pairs_hook=OrderedDict)
# 2. Get the original configuration sets from the tree
original_included_configs = get_all_included_configs(original_tree)
original_main_configs = get_main_configs(original_tree)
# 3. Dictionary to store the final configurations that will go into the main defconfig file
final_main_configs = OrderedDict()
# --- Logic to determine final content of the main defconfig file ---
# a. Handle configurations that were originally in included files
# We only place them in the main defconfig if they were explicitly added/changed/removed.
# If untouched, they remain in their included files implicitly.
for key in original_included_configs:
if key in added:
# User added/changed a config that was originally in an included file.
# It must now be explicitly set in the main defconfig to override the included value.
final_main_configs[key] = added[key]
elif key in changed:
# User changed a config that was originally in an included file.
final_main_configs[key] = changed[key][1] # Use the new value
elif key in removed:
# User removed a config that was originally in an included file.
# To "remove" it, we explicitly set it to opposite orig value in the main defconfig.
# This overrides the value from the included file.
final_main_configs[key] = opposite(removed[key])
# b. Handle configurations that were originally in the main file
# They should generally stay represented in the main file output.
for key in original_main_configs:
if key in added:
# User added/changed a config that was already in the main file.
final_main_configs[key] = added[key]
elif key in changed:
# User changed a config that was in the main file.
final_main_configs[key] = changed[key][1] # Use the new value
elif key in removed:
# User removed a config that was in the main file.
# Explicitly set to opposite orig value to override its previous state.
final_main_configs[key] = opposite(removed[key])
else:
# Config was in the original main file and user did NOT touch it.
# According to the new logic, we should PRESERVE these in the output main defconfig
# to maintain the structure and non-default values from the original main file.
# This prevents the output from becoming sparse if the user only made minor changes.
final_main_configs[key] = original_main_configs[key]
# c. Handle configurations that are entirely new (not present in original main or included)
# These must go into the main defconfig file.
for key, value in added.items():
if key not in original_main_configs and key not in original_included_configs:
final_main_configs[key] = value
# 4. Write the final output defconfig file
with open(output_path, "w", encoding="utf-8") as f:
# Write the original #include directives to preserve the structure
for include_line in original_tree.get("include_lines", []):
f.write(include_line + "\n")
# Add a newline for separation if there were includes
if original_tree.get("include_lines"):
f.write("\n")
# Write the final configurations for the main file in sorted order
final_write_list = []
for key, value in final_main_configs.items():
if value == "n":
final_write_list.append(f"# {key} is not set\n")
else:
final_write_list.append(f"{key}={value}\n")
# Sort configurations for consistent and readable output
final_write_list.sort()
for write_line in final_write_list:
f.write(write_line)
def get_config_diff(old_config, new_config):
"""
Compare two config dictionaries and return the differences.
Args:
old_config (dict): The original configuration.
new_config (dict): The modified configuration.
Returns:
tuple: (added, changed, removed)
added (dict): Items in new_config but not in old_config.
changed (dict): Items with different values. {key: (old_value, new_value)}.
removed (dict): Items in old_config but not in new_config.
"""
added = {}
changed = {}
removed = {}
# Find added and changed items
for key, new_value in new_config.items():
if key not in old_config:
added[key] = new_value
elif old_config[key] != new_value:
changed[key] = (old_config[key], new_value) # (old_value, new_value)
# Find removed items
for key in old_config:
if key not in new_config:
removed[key] = old_config[key]
return added, changed, removed
def load_config_file(filepath):
"""
Load a .config or defconfig file into an OrderedDict.
"""
config = OrderedDict()
try:
with open(filepath, "r") as f:
for line in f:
key, value = parse_config_line(line)
if key is not None:
config[key] = value
except FileNotFoundError:
print(
f"Warning: Config file {filepath} not found. Treating as empty.",
file=sys.stderr,
)
return config
def postprocess(
tree_path, original_defconfig_path, modified_defconfig_path, output_defconfig_path
):
"""
An improved postprocess that compares defconfig files before and after modification.
This function addresses the issue where Kconfig's savedefconfig omits default values,
making it hard to distinguish user deletions from optimizations.
Args:
tree_path (str): Path to the config_tree.json generated during preprocessing.
original_defconfig_path (str): Path to the defconfig file BEFORE user modification.
modified_defconfig_path (str): Path to the defconfig file AFTER user modification.
output_defconfig_path (str): Path where the updated defconfig should be written.
"""
# 1. Load the defconfig files
defconfig_original = load_config_file(original_defconfig_path)
defconfig_modified = load_config_file(modified_defconfig_path)
# 2. Compare the defconfig files to find the actual user changes
added, changed, removed = get_config_diff(defconfig_original, defconfig_modified)
# 3. Use the new postprocess_inner function to generate the final defconfig
# Pass the calculated differences (added, changed, removed) and the original tree.
postprocess_inner(tree_path, added, changed, removed, output_defconfig_path)
if __name__ == "__main__":
if len(sys.argv) < 3:
print(
"Usage: process_config.py <mode> [options]",
file=sys.stderr,
)
print("Modes:", file=sys.stderr)
print(
" preprocess <output_file> <input_file> [include_paths...] [--tree <tree_file>]",
file=sys.stderr,
)
print(
" postprocess <tree_file> <original_defconfig> <modified_defconfig> <output_defconfig>",
file=sys.stderr,
)
sys.exit(1)
mode = sys.argv[1]
if mode == "preprocess":
if len(sys.argv) < 4:
print(
"Usage: preprocess <output_file> <input_file> [include_paths...] [--tree <tree_file>]",
file=sys.stderr,
)
sys.exit(1)
output_file = Path(sys.argv[2])
input_file = sys.argv[3]
include_dirs = []
tree_file = None
# Parse arguments
i = 4
while i < len(sys.argv):
if sys.argv[i] == "--tree" and i + 1 < len(sys.argv):
tree_file = sys.argv[i + 1]
i += 2
else:
include_dirs.append(sys.argv[i])
i += 1
if output_file.exists():
output_file.unlink()
preprocess(output_file, input_file, include_dirs, tree_file)
elif mode == "postprocess":
if len(sys.argv) < 6:
print(
"Usage: postprocess <tree_file> <original_defconfig> <modified_defconfig> <output_defconfig>",
file=sys.stderr,
)
sys.exit(1)
tree_file = sys.argv[2]
original_defconfig = sys.argv[3]
modified_defconfig = sys.argv[4]
output_defconfig = sys.argv[5]
if Path(tree_file).is_file():
post_defconfig = output_defconfig + "tmp"
postprocess(
tree_file, original_defconfig, modified_defconfig, post_defconfig
)
shutil.copy2(post_defconfig, output_defconfig)
os.remove(post_defconfig)
else:
shutil.copy2(modified_defconfig, output_defconfig)
else:
print(f"Unknown mode: {mode}", file=sys.stderr)
sys.exit(1)
Reference in New Issue View Git Blame Copy Permalink