mapuche 0.0.1__tar.gz

mapuche-0.0.1/.github/workflows/python-publish.yml

@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

mapuche-0.0.1/.gitignore

@@ -0,0 +1,4 @@
+*.egg-info
+*.whl
+__pycache__
+build

mapuche-0.0.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2024 Alexey Lapshin and others
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

mapuche-0.0.1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: mapuche
+Version: 0.0.1
+Summary: Linker's map file browser
+Author-email: Alexey Lapshin <alexeyfonlapshin@gmail.com>
+License: MIT
+Keywords: map,elf,linker
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual==0.40.0
+
+# mapuche
+
+Mapuche is a linker's map file browser
+
+If you are reading this, please don't forget to give this project a star on GitHub!
+
+> [!CAUTION]
+> Mapuche is in pre-alfa development stage. Crashes or unexpected output may occur! Please create an issue if any.
+
+
+## Install
+
+```
+pip install mapuche
+```
+
+## Usage
+
+> [!IMPORTANT]
+> For now mapuche supports only map files of ELFs generated with `-ffunction-sections` and `-fdata-sections` compile options.
+
+```
+mapuche <elf.map> [elf_for_diff.map]
+```
+
+## Screenshot
+
+![mapuche diff maps](./imgs/mapuche_diff_demo.png)
+
+## TODO list
+
+- [ ] implement `--help`/`--version` 
+- [ ] regex filters
+- [ ] columns sort
+- [ ] support expand/collapse by space button
+- [ ] move input section name from "name" to separate column
+- [ ] cute alignment for `size`/`diff`/`delta` columns
+- [ ] assembler diff viewer in popup widget
+- [ ] support map files for ELFs without `-ffunction-sections`/`-fdata-sections`
+- [ ] tests

mapuche-0.0.1/README.md

@@ -0,0 +1,40 @@
+# mapuche
+
+Mapuche is a linker's map file browser
+
+If you are reading this, please don't forget to give this project a star on GitHub!
+
+> [!CAUTION]
+> Mapuche is in pre-alfa development stage. Crashes or unexpected output may occur! Please create an issue if any.
+
+
+## Install
+
+```
+pip install mapuche
+```
+
+## Usage
+
+> [!IMPORTANT]
+> For now mapuche supports only map files of ELFs generated with `-ffunction-sections` and `-fdata-sections` compile options.
+
+```
+mapuche <elf.map> [elf_for_diff.map]
+```
+
+## Screenshot
+
+![mapuche diff maps](./imgs/mapuche_diff_demo.png)
+
+## TODO list
+
+- [ ] implement `--help`/`--version` 
+- [ ] regex filters
+- [ ] columns sort
+- [ ] support expand/collapse by space button
+- [ ] move input section name from "name" to separate column
+- [ ] cute alignment for `size`/`diff`/`delta` columns
+- [ ] assembler diff viewer in popup widget
+- [ ] support map files for ELFs without `-ffunction-sections`/`-fdata-sections`
+- [ ] tests

mapuche-0.0.1/mapuche/map_parse.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python
+
+import sys
+
+INFO = "*info*"  # TODO remove
+
+sections = {}
+sections_diff = {}
+
+def pretty_print_dict(d):
+    # print pretty json
+    import json
+    print(json.dumps(d, indent=4))
+
+def parse_lib_and_objfile(source):
+    if source == None:
+        return (None, None)
+    objfile = None
+
+    lib_end = source.rfind('(')
+    if lib_end > 0:
+        objfile = source[lib_end + 1:-1]
+    else:
+        lib_end = len(source)
+    lib_start = source.rfind('/') + 1
+    lib = source[lib_start:lib_end]
+    return (lib, objfile)
+
+def parse_mapfile_entry(f, line):
+    split = line.split()
+    name = split[0]
+    # remove the first element from split
+    split.pop(0)
+    # check if one word in line
+    if len(split) == 0:
+        # read new line and print
+        line = f.readline()
+        split = line.split()
+
+    if len(split) == 1:
+        return None
+
+    source = split[2] if len(split) == 3 else None
+
+    return {'name': name, 'address': split[0], 'size': int(split[1], 16), 'source': source}
+
+
+def fill_all_fields_with_info(data):
+    size = 0
+    for k in data['entries']:
+        size += fill_all_fields_with_info(data['entries'][k])
+
+    if data['size'] == None:
+        data['size'] = size
+    return data['size']
+
+def convert_to_textual_rows(json_data, is_diff=False, add_header=True):
+    rows = []
+    if add_header:
+        if is_diff:
+            rows += [tuple(['name', 'address', 'size', 'diff', 'delta'])]
+        else:
+            rows += [tuple(['name', 'address', 'size'])]
+    for k, v in json_data['entries'].items():
+        if is_diff:
+            rows.append(tuple([v['name'], v['address'], v['size'], v['diff'], v['delta']]))
+        else:
+            rows.append(tuple([v['name'], v['address'], v['size']]))
+        if len(v['entries']) == 0:
+            continue
+        rows += tuple([convert_to_textual_rows(v, is_diff, False)])
+    return rows
+
+
+def add_entry_to_entries(entries, name, entry=None):
+    if name in entries:
+        return
+
+    if entry != None:
+        entries[name] = entry
+    else:
+        entries[name] = {'name': name, 'address': None, 'size': None, 'source': None}
+    entries[name]['entries'] = {}
+
+def _parse_map_file(map_file):
+    # open file in argv[0] and read until string "Linker script and memory map"
+    # array of sections. Contains section name, address and size
+    sections = {}
+    parse = False
+    root_entry_name = ''
+    with open(map_file, 'r') as f:
+        while True:
+            line = f.readline()
+            if not line:
+                break
+            if not parse:
+                if "Linker script and memory map" in line:
+                    parse = True
+                continue
+            if "Cross Reference Table" in line:
+                break
+
+            if line.startswith('.'):
+                is_root_entry = True
+            elif line.startswith(' .'):
+                is_root_entry = False
+            else:
+                continue
+
+            map_entry = parse_mapfile_entry(f, line)
+            
+            if map_entry is None:
+                continue
+            
+            if is_root_entry:
+                root_entry_name = map_entry['name']
+                add_entry_to_entries(sections, root_entry_name, map_entry)
+            else:
+                # append last sections element with entry
+                lib, obj_file = parse_lib_and_objfile(map_entry['source'])
+                add_entry_to_entries(sections[root_entry_name]['entries'], lib)
+                add_entry_to_entries(sections[root_entry_name]['entries'][lib]['entries'], obj_file)
+                add_entry_to_entries(sections[root_entry_name]['entries'][lib]['entries'][obj_file]['entries'], map_entry['name'], map_entry)
+    sections = {'name': 'total', 'size': 0, 'entries': sections}
+    fill_all_fields_with_info(sections)
+    return sections
+
+def parse_map_file(map_file):
+    p = _parse_map_file(map_file)
+    return convert_to_textual_rows(p, False)
+
+def get_all_entries_keys(d1, d2):
+    result = []
+    if not d1 is None:
+        result += d1['entries'].keys()
+    if not d2 is None:
+        result += d2['entries'].keys()
+    return list(dict.fromkeys(result))
+
+def _collect_diff(diff_entries, leaf, m1, m2):
+    has_diff = False
+
+    diff_entries[leaf] = {'name': leaf, 'address': None, 'size': 0, 'diff': 0, 'delta': 0, 'source': None, 'entries': {}}
+
+    for k in get_all_entries_keys(m1, m2):
+        if m2 == None or not k in m2['entries']:
+            has_diff |= _collect_diff(diff_entries[leaf]['entries'], k, m1['entries'][k], None)
+            continue
+
+        if m1 == None or not k in m1['entries']:
+            has_diff |= _collect_diff(diff_entries[leaf]['entries'], k, None, m2['entries'][k])
+            continue
+
+        has_diff |= _collect_diff(diff_entries[leaf]['entries'], k, m1['entries'][k], m2['entries'][k])
+
+
+    s1 = 0 if m1 == None else m1['size']
+    s2 = 0 if m2 == None else m2['size']
+    has_diff |= s1 != s2
+
+    if not has_diff:
+        del diff_entries[leaf]
+        return has_diff
+
+    reference = m1
+    if m1 is None:
+        reference = m2
+
+    diff_entries[leaf]['name'] = reference['name']
+    diff_entries[leaf]['size'] = s1
+    diff_entries[leaf]['address'] = reference['address'] if 'address' in reference else None
+    diff_entries[leaf]['source'] = reference['source'] if 'source' in reference else None
+    diff_entries[leaf]['diff'] = s1 - s2
+    diff_entries[leaf]['delta'] = 100 if s2 == 0 else round((s1 - s2 ) / s2 * 100, 1)
+
+    return has_diff
+
+
+def generate_diff_table(map_1, map_2):
+    m1 = _parse_map_file(map_1)
+    m2 = _parse_map_file(map_2)
+
+    _collect_diff(sections_diff, 'total', m1, m2)
+
+    return convert_to_textual_rows(sections_diff['total'], True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 2:
+        rows_file = parse_map_file(sys.argv[1])
+        print(rows_file)
+    elif len(sys.argv) == 3:
+        rows_diff = generate_diff_table(sys.argv[1], sys.argv[2])
+    else:
+        print("Wrong number of arguments. Please provide one or two files.")
+        exit()

mapuche-0.0.1/mapuche/mapuche.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+from itertools import cycle
+from os import sys
+from textual.app import App, ComposeResult
+from .tree_table import DataTable
+from .map_parse import parse_map_file, generate_diff_table
+
+class TableApp(App):
+    def compose(self) -> ComposeResult:
+        yield DataTable()
+
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.cursor_type = next(cycle(["row"]))
+        table.zebra_stripes = True
+        if len(sys.argv) == 2:
+            rows = parse_map_file(sys.argv[1])
+        elif len(sys.argv) == 3:
+            rows = generate_diff_table(sys.argv[1], sys.argv[2])
+        table.add_columns(*rows[0])
+        table.add_rows(rows[1:])
+
+    def key_c(self):
+        table = self.query_one(DataTable)
+        table.cursor_type = next(cursors)
+
+
+def main():
+    if len(sys.argv) != 2 and len(sys.argv) != 3:
+        print("Wrong parameters count!")
+    app = TableApp()
+    app.run()
+
+if __name__ == "__main__":
+    main()