upeepz80 0.2.0__tar.gz

upeepz80-0.2.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: upeepz80
+Version: 0.2.0
+Summary: Universal peephole optimizer for Z80 compilers - pure Z80 assembly input/output
+Author: upeepz80 project
+License: GPLv2
+Project-URL: Homepage, https://github.com/avwohl/upeepz80
+Project-URL: Repository, https://github.com/avwohl/upeepz80
+Project-URL: Documentation, https://github.com/avwohl/upeepz80/tree/main/docs
+Project-URL: Bug Tracker, https://github.com/avwohl/upeepz80/issues
+Keywords: compiler,optimization,z80,peephole,retro
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: black>=23.7.0; extra == "dev"
+Requires-Dist: ruff>=0.0.285; extra == "dev"
+
+# upeepz80 - Universal Peephole Optimizer for Z80
+
+A language-agnostic peephole optimization library for Z80 compilers that generate pure Z80 assembly.
+
+## Overview
+
+upeepz80 provides high-quality optimization passes for compilers targeting the Zilog Z80 processor. Unlike upeep80, this library expects **pure Z80 mnemonics in lowercase** as input (ld, jp, jr, etc.) and produces optimized Z80 assembly output with lowercase mnemonics.
+
+If your compiler generates 8080 mnemonics (MOV, MVI, LXI, etc.) that need translation to Z80, use [upeep80](https://github.com/avwohl/upeep80) instead.
+
+## Features
+
+### Peephole Optimizations
+- **Pattern-based optimization** on Z80 assembly
+- **Redundant load/store elimination**
+- **Jump optimization** (jp to jr conversion, jump threading)
+- **djnz conversion** (dec b; jr nz → djnz)
+- **Stack operation combining** (push/pop to ld conversions)
+- **Dead store elimination**
+- **Tail call optimization** (call x; ret → jp x)
+- **Register copy optimization** (push hl; pop de → ld d,h; ld e,l)
+
+### Z80-Specific Features
+- Relative jump optimization (jp → jr where in range)
+- djnz loop optimization
+- Z80 block instruction awareness
+- Direct ld de,(addr) usage (Z80-only instruction)
+
+## Installation
+
+```bash
+pip install upeepz80
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/avwohl/upeepz80.git
+cd upeepz80
+pip install -e ".[dev]"
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from upeepz80 import optimize
+
+# Optimize Z80 assembly code
+assembly = """
+    ld a,0
+    push hl
+    pop de
+    jp LABEL
+LABEL:
+    ret
+"""
+
+optimized = optimize(assembly)
+print(optimized)
+# Output:
+#     xor a          ; ld a,0 → xor a (smaller)
+#     ld d,h         ; push/pop → register moves (faster)
+#     ld e,l
+#     ret            ; jp to next instruction eliminated
+```
+
+### Using the Optimizer Class
+
+```python
+from upeepz80 import PeepholeOptimizer
+
+# Create optimizer
+optimizer = PeepholeOptimizer()
+
+# Optimize assembly code
+optimized_asm = optimizer.optimize(assembly_text)
+
+# Check statistics
+print(f"xor a conversions: {optimizer.stats.get('xor_a', 0)}")
+print(f"Jump threading: {optimizer.stats.get('jump_thread', 0)}")
+print(f"djnz conversions: {optimizer.stats.get('djnz', 0)}")
+```
+
+## Optimization Phases
+
+The optimizer runs multiple phases:
+
+1. **Pattern Matching** - Apply peephole patterns (up to 10 passes)
+2. **Z80-Specific Optimizations** - Inline patterns for Z80 instructions
+3. **Jump Threading** - Thread through intermediate jumps
+4. **Relative Jump Conversion** - Convert jp to jr where possible
+5. **djnz Optimization** - Convert dec b; jr nz to djnz
+6. **Dead Store Elimination** - Remove unused stores
+
+## Architecture
+
+upeepz80 is designed to be language-agnostic:
+
+- Works directly on Z80 assembly text
+- No knowledge of source language required
+- Pattern-based transformation engine
+- Zero runtime dependencies
+
+## Comparison with upeep80
+
+| Feature | upeep80 | upeepz80 |
+|---------|---------|----------|
+| Input | 8080 or Z80 mnemonics | Z80 mnemonics only |
+| Output | Z80 or 8080 (configurable) | Z80 only |
+| Translation | 8080 → Z80 translation | None needed |
+| Use case | Compilers generating 8080 code | Compilers generating Z80 code |
+
+Choose **upeepz80** if your compiler already generates Z80 mnemonics.
+Choose **upeep80** if your compiler generates 8080 mnemonics.
+
+## Used By
+
+- **[uplm80](https://github.com/avwohl/uplm80)** - PL/M-80 compiler for Z80 (after migration)
+- **[uada80](https://github.com/avwohl/uada80)** - Ada compiler for Z80 (after migration)
+
+## Development
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Type Checking
+
+```bash
+mypy upeepz80
+```
+
+### Code Formatting
+
+```bash
+black upeepz80
+ruff check upeepz80
+```
+
+## Performance
+
+Benchmarks on typical compiler workloads:
+
+- Peephole optimization: ~50,000 instructions/second
+- Memory usage: Minimal (pattern-based, no large data structures)
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+This project is licensed under the GNU General Public License v2.0 - see [LICENSE](LICENSE) for details.
+
+## History
+
+upeepz80 is a sibling project to upeep80, designed for compilers that generate native Z80 assembly. It shares the same optimization algorithms but removes the 8080 translation layer for cleaner, more efficient code when 8080 support isn't needed.
+
+## See Also
+
+- [upeep80](https://github.com/avwohl/upeep80) - Optimizer with 8080 input support
+- [Z80 CPU User Manual](http://www.z80.info/zip/z80cpu_um.pdf)

upeepz80-0.2.0/README.md

@@ -0,0 +1,166 @@
+# upeepz80 - Universal Peephole Optimizer for Z80
+
+A language-agnostic peephole optimization library for Z80 compilers that generate pure Z80 assembly.
+
+## Overview
+
+upeepz80 provides high-quality optimization passes for compilers targeting the Zilog Z80 processor. Unlike upeep80, this library expects **pure Z80 mnemonics in lowercase** as input (ld, jp, jr, etc.) and produces optimized Z80 assembly output with lowercase mnemonics.
+
+If your compiler generates 8080 mnemonics (MOV, MVI, LXI, etc.) that need translation to Z80, use [upeep80](https://github.com/avwohl/upeep80) instead.
+
+## Features
+
+### Peephole Optimizations
+- **Pattern-based optimization** on Z80 assembly
+- **Redundant load/store elimination**
+- **Jump optimization** (jp to jr conversion, jump threading)
+- **djnz conversion** (dec b; jr nz → djnz)
+- **Stack operation combining** (push/pop to ld conversions)
+- **Dead store elimination**
+- **Tail call optimization** (call x; ret → jp x)
+- **Register copy optimization** (push hl; pop de → ld d,h; ld e,l)
+
+### Z80-Specific Features
+- Relative jump optimization (jp → jr where in range)
+- djnz loop optimization
+- Z80 block instruction awareness
+- Direct ld de,(addr) usage (Z80-only instruction)
+
+## Installation
+
+```bash
+pip install upeepz80
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/avwohl/upeepz80.git
+cd upeepz80
+pip install -e ".[dev]"
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from upeepz80 import optimize
+
+# Optimize Z80 assembly code
+assembly = """
+    ld a,0
+    push hl
+    pop de
+    jp LABEL
+LABEL:
+    ret
+"""
+
+optimized = optimize(assembly)
+print(optimized)
+# Output:
+#     xor a          ; ld a,0 → xor a (smaller)
+#     ld d,h         ; push/pop → register moves (faster)
+#     ld e,l
+#     ret            ; jp to next instruction eliminated
+```
+
+### Using the Optimizer Class
+
+```python
+from upeepz80 import PeepholeOptimizer
+
+# Create optimizer
+optimizer = PeepholeOptimizer()
+
+# Optimize assembly code
+optimized_asm = optimizer.optimize(assembly_text)
+
+# Check statistics
+print(f"xor a conversions: {optimizer.stats.get('xor_a', 0)}")
+print(f"Jump threading: {optimizer.stats.get('jump_thread', 0)}")
+print(f"djnz conversions: {optimizer.stats.get('djnz', 0)}")
+```
+
+## Optimization Phases
+
+The optimizer runs multiple phases:
+
+1. **Pattern Matching** - Apply peephole patterns (up to 10 passes)
+2. **Z80-Specific Optimizations** - Inline patterns for Z80 instructions
+3. **Jump Threading** - Thread through intermediate jumps
+4. **Relative Jump Conversion** - Convert jp to jr where possible
+5. **djnz Optimization** - Convert dec b; jr nz to djnz
+6. **Dead Store Elimination** - Remove unused stores
+
+## Architecture
+
+upeepz80 is designed to be language-agnostic:
+
+- Works directly on Z80 assembly text
+- No knowledge of source language required
+- Pattern-based transformation engine
+- Zero runtime dependencies
+
+## Comparison with upeep80
+
+| Feature | upeep80 | upeepz80 |
+|---------|---------|----------|
+| Input | 8080 or Z80 mnemonics | Z80 mnemonics only |
+| Output | Z80 or 8080 (configurable) | Z80 only |
+| Translation | 8080 → Z80 translation | None needed |
+| Use case | Compilers generating 8080 code | Compilers generating Z80 code |
+
+Choose **upeepz80** if your compiler already generates Z80 mnemonics.
+Choose **upeep80** if your compiler generates 8080 mnemonics.
+
+## Used By
+
+- **[uplm80](https://github.com/avwohl/uplm80)** - PL/M-80 compiler for Z80 (after migration)
+- **[uada80](https://github.com/avwohl/uada80)** - Ada compiler for Z80 (after migration)
+
+## Development
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Type Checking
+
+```bash
+mypy upeepz80
+```
+
+### Code Formatting
+
+```bash
+black upeepz80
+ruff check upeepz80
+```
+
+## Performance
+
+Benchmarks on typical compiler workloads:
+
+- Peephole optimization: ~50,000 instructions/second
+- Memory usage: Minimal (pattern-based, no large data structures)
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+This project is licensed under the GNU General Public License v2.0 - see [LICENSE](LICENSE) for details.
+
+## History
+
+upeepz80 is a sibling project to upeep80, designed for compilers that generate native Z80 assembly. It shares the same optimization algorithms but removes the 8080 translation layer for cleaner, more efficient code when 8080 support isn't needed.
+
+## See Also
+
+- [upeep80](https://github.com/avwohl/upeep80) - Optimizer with 8080 input support
+- [Z80 CPU User Manual](http://www.z80.info/zip/z80cpu_um.pdf)

upeepz80-0.2.0/pyproject.toml

@@ -0,0 +1,96 @@
+[build-system]
+requires = ["setuptools>=68.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "upeepz80"
+version = "0.2.0"
+description = "Universal peephole optimizer for Z80 compilers - pure Z80 assembly input/output"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "GPLv2"}
+authors = [
+    {name = "upeepz80 project"}
+]
+keywords = ["compiler", "optimization", "z80", "peephole", "retro"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Compilers",
+    "Topic :: Software Development :: Code Generators",
+]
+
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+    "pytest-benchmark>=4.0.0",
+    "mypy>=1.5.0",
+    "black>=23.7.0",
+    "ruff>=0.0.285",
+]
+
+[project.urls]
+Homepage = "https://github.com/avwohl/upeepz80"
+Repository = "https://github.com/avwohl/upeepz80"
+Documentation = "https://github.com/avwohl/upeepz80/tree/main/docs"
+"Bug Tracker" = "https://github.com/avwohl/upeepz80/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["upeepz80*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "--verbose",
+]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+strict_equality = true
+
+[tool.black]
+line-length = 100
+target-version = ['py310']
+include = '\.pyi?$'
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "N",   # pep8-naming
+    "UP",  # pyupgrade
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+]
+ignore = [
+    "E501",  # line too long (handled by black)
+]
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["F401"]
+"tests/*.py" = ["N802", "N806"]

upeepz80-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

upeepz80-0.2.0/upeepz80/__init__.py

@@ -0,0 +1,28 @@
+"""
+upeepz80 - Universal Peephole Optimizer for Z80
+
+A language-agnostic optimization library for compilers targeting
+the Zilog Z80 processor with pure Z80 assembly input/output.
+
+For compilers that generate 8080 mnemonics (MOV, MVI, etc.),
+use upeep80 instead.
+"""
+
+__version__ = "0.1.0"
+__author__ = "upeepz80 project"
+
+from .peephole import (
+    PeepholeOptimizer,
+    PeepholePattern,
+    optimize,
+)
+
+__all__ = [
+    # Version
+    "__version__",
+
+    # Peephole Optimization
+    "PeepholeOptimizer",
+    "PeepholePattern",
+    "optimize",
+]