atlispcc 0.1.0__py3-none-any.whl

atlispcc-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,25 @@
+fas4_decompiler.py,sha256=Z1lguVxy1KuPJx9Rcz-MI6tyD2YC852oeFD9vz-MhD0,113187
+fas_core.py,sha256=FhXKyO_HMmyZNuM-EVGCDqoXKQGycRkVHLyzFZFftXo,23976
+validate.py,sha256=7G6Y4G8BranlICusBlmaNR5lyx3GofEK1QJT0pcvoa8,7669
+compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compiler/analyzer.py,sha256=ahxB5N3rU8t78LCBVp8kWq_QQGIK4Lu_dotv3ulRr-o,6508
+compiler/assembler.py,sha256=IS0HL2F__ZNox40JcXO7Ori6PINlhz4cy5nxFe2rhXQ,9332
+compiler/ast.py,sha256=isnMGZRSYBnumoHGFU-n00hmNb6fHhaFYx8Rx2FpivY,2217
+compiler/cad_symbols.py,sha256=rqA6C6cBuXrIxV1w_cYjc5u-7-ELaKKvNyIfD34KYv8,5678
+compiler/cli.py,sha256=DNRY-0jR9tQY8hZ5p2rQUhTF0Fl_3h2RbxmCjGydte0,17881
+compiler/codegen.py,sha256=8z8PtoZcrZlXKt6d-AQICrxQXIQz7g6TNpHeC7V2rm0,29140
+compiler/fas_writer.py,sha256=qQx6JwEBsOZ8owIpeoltmqePZjhQvwMIEGlSfYhIr1Q,4004
+compiler/lexer.py,sha256=BsW4vafVCf9dog1nMVpfBxjgbC5P_PRaIbIN1WpNV-k,2704
+compiler/linker.py,sha256=TlD7N0AuKy-HuaqSJJvr-Z2QkpZyV5Sm0BSSd0HzaJ0,20538
+compiler/opcodes.py,sha256=_4xOnuuMQBIR5ghR6xTWLvjD0Wna21QqQkvGWDl82mU,5375
+compiler/opt.py,sha256=TvN6J7Mw-GjANX2GbiGsePcut8iZDCb5hDFy_mpdBhY,50300
+compiler/packages.py,sha256=TZKa2dxtzS-Q4t2elCGSdG_s8c4bem7HbMpK2g0xg-E,1440
+compiler/parser.py,sha256=pfoII5WSlrGAW7Bu4L03fNsFrfgZEqDUHsZfrJc3Z2g,11452
+compiler/resource_builder.py,sha256=VADirA_pRFcRQlPi4k7mufNv00UbCFtOOPO4Ig7EKY4,10873
+compiler/symbol_table.py,sha256=tFPqLiLn6VRe-A3D8bS5-x4rh4JZKA37bqDwrEDFefE,8869
+compiler/vlx_builder.py,sha256=LBH_bYRl4r4-9KPWpB2RkBIL2QMlvumshQvqE5DVHI0,2917
+atlispcc-0.1.0.dist-info/METADATA,sha256=fvTsAPGnSAO0DXJpf4zvojjY-CIS9CanNyj0lML4BL4,363
+atlispcc-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+atlispcc-0.1.0.dist-info/entry_points.txt,sha256=3VWSfOrIUal05XiRUYbqHvP5Lzb8tCMjEj2ngYnxv5E,47
+atlispcc-0.1.0.dist-info/top_level.txt,sha256=tQ25b7vfMG8b2mIVPwdmSi9jAPbwfjwi-hvgPdJDyuI,43
+atlispcc-0.1.0.dist-info/RECORD,,

atlispcc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

atlispcc-0.1.0.dist-info/entry_points.txt

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

atlispcc-0.1.0.dist-info/top_level.txt

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

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),
+    }

compiler/assembler.py

@@ -0,0 +1,265 @@
+"""FAS4 assembler/disassembler: .fas ↔ .lasm (Lisp Assembly)."""
+
+import os
+import re
+from typing import Any, List, Dict, Tuple, Optional
+
+from compiler.opcodes import (
+    NAME_TO_OPCODE,
+    OPCODE_TO_NAME,
+    encode_instruction,
+    encode_op_u16,
+)
+from compiler.symbol_table import SymbolTable
+from compiler.resource_builder import ResourceBuilder
+from compiler.fas_writer import FasWriter
+
+# ─── Disassembler (FAS → .lasm text) ─────────────────────────────────────────
+
+# Opcodes that share a name with another opcode — disambiguate in output
+_DUPLICATE_NAMES = {
+    0x5C: "GET_LOCAL_WIDE",  # shares name 'GET_LOCAL' with 0x05
+}
+
+
+def _disasm_op_name(opcode: int) -> str:
+    """Return the assembly mnemonic, disambiguating duplicates."""
+    if opcode in _DUPLICATE_NAMES:
+        return _DUPLICATE_NAMES[opcode]
+    return OPCODE_TO_NAME.get(opcode, f"UNK_{opcode:02x}")
+
+
+def _resolve_sym(symbols: List[str], idx: int) -> str:
+    if 0 <= idx < len(symbols):
+        return symbols[idx]
+    return f"[{idx}]"
+
+
+def _fmt_inst(inst, symbols: List[str]) -> str:
+    """Format one instruction as a .lasm line."""
+    prefix = f"  0x{inst.offset:04x}:"
+    name = _disasm_op_name(inst.opcode)
+    ops = list(inst.operands)
+
+    # DEFUN packs 4 bytes → gv(u16), offset(u16)
+    if name == "DEFUN" and len(ops) >= 4:
+        gv = ops[0] | (ops[1] << 8)
+        off = ops[2] | (ops[3] << 8)
+        sym = _resolve_sym(symbols, gv)
+        return f"{prefix} DEFUN {sym}, {off}"
+    # FUNC/USUBR: second operand is a symbol index
+    if name in ("FUNC", "USUBR") and len(ops) >= 2:
+        sym = _resolve_sym(symbols, ops[1])
+        rest = [str(ops[0]), sym]
+        if len(ops) > 2:
+            rest.extend(str(o) for o in ops[2:])
+        return f'{prefix} {name} {", ".join(rest)}'
+    # PUSH_VALUE/PUSH_G/SETQ_G/PUSH_GLOBAL: first operand is a symbol index
+    if name in ("PUSH_VALUE", "PUSH_G", "PUSH_GLOBAL", "SETQ_G") and ops:
+        sym_info = _resolve_sym(symbols, ops[0])
+        rest = [sym_info]
+        rest.extend(str(o) for o in ops[1:3])
+        return f'{prefix} {name} {", ".join(rest)}'
+    # GET_LOCAL/SET_LOCAL/CLEAR_LOCAL: operand is a local slot index (integer)
+    if name in ("GET_LOCAL", "GET_LOCAL_WIDE", "SET_LOCAL", "CLEAR_LOCAL") and ops:
+        return f"{prefix} {name} {ops[0]}"
+
+    if not ops:
+        return f"{prefix} {name}"
+    return f'{prefix} {name} {", ".join(str(o) for o in ops)}'
+
+
+def disassemble_fas(fas_path: str) -> str:
+    """Disassemble a FAS4 file into .lasm text format."""
+    from fas4_decompiler import Fas4Parser, Disassembler, ControlFlowAnalyzer, is_compact_stub, extract_stub_function_names
+
+    parser = Fas4Parser()
+    fas = parser.parse(fas_path)
+    disasm = Disassembler(short_subr=is_compact_stub(fas.bytecode, fas.function_catalog, len(fas.symbol_slots)))
+    instructions = disasm.disassemble(fas.bytecode, fas.nsyms,
+                                      sym_count=len(fas.symbol_slots) if is_compact_stub(fas.bytecode, fas.function_catalog, len(fas.symbol_slots)) else None)
+    cfa = ControlFlowAnalyzer(instructions, fas.function_catalog,
+                              function_names=extract_stub_function_names(fas))
+    functions = cfa.find_functions()
+
+    lines: List[str] = []
+    lines.append("; FAS4 assembly")
+    lines.append(f"; Source: {os.path.basename(fas_path)}")
+    if fas.crunch_date:
+        lines.append(f"; Crunch date: {fas.crunch_date}")
+    lines.append("")
+
+    # 紧凑 stub 格式按资源注册顺序（symbol_slots）编址
+    if getattr(fas, "symbol_slots", None):
+        symbols = [str(it[1]) for it in fas.symbol_slots]
+    else:
+        symbols = fas.symbols
+
+    lines.append(".symbols")
+    for idx, sym in enumerate(symbols):
+        lines.append(f"  {idx}: SYMBOL {sym}")
+    lines.append(".end_symbols")
+    lines.append("")
+
+    for func in functions:
+        fname = func.name if func.name and func.name != "c:init" else "__init__"
+        lines.append(f".function {fname}, {func.sym_idx}")
+        for inst in func.instructions:
+            lines.append(_fmt_inst(inst, symbols))
+        lines.append(".end_function")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+# ─── Assembler (.lasm text → FAS) ────────────────────────────────────────────
+
+
+def assemble_lasm(lasm_text: str, output_path: str) -> str:
+    """Assemble .lasm text into a FAS4 binary file."""
+
+    # === Pass 1: parse structure ===
+    symbols_list: List[str] = []
+    functions: List[Tuple[str, int, List[str]]] = []
+    current_func_name = ""
+    current_func_idx = 0
+    current_func_body: List[str] = []
+    in_symbols = False
+    in_function = False
+
+    for raw in lasm_text.split("\n"):
+        line = raw.split(";", 1)[0].strip()
+        if not line:
+            continue
+
+        if line == ".symbols":
+            in_symbols = True
+        elif line == ".end_symbols":
+            in_symbols = False
+        elif line.startswith(".function"):
+            m = re.match(r"\.function\s+(\S+),\s*(\d+)", line)
+            if m:
+                if in_function:
+                    functions.append((current_func_name, current_func_idx, current_func_body))
+                current_func_name = m.group(1)
+                current_func_idx = int(m.group(2))
+                current_func_body = []
+                in_function = True
+        elif line == ".end_function":
+            if in_function:
+                functions.append((current_func_name, current_func_idx, current_func_body))
+                current_func_name = ""
+                current_func_body = []
+                in_function = False
+        elif in_symbols:
+            m = re.match(r"\s*(\d+)\s*:\s*SYMBOL\s+(.+)", line)
+            if m:
+                idx = int(m.group(1))
+                name = m.group(2).strip()
+                while len(symbols_list) <= idx:
+                    symbols_list.append("")
+                symbols_list[idx] = name
+        elif in_function:
+            current_func_body.append(line)
+
+    if in_function and current_func_name:
+        functions.append((current_func_name, current_func_idx, current_func_body))
+
+    # === Build SymbolTable with all symbols ===
+    symtab = SymbolTable()
+    for sym in symbols_list:
+        symtab.get_or_add(sym)
+
+    # === Pass 2: assemble bytecode ===
+    init_code = bytearray()
+    function_bytes: List[bytes] = []
+    function_names: List[str] = []
+
+    for fname, _fidx, body_lines in functions:
+        if fname == "__init__":
+            for line in body_lines:
+                bc = _asm_instr(line, symtab, symbols_list)
+                if bc:
+                    init_code.extend(bc)
+            continue
+
+        fb = bytearray()
+        for line in body_lines:
+            bc = _asm_instr(line, symtab, symbols_list)
+            if bc:
+                fb.extend(bc)
+        function_bytes.append(bytes(fb))
+        function_names.append(fname)
+
+    # === Build function catalog and write FAS ===
+    func_offsets: Dict[str, int] = {}
+    all_bc = bytearray(init_code)
+
+    for fname, fbytes in zip(function_names, function_bytes):
+        offset = len(all_bc)
+        func_offsets[fname] = offset
+        all_bc.extend(fbytes)
+
+    for name in function_names:
+        symtab.add_func_ref(name, func_offsets[name])
+
+    seg0 = bytes(all_bc)
+    resource = ResourceBuilder(symtab)
+    seg1 = resource.build(func_offsets)
+    writer = FasWriter(symtab)
+    writer.write(output_path, seg0, seg1)
+    return output_path
+
+
+_INSTR_RE = re.compile(r"(\w+)(.*)")
+_ADDR_PREFIX = re.compile(r"^0x[0-9a-fA-F]+:")
+
+
+def _asm_instr(line: str, symtab: SymbolTable, symbols: List[str]) -> Optional[bytes]:
+    """Parse one assembly instruction line and encode to bytes."""
+    content = _ADDR_PREFIX.sub("", line).strip()
+    if not content:
+        return None
+
+    m = _INSTR_RE.match(content)
+    if not m:
+        return None
+
+    mnemonic = m.group(1).upper()
+    rest = m.group(2).strip()
+    operands = _parse_ops(rest, symtab)
+
+    if mnemonic == "GET_LOCAL_WIDE":
+        # Use wide GET_LOCAL opcode (0x5c) instead of standard (0x05)
+        from compiler.opcodes import encode_op_u16
+
+        op = NAME_TO_OPCODE.get("GET_LOCAL", 0xFF)
+        # Force opcode 0x5c
+        return encode_op_u16(0x5C, int(operands[0]) if operands else 0)
+
+    return encode_instruction(mnemonic, operands)
+
+
+def _parse_ops(text: str, symtab: SymbolTable) -> List:
+    """Parse comma-separated operands, resolving symbol names to indices."""
+    if not text.strip():
+        return []
+
+    parts = [p.strip() for p in text.split(",")]
+    result: List[Any] = []
+    for p in parts:
+        if not p:
+            continue
+        if p in symtab.name_to_idx:
+            result.append(symtab.name_to_idx[p])
+        elif p.startswith("[") and p.endswith("]") and p[1:-1].isdigit():
+            result.append(int(p[1:-1]))
+        else:
+            try:
+                result.append(int(p))
+            except ValueError:
+                try:
+                    result.append(float(p))
+                except ValueError:
+                    raise ValueError(f"Cannot resolve operand: {p!r}")
+    return result

compiler/ast.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass, field
+from typing import List, Any, Optional
+
+
+@dataclass
+class Node:
+    pass
+
+
+@dataclass
+class Program(Node):
+    forms: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class Symbol(Node):
+    name: str = ''
+
+
+@dataclass
+class Integer(Node):
+    value: int = 0
+
+
+@dataclass
+class Real(Node):
+    value: float = 0.0
+
+
+@dataclass
+class String(Node):
+    value: str = ''
+
+
+@dataclass
+class ListExpr(Node):
+    items: List['Node'] = field(default_factory=list)
+    dotted: Optional['Node'] = None
+
+
+@dataclass
+class QuotedExpr(Node):
+    expr: Optional['Node'] = None
+
+
+@dataclass
+class Defun(Node):
+    name: str = ''
+    args: List[str] = field(default_factory=list)
+    optional: List[str] = field(default_factory=list)
+    rest: Optional[str] = None
+    locals: List[str] = field(default_factory=list)
+    body: List['Node'] = field(default_factory=list)
+    is_command: bool = False
+    quoted: bool = False
+
+
+@dataclass
+class Setq(Node):
+    pairs: List[tuple] = field(default_factory=list)
+
+
+@dataclass
+class IfNode(Node):
+    cond: Optional['Node'] = None
+    then: Optional['Node'] = None
+    else_expr: Optional['Node'] = None
+
+
+@dataclass
+class WhileNode(Node):
+    cond: Optional['Node'] = None
+    body: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class ForeachNode(Node):
+    var: Optional['Node'] = None
+    list_expr: Optional['Node'] = None
+    body: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class Call(Node):
+    name: str = ''
+    args: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class Progn(Node):
+    forms: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class LambdaNode(Node):
+    args: List[str] = field(default_factory=list)
+    body: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class RepeatNode(Node):
+    count: Optional['Node'] = None
+    body: List['Node'] = field(default_factory=list)
+
+
+@dataclass
+class Cond(Node):
+    clauses: List[tuple] = field(default_factory=list)
+
+
+@dataclass
+class Defpackage(Node):
+    name: str = ''
+    use: List[str] = field(default_factory=list)
+    export: List[str] = field(default_factory=list)
+
+
+@dataclass
+class InPackage(Node):
+    name: str = ''