リポジトリ / emssr / independent_common_compiler

# -*- coding: utf-8 -*-

"""セル一つを compile して実行し、scope を組む。

doc: commonc.pipeline casm.lane64.host plain.format

道は一本になる（19 §7.1）。

    .dic + .cmn ──(commonc_lane64.bin on lane64)──▶ lane64 image ──(lane64)──▶ M

compile の受け渡しは toolchain.compile と同じだが、入口が path ではなく文字列で、

commonc の作業領域を捨てずに返す。scope はその作業領域から組む。

CPython でも Pyodide でも同じ code が動く。違うのは commonc の image の場所だけで、

それは start() の引数で決まる。

"""

import hashlib

import os

import sys

import tempfile

import scope

_HERE = os.path.dirname(os.path.abspath(__file__))

if _HERE not in sys.path:

    sys.path.insert(0, _HERE)

import lex          # noqa: E402  Python_vCPU から借りる

import toolchain    # noqa: E402

import vcpu         # noqa: E402

WORK = toolchain.WORK               # 本文の作業領域の基底。ワイヤ（語 64+w）の上

DEFAULT_WORDS = WORK + (1 << 13)

DEFAULT_BUDGET = 1 << 24            # block を辿る上限。止まらないセルをここで止める

class CellError(Exception):

    pass

def start(commonc):

    """commonc の image の場所を決める。翻訳は最初の compile のときに一度だけ行う"""

    toolchain.COMMONC = commonc

# ===== compile =====

#

# host が commonc へ渡すもの（19 §3.1）。toolchain.compile と同じ値を置く。

#

#   語 0    N      入力の byte 数（表 + 本文）

#   語 1    IB     入力の基底語番号

#   語 4    B      配列の刻み

#   語 130  LEXB   表の byte 数

# 読み取り専用の場所へ入れても動くように、表は一時フォルダへ書く

_DIC = os.path.join(tempfile.gettempdir(), "common_scope_cell.dic")

def _dic_file(text):

    """採用語彙の表を lex へ渡すために一度だけ file にする"""

    open(_DIC, "w", encoding="utf-8", newline="\n").write(text)

    return _DIC

def compile_text(source, dic=None):

    """平文を image にする。返りは (image, n_need, commonc の作業領域)"""

    table, est, fold = "", len(source) // 2, {}

    if dic and dic.strip():

        path = _dic_file(dic)

        table = lex.lexicon(path)

        est = lex.expanded_syllables(path, source)

        fold = scope.lexicon(lex.entries(path))

    # commonc を正本にする。scope.check は表示用の補助表から行う診断なので、

    # Common 本体より先に文を棄却してはいけない。語彙が増えたときに補助表だけが

    # 古いと、正規の commonc では通る文を notebook だけが拒否してしまうためになる。

    data = (table + source).encode("utf-8")

    n = len(data)

    b = max(n + 80, 4096, 2 * est + 80)

    base = toolchain.IN_MUL * b

    lane = vcpu.Lane(base + n + 4096)

    lane.put_input(list(data), base)

    lane.M[toolchain.W_B] = b

    lane.M[toolchain.W_LEXB] = len(table.encode("utf-8"))

    rep = vcpu.run_lane(toolchain._commonc(), lane)

    if rep != 0:

        # commonc が実際に拒否したときだけ、平文側の診断で理由を細かくする。

        # 診断表が Common の全語彙を知らなくても、成功した文を壊すことはない。

        hit = scope.check(source, fold)

        if hit:

            raise CellError(hit)

        raise CellError("commonc がこの文を読めない（報告 %s）。"

                        "音節表の外の綴りか、机の上が合っていない" % rep)

    imgb, nimg, need = lane.M[1], lane.M[2], lane.M[3]

    if not (imgb and nimg):

        raise CellError("commonc が image を出さない")

    if need > WORK:

        raise CellError("箱が多すぎてワイヤが作業領域に重なる（n_need %d > %d）" % (need, WORK))

    return bytes(v & 255 for v in lane.M[imgb:imgb + nimg]), need, lane.M

# ===== 実行する =====

#

# ワイヤの語を落とす覆い（toolchain.load の wires）は使わない。scope は

# 箱ひとつずつの値を見せるので、語 64+w を全部残す。

def run_image(image, seeds=None, words=DEFAULT_WORDS, budget=DEFAULT_BUDGET):

    tab = vcpu.translate(vcpu.decode(image))[1]

    lane = vcpu.Lane(words)

    for k, v in (seeds or {}).items():

        lane.M[int(k)] = int(v)

    try:

        rep = vcpu.run_lane(tab, lane, budget=budget)

    except RuntimeError:

        raise CellError("block を %d 回辿っても終わりません。Ω の「もう良いか」を見直す" % budget)

    except IndexError:

        raise CellError("語番号が作業領域を越えた（語数 %d）。セルの words を増やす" % words)

    return rep, lane

def cell(source, dic=None, seeds=None, words=DEFAULT_WORDS, budget=DEFAULT_BUDGET):

    """セル一つ。compile して実行し、scope を返す"""

    image, need, cm = compile_text(source, dic)

    rep, lane = run_image(image, seeds, words, budget)

    table = scope.lexicon(lex.entries(_DIC)) if (dic and dic.strip()) else {}

    a = scope.arrays(cm)

    ws = scope.words(a, table)

    bx = scope.boxes(a, lane.M)

    gm = scope.gamma(a)

    depth = {g["word"]: a["opd"][g["box"]] for g in gm}

    return {

        "ok": True,

        "report": rep,

        "source": source,

        "size": {"syl": a["nSyl"] - a["body"], "box": a["nBox"],

                 "need": need, "image": len(image)},

        # 二つの平文が同じチェンバーかを見る hash。image が一致すれば読みも一致する

        "mark": hashlib.sha256(image).hexdigest()[:16],

        "words": ws,

        "frontier": scope.frontier(ws),

        "boxes": bx,

        "align": scope.align(ws, a),

        "gamma": [dict(g, **scope.dyad(lane.M[g["word"]], depth[g["word"]]))

                  for g in gm],

        "image": scope.image(vcpu, image),

        "out": [lane.M[k] for k in range(64)],

        "put": bytes(lane.OUT).decode("latin-1"),

    }

# ===== 接合秩（Common-Lang/1 定理 4.1）=====

#

#   F[α][β] = f(α, β),   ρ = rank_F2 F,   f = ⊕_{r<ρ} p_r(x_A) q_r(x_B)

#

# 階数は common_apps/joinrank の平文が持つ。ここは頂点値の表を作って渡すだけになる。

# 表は同じ image を 2^n 回実行して集める。lane の作業領域は交わらない（20 式 1.2）ので、

# 実行は互いに独立になる。

def vertices(image, inputs, words=DEFAULT_WORDS, budget=DEFAULT_BUDGET, out=0):

    """入力の語へ {0,1}^n を全部当て、語 out の値を頂点値として並べる"""

    n = len(inputs)

    if n > 12:

        raise CellError("入口が %d 本。頂点は 2^n なので 12 本までにする" % n)

    tab = vcpu.translate(vcpu.decode(image))[1]

    tbl = []

    for v in range(1 << n):

        lane = vcpu.Lane(words)

        for k, w in enumerate(inputs):

            lane.M[int(w)] = (v >> k) & 1

        vcpu.run_lane(tab, lane, budget=budget)

        tbl.append(1 if lane.M[out] else 0)

    return tbl