autosar-calltree 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

autosar_calltree/cli/main.py

@@ -17,6 +17,7 @@ from ..analyzers.call_tree_builder import CallTreeBuilder
 from ..config.module_config import ModuleConfig
 from ..database.function_database import FunctionDatabase
 from ..generators.mermaid_generator import MermaidGenerator
+from ..generators.xmi_generator import XmiGenerator
 from ..version import __version__
 
 console = Console(record=True)
@@ -295,11 +296,47 @@ def cli(
             )
 
         if format == "xmi":
-            console.print("[yellow]Warning:[/yellow] XMI format not yet implemented")
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True,
+            ) as progress:
+                task = progress.add_task("Generating XMI document...", total=None)
+
+                xmi_output = output_path.with_suffix(".xmi") if output_path.suffix != ".xmi" else output_path
+
+                xmi_generator = XmiGenerator(
+                    use_module_names=use_module_names,
+                )
+                xmi_generator.generate(result, str(xmi_output))
+
+                progress.update(task, completed=True)
+
+            console.print(
+                f"[green]Generated[/green] XMI document: [cyan]{xmi_output}[/cyan]"
+            )
 
         if format == "both":
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True,
+            ) as progress:
+                task = progress.add_task("Generating XMI document...", total=None)
+
+                xmi_output = output_path.with_suffix(".xmi")
+
+                xmi_generator = XmiGenerator(
+                    use_module_names=use_module_names,
+                )
+                xmi_generator.generate(result, str(xmi_output))
+
+                progress.update(task, completed=True)
+
             console.print(
-                "[yellow]Warning:[/yellow] XMI format not yet implemented (only Mermaid generated)"
+                f"[green]Generated[/green] XMI document: [cyan]{xmi_output}[/cyan]"
             )
 
         # Print warnings for circular dependencies

autosar_calltree/generators/__init__.py

@@ -1,5 +1,6 @@
 """Generators package initialization."""
 
 from .mermaid_generator import MermaidGenerator
+from .xmi_generator import XmiGenerator
 
-__all__ = ["MermaidGenerator"]
+__all__ = ["MermaidGenerator", "XmiGenerator"]

autosar_calltree/generators/xmi_generator.py

@@ -0,0 +1,357 @@
+"""
+XMI (XML Metadata Interchange) generator for UML sequence diagrams.
+
+This module generates XMI 2.5 compliant XML documents representing
+UML sequence diagrams from call trees. The XMI format can be imported
+into UML tools like Enterprise Architect, Visual Paradigm, etc.
+
+Requirements:
+- SWR_XMI_00001: XMI 2.5 Compliance
+- SWR_XMI_00002: Sequence Diagram Representation
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+from xml.dom import minidom
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+from ..database.models import AnalysisResult, CallTreeNode
+
+
+class XmiGenerator:
+    """
+    Generates XMI 2.5 format UML sequence diagrams from call trees.
+
+    This class converts call tree structures into XMI XML documents,
+    following the UML 2.5 XMI specification for sequence diagrams.
+    """
+
+    # XMI/UML namespaces
+    XMI_NAMESPACE = "http://www.omg.org/spec/XMI/20131001"
+    XMI_URI = "http://www.omg.org/spec/XMI/20131001"
+    UML_NAMESPACE = "http://www.eclipse.org/uml2/5.0.0/UML"
+    UML_URI = "http://www.eclipse.org/uml2/5.0.0/UML"
+
+    def __init__(
+        self,
+        use_module_names: bool = False,
+    ):
+        """
+        Initialize the XMI generator.
+
+        Args:
+            use_module_names: Use SW module names as participants instead of function names
+        """
+        self.use_module_names = use_module_names
+        self.element_id_counter = 0
+        self.participant_map: Dict[str, str] = {}  # Map names to XMI IDs
+
+    def generate(
+        self,
+        result: AnalysisResult,
+        output_path: str,
+    ) -> None:
+        """
+        Generate XMI document and save to file.
+
+        Args:
+            result: Analysis result containing call tree
+            output_path: Path to output XMI file
+        """
+        if not result.call_tree:
+            raise ValueError("Cannot generate XMI: call tree is None")
+
+        # Build XMI document
+        root_element = self._generate_xmi_document(result, result.call_tree)
+
+        # Pretty print and write to file
+        xml_str = self._prettify_xml(root_element)
+        output_file = Path(output_path)
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        output_file.write_text(xml_str, encoding="utf-8")
+
+    def _generate_xmi_document(self, result: AnalysisResult, call_tree: CallTreeNode) -> Element:
+        """
+        Generate XMI root element with complete document structure.
+
+        Args:
+            result: Analysis result containing metadata
+            call_tree: Root node of the call tree (non-optional)
+
+        Returns:
+            Root XML Element for the XMI document
+        """
+        # Create root element with XMI namespace
+        root = Element(
+            f"{{{self.XMI_NAMESPACE}}}XMI",
+            attrib={
+                f"{{{self.XMI_NAMESPACE}}}version": "4.0",
+                "xmlns:xmi": self.XMI_URI,
+                "xmlns:uml": self.UML_URI,
+            },
+        )
+
+        # Create UML model
+        model = SubElement(root, f"{{{self.UML_NAMESPACE}}}Model", attrib={
+            f"{{{self.XMI_NAMESPACE}}}id": self._generate_id(),
+            "name": f"CallTree_{result.root_function}",
+            "visibility": "public",
+        })
+
+        # Package the model
+        packaged_element = SubElement(model, f"{{{self.UML_NAMESPACE}}}packagedElement")
+        packaged_element.set(f"{{{self.XMI_NAMESPACE}}}id", self._generate_id())
+        packaged_element.set("name", f"Sequence_{result.root_function}")
+        packaged_element.set("visibility", "public")
+
+        # Create interaction (sequence diagram container)
+        interaction = self._create_interaction(packaged_element, result)
+
+        # Collect all participants and create lifelines
+        participants = self._collect_participants(call_tree)
+        lifeline_elements = self._create_lifelines(interaction, participants)
+
+        # Create messages (function calls)
+        self._create_messages(call_tree, lifeline_elements, interaction)
+
+        return root
+
+    def _create_interaction(
+        self, parent: Element, result: AnalysisResult
+    ) -> Element:
+        """
+        Create UML interaction element (sequence diagram container).
+
+        Args:
+            parent: Parent element
+            result: Analysis result
+
+        Returns:
+            Interaction element
+        """
+        interaction = SubElement(parent, f"{{{self.UML_NAMESPACE}}}packagedElement")
+        interaction.set(f"{{{self.XMI_NAMESPACE}}}id", self._generate_id())
+        interaction.set("name", f"CallSequence_{result.root_function}")
+        interaction.set("visibility", "public")
+        interaction.set("isReentrant", "false")
+
+        # Set type to Interaction
+        interaction_type = SubElement(interaction, f"{{{self.UML_NAMESPACE}}}ownedAttribute")
+        interaction_type.set(f"{{{self.XMI_NAMESPACE}}}id", self._generate_id())
+        interaction_type.set("name", "interactionType")
+        interaction_type.set("visibility", "public")
+        interaction_type.set("type", "Interaction")
+
+        return interaction
+
+    def _collect_participants(self, root: CallTreeNode) -> List[str]:
+        """
+        Collect all unique participants (functions or modules) in tree.
+
+        Args:
+            root: Root node of call tree
+
+        Returns:
+            List of participant names in the order they are first encountered
+        """
+        participants = []
+
+        def traverse(node: CallTreeNode):
+            # Use module name if enabled, otherwise use function name
+            if self.use_module_names:
+                participant = (
+                    node.function_info.sw_module
+                    or Path(node.function_info.file_path).stem
+                )
+            else:
+                participant = node.function_info.name
+
+            # Add participant only if not already in the list
+            if participant not in participants:
+                participants.append(participant)
+
+            for child in node.children:
+                traverse(child)
+
+        traverse(root)
+        return participants
+
+    def _create_lifelines(
+        self, interaction: Element, participants: List[str]
+    ) -> Dict[str, Element]:
+        """
+        Create UML lifelines for each participant.
+
+        Args:
+            interaction: Interaction element
+            participants: List of participant names
+
+        Returns:
+            Dictionary mapping participant names to their lifeline elements
+        """
+        lifeline_elements = {}
+
+        for idx, participant in enumerate(participants):
+            # Create lifeline
+            lifeline = SubElement(interaction, f"{{{self.UML_NAMESPACE}}}lifeline")
+            lifeline_id = self._generate_id()
+            lifeline.set(f"{{{self.XMI_NAMESPACE}}}id", lifeline_id)
+            lifeline.set("name", participant)
+            lifeline.set("visibility", "public")
+
+            # Create represents property (connects to classifier)
+            represents = SubElement(lifeline, f"{{{self.UML_NAMESPACE}}}represents")
+            represents_id = self._generate_id()
+            represents.set(f"{{{self.XMI_NAMESPACE}}}id", represents_id)
+            represents.set("name", participant)
+
+            # Store mapping
+            self.participant_map[participant] = lifeline_id
+            lifeline_elements[participant] = lifeline
+
+        return lifeline_elements
+
+    def _create_messages(
+        self,
+        root: CallTreeNode,
+        lifeline_elements: Dict[str, Element],
+        interaction: Element,
+    ) -> None:
+        """
+        Create UML messages (function calls) between lifelines.
+
+        Args:
+            root: Root node of call tree
+            lifeline_elements: Dictionary of lifeline elements
+            interaction: Interaction element
+        """
+        message_counter = 0
+
+        def traverse(node: CallTreeNode, parent_participant: Optional[str] = None):
+            nonlocal message_counter
+
+            # Determine current participant
+            if self.use_module_names:
+                current_participant = (
+                    node.function_info.sw_module
+                    or Path(node.function_info.file_path).stem
+                )
+            else:
+                current_participant = node.function_info.name
+
+            # Create message from parent to current
+            if parent_participant:
+                message = SubElement(interaction, f"{{{self.UML_NAMESPACE}}}message")
+                message_id = self._generate_id()
+                message.set(f"{{{self.XMI_NAMESPACE}}}id", message_id)
+                message.set("name", node.function_info.name)
+                message.set("visibility", "public")
+                message.set("messageSort", "synchCall")
+
+                # Set message signature
+                signature = self._format_message_signature(node)
+                message.set("signature", signature)
+
+                # Connect to lifelines
+                send_event = SubElement(message, f"{{{self.UML_NAMESPACE}}}sendEvent")
+                send_event.set(f"{{{self.XMI_NAMESPACE}}}id", self._generate_id())
+
+                receive_event = SubElement(message, f"{{{self.UML_NAMESPACE}}}receiveEvent")
+                receive_event.set(f"{{{self.XMI_NAMESPACE}}}id", self._generate_id())
+
+                # Set source and target
+                message.set(
+                    "sendEvent",
+                    f"{{{self.XMI_NAMESPACE}}}{self.participant_map.get(parent_participant, '')}"
+                )
+                message.set(
+                    "receiveEvent",
+                    f"{{{self.XMI_NAMESPACE}}}{self.participant_map.get(current_participant, '')}"
+                )
+
+                message_counter += 1
+
+                # Mark recursive calls
+                if node.is_recursive:
+                    message.set("messageSort", "reply")
+
+            # Traverse children
+            for child in node.children:
+                traverse(child, current_participant)
+
+        # Start traversal from root's children
+        for child in root.children:
+            traverse(child, None)
+
+    def _format_message_signature(self, node: CallTreeNode) -> str:
+        """
+        Format message signature with parameters.
+
+        Args:
+            node: Call tree node
+
+        Returns:
+            Formatted signature string
+        """
+        func = node.function_info
+
+        if not func.parameters:
+            return f"{func.name}()"
+
+        params = []
+        for param in func.parameters:
+            if param.name:
+                params.append(param.name)
+            else:
+                type_str = param.param_type
+                if param.is_pointer:
+                    type_str += "*"
+                params.append(type_str)
+
+        return f"{func.name}({', '.join(params)})"
+
+    def _generate_id(self) -> str:
+        """
+        Generate unique XMI ID.
+
+        Returns:
+            Unique identifier string
+        """
+        self.element_id_counter += 1
+        return f"calltree_{self.element_id_counter}"
+
+    def _prettify_xml(self, element: Element) -> str:
+        """
+        Convert XML element to pretty-printed string.
+
+        Args:
+            element: Root XML element
+
+        Returns:
+            Pretty-printed XML string
+        """
+        rough_string = tostring(element, encoding="unicode")
+        reparsed = minidom.parseString(rough_string)
+        pretty_xml = reparsed.toprettyxml(indent="  ")
+
+        # Add XML declaration and comments
+        lines = pretty_xml.split('\n')
+        filtered_lines = [line for line in lines if line.strip()]
+
+        return '\n'.join(filtered_lines)
+
+    def generate_to_string(self, result: AnalysisResult) -> str:
+        """
+        Generate XMI document as string without writing to file.
+
+        Args:
+            result: Analysis result
+
+        Returns:
+            XMI document as string
+        """
+        if not result.call_tree:
+            raise ValueError("Cannot generate XMI: call tree is None")
+
+        root_element = self._generate_xmi_document(result, result.call_tree)
+        return self._prettify_xml(root_element)

autosar_calltree/parsers/c_parser.py

@@ -58,6 +58,29 @@ class CParser:
         "_Generic",
     }
 
+    # AUTOSAR and standard C macros to exclude from function detection
+    # These macros look like function calls but should not be parsed as functions
+    AUTOSAR_MACROS = {
+        # Standard C integer literal macros (stdint.h)
+        "INT8_C",
+        "INT16_C",
+        "INT32_C",
+        "INT64_C",
+        "UINT8_C",
+        "UINT16_C",
+        "UINT32_C",
+        "UINT64_C",
+        "INTMAX_C",
+        "UINTMAX_C",
+        # AUTOSAR tool-specific macros
+        "TS_MAKEREF2CFG",
+        "TS_MAKENULLREF2CFG",
+        "TS_MAKEREFLIST2CFG",
+        # Common AUTOSAR configuration macros
+        "STD_ON",
+        "STD_OFF",
+    }
+
     # Common AUTOSAR types
     AUTOSAR_TYPES = {
         "uint8",
@@ -244,6 +267,16 @@ class CParser:
         if return_type in self.C_KEYWORDS or function_name in self.C_KEYWORDS:
             return None
 
+        # Skip AUTOSAR and standard C macros that look like function calls
+        # This prevents false positives on macros like UINT32_C(value), TS_MAKEREF2CFG(...)
+        if function_name in self.AUTOSAR_MACROS:
+            return None
+
+        # Skip standard C integer literal macros (those ending with _C)
+        # These are defined in stdint.h and look like: INT32_C(42), UINT64_C(100)
+        if function_name.endswith("_C"):
+            return None
+
         # Skip common control structures
         if function_name in ["if", "for", "while", "switch", "case", "else"]:
             return None

autosar_calltree/version.py

@@ -1,5 +1,5 @@
 """Version information for autosar-calltree package."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"
 __author__ = "melodypapa"
 __email__ = "melodypapa@outlook.com"

{autosar_calltree-0.3.2.dist-info → autosar_calltree-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autosar-calltree
-Version: 0.3.2
+Version: 0.4.0
 Summary: A Python tool to analyze C/AUTOSAR codebases and generate function call trees with Mermaid and XMI output
 Author-email: melodypapa <melodypapa@outlook.com>
 Maintainer-email: melodypapa <melodypapa@outlook.com>
@@ -255,7 +255,7 @@ default_module: "Other"
 
 **Usage**:
 ```bash
-calltree --start-function Demo_Init --module-config module_mapping.yaml --use-module-names --max-depth 3
+calltree --start-function Demo_Init --module-config demo/module_mapping.yaml --use-module-names --max-depth 3 --output demo/demo_sequence.md
 ```
 
 This generates diagrams with:

{autosar_calltree-0.3.2.dist-info → autosar_calltree-0.4.0.dist-info}/RECORD

@@ -1,22 +1,23 @@
 autosar_calltree/__init__.py,sha256=WiP2aFfs0H3ze4X8tQg6ZiStdzgrp6uC8DPRUyGm_zg,660
-autosar_calltree/version.py,sha256=zDB6LGdYGRR-wdfWuRQEezaGHN9pJEeYwqXX2LokRZI,142
+autosar_calltree/version.py,sha256=Nt6KvWNqsurDjWOhy4Xi-L1EtfOXOROb5rxxO8OE_bA,142
 autosar_calltree/analyzers/__init__.py,sha256=qUvB7CAa5xNcUYkhD7Rha-9quPG8yQJqg-GikHD41U0,119
 autosar_calltree/analyzers/call_tree_builder.py,sha256=tSsIj_BHzT4XQ-XsXXfyU-KyGK61p6O7nLBx1AiwxCA,11627
 autosar_calltree/cli/__init__.py,sha256=qwsSUuDyV6i1PYS7Mf6JBkBJKtcldxiIh5S0wOucWVY,76
-autosar_calltree/cli/main.py,sha256=5svIu95DykrQBtjmhQTOTe-RdM9LkIgnnUnvfvivMM8,11334
+autosar_calltree/cli/main.py,sha256=f9awQW_1dKIc1IjhOp5_yx7f2CzRybNFKQt2tILwj1c,12676
 autosar_calltree/config/__init__.py,sha256=mSrB2uvrax_MTgGynfPObXYUh6eCe5BZD21_cebfMQM,258
 autosar_calltree/config/module_config.py,sha256=--ptsY6drvVKn_HD5_JDEpCv9D1xI8kiJXi8bwrSFBI,6329
 autosar_calltree/database/__init__.py,sha256=qg0IfUGgkecJQXqe9lPrU0Xbu-hBZa8NOe8E8UZqC_s,405
 autosar_calltree/database/function_database.py,sha256=PJghwv2Duxx7vSIvApyVwg4N_bCTfnk85mtA89BpIuA,17561
 autosar_calltree/database/models.py,sha256=xo85zao2LDHJMR6FeMVxopPyXxEv7jQUzeh4fzHwNKo,6265
-autosar_calltree/generators/__init__.py,sha256=wlSAuykXkxIjwP9H1C2iY99nbyt14Kp1Y6GxmDEDmDk,122
+autosar_calltree/generators/__init__.py,sha256=5gl3dF3imJIsvfmdg0bkZdnQ9vFWCTlpMWEhz6I_IZg,178
 autosar_calltree/generators/mermaid_generator.py,sha256=LcmWOACLAw3r7UQlnSlTM-_kpKQ6RGdgc6aNqXeMF7A,16191
+autosar_calltree/generators/xmi_generator.py,sha256=ndvDapHppOoDQ9q5Zu9b1AFbUKKc8q3copUti3UaFZM,12168
 autosar_calltree/parsers/__init__.py,sha256=O0NTHrZqe6GXvU9_bLuAoAV_hxv7gHOgkH8KWSBmX1Y,151
 autosar_calltree/parsers/autosar_parser.py,sha256=iwF1VR4NceEfmc3gPP31CcVNPfRRVTj_aA6N94saXDA,10750
-autosar_calltree/parsers/c_parser.py,sha256=OQ0HklIV1aSWvxe6qjj5bwP5Drz4cmxhFrdrOBpZdFU,14744
-autosar_calltree-0.3.2.dist-info/licenses/LICENSE,sha256=Xy30Wm38nOLXLZZFgn9oD_3UcayYkm81xtn8IByrBlk,1067
-autosar_calltree-0.3.2.dist-info/METADATA,sha256=oLQzj1T0HauxX38XVi7tHunMvO20raEydsGHKDfnFRY,15530
-autosar_calltree-0.3.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-autosar_calltree-0.3.2.dist-info/entry_points.txt,sha256=HfntIC1V_COOhGJ-OhtLKH_2vJ1jQy5Hlz8NmcJg4TQ,54
-autosar_calltree-0.3.2.dist-info/top_level.txt,sha256=eusKGYzQfbhwIFDsUYTby40SdMpe95Y9GtR0l1GVIDQ,17
-autosar_calltree-0.3.2.dist-info/RECORD,,
+autosar_calltree/parsers/c_parser.py,sha256=2LCDVZ8bcrBiQe9DK7kNMmvzhGegEDfd57KbI5JB43A,15846
+autosar_calltree-0.4.0.dist-info/licenses/LICENSE,sha256=Xy30Wm38nOLXLZZFgn9oD_3UcayYkm81xtn8IByrBlk,1067
+autosar_calltree-0.4.0.dist-info/METADATA,sha256=9O3LbtSX1byivDrDmCATcTSX5fT_Cxb-E6F0pyqhyIE,15566
+autosar_calltree-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+autosar_calltree-0.4.0.dist-info/entry_points.txt,sha256=HfntIC1V_COOhGJ-OhtLKH_2vJ1jQy5Hlz8NmcJg4TQ,54
+autosar_calltree-0.4.0.dist-info/top_level.txt,sha256=eusKGYzQfbhwIFDsUYTby40SdMpe95Y9GtR0l1GVIDQ,17
+autosar_calltree-0.4.0.dist-info/RECORD,,