atlispcc 0.1.0__tar.gz

atlispcc-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: atlispcc
+Version: 0.1.0
+Summary: FAS4 bytecode decompiler and compiler toolchain for AutoLISP-compatible CAD platforms
+Requires-Python: >=3.8
+Requires-Dist: typing-extensions>=4.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.3.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"

atlispcc-0.1.0/README.md

@@ -0,0 +1,167 @@
+# atlispcc — FAS4 字节码编译器 & 反编译器
+
+`atlispcc` 是一个统一的 CLI 工具链，用于将 AutoLISP (`.lsp`) 编译为 FAS4 字节码 (`.fas`)，反编译 FAS4 回 Lisp，链接多个 FAS 文件，以及验证 Lisp 语法。
+
+## CLI
+
+```sh
+atlispcc compile [-O {0,1,2,3}] <input.lsp> [output.fas]        # 编译
+atlispcc decompile <input.fas> [output.lsp]                      # 反编译 FAS → Lisp
+atlispcc disasm <input.fas> [output.lasm]                        # 反汇编 FAS → 字节码指令列表
+atlispcc asm <input.lasm> [output.fas]                           # 汇编 .lasm → FAS
+atlispcc validate <input.lsp>                                     # 验证
+atlispcc link [-o OUTPUT] <input.fas> <input.fas> [...]          # 链接 FAS
+atlispcc build-vlx <input.fas>... -o output.vlx [--export ...]   # 构建 VLX 容器
+```
+
+无子命令时默认为 compile：`atlispcc <input.lsp> [output.fas]`
+
+`disasm` / `asm` 互为逆操作，支持 `.fas → .lasm → .fas` 往返。
+
+## 编译器管线
+
+```
+Lisp 源码 → Parser.parse() → AST
+         → SymbolTableBuilder.build() → SymbolTable
+         → Codegen.generate() → List[FunctionDef]（指令流）
+         → [OptPipeline.optimize()  # 可选：-O1/-O2/-O3]
+         → ResourceBuilder.build() → 资源段
+         → FasWriter.write() → FAS4 二进制
+```
+
+## 反编译器管线
+
+```
+Fas4Parser.parse() → Disassembler.disassemble()
+→ ControlFlowAnalyzer.find_functions() → LispGenerator.generate()
+```
+
+## 链接器管线
+
+```
+FAS A + FAS B + ... → 合并符号表/函数目录 → 重排索引 → 修复交叉引用 → 合并 FAS
+```
+
+## 包系统 (CL-style Namespace)
+
+### 语法
+
+```lisp
+(defpackage vec
+  (:use)
+  (:export vec2 vec3))
+
+(in-package vec)
+
+(defun vec2 (x) (+ x 1))   ; 内部名混淆为 vec|vec2
+
+;; 跨包调用：
+(in-package app)
+(defun foo (x) (vec:vec2 x))  ; 编译时解析为 vec|vec2
+```
+
+### 原理
+
+- CL 风格的包系统在**编译期**工作，不影响 FAS4 格式
+- 包限定的函数名通过名混淆（`pkg|name`）编码为平展符号名
+- FAS4 二进制格式完全不变，兼容所有 CAD
+- 反编译器自动还原 `pkg|name` → `pkg:name`
+- 只对 `defun` 名和 `pkg:name` 语法的引用生效，不干扰局部变量
+
+## VLX 容器
+
+`atlispcc build-vlx` 将 FAS 文件打包为 VLX 容器，支持独立命名空间：
+
+```sh
+atlispcc build-vlx app.fas lib.fas -o app.vlx --export main setup
+```
+
+- 自动生成 `_VLX` 元数据条目（含 `vl-doc-export` 调用）
+- 加载 VLX 时 CAD 运行时创建隔离命名空间
+- 仅导出的函数可被外部访问
+- VLX 格式基于逆向工程，标记为实验性
+
+## 优化级别
+
+| 级别 | Pass 列表 | 说明 |
+|-------|--------|------|
+| `-O0` | 无 | 原始编译，不做优化 |
+| `-O1` | ConstantFold, DeadBranchElim, Peephole | 基本清理：`(+ 1 2)` → `3`、`(if T e1 e2)` → `e1`、`(progn x)` → `x` |
+| `-O2` | O1 + ConstantPropagate, DeadAssignElim | 激进优化：`(setq x 3) (+ x 1)` → `(+ 3 1)`、移除未使用的 `setq` |
+| `-O3` | O2 + CrossFuncConstPropagate, DeadCodeElim, InlineSmallFuncs | 极致优化：内联单次调用函数、跨函数常量替换、删除 `exit`/`quit` 后的死代码 |
+
+### 分析
+
+使用 `--analyze` 配合任何 `-O` 级别查看编译统计：
+
+```sh
+atlispcc compile --analyze -O3 input.lsp output.fas
+```
+
+输出包含：
+- 函数数、指令数、常量估算数
+- 尾递归函数检测
+- 每个函数的参数数、局部变量、调用关系
+- 开启优化时输出优化前后对比
+
+## 关键文件
+
+| 文件 | 作用 |
+|------|------|
+| `fas4_decompiler.py` | 主反编译器：解析 + 反汇编 + 分析 + 生成 |
+| `fas_core.py` | 共享加密/解析/符号工具函数 |
+| `compiler/cli.py` | CLI 入口，子命令分发 |
+| `compiler/parser.py` | Lisp 源码解析器 → AST |
+| `compiler/ast.py` | AST 节点定义（含 Defpackage、InPackage） |
+| `compiler/packages.py` | 包系统：PackageTable、名混淆/还原 |
+| `compiler/symbol_table.py` | 符号表构建与作用域分析（含包解析） |
+| `compiler/codegen.py` | 字节码生成器（AST → 指令流） |
+| `compiler/resource_builder.py` | 常量/符号/函数索引 → 资源段 |
+| `compiler/fas_writer.py` | 指令流 → FAS4 二进制 |
+| `compiler/opt.py` | 优化器：8 个 pass 跨 O1-O3 级别 |
+| `compiler/analyzer.py` | 编译分析与统计 |
+| `compiler/assembler.py` | 反汇编/汇编（.fas ↔ .lasm） |
+| `compiler/linker.py` | 多文件 FAS 链接器 |
+| `compiler/vlx_builder.py` | VLX 容器构建器 |
+| `validate.py` | 生成的 `.lsp` 语法验证器 |
+
+## 安装
+
+```sh
+pip install -e ".[dev]"      # 开发模式（含 dev 工具）
+```
+
+## 测试
+
+```sh
+python -m pytest              # 运行所有测试（161 用例）
+python -m pytest tests/ -v   # 详细输出
+```
+
+测试文件在 `tests/` 目录：
+- `test_parser.py` — AST 解析器（19 用例）
+- `test_lexer.py` — 词法分析（11 用例）
+- `test_symbol_table.py` — 符号表/作用域（10 用例）
+- `test_analyzer.py` — 编译分析/尾递归（9 用例）
+- `test_cli.py` — CLI 路径（10 用例）
+- `test_compile_decompile.py` — 编译-反编译往返（28 用例）
+- `test_compiler_output.py` — FAS 输出正确性（12 用例）
+- `test_optimizer.py` — 所有优化 pass（32 用例）
+- `test_linker.py` — 多文件链接（10 用例）
+- `test_assembler.py` — 反汇编/汇编往返（5 用例）
+- `test_disasm.py` — 反汇编健壮性（8 用例）
+- `test_packages.py` — 包系统（4 用例）
+- `test_vlx_builder.py` — VLX 容器（3 用例）
+
+## 文档
+
+- `docs/cad-stub-format.md` — AutoCAD 紧凑 stub 格式规范与兼容实现（核心）
+- `docs/development-plan.md` — 开发计划、遗留问题与路线图
+- `docs/fas-format.md` — FAS4 二进制文件格式详解
+- `docs/opcodes.md` — 操作码参考
+- `docs/development.md` — 架构详解、代码规范、调试指南
+- `docs/usage.md` — 用户安装、编译/反编译工作流、工具参考
+
+## 安全
+
+反编译生成的 `.lsp` 应先审查再使用。先在空白图形中测试。某些命令可能会创建、修改或删除图形实体。

atlispcc-0.1.0/atlispcc.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: atlispcc
+Version: 0.1.0
+Summary: FAS4 bytecode decompiler and compiler toolchain for AutoLISP-compatible CAD platforms
+Requires-Python: >=3.8
+Requires-Dist: typing-extensions>=4.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.3.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"

atlispcc-0.1.0/atlispcc.egg-info/SOURCES.txt

@@ -0,0 +1,42 @@
+README.md
+fas4_decompiler.py
+fas_core.py
+pyproject.toml
+validate.py
+atlispcc.egg-info/PKG-INFO
+atlispcc.egg-info/SOURCES.txt
+atlispcc.egg-info/dependency_links.txt
+atlispcc.egg-info/entry_points.txt
+atlispcc.egg-info/requires.txt
+atlispcc.egg-info/top_level.txt
+compiler/__init__.py
+compiler/analyzer.py
+compiler/assembler.py
+compiler/ast.py
+compiler/cad_symbols.py
+compiler/cli.py
+compiler/codegen.py
+compiler/fas_writer.py
+compiler/lexer.py
+compiler/linker.py
+compiler/opcodes.py
+compiler/opt.py
+compiler/packages.py
+compiler/parser.py
+compiler/resource_builder.py
+compiler/symbol_table.py
+compiler/vlx_builder.py
+tests/test_analyzer.py
+tests/test_assembler.py
+tests/test_cli.py
+tests/test_compile_decompile.py
+tests/test_compiler_output.py
+tests/test_disasm.py
+tests/test_lexer.py
+tests/test_linker.py
+tests/test_optimizer.py
+tests/test_packages.py
+tests/test_parser.py
+tests/test_symbol_table.py
+tests/test_variadic_args.py
+tests/test_vlx_builder.py

atlispcc-0.1.0/atlispcc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

atlispcc-0.1.0/atlispcc.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+atlispcc = compiler.cli:main

atlispcc-0.1.0/atlispcc.egg-info/requires.txt

@@ -0,0 +1,6 @@
+typing-extensions>=4.5.0
+
+[dev]
+pytest>=7.0.0
+black>=22.3.0
+mypy>=1.0.0

atlispcc-0.1.0/atlispcc.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+compiler
+fas4_decompiler
+fas_core
+validate

atlispcc-0.1.0/compiler/analyzer.py

@@ -0,0 +1,217 @@
+from typing import Dict, List, Set, Tuple, Optional
+from compiler.ast import (
+    Node,
+    Program,
+    Symbol,
+    Integer,
+    Real,
+    String,
+    ListExpr,
+    QuotedExpr,
+    Defun,
+    Setq,
+    IfNode,
+    WhileNode,
+    ForeachNode,
+    RepeatNode,
+    Call,
+    Progn,
+    LambdaNode,
+    Cond,
+)
+from compiler.codegen import CodeGenerator, BytecodeBuffer
+from compiler.symbol_table import SymbolTable
+
+
+def count_instructions(func: Defun, symtab: SymbolTable) -> int:
+    codegen = CodeGenerator(symtab)
+    bytecode, _ = codegen.generate_function(func)
+    return len(bytecode)
+
+
+def _collect_call_names(node: Optional[Node], calls: Set[str]):
+    if node is None:
+        return
+    if isinstance(node, Call):
+        calls.add(node.name)
+        for a in node.args:
+            _collect_call_names(a, calls)
+    elif isinstance(node, Setq):
+        for _, v in node.pairs:
+            _collect_call_names(v, calls)
+    elif isinstance(node, IfNode):
+        _collect_call_names(node.cond, calls)
+        if node.then:
+            _collect_call_names(node.then, calls)
+        if node.else_expr:
+            _collect_call_names(node.else_expr, calls)
+    elif isinstance(node, WhileNode):
+        _collect_call_names(node.cond, calls)
+        for b in node.body:
+            _collect_call_names(b, calls)
+    elif isinstance(node, ForeachNode):
+        _collect_call_names(node.var, calls)
+        _collect_call_names(node.list_expr, calls)
+        for b in node.body:
+            _collect_call_names(b, calls)
+    elif isinstance(node, RepeatNode):
+        _collect_call_names(node.count, calls)
+        for b in node.body:
+            _collect_call_names(b, calls)
+    elif isinstance(node, Progn):
+        for f in node.forms:
+            _collect_call_names(f, calls)
+    elif isinstance(node, Cond):
+        for cl in node.clauses:
+            for c in cl:
+                _collect_call_names(c, calls)
+    elif isinstance(node, LambdaNode):
+        for b in node.body:
+            _collect_call_names(b, calls)
+
+
+def _is_tail_call(node: Node, func_name: str) -> bool:
+    if isinstance(node, Call) and node.name == func_name:
+        return True
+    if isinstance(node, IfNode):
+        if node.then and _is_tail_call(node.then, func_name):
+            return True
+        if node.else_expr and _is_tail_call(node.else_expr, func_name):
+            return True
+        return False
+    if isinstance(node, Cond):
+        for clause in node.clauses:
+            if clause:
+                tail = clause[-1] if len(clause) > 1 else clause[0]
+                if _is_tail_call(tail, func_name):
+                    return True
+        return False
+    if isinstance(node, Progn):
+        if node.forms:
+            return _is_tail_call(node.forms[-1], func_name)
+        return False
+    return False
+
+
+def find_tail_recursive(func: Defun) -> bool:
+    if not func.body:
+        return False
+    return _is_tail_call(func.body[-1], func.name)
+
+
+def estimate_constants(program: Program) -> int:
+    count = 0
+
+    def walk(node: Optional[Node]):
+        nonlocal count
+        if node is None:
+            return
+        if isinstance(node, (Integer, Real, String)):
+            count += 1
+        elif isinstance(node, Call):
+            for a in node.args:
+                walk(a)
+        elif isinstance(node, Setq):
+            for _, v in node.pairs:
+                walk(v)
+        elif isinstance(node, IfNode):
+            walk(node.cond)
+            if node.then:
+                walk(node.then)
+            if node.else_expr:
+                walk(node.else_expr)
+        elif isinstance(node, WhileNode):
+            walk(node.cond)
+            for b in node.body:
+                walk(b)
+        elif isinstance(node, ForeachNode):
+            walk(node.var)
+            walk(node.list_expr)
+            for b in node.body:
+                walk(b)
+        elif isinstance(node, RepeatNode):
+            walk(node.count)
+            for b in node.body:
+                walk(b)
+        elif isinstance(node, Progn):
+            for f in node.forms:
+                walk(f)
+        elif isinstance(node, Cond):
+            for cl in node.clauses:
+                for c in cl:
+                    walk(c)
+        elif isinstance(node, ListExpr):
+            for i in node.items:
+                walk(i)
+        elif isinstance(node, QuotedExpr):
+            if node.expr:
+                walk(node.expr)
+        elif isinstance(node, LambdaNode):
+            for b in node.body:
+                walk(b)
+
+    for f in program.forms:
+        if isinstance(f, Defun):
+            for e in f.body:
+                walk(e)
+        else:
+            walk(f)
+    return count
+
+
+def analyze(program: Program) -> Dict:
+    symtab = SymbolTable()
+    symtab.collect_symbols(program)
+
+    defuns = [f for f in program.forms if isinstance(f, Defun)]
+    other = [f for f in program.forms if not isinstance(f, Defun)]
+
+    func_stats = []
+    total_instructions = 0
+    tail_recursive = []
+
+    for f in defuns:
+        inst_count = count_instructions(f, symtab)
+        total_instructions += inst_count
+        calls: Set[str] = set()
+        for e in f.body:
+            _collect_call_names(e, calls)
+
+        is_tail_rec = find_tail_recursive(f)
+        if is_tail_rec:
+            tail_recursive.append(f.name)
+
+        func_stats.append(
+            {
+                "name": f.name,
+                "args": len(f.args),
+                "locals": len(f.locals),
+                "instructions": inst_count,
+                "calls": sorted(calls) if calls else [],
+                "tail_recursive": is_tail_rec,
+            }
+        )
+
+    all_calls: Set[str] = set()
+    for f in defuns:
+        for e in f.body:
+            _collect_call_names(e, all_calls)
+    for e in other:
+        _collect_call_names(e, all_calls)
+
+    builtin_calls = {c for c in all_calls if c[0].islower() and c != "setq"}
+    user_funcs = {f.name for f in defuns}
+    extern_calls = builtin_calls - user_funcs
+
+    return {
+        "functions": len(defuns),
+        "top_level_forms": len(other),
+        "total_instructions": total_instructions,
+        "constants_estimate": estimate_constants(program),
+        "symbol_table_entries": len(symtab.entries),
+        "function_offsets": len(symtab.function_offsets),
+        "locals": sum(len(f.locals) for f in defuns),
+        "tail_recursive_functions": tail_recursive,
+        "functions_detail": func_stats,
+        "builtin_calls": sorted(extern_calls),
+    }