sdbtool 0.3.2__tar.gz → 0.4.0__tar.gz

{sdbtool-0.3.2 → sdbtool-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdbtool
-Version: 0.3.2
+Version: 0.4.0
 Summary: Dump SDB file to xml using apphelp.dll
 Project-URL: Homepage, https://pypi.org/project/sdbtool/
 Project-URL: Changelog, https://github.com/learn-more/sdbtool/releases
@@ -35,6 +35,7 @@ A tool for converting Microsoft Application Compatibility Database (SDB) files t
 
 - Parses SDB files used by Windows for application compatibility.
 - Converts SDB data into readable XML.
+- Dump file attributes in SDB-recognizable format
 - Useful for analysis, migration, or documentation.
 
 
@@ -47,8 +48,9 @@ Sdbtool is available as [`sdbtool`](https://pypi.org/project/sdbtool/) on PyPI.
 Invoke sdbtool directly with [`uvx`](https://docs.astral.sh/uv/):
 
 ```shell
-uvx sdbtool your.sdb                    # Convert the file 'your.sdb' to xml, and print it to the console
-uvx sdbtool your.sdb --output your.xml  # Convert the file 'your.sdb' to xml, and write it to 'your.xml'
+uvx sdbtool sdb2xml your.sdb                    # Convert the file 'your.sdb' to xml, and print it to the console
+uvx sdbtool sdb2xml your.sdb --output your.xml  # Convert the file 'your.sdb' to xml, and write it to 'your.xml'
+uvx sdbtool attributes your.exe                 # Show the file attributes as recognized by apphelp in an XML-friendly format
 ```
 
 Or install sdbtool with `uv` (recommended), `pip`, or `pipx`:

{sdbtool-0.3.2 → sdbtool-0.4.0}/README.md

@@ -13,6 +13,7 @@ A tool for converting Microsoft Application Compatibility Database (SDB) files t
 
 - Parses SDB files used by Windows for application compatibility.
 - Converts SDB data into readable XML.
+- Dump file attributes in SDB-recognizable format
 - Useful for analysis, migration, or documentation.
 
 
@@ -25,8 +26,9 @@ Sdbtool is available as [`sdbtool`](https://pypi.org/project/sdbtool/) on PyPI.
 Invoke sdbtool directly with [`uvx`](https://docs.astral.sh/uv/):
 
 ```shell
-uvx sdbtool your.sdb                    # Convert the file 'your.sdb' to xml, and print it to the console
-uvx sdbtool your.sdb --output your.xml  # Convert the file 'your.sdb' to xml, and write it to 'your.xml'
+uvx sdbtool sdb2xml your.sdb                    # Convert the file 'your.sdb' to xml, and print it to the console
+uvx sdbtool sdb2xml your.sdb --output your.xml  # Convert the file 'your.sdb' to xml, and write it to 'your.xml'
+uvx sdbtool attributes your.exe                 # Show the file attributes as recognized by apphelp in an XML-friendly format
 ```
 
 Or install sdbtool with `uv` (recommended), `pip`, or `pipx`:

{sdbtool-0.3.2 → sdbtool-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sdbtool"
-version = "0.3.2"
+version = "0.4.0"
 description = "Dump SDB file to xml using apphelp.dll"
 readme = "README.md"
 license = "MIT"
@@ -28,7 +28,8 @@ CI = "https://github.com/learn-more/sdbtool/actions"
 Repository = "https://github.com/learn-more/sdbtool"
 
 [project.scripts]
-sdbtool = "sdbtool.cli:cli"
+sdbtool = "sdbtool.cli:sdbtool_command"
+sdb2xml = "sdbtool.cli:sdb2xml_command"
 
 [build-system]
 requires = ["hatchling"]

sdbtool-0.4.0/sdbtool/__main__.py

@@ -0,0 +1,4 @@
+from sdbtool.cli import sdbtool_command
+
+if __name__ == "__main__":
+    sdbtool_command()

{sdbtool-0.3.2 → sdbtool-0.4.0}/sdbtool/apphelp/__init__.py

@@ -15,9 +15,10 @@ class PathType(IntEnum):
     NT_PATH = 1
 
 
+TAG_NULL = 0x0
 TAGID_NULL = 0x0
 TAGID_ROOT = 0x0
-_TAGID_ROOT = 12
+SHIMDB_INDEX_UNIQUE_KEY = 0x1
 
 
 class TagType(IntEnum):
@@ -35,10 +36,7 @@ class TagType(IntEnum):
     MASK = 0xF000
 
 
-TAG_NULL = 0x0
-
-
-def _get_tag_type(tag: int) -> TagType:
+def get_tag_type(tag: int) -> TagType:
     """Extracts the type from a tag."""
     return TagType(tag & TagType.MASK)
 
@@ -48,6 +46,19 @@ def tag_to_string(tag: int) -> str:
     return apphelp.SdbTagToString(tag)
 
 
+def guid_to_string(guid: bytes) -> str:
+    """Converts a GUID (16-byte binary) to its string representation."""
+    if len(guid) != 16:
+        raise ValueError("GUID must be 16 bytes long")
+    return (
+        f"{guid[3]:02x}{guid[2]:02x}{guid[1]:02x}{guid[0]:02x}-"
+        f"{guid[5]:02x}{guid[4]:02x}-"
+        f"{guid[7]:02x}{guid[6]:02x}-"
+        f"{guid[8]:02x}{guid[9]:02x}-"
+        f"{guid[10]:02x}{guid[11]:02x}{guid[12]:02x}{guid[13]:02x}{guid[14]:02x}{guid[15]:02x}"
+    )
+
+
 class Tag:
     def __init__(self, db: "SdbDatabase", tag_id: int):
         self.db = db
@@ -59,7 +70,7 @@ class Tag:
         else:
             self.tag = apphelp.SdbGetTagFromTagID(self._ensure_db_handle(), tag_id)
             self.name = apphelp.SdbTagToString(self.tag)
-            self.type = _get_tag_type(self.tag)
+            self.type = get_tag_type(self.tag)
 
     def _ensure_db_handle(self) -> c_void_p:
         """Ensures that the database handle is initialized."""

{sdbtool-0.3.2 → sdbtool-0.4.0}/sdbtool/apphelp/winapi.py

@@ -6,14 +6,19 @@ COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
 """
 
 from ctypes import (
+    byref,
+    create_unicode_buffer,
     windll,
     c_void_p,
     c_uint16,
     c_uint32,
     c_wchar_p,
     POINTER,
+    pointer,
     c_ubyte,
     c_uint64,
+    Structure,
+    Union,
 )
 
 APPHELP = windll.apphelp
@@ -66,6 +71,86 @@ APPHELP.SdbGetStringTagPtr.argtypes = [c_void_p, c_uint32]
 APPHELP.SdbGetStringTagPtr.restype = c_wchar_p
 
 
+# typedef struct tagATTRINFO {
+#   TAG   tAttrID;
+#   DWORD dwFlags;
+#   union {
+#     ULONGLONG ullAttr;
+#     DWORD     dwAttr;
+#     TCHAR     *lpAttr;
+#   };
+# } ATTRINFO, *PATTRINFO;
+
+
+class _U(Union):
+    _fields_ = [("ullAttr", c_uint64), ("dwAttr", c_uint32), ("lpAttr", c_wchar_p)]
+
+
+class ATTRINFO(Structure):
+    _anonymous_ = ("_u",)
+    _fields_ = [
+        ("tAttrID", c_uint16),  # TAG
+        ("dwFlags", c_uint32),
+        ("_u", _U),  # Union for ullAttr, dwAttr, lpAttr
+    ]
+
+
+ATTRIBUTE_AVAILABLE = 0x00000001  # Attribute is available
+
+
+# BOOL WINAPI SdbFormatAttribute(
+#   _In_  PATTRINFO pAttrInfo,
+#   _Out_ LPTSTR    pchBuffer,
+#   _In_  DWORD     dwBufferSize
+# );
+APPHELP.SdbFormatAttribute.argtypes = [POINTER(ATTRINFO), c_wchar_p, c_uint32]
+APPHELP.SdbFormatAttribute.restype = c_uint32
+
+# BOOL WINAPI SdbGetFileAttributes(
+#   _In_  LPCTSTR   lpwszFileName,
+#   _Out_ PATTRINFO *ppAttrInfo,
+#   _Out_ LPDWORD   lpdwAttrCount
+# );
+APPHELP.SdbGetFileAttributes.argtypes = [
+    c_wchar_p,
+    POINTER(POINTER(ATTRINFO)),
+    POINTER(c_uint32),
+]
+APPHELP.SdbGetFileAttributes.restype = c_uint32
+
+# BOOL WINAPI SdbFreeFileAttributes(
+#   _In_ PATTRINFO pFileAttributes
+# );
+APPHELP.SdbFreeFileAttributes.argtypes = [c_void_p]
+APPHELP.SdbFreeFileAttributes.restype = c_uint32
+
+
+# BOOL WINAPI SdbGetMatchingExe(
+#   _In_opt_ HSDB            hSDB,
+#   _In_     LPCTSTR         szPath,
+#   _In_opt_ LPCTSTR         szModuleName,
+#   _In_opt_ LPCTSTR         pszEnvironment,
+#   _In_     DWORD           dwFlags,
+#   _Out_    PSDBQUERYRESULT pQueryResult
+# );
+APPHELP.SdbGetMatchingExe.argtypes = [
+    c_void_p,
+    c_wchar_p,
+    c_wchar_p,
+    c_wchar_p,
+    c_uint32,
+    POINTER(c_void_p),
+]
+APPHELP.SdbGetMatchingExe.restype = c_uint32
+
+# void WINAPI SdbReleaseMatchingExe(
+#   _In_ HSDB   hSDB,
+#   _In_ TAGREF trExe
+# );
+APPHELP.SdbReleaseMatchingExe.argtypes = [c_void_p, c_uint32]
+APPHELP.SdbReleaseMatchingExe.restype = None
+
+
 def SdbOpenDatabase(path: str, path_type: int) -> c_void_p:
     """Open a database at the specified path."""
     return APPHELP.SdbOpenDatabase(path, path_type)
@@ -126,3 +211,31 @@ def SdbReadBinaryTag(db: c_void_p, tag_id: int) -> bytes:
 def SdbGetStringTagPtr(db: c_void_p, tag_id: int) -> str:
     """Get the string pointer of the specified tag."""
     return APPHELP.SdbGetStringTagPtr(db, tag_id)
+
+
+def GetFileAttributes(file_name: str):
+    """Get file attributes for the specified file."""
+    attr_info = POINTER(ATTRINFO)()
+    attr_count = c_uint32()
+    result = APPHELP.SdbGetFileAttributes(
+        file_name, byref(attr_info), byref(attr_count)
+    )
+    if result == 0:
+        raise ValueError(f"Failed to get file attributes for '{file_name}'")
+    return attr_info, attr_count
+
+
+def SdbFormatAttribute(attr_info: ATTRINFO) -> str:
+    """Format the attribute information into a string."""
+    buffer_size = 1024 * 2
+    buffer = create_unicode_buffer(buffer_size)
+    result = APPHELP.SdbFormatAttribute(pointer(attr_info), buffer, buffer_size)
+    if result == 0:
+        name = SdbTagToString(attr_info.tAttrID)
+        raise ValueError(f"Failed to format attribute ({name})")
+    return buffer.value if buffer.value else ""
+
+
+def SdbFreeFileAttributes(attr_info):
+    """Free the file attributes structure."""
+    APPHELP.SdbFreeFileAttributes(attr_info)

sdbtool-0.4.0/sdbtool/attributes.py

@@ -0,0 +1,24 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     Wrapper around the low level apphelp file attributes API
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+from sdbtool.apphelp.winapi import (
+    GetFileAttributes,
+    SdbFormatAttribute,
+    SdbFreeFileAttributes,
+    ATTRIBUTE_AVAILABLE,
+)
+
+
+def get_attributes(file_name: str) -> list[str]:
+    attr_info, attr_count = GetFileAttributes(file_name)
+    res = [
+        SdbFormatAttribute(attr_info[i])
+        for i in range(attr_count.value)
+        if attr_info[i].dwFlags & ATTRIBUTE_AVAILABLE != 0
+    ]
+    SdbFreeFileAttributes(attr_info)
+    return res

sdbtool-0.4.0/sdbtool/cli.py

@@ -0,0 +1,53 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     Entrypoint of the sdbtool tool
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+import sys
+from sdbtool import sdb2xml
+from sdbtool.attributes import get_attributes
+import click
+
+
+@click.group(name="sdbtool", help="A command-line tool for working with SDB files.")
+@click.version_option()
+def sdbtool_command():
+    """sdbtool: A command-line tool for working with SDB files."""
+    pass
+
+
+@sdbtool_command.command("sdb2xml")
+@click.argument("input_file", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--output",
+    type=click.File("w", encoding="utf-8"),
+    default="-",
+    help="Path to the output XML file, or '-' for stdout.",
+)
+def sdb2xml_command(input_file, output):
+    """Convert an SDB file to XML format."""
+    try:
+        sdb2xml.convert(input_file, output)
+    except Exception as e:
+        click.echo(f"Error converting SDB to XML: {e}")
+        sys.exit(1)
+
+
+@sdbtool_command.command("attributes")
+@click.argument("files", type=click.Path(exists=True, dir_okay=False), nargs=-1)
+def attributes_command(files):
+    """Display file attributes as recognized by AppHelp."""
+    for file_name in files:
+        try:
+            attrs = get_attributes(file_name)
+        except ValueError as e:
+            click.echo(f"Error getting attributes for {file_name}: {e}")
+            continue
+        click.echo(f"Attributes for {file_name}:")
+        if not attrs:
+            click.echo("  No attributes found.")
+            continue
+        for attr in attrs:
+            click.echo(f"  {attr}")

sdbtool-0.4.0/sdbtool/sdb2xml.py

@@ -0,0 +1,124 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     Convert SDB files to XML format.
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+from sdbtool.apphelp import (
+    PathType,
+    SdbDatabase,
+    TagVisitor,
+    TagType,
+    Tag,
+    tag_to_string,
+    guid_to_string,
+    SHIMDB_INDEX_UNIQUE_KEY
+)
+from sdbtool.xml import XmlWriter
+from base64 import b64encode
+from pathlib import Path
+
+
+def tagtype_to_xmltype(tag_type: TagType) -> str | None:
+    tagtype_map = {
+        TagType.BYTE: "xs:byte",
+        TagType.WORD: "xs:unsignedShort",
+        TagType.DWORD: "xs:unsignedInt",
+        TagType.QWORD: "xs:unsignedLong",
+        TagType.STRINGREF: "xs:string",
+        TagType.STRING: "xs:string",
+        TagType.BINARY: "xs:base64Binary",
+    }
+    return tagtype_map.get(tag_type, None)
+
+
+class XmlTagVisitor(TagVisitor):
+    def __init__(self, stream, input_filename: str):
+        """Initialize the XML tag visitor with a filename."""
+        self.writer = XmlWriter(stream)
+        self._first = True
+        self._input_filename = input_filename
+
+    def visit_list_begin(self, tag: Tag):
+        """Visit the beginning of a list tag."""
+        attrs = None
+        if self._first:
+            self._first = False
+            self.writer.write_xml_declaration()
+            attrs = {
+                "xmlns:xs": "http://www.w3.org/2001/XMLSchema",
+                "file": self._input_filename,
+            }
+        self.writer.open(tag.name, attrs)
+
+    def visit_list_end(self, tag: Tag):
+        """Visit the end of a list tag."""
+        self.writer.close(tag.name)
+
+    def visit(self, tag: Tag):
+        """Visit a tag."""
+        if tag.type == TagType.NULL:
+            self.writer.empty_tag(tag.name)
+            return
+
+        attrs = {}
+        if tag.type != TagType.LIST:
+            typename = tagtype_to_xmltype(tag.type)
+            if typename is not None:
+                attrs["type"] = typename
+            else:
+                raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")
+
+        self.writer.open(tag.name, attrs)
+        self._write_tag_value(tag)
+        self.writer.close(tag.name)
+
+    def _write_tag_value(self, tag: Tag):
+        """Write the value of a tag based on its type."""
+        if tag.type == TagType.BYTE:
+            self.writer.write_comment(
+                "UNHANDLED BYTE TAG, please report this at https://github.com/learn-more/sdbtool"
+            )
+        elif tag.type == TagType.WORD:
+            value = tag.as_word()
+            self.writer.write(f"{value}")
+            if tag.name in ("INDEX_TAG", "INDEX_KEY"):
+                self.writer.write_comment(f"{tag_to_string(value)}")
+        elif tag.type == TagType.DWORD:
+            value = tag.as_dword()
+            self.writer.write(f"{value}")
+            if tag.name in ("INDEX_FLAGS",):
+                comment = ""
+                if value & SHIMDB_INDEX_UNIQUE_KEY:
+                    comment += "1 = SHIMDB_INDEX_UNIQUE_KEY"  # https://learn.microsoft.com/en-us/windows/win32/devnotes/sdbgetindex
+                if comment:
+                    self.writer.write_comment(comment)
+        elif tag.type == TagType.QWORD:
+            self.writer.write(f"{tag.as_qword()}")
+        elif tag.type in (TagType.STRINGREF, TagType.STRING):
+            val = tag.as_string()
+            if val:
+                self.writer.write(f"{val}")
+        elif tag.type == TagType.BINARY:
+            data = tag.as_bytes()
+            if data:
+                base64_data = b64encode(data).decode("utf-8")
+                self.writer.write(base64_data)
+                if tag.name.endswith("_ID") and len(data) == 16:
+                    guid_str = guid_to_string(data)
+                    self.writer.write_comment(f"{{{guid_str}}}")
+        else:
+            raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")
+
+
+def convert(input_file: str, output_stream):
+    with SdbDatabase(input_file, PathType.DOS_PATH) as db:
+        if not db:
+            raise ValueError(f"Failed to open database at '{input_file}'")
+
+        visitor = XmlTagVisitor(output_stream, Path(input_file).name)
+        root = db.root()
+        if root is None:
+            raise ValueError(f"No root tag found in database '{input_file}'")
+        root.accept(visitor)

sdbtool-0.4.0/sdbtool/xml.py

@@ -0,0 +1,60 @@
+"""
+PROJECT:     sdbtool
+LICENSE:     MIT (https://spdx.org/licenses/MIT)
+PURPOSE:     Simple streaming Xml writer
+COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
+"""
+
+from xml.sax.saxutils import escape, quoteattr
+
+INDENT_DEPTH = 2  # Number of spaces for each indentation level in XML output
+
+
+class XmlWriter:
+    def __init__(self, stream):
+        self._stream = stream
+        self._indent_level = 0
+        self._indent_on_close = False
+
+    def write_xml_declaration(self):
+        """Write the XML declaration at the start of the document."""
+        self._stream.write('<?xml version="1.0" encoding="utf-8" standalone="yes"?>')
+
+    def _indent(self):
+        """Return the indentation string for the given level."""
+        self._stream.write("\n")
+        self._stream.write(" " * (self._indent_level * INDENT_DEPTH))
+
+    def open(self, name, attrib=None):
+        """Open an XML tag with the given name and attributes."""
+        self._indent()
+        self._stream.write(f"<{name}")
+        if attrib:
+            for key, value in attrib.items():
+                self._stream.write(f" {key}={quoteattr(value)}")
+        self._stream.write(">")
+
+        self._indent_level += 1
+        self._indent_on_close = False
+
+    def close(self, name):
+        """Close an XML tag with the given name."""
+        self._indent_level -= 1
+        if self._indent_on_close:
+            self._indent()
+        self._stream.write(f"</{name}>")
+        self._indent_on_close = True
+
+    def empty_tag(self, name):
+        """Write an empty XML tag with the given name and attributes."""
+        self._indent()
+        self._stream.write(f"<{name} />")
+        self._indent_on_close = True
+
+    def write(self, text):
+        """Write text content to the XML stream."""
+        self._stream.write(escape(text))
+
+    def write_comment(self, comment):
+        """Write a comment to the XML stream."""
+        self._stream.write(f"<!-- {escape(comment)} -->")

sdbtool-0.3.2/sdbtool/__init__.py

@@ -1,25 +0,0 @@
-"""
-PROJECT:     sdbtool
-LICENSE:     MIT (https://spdx.org/licenses/MIT)
-PURPOSE:     Entrypoint of the sdbtool tool, which converts SDB files to XML format.
-COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
-"""
-
-import sdbtool.apphelp as apphelp
-from pathlib import Path
-
-from sdbtool.xml import XmlTagVisitor
-
-
-def sdb2xml(input_file: str, output_stream):
-    with apphelp.SdbDatabase(input_file, apphelp.PathType.DOS_PATH) as db:
-        if not db:
-            print(f"Failed to open database at '{input_file}'")
-            return
-
-        visitor = XmlTagVisitor(output_stream, Path(input_file).name)
-        root = db.root()
-        if root is None:
-            print(f"No root tag found in database '{input_file}'")
-            return
-        root.accept(visitor)

sdbtool-0.3.2/sdbtool/__main__.py

@@ -1,4 +0,0 @@
-from sdbtool.cli import cli
-
-if __name__ == "__main__":
-    cli()

sdbtool-0.3.2/sdbtool/cli.py

@@ -1,14 +0,0 @@
-from sdbtool import sdb2xml
-import click
-
-@click.command()
-@click.version_option()
-@click.argument("input_file", type=click.Path(exists=True, dir_okay=False))
-@click.option(
-    "--output",
-    type=click.File("w", encoding="utf-8"),
-    default="-",
-    help="Path to the output XML file, or '-' for stdout.",
-)
-def cli(input_file, output):
-    sdb2xml(input_file, output)

sdbtool-0.3.2/sdbtool/xml.py

@@ -1,139 +0,0 @@
-"""
-PROJECT:     sdbtool
-LICENSE:     MIT (https://spdx.org/licenses/MIT)
-PURPOSE:     Xml writer + visitor for SDB files.
-COPYRIGHT:   Copyright 2025 Mark Jansen <mark.jansen@reactos.org>
-"""
-
-from sdbtool.apphelp import TagVisitor, Tag, TagType, tag_to_string
-from xml.sax.saxutils import escape, quoteattr
-from base64 import b64encode
-
-INDENT_DEPTH = 2  # Number of spaces for each indentation level in XML output
-
-
-def tagtype_to_xmltype(tag_type: TagType) -> str | None:
-    switch = {
-        TagType.BYTE: "xs:byte",
-        TagType.WORD: "xs:unsignedShort",
-        TagType.DWORD: "xs:unsignedInt",
-        TagType.QWORD: "xs:unsignedLong",
-        TagType.STRINGREF: "xs:string",
-        TagType.STRING: "xs:string",
-        TagType.BINARY: "xs:base64Binary",
-    }
-    return switch.get(tag_type, None)
-
-
-class XmlWriter:
-    def __init__(self, stream):
-        self._stream = stream
-
-    def write_xml_declaration(self):
-        """Write the XML declaration at the start of the document."""
-        self._stream.write('<?xml version="1.0" encoding="utf-8" standalone="yes"?>')
-
-    def indent(self, level):
-        """Return the indentation string for the given level."""
-        self._stream.write("\n")
-        self._stream.write(" " * (level * INDENT_DEPTH))
-        return self
-
-    def open(self, name, attrib=None):
-        """Open an XML tag with the given name and attributes."""
-        self._stream.write(f"<{name}")
-        if attrib:
-            for key, value in attrib.items():
-                self._stream.write(f' {key}={quoteattr(value)}')
-        self._stream.write(">")
-        return self
-
-    def close(self, name):
-        """Close an XML tag with the given name."""
-        self._stream.write(f"</{name}>")
-
-    def empty_tag(self, name):
-        """Write an empty XML tag with the given name and attributes."""
-        self._stream.write(f"<{name} />")
-
-    def write(self, text):
-        """Write text content to the XML stream."""
-        self._stream.write(text)
-
-
-class XmlTagVisitor(TagVisitor):
-    def __init__(self, stream, input_filename: str):
-        """Initialize the XML tag visitor with a filename."""
-        self.writer = XmlWriter(stream)
-        self.writer.write_xml_declaration()
-        self._depth = 0
-        self._input_filename = input_filename
-        self._indent_on_close = False
-
-    def visit_list_begin(self, tag: Tag):
-        """Visit the beginning of a list tag."""
-
-        attrs = None
-        if self._depth == 0:
-            attrs = {
-                "xmlns:xs": "http://www.w3.org/2001/XMLSchema",
-                "file": self._input_filename,
-            }
-
-        self.writer.indent(self._depth).open(tag.name, attrs)
-        self._depth += 1
-        self._indent_on_close = False
-
-    def visit_list_end(self, tag: Tag):
-        """Visit the end of a list tag."""
-        self._depth -= 1
-        if self._indent_on_close:
-            self.writer.indent(self._depth)
-        self.writer.close(tag.name)
-        self._indent_on_close = True
-
-    def visit(self, tag: Tag):
-        """Visit a tag."""
-        self._indent_on_close = True
-        if tag.type == TagType.NULL:
-            self.writer.indent(self._depth).empty_tag(tag.name)
-            return
-
-        attrs = {}
-        if tag.type != TagType.LIST:
-            typename = tagtype_to_xmltype(tag.type)
-            if typename is not None:
-                attrs["type"] = typename
-            else:
-                raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")
-
-        self.writer.indent(self._depth).open(tag.name, attrs)
-        self._write_tag_value(tag)
-        self.writer.close(tag.name)
-
-    def _write_tag_value(self, tag: Tag):
-        """Write the value of a tag based on its type."""
-        if tag.type == TagType.BYTE:
-            self.writer.write(
-                "<!-- UNHANDLED BYTE TAG, please report this at https://github.com/learn-more/sdbtool -->"
-            )
-        elif tag.type == TagType.WORD:
-            value = tag.as_word()
-            self.writer.write(f"{value}")
-            if tag.name in ("INDEX_TAG", "INDEX_KEY"):
-                self.writer.write(f"<!-- {tag_to_string(value)} -->")
-        elif tag.type == TagType.DWORD:
-            self.writer.write(f"{tag.as_dword()}")
-        elif tag.type == TagType.QWORD:
-            self.writer.write(f"{tag.as_qword()}")
-        elif tag.type in (TagType.STRINGREF, TagType.STRING):
-            val = tag.as_string()
-            if val:
-                self.writer.write(f"{escape(val)}")
-        elif tag.type == TagType.BINARY:
-            data = tag.as_bytes()
-            if data:
-                base64_data = b64encode(data).decode("utf-8")
-                self.writer.write(base64_data)
-        else:
-            raise ValueError(f"Unknown tag type: {tag.type} for tag {tag.name}")