# -*- coding: utf-8 -*-
"""PDF「ソースコード地図」（docs/code-map.md から作る PDF）の自己点検。
原稿の文字がすべて PDF に出ているか、フォントが日本語フォントだけか、
しおりと章内リンクが揃っているかを見る。
PDF のパスは第1引数で渡せる。省略時はこのスクリプトと同じディレクトリの
DWatch_ソースコード地図_20261005.pdf。原稿は第2引数で渡せる。省略時は
docs/code-map.md。終了コードは OK なら 0、NG なら 1。
土台は check_teamworks_qa11_pdf.py（写して改造した）。
★このスクリプトは生成スクリプト（make_code_map_pdf.py）を import しない★
見るのは「PDF から読んだもの（テキスト・フォント・しおり・リンク注釈）」と
「原稿の .md」だけ。原稿の読み方（記法の外し方）もこのファイルの中で独自に書いてある。
生成側の実装が変わっても、この点検の結果は変わらない。
★期待する数は原稿から数える★（見出し・コードブロック・Mermaid・しおり・章内リンク）。
スクリプトに数字を直書きしないので、原稿が変わってもこのまま使える。
（2026-10-05 の原稿では 見出し 1+23+137+71=232 / コードブロック 37（うち Mermaid 9）/
しおり 23+137=160 / 章内リンク 56）
点検の項目
0. ページ数とサイズ（参考）
1. ★フォント★ — 埋め込まれているフォントが BIZ UDGothic と Segoe UI Symbol だけであること。
Segoe UI Symbol は「BIZ UDGothic に字の無い記号（✅ ❌ ⚠ 📋 ≥ ‹ › ✗ など）」だけを描く
補助フォント（2026-10-05 決定。置き換え ✅→✓ 等はやめ、原文の文字のまま出す）。
中国語向けフォント（SimSun / Microsoft YaHei / Noto Sans SC / STSong / SimHei 等）が
1つでも混ざっていたら NG（CLAUDE.md §0-3）。
ページのリソースを辿ってフォントを集め、本文で実際に文字を描いているフォントも見る。
★日本語の文字（CJK 統合漢字・ひらがな・カタカナ）を描いているフォントが BIZ UDGothic だけ
であること★も見る。ページの描画命令から「どのフォントでどの文字を描いたか」を取って確かめ、
あわせて補助フォントの埋め込みサブセット（ToUnicode）に日本語の文字が無いことも確かめる。
（Segoe UI Symbol には漢字の字形が無いので、reportlab が漢字を Segoe UI Symbol で組むと
.notdef（抽出テキストの \\x00）になる。その形は 7. の豆腐の検査で NG になる。
SimSun のように漢字を持つフォントで描いた場合は、この 1. で NG になる。どちらも試験済み）
2. ★見出し★ — 原稿の # 〜 ###### の見出しの文字が、PDF のテキストに原稿の順で全部あること
3. ★本文★ — 原稿の段落・表のセル・箇条書き・引用の文字が、PDF のテキストに原稿の順であること。
見つからない行は原稿の行番号つきで出す（表は、どのセルが無いかも出す）
4. ★コードブロック★ — 中身（Mermaid も記法のまま）が PDF のテキストに入っていること
5. ★しおり★ — PDF のアウトラインの数が、原稿の ## と ### の数と一致すること
（題名の食い違い・階層の食い違いは ★注意★ として出す。宛先のページが無いものは NG）
6. ★章内リンク★ — 文書内へ飛ぶリンク注釈（GoTo / 名前付き宛先）が原稿の [..](#..) の数以上あり、
宛先がすべて実在すること。あわせて、原稿の #.. が原稿の見出しに実在するか（GitHub の
アンカーの付け方で）も見る（原稿側で切れているリンクは PDF でも飛べない）
7. 豆腐（グリフ欠け）と、字の無い文字 — 土台から引き継ぎ、次を足した:
- 描いた文字ごとに、描いたフォント（BIZ UDGothic R / B か Segoe UI Symbol）に字があること
- 抽出テキストの \\x00（.notdef ＝ 豆腐として描かれた字）があれば NG
- 原稿にあって BIZ UDGothic に字の無い文字（2026-10-05 の原稿で19種）が、PDF のテキストに
原文の文字のまま、原稿と同じ数以上出ていること。どのフォントで描いたかも出す
8. 空白ページ — 土台から引き継いだ
★字の無い文字の照合★
置き換えはしない約束なので、字の無い文字も含めて原文どおりに照合する（行頭・行末も外さない）。
絵文字の異体字セレクタ（U+FE0F。目に見えない）だけは、比べる前に両方から取り除く
（生成側が取り除くため）。
★照合の前の正規化★
原稿側: ★ を消す / ** と ~~ を消す / ` を消す / リンク [文字](…) は 文字 だけにする /
<br> 類を消す / HTML の実体参照を戻す / 表のセルの \\| は | に戻す /
行頭の箇条書きの印（- * 1.）と引用の > を外す。
★コードスパン（`…`）の中の ** / ~~ / <br> は記法ではなく文字なので外さない★
（`app/api/**/route.ts` の ** は PDF にもそのまま出る）
両方: 空白・改行をすべて取り除く（全角空白・NBSP・ゼロ幅を含む）。PDF は行の折り返しで
改行や空白が入るため。
★ も両方から落とす（「★印は事故が起きやすい変更」のように ★ そのものを指す文では
生成側が ★ を残すため）
コードブロックは記法を外さず、そのまま照合する。ただし Mermaid のラベルの <br/> は
生成側が外すこともありうるので、外した形でも見つかれば可とする（どの形で見つかったかは出す）。
ページを跨ぐ文はフッター（D-Watch / DFA Robotics とページ番号）で分断されるので、
各ページからフッターを落としてから繋いだテキストで照合する。
★この点検があっても、全ページの目視確認は省かないこと★（pdf/README.md）。
枠のはみ出し・改ページ位置・識別子の語中改行は文字の有無では見られない。
必要なもの: pypdf。reportlab は 7.（豆腐の検査）にだけ使い、
無ければその項目を飛ばす（他の検査は走る）。
"""
import html
import os
import re
import sys
import unicodedata
try:
sys.stdout.reconfigure(errors="backslashreplace") # cp932 で落ちないように
except Exception:
pass
try:
from pypdf import PdfReader
from pypdf.generic import ArrayObject, DictionaryObject, IndirectObject
except ImportError:
print("★NG★ pypdf が入っていない。`pip install pypdf` が必要。")
sys.exit(1)
HERE = os.path.dirname(os.path.abspath(__file__))
REPO = os.path.normpath(os.path.join(HERE, "..", "..", ".."))
PDF = (sys.argv[1] if len(sys.argv) > 1 else
os.path.join(HERE, "DWatch_ソースコード地図_20261005.pdf"))
SRC = (sys.argv[2] if len(sys.argv) > 2 else
os.path.join(REPO, "docs", "code-map.md"))
if not os.path.exists(PDF):
print("★NG★ PDF が見つからない: %s" % PDF)
print("先に make_code_map_pdf.py を実行するか、PDF のパスを第1引数で渡すこと。")
sys.exit(1)
if not os.path.exists(SRC):
print("★NG★ 原稿が見つからない: %s" % SRC)
sys.exit(1)
# 一覧の出しすぎで肝心の結果が流れないように、各項目の詳細は最大この件数まで出す
MAX_LIST = 300
raw = open(PDF, "rb").read()
reader = PdfReader(PDF)
pages = [p.extract_text() or "" for p in reader.pages]
text = "\n".join(pages)
md_lines = open(SRC, encoding="utf-8").read().splitlines()
ng = []
def sq(s):
"""空白（全角・NBSP・ゼロ幅を含む）、絵文字の異体字セレクタ・ZWJ、★ を落とす。
★ は原稿・PDF の両方から落とす。原稿の ★ は強調の印として外すのが原則だが、
「★印は事故が起きやすい変更」のように★そのものを指す文では、生成側が ★ を残す。
どちらでも照合が通るように、PDF 側からも落としてから比べる。
"""
for c in (0xFE0E, 0xFE0F, 0x200D):
s = s.replace(chr(c), "")
s = s.replace("★", "")
return re.sub(r"[\s\u00a0\u3000\u200b\ufeff]+", "", s)
# ---------------------------------------------------------------- 字の無い文字
# 原稿には BIZ UDGothic に字（グリフ）の無い文字がある（✅ ❌ ⚠ 📋 ≥ ‹ › ✗ など。
# 2026-10-05 の原稿で19種）。生成側はこれらだけを補助フォント Segoe UI Symbol で描く
# （置き換えはしない）。点検では、
# - 照合は原文どおり（置き換えを許さない）
# - 描いた文字ごとに、描いたフォントに字があることを見る（7.）
# - 字の無い文字が PDF のテキストに原文のまま出ていることを見る（7.）
BIZ_R = "C:/Windows/Fonts/BIZ-UDGothicR.ttc"
BIZ_B = "C:/Windows/Fonts/BIZ-UDGothicB.ttc"
SYM = "C:/Windows/Fonts/seguisym.ttf"
GLYPH_FONTS = [] # (名前, charToGlyph) — BIZ UDGothic の R と B
SYM_C2G = None # Segoe UI Symbol の charToGlyph
GLYPH_ERR = None
try:
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
for fname, fpath in (("JP", BIZ_R), ("JP-B", BIZ_B)):
pdfmetrics.registerFont(TTFont(fname, fpath, subfontIndex=0))
GLYPH_FONTS.append((fname, pdfmetrics.getFont(fname).face.charToGlyph))
pdfmetrics.registerFont(TTFont("SYM", SYM))
SYM_C2G = pdfmetrics.getFont("SYM").face.charToGlyph
except Exception as e: # reportlab かフォントが無い
GLYPH_ERR = e
GLYPHLESS = set()
if GLYPH_FONTS:
GLYPHLESS = set(ch for ch in set("".join(md_lines))
if sq(ch) and any(ord(ch) not in c2g for _, c2g in GLYPH_FONTS))
def locate(s, hay, pos=0):
"""s を（空白を詰めて）hay の pos 以降で探す。見つかれば (開始, 終了) を返す。"""
t = sq(s)
if not t:
return None
k = hay.find(t, pos)
return None if k < 0 else (k, k + len(t))
def strip_footer(p, num):
"""ページのフッター（D-Watch / DFA Robotics とそのページの番号）を落とす。
ページ番号はそのページの番号に限って落とす（本文の数字を食わないように）。
"""
return re.sub(r"D-Watch\s*/\s*DFA\s*Robotics\s*%d(?!\d)" % num, "", p, count=1)
flat = sq(text)
flat_nofoot = sq("".join(strip_footer(p, i) for i, p in enumerate(pages, 1)))
def has(s):
return bool(locate(s, flat_nofoot) or locate(s, flat))
RE_LINK = re.compile(r"\[([^\]]*)\]\(([^)]*)\)")
RE_BR = re.compile(r"<br\s*/?>", re.I)
def md_plain(s):
"""原稿の行内記法を外す（リンク → 文字 / ★ / ** / ~~ / ` / <br> / 実体参照）。
★コードスパン（`…`）の中は文字どおり★に扱い、** や ~~ を外さない。
`app/api/**/route.ts` の ** は記法ではなく文字で、PDF にもそのまま出るため
（2026-10-05、生成した PDF で実際にこれを誤検出した）。
バッククォートの数が奇数の行は、コードスパンが閉じていないとみなして全体を外側として扱う。
"""
segs = s.split("`")
if len(segs) % 2 == 0:
segs = ["".join(segs)]
out = []
for j, seg in enumerate(segs):
if j % 2 == 1: # コードスパンの中
out.append(seg.replace("★", ""))
continue
seg = RE_LINK.sub(lambda m: m.group(1), seg)
seg = seg.replace("★", "").replace("**", "").replace("~~", "")
seg = RE_BR.sub("", seg)
out.append(html.unescape(seg))
return "".join(out)
def split_row(line):
"""表の行をセルに分ける。\\| はセルの区切りではなく文字の | として扱う。"""
s = line.strip()
if s.startswith("|"):
s = s[1:]
if s.endswith("|") and not s.endswith("\\|"):
s = s[:-1]
cells = re.split(r"(?<!\\)\|", s)
return [c.strip().replace("\\|", "|") for c in cells]
def find_in_order(items, hay, key=lambda x: x[-1]):
"""items を hay の中で順に探す。
見つかったものは位置を進める。見つからなかったものは位置を進めずに記録する
（1件の欠落で後続が全部 NG にならないように）。
"""
pos = 0
missing = []
found = 0
for it in items:
if not sq(key(it)):
continue
loc = locate(key(it), hay, pos)
if loc is None:
missing.append(it)
else:
found += 1
pos = loc[1]
return found, missing
def gh_slug(s):
"""GitHub の見出しアンカーの付け方（小文字化・記号を落とす・空白を - に）。"""
s = md_plain(s).strip().lower()
out = []
for ch in s:
cat = unicodedata.category(ch)
if ch in " -" or cat[0] in "LMN" or cat == "Pc":
out.append(ch)
return "".join(out).replace(" ", "-")
# ---------------------------------------------------------------- 原稿を読む
RE_SEP = re.compile(r"^\|?(\s*:?-{3,}:?\s*\|)+\s*(:?-{3,}:?\s*)?$")
headings = [] # (行番号, レベル, 原文, 記法を外した文字列)
codes = [] # {"ln": 開始行, "lang": 言語, "lines": [(行番号, 原文), …]}
body = [] # (行番号, 種類, [セル…] または None, 記法を外した文字列)
md_links = [] # (行番号, リンクの文字, アンカー)
in_code = False
cur_code = None
for i, line in enumerate(md_lines, 1):
if line.startswith("```"):
if not in_code:
cur_code = {"ln": i, "lang": line[3:].strip().lower(), "lines": []}
codes.append(cur_code)
in_code = not in_code
continue
if in_code:
cur_code["lines"].append((i, line))
continue
for m in RE_LINK.finditer(line):
if m.group(2).startswith("#"):
md_links.append((i, m.group(1), m.group(2)[1:]))
s = line.strip()
if not s or re.match(r"^(-{3,}|\*{3,}|_{3,})$", s):
continue
m = re.match(r"^(#{1,6})\s+(.*?)\s*#*\s*$", s)
if m:
headings.append((i, len(m.group(1)), m.group(2), md_plain(m.group(2))))
continue
if s.startswith("|"):
if RE_SEP.match(s):
continue
cells = [md_plain(c) for c in split_row(s)]
body.append((i, "表", cells, "".join(cells)))
continue
kind = "段落"
if s.startswith(">"):
kind = "引用"
s = re.sub(r"^(>\s?)+", "", s)
if re.match(r"^([-*+]|\d+[.)])\s+", s):
kind = "箇条書き" if kind == "段落" else kind
s = re.sub(r"^([-*+]|\d+[.)])\s+", "", s) # PDF では「・」や番号に置き換わりうる
if s.startswith("|"): # 引用の中の表
if RE_SEP.match(s):
continue
cells = [md_plain(c) for c in split_row(s)]
body.append((i, "表", cells, "".join(cells)))
continue
body.append((i, kind, None, md_plain(s)))
if in_code:
print("★注意★ 原稿のコードブロックが閉じていない（%d行から）" % cur_code["ln"])
lv_count = {lv: sum(1 for h in headings if h[1] == lv) for lv in range(1, 7)}
mermaids = [c for c in codes if c["lang"] == "mermaid"]
print("原稿:", SRC)
print("PDF :", PDF)
print(" %d 行 / 見出し %d（%s）/ コードブロック %d（うち Mermaid %d）/ "
"本文の行 %d / 章内リンク %d"
% (len(md_lines), len(headings),
" + ".join("%s:%d" % ("#" * lv, n) for lv, n in lv_count.items() if n),
len(codes), len(mermaids), len(body), len(md_links)))
# ---------------------------------------------------------------- 0.
print("\n== 0. ページ数とサイズ（参考） ==")
print("ページ数:", len(reader.pages), " サイズ:", len(raw), "bytes",
"(%.1f KB)" % (len(raw) / 1024))
print("抽出文字数:", len(text), " 空白を詰めた文字数:", len(flat))
if len(flat) < 2000:
print(" ★NG★ 抽出できた文字が少なすぎる。テキストが図形化されている疑い")
ng.append("抽出文字数が少なすぎる")
# ---------------------------------------------------------------- 1.
print("\n== 1. フォント（★最重要★） ==")
CN = ["SimSun", "NSimSun", "SimHei", "MicrosoftYaHei", "YaHei", "NotoSansSC",
"NotoSerifSC", "NotoSansCJKsc", "NotoSerifCJKsc", "NotoSansHans",
"SourceHanSansSC", "SourceHanSansCN", "SourceHanSerifSC", "SourceHanSerifCN",
"FangSong", "KaiTi", "STSong", "STHeiti", "STKaiti", "STFangsong",
"STXihei", "PingFang", "DengXian", "MingLiU", "PMingLiU", "DFKai",
"YouYuan", "LiSu", "HiraginoSansGB", "WenQuanYi"]
def font_info(fobj):
"""フォント辞書から (BaseFont 名, 埋め込みの有無) を返す。Type0 は子孫フォントを見る。"""
f = fobj.get_object()
name = str(f.get("/BaseFont", "?")).lstrip("/")
descs = []
if f.get("/Subtype") == "/Type0":
for d in f.get("/DescendantFonts", []):
descs.append(d.get_object())
else:
descs.append(f)
embedded = False
for d in descs:
fd = d.get("/FontDescriptor")
if fd is not None:
fd = fd.get_object()
if any(k in fd for k in ("/FontFile", "/FontFile2", "/FontFile3")):
embedded = True
return name, embedded
RE_SHOW = re.compile(rb"(\((?:[^)\\]|\\.)+\)|<[0-9A-Fa-f\s]+>)\s*(Tj|'|\")"
rb"|\[[^\]]*[(<][^\]]*\]\s*TJ", re.S)
fonts = {} # BaseFont 名 → 埋め込みの有無
used = set() # 本文で Tf で選ばれているフォントの BaseFont 名
def walk_resources(res, content_data, seen):
"""リソース辞書のフォントを集め、content_data の Tf で選ばれたものを used に入れる。
Form XObject の中も辿る。
"""
if res is None:
return
res = res.get_object()
fmap = {}
fd = res.get("/Font")
if fd is not None:
for rname, fobj in fd.get_object().items():
name, emb = font_info(fobj)
fonts[name] = fonts.get(name, False) or emb
fmap[str(rname)] = name
# Tf で選んでから次の Tf までの間に、文字を描く命令（空でない Tj / TJ / ' / "）が
# あるものだけを「使っている」とみなす。reportlab はページの頭で Helvetica を選ぶだけの
# 「BT /F1 12 Tf 14.4 TL ET」を必ず書くが、これは文字を描かないので数えない。
data = content_data or b""
marks = list(re.finditer(rb"(/[^\s/\[\]<>(){}%]+)\s+[-\d.]+\s+Tf", data))
for j, m in enumerate(marks):
seg = data[m.end():marks[j + 1].start() if j + 1 < len(marks) else len(data)]
if RE_SHOW.search(seg):
rn = m.group(1).decode("latin-1")
if rn in fmap:
used.add(fmap[rn])
xo = res.get("/XObject")
if xo is not None:
for _, x in xo.get_object().items():
ref = x.idnum if isinstance(x, IndirectObject) else id(x)
if ref in seen:
continue
seen.add(ref)
x = x.get_object()
if x.get("/Subtype") == "/Form":
try:
data = x.get_data()
except Exception:
data = b""
walk_resources(x.get("/Resources"), data, seen)
for p in reader.pages:
try:
c = p.get_contents()
data = c.get_data() if c is not None else b""
except Exception:
data = b""
walk_resources(p.get("/Resources"), data, set())
embedded = sorted(n for n, e in fonts.items() if e)
not_embedded = sorted(n for n, e in fonts.items() if not e)
def is_biz(name):
return "BIZ" in name
def is_sym(name):
return "SEGOEUISYMBOL" in re.sub(r"[-_ ]|#20", "", name).upper()
def allowed(name):
return is_biz(name) or is_sym(name)
print("/FontFile2 出現回数（生の PDF）:", raw.count(b"/FontFile2"))
print("埋め込みフォント:", embedded or "なし")
print("非埋め込みのフォント:", not_embedded or "なし",
"（reportlab は使わない Helvetica を1つ書き出す。本文で使っていなければ可）")
print("本文で使っているフォント:", sorted(used) or "（Tf を見つけられなかった）")
print("許可するフォント: BIZ UDGothic（本文）/ Segoe UI Symbol（BIZ UDGothic に字の無い記号だけ）")
if not [f for f in embedded if is_biz(f)]:
print(" ★NG★ BIZ UDGothic が埋め込まれていない")
ng.append("BIZ UDGothic が埋め込まれていない")
bad_emb = [f for f in embedded if not allowed(f)]
if bad_emb:
print(" ★NG★ BIZ UDGothic・Segoe UI Symbol 以外のフォントが埋め込まれている:", bad_emb)
ng.append("許可していない埋め込みフォント %s" % bad_emb)
bad_used = sorted(f for f in used if not allowed(f))
if bad_used:
print(" ★NG★ 本文で BIZ UDGothic・Segoe UI Symbol 以外のフォントを使っている:", bad_used)
ng.append("本文で許可していないフォント %s" % bad_used)
# 生の PDF の /BaseFont・/FontName・/FontFamily も見る（リソースを辿れなかった
# フォントの取りこぼしの保険）。生のバイト列全体を探すと、埋め込んだフォントの中身に
# 偶然含まれる文字列（"LiSu" など）で誤検出するので、名前の位置に限る。
# 名前の中の空白は PDF では #20 になるので、#20 を詰めて比べる。
raw_names = set(m.decode("latin-1").replace("#20", "") for m in re.findall(
rb"/(?:BaseFont|FontName|FontFamily)\s*[/(]([^\s/\[\]<>()]+)", raw))
all_names = raw_names | set(fonts)
cn_hit = sorted(set(n for n in CN for f in all_names if n.lower() in f.lower()))
print("中国語向けフォント:", cn_hit if cn_hit else "混入なし")
if cn_hit:
print(" ★NG★ 中国語向けフォントが混ざっている（CLAUDE.md §0-3）")
ng.append("中国語向けフォント %s" % cn_hit)
print("BIZ UDGothic のうち Bold:", [f for f in embedded if is_biz(f) and "Bold" in f] or "なし",
" Regular:", [f for f in embedded if is_biz(f) and "Bold" not in f] or "なし")
print("Segoe UI Symbol:", [f for f in embedded if is_sym(f)] or "なし")
# ---- 1-b. 日本語の文字を描いているフォントが BIZ UDGothic だけであること
def is_ja(ch):
"""CJK 統合漢字（拡張A・互換漢字・拡張B 以降を含む）・ひらがな・カタカナ。"""
o = ord(ch)
return (0x4E00 <= o <= 0x9FFF or 0x3400 <= o <= 0x4DBF or 0xF900 <= o <= 0xFAFF
or 0x20000 <= o <= 0x3FFFF or 0x3040 <= o <= 0x30FF or 0x31F0 <= o <= 0x31FF
or 0xFF66 <= o <= 0xFF9F)
drawn = {} # BaseFont 名 → {描いた文字: 回数}（ページの描画命令から）
def _visit(txt, cm, tm, font_dict, font_size):
if not txt or font_dict is None:
return
try:
name = str(font_dict.get("/BaseFont", "?")).lstrip("/")
except Exception:
name = "?"
d = drawn.setdefault(name, {})
for ch in txt:
if ch not in "\n\r\t ":
d[ch] = d.get(ch, 0) + 1
visit_err = None
for p in reader.pages:
try:
p.extract_text(visitor_text=_visit)
except Exception as e:
visit_err = e
if visit_err is not None:
print(" ★注意★ 描画命令の読み取りで例外:", visit_err)
print("描画命令から見た、フォントごとの描いた文字種:",
", ".join("%s %d種" % (n, len(d)) for n, d in sorted(drawn.items())) or "（取れなかった）")
if not drawn:
print(" ★NG★ 描画命令からフォントと文字の対応を取れなかった（1-b を確かめられない）")
ng.append("描画命令からフォントと文字の対応を取れない")
ja_by_other = {}
for n, d in drawn.items():
if is_biz(n):
continue
js = sorted(c for c in d if is_ja(c))
if js:
ja_by_other[n] = js
if ja_by_other:
for n, js in ja_by_other.items():
print(" ★NG★ %s が日本語の文字を描いている（%d種）: %s" % (n, len(js), "".join(js[:40])))
ng.append("BIZ UDGothic 以外のフォントが日本語の文字を描いている %s" % sorted(ja_by_other))
else:
print("日本語の文字（漢字・かな）を描いているフォント:",
sorted(n for n, d in drawn.items() if any(is_ja(c) for c in d)) or "なし",
"→ BIZ UDGothic だけ")
# 補助フォントの埋め込みサブセットの ToUnicode に、日本語の文字が無いこと（保険）
RE_HEX = re.compile(rb"<([0-9A-Fa-f]+)>")
def tounicode_chars(fobj):
"""フォントの ToUnicode CMap が対応づけている Unicode の文字の集合。"""
f = fobj.get_object()
tu = f.get("/ToUnicode")
if tu is None:
return set()
data = tu.get_object().get_data()
out = set()
def u(hexs):
try:
return bytes.fromhex(hexs.decode()).decode("utf-16-be", errors="ignore")
except Exception:
return ""
for blk in re.findall(rb"beginbfchar(.*?)endbfchar", data, re.S):
hx = RE_HEX.findall(blk)
for j in range(1, len(hx), 2):
out.update(u(hx[j]))
for blk in re.findall(rb"beginbfrange(.*?)endbfrange", data, re.S):
for line in blk.splitlines():
hx = RE_HEX.findall(line)
if len(hx) >= 3 and b"[" not in line:
lo, hi, dst = int(hx[0], 16), int(hx[1], 16), u(hx[2])
if dst and hi - lo < 0x10000:
base = ord(dst[-1])
for k in range(hi - lo + 1):
out.add(chr(base + k))
elif b"[" in line:
for h in RE_HEX.findall(line[line.index(b"["):]):
out.update(u(h))
return out
sym_subset = {}
seen_fonts = set()
for p in reader.pages:
res = p.get("/Resources")
fd = res.get_object().get("/Font") if res is not None else None
if fd is None:
continue
for _, fobj in fd.get_object().items():
ref = fobj.idnum if isinstance(fobj, IndirectObject) else id(fobj)
if ref in seen_fonts:
continue
seen_fonts.add(ref)
name, _ = font_info(fobj)
if not is_biz(name):
sym_subset.setdefault(name, set()).update(tounicode_chars(fobj))
for n, cs in sorted(sym_subset.items()):
js = sorted(c for c in cs if is_ja(c))
print("BIZ 以外のフォント %s のサブセット: %d 字 / うち日本語の文字 %d"
% (n, len(cs), len(js)))
if js:
print(" ★NG★ サブセットに日本語の文字がある:", "".join(js[:40]))
ng.append("%s のサブセットに日本語の文字 %d 字" % (n, len(js)))
# ---------------------------------------------------------------- 2.
print("\n== 2. 見出しがすべて入っていること ==")
h_found, h_missing = find_in_order(headings, flat_nofoot)
print("見出し: 原稿 %d（%s）/ PDF で原稿の順に見つかった %d"
% (len(headings),
" + ".join("%s:%d" % ("#" * lv, n) for lv, n in lv_count.items() if n),
h_found))
for ln, lv, _, s in h_missing[:MAX_LIST]:
if has(s):
print(" ★NG★ %d行の見出し（%s）は PDF にあるが、順序が原稿と違う: %s"
% (ln, "#" * lv, s))
else:
print(" ★NG★ %d行の見出し（%s）が PDF に無い: %s" % (ln, "#" * lv, s))
if len(h_missing) > MAX_LIST:
print(" …ほか %d 件" % (len(h_missing) - MAX_LIST))
if h_missing:
ng.append("見出しの欠落・順序違い %d 件（原稿 %d）" % (len(h_missing), len(headings)))
# ---------------------------------------------------------------- 3.
print("\n== 3. 本文の取りこぼしが無いこと（段落・表のセル・箇条書き・引用） ==")
b_found, b_missing = find_in_order(body, flat_nofoot)
by_kind = {}
for _, kind, _, s in body:
if sq(s):
by_kind[kind] = by_kind.get(kind, 0) + 1
print("照合した行: %d（%s）/ 見つかった %d / 見つからない %d"
% (sum(by_kind.values()),
" / ".join("%s %d" % kv for kv in sorted(by_kind.items())),
b_found, len(b_missing)))
for ln, kind, cells, s in b_missing[:MAX_LIST]:
where = "順序違い" if has(s) else "欠落"
print(" ★NG★ %d行（%s・%s）: %s" % (ln, kind, where, s[:90]))
if cells is not None and where == "欠落":
lost_cells = [(ci, c) for ci, c in enumerate(cells, 1) if sq(c) and not has(c)]
for ci, c in lost_cells:
print(" %d列目のセルが PDF に無い: %s" % (ci, c[:80]))
if not lost_cells:
print(" （セルは1つずつなら全部 PDF にある。並び・繋がりが原稿と違う）")
if len(b_missing) > MAX_LIST:
print(" …ほか %d 行" % (len(b_missing) - MAX_LIST))
if b_missing:
ng.append("本文の欠落・順序違い %d 行" % len(b_missing))
md_chars = len(sq("".join(s for _, _, _, s in body)))
print("記法を外した原稿の本文の文字数 %d / PDF（フッター除く）の文字数 %d"
"（PDF には見出し・コード・箇条書きの印・繰り返した表の見出し行も入る）"
% (md_chars, len(flat_nofoot)))
# ---------------------------------------------------------------- 4.
print("\n== 4. コードブロック（Mermaid を含む）の中身 ==")
variants_used = {"そのまま": 0, "<br/> を外した形": 0}
def code_forms(s):
yield "そのまま", s
yield "<br/> を外した形", RE_BR.sub("", s)
pos = 0
c_bad = []
n_code_lines = 0
for bi, blk in enumerate(codes, 1):
miss = []
found = 0
for ln, line in blk["lines"]:
if not sq(line):
continue
n_code_lines += 1
hit = None
for label, form in code_forms(line):
loc = locate(form, flat_nofoot, pos)
if loc is not None:
hit = (label, loc)
break
if hit:
variants_used[hit[0]] += 1
pos = hit[1][1]
found += 1
else:
miss.append((ln, line))
total = len([1 for _, l in blk["lines"] if sq(l)])
mark = "OK" if not miss else "★NG★"
print(" コード%-3d %4d行目 %-8s 原稿 %3d 行 / PDF %3d 行 %s"
% (bi, blk["ln"], blk["lang"] or "(なし)", total, found, mark))
for ln, line in miss[:20]:
where = "順序違い" if any(has(f) for _, f in code_forms(line)) else "欠落"
print(" ★NG★ %d行（%s）: %s" % (ln, where, line.strip()[:90]))
if len(miss) > 20:
print(" …ほか %d 行" % (len(miss) - 20))
if miss:
c_bad.append(bi)
print("コードブロック: 原稿 %d（うち Mermaid %d）/ 中身が全部 PDF にあった %d"
% (len(codes), len(mermaids), len(codes) - len(c_bad)))
print("Mermaid: 原稿 %d / 中身が全部 PDF にあった %d"
% (len(mermaids), len([1 for bi, b in enumerate(codes, 1)
if b["lang"] == "mermaid" and bi not in c_bad])))
print("照合したコードの行 %d。見つかった形: %s"
% (n_code_lines, " / ".join("%s %d" % kv for kv in variants_used.items())))
if c_bad:
ng.append("中身が欠けたコードブロック %d 個（コード%s）"
% (len(c_bad), ",".join(map(str, c_bad))))
# ---------------------------------------------------------------- 5.
print("\n== 5. しおり（PDF のアウトライン） ==")
exp_bm = [h for h in headings if h[1] in (2, 3)]
bms = [] # (深さ, 題名, ページ番号 or None)
def walk_outline(items, depth):
for it in items:
if isinstance(it, list):
walk_outline(it, depth + 1)
continue
try:
pn = reader.get_destination_page_number(it)
except Exception:
pn = None
if pn is not None and pn < 0:
pn = None
bms.append((depth, str(getattr(it, "title", "") or ""), pn))
try:
walk_outline(reader.outline, 1)
except Exception as e:
print(" ★NG★ しおりを読めなかった:", e)
ng.append("しおりを読めない")
print("しおり: PDF %d / 期待 %d（原稿の ## %d + ### %d）"
% (len(bms), len(exp_bm), lv_count[2], lv_count[3]))
depths = sorted(set(d for d, _, _ in bms))
print("しおりの階層:", ", ".join("深さ%d: %d 個" % (d, sum(1 for x in bms if x[0] == d))
for d in depths) or "なし")
if len(bms) != len(exp_bm):
print(" ★NG★ しおりの数が ## と ### の数と合わない")
ng.append("しおりの数 %d（期待 %d）" % (len(bms), len(exp_bm)))
no_page = [(i, t) for i, (_, t, pn) in enumerate(bms, 1) if pn is None]
for i, t in no_page[:MAX_LIST]:
print(" ★NG★ しおり%d の宛先ページが無い: %s" % (i, t[:60]))
if no_page:
ng.append("宛先ページの無いしおり %d 個" % len(no_page))
# 題名・階層の突き合わせ（参考。生成側が題名を縮めることもあるので ★注意★ に留める）
mism = 0
base = min(depths) if depths else 1
for (ln, lv, _, s), (d, t, _) in zip(exp_bm, bms):
if sq(t) != sq(s) or (d - base) != (lv - 2):
mism += 1
if mism <= 20:
print(" ★注意★ %d行の %s「%s」⇔ しおり（深さ%d）「%s」"
% (ln, "#" * lv, s[:40], d, t[:40]))
if mism > 20:
print(" …ほか %d 件" % (mism - 20))
print("題名・階層が原稿と食い違うしおり:", mism if mism else "なし")
# しおりのページが原稿の順に並んでいること
pns = [pn for _, _, pn in bms if pn is not None]
back = sum(1 for a, b in zip(pns, pns[1:]) if b < a)
if back:
print(" ★注意★ しおりのページが前に戻る箇所が %d 個ある" % back)
# ---------------------------------------------------------------- 6.
print("\n== 6. 章内リンク ==")
# 6-a. 原稿側 — #.. が原稿の見出しに実在するか（GitHub のアンカーの付け方）
slugs = {}
for ln, lv, rawh, _ in headings:
base_slug = gh_slug(rawh)
sl = base_slug
n = 0
while sl in slugs:
n += 1
sl = "%s-%d" % (base_slug, n)
slugs[sl] = ln
bad_md = [(ln, t, a) for ln, t, a in md_links if a not in slugs]
print("原稿の章内リンク [..](#..): %d 個（宛先の見出し %d 種）"
% (len(md_links), len(set(a for _, _, a in md_links))))
for ln, t, a in bad_md:
print(" ★NG★ %d行のリンク「%s」の宛先 #%s が原稿の見出しに無い" % (ln, md_plain(t), a))
if bad_md:
ng.append("原稿の章内リンクの宛先が見出しに無い %d 個" % len(bad_md))
# 6-b. PDF 側 — リンク注釈を集める
page_ids = {}
for i, p in enumerate(reader.pages):
if p.indirect_reference is not None:
page_ids[p.indirect_reference.idnum] = i
def dest_page(arr):
"""宛先の配列 [ページ /XYZ …] からページ番号（0始まり）を返す。無ければ None。"""
arr = arr.get_object() if isinstance(arr, IndirectObject) else arr
if isinstance(arr, DictionaryObject):
arr = arr.get("/D")
arr = arr.get_object() if isinstance(arr, IndirectObject) else arr
if not isinstance(arr, (list, ArrayObject)) or not arr:
return None
first = arr[0]
if isinstance(first, IndirectObject):
return page_ids.get(first.idnum)
try:
n = int(first)
return n if 0 <= n < len(reader.pages) else None
except Exception:
return None
def dkey(v):
return str(v.get_object() if isinstance(v, IndirectObject) else v).lstrip("/")
named = {} # 宛先の名前 → ページ番号 or None
root = reader.trailer["/Root"].get_object()
if "/Dests" in root: # 古い形（カタログの /Dests 辞書）
for k, v in root["/Dests"].get_object().items():
named[dkey(k)] = dest_page(v)
def walk_name_tree(node):
node = node.get_object()
if "/Names" in node:
arr = node["/Names"]
for j in range(0, len(arr) - 1, 2):
named[dkey(arr[j])] = dest_page(arr[j + 1])
for kid in node.get("/Kids", []):
walk_name_tree(kid)
if "/Names" in root and "/Dests" in root["/Names"].get_object():
walk_name_tree(root["/Names"].get_object()["/Dests"])
print("PDF の名前付き宛先: %d 個" % len(named))
internal = [] # (ページ番号, 宛先の表示, 飛び先ページ or None)
external = 0
other = 0
for pi, p in enumerate(reader.pages):
for a in (p.get("/Annots") or []):
a = a.get_object()
if a.get("/Subtype") != "/Link":
continue
dest = a.get("/Dest")
act = a.get("/A")
act = act.get_object() if act is not None else None
if dest is None and act is not None:
s = act.get("/S")
if s == "/GoTo":
dest = act.get("/D")
elif s == "/URI":
external += 1
continue
else:
other += 1
continue
if dest is None:
other += 1
continue
d = dest.get_object() if isinstance(dest, IndirectObject) else dest
if isinstance(d, (list, ArrayObject)):
internal.append((pi + 1, "（ページ直指定）", dest_page(d)))
else:
name = dkey(d)
internal.append((pi + 1, name, named.get(name) if name in named else None))
print("リンク注釈: 文書内（GoTo / 名前付き宛先）%d / 外部（URI）%d / その他 %d"
% (len(internal), external, other))
print("文書内リンク: PDF %d / 期待 %d 以上（原稿の [..](#..) の数）"
% (len(internal), len(md_links)))
if len(internal) < len(md_links):
print(" ★NG★ 文書内リンクが原稿の章内リンクより少ない")
ng.append("文書内リンク %d（期待 %d 以上）" % (len(internal), len(md_links)))
broken = [(pg, nm) for pg, nm, tp in internal if tp is None]
for pg, nm in broken[:MAX_LIST]:
print(" ★NG★ p%d のリンクの宛先が実在しない: %s" % (pg, nm))
if broken:
ng.append("宛先が実在しない文書内リンク %d 個" % len(broken))
else:
print("宛先: 全部実在する（%d 個）" % len(internal))
# ---------------------------------------------------------------- 7.
print("\n== 7. 豆腐（グリフ欠け）と、字の無い文字 ==")
if GLYPH_FONTS and SYM_C2G is not None:
# 描いた文字ごとに、描いたフォントに字があること
c2g_r = dict(GLYPH_FONTS)["JP"]
c2g_b = dict(GLYPH_FONTS)["JP-B"]
for n, d in sorted(drawn.items()):
if is_biz(n):
c2g = c2g_b if "Bold" in n else c2g_r
label = "BIZ UDGothic %s" % ("B" if "Bold" in n else "R")
elif is_sym(n):
c2g, label = SYM_C2G, "Segoe UI Symbol"
else:
continue # 許可していないフォントは 1. で NG 済み
miss = sorted(c for c in d if c != "\x00" and ord(c) not in c2g)
print("%-32s %4d 字種 / %s に字が無い文字: %s"
% (n, len(d), label, miss if miss else "なし"))
if miss:
ng.append("%s で描いた文字のうち字が無い %s" % (n, miss))
else:
print(" ★この検査は飛ばした★（reportlab かフォントが無い）:", GLYPH_ERR)
# 字の無い文字をそのまま組むと、抽出テキストでは \x00（.notdef）になる
n_nul = text.count("\x00")
tofu = sorted(set(c for c in text if c in "\ufffd□"))
print("豆腐（.notdef。抽出テキストの \\x00）: %s" % (("%d 個" % n_nul) if n_nul else "なし"))
for i, t in enumerate(pages, 1):
if "\x00" in t:
k = t.index("\x00")
print(" ★NG★ p%d に豆腐: …%s…" % (i, sq(t[max(0, k - 15):k + 15]).replace("\x00", "□")))
if n_nul:
ng.append("豆腐（.notdef）%d 個" % n_nul)
print("置換文字・豆腐そのものの混入:", tofu if tofu else "なし")
if tofu and not set(tofu) <= set("".join(md_lines)):
ng.append("豆腐 %s" % tofu)
md_chars_set = set(md_plain("".join(
l for l in md_lines if not l.startswith("```")))) - set(" \t#>|-\\")
lost = sorted(md_chars_set - set(text) - set("\u3000\u00a0\ufe0e\ufe0f\u200d"))
print("原稿にあって PDF に1度も出ない文字:", lost if lost else "なし")
if lost:
ng.append("PDF に出ない文字 %s" % lost)
# 字の無い文字（原稿にあって BIZ UDGothic に字が無い文字）が原文のまま出ていること
print("原稿にあって BIZ UDGothic に字が無い文字: %d 種（PDF には原文のまま出ること）"
% len(GLYPHLESS))
by_font = {}
for n, d in drawn.items():
for c in d:
by_font.setdefault(c, set()).add(n)
g_bad = []
for ch in sorted(GLYPHLESS):
n_md = sum(l.count(ch) for l in md_lines)
n_pdf = text.count(ch)
fnames = sorted(by_font.get(ch, []))
kinds = sorted(set("Segoe UI Symbol" if is_sym(f) else
("BIZ UDGothic" if is_biz(f) else f) for f in fnames))
in_sym = SYM_C2G is not None and ord(ch) in SYM_C2G
mark = "OK" if n_pdf >= n_md else "★NG★"
print(" U+%04X %s %-30s 原稿 %2d / PDF %2d 描いたフォント: %s%s %s"
% (ord(ch), ch, unicodedata.name(ch, "?")[:30], n_md, n_pdf,
"・".join(kinds) or "（無し）",
"" if in_sym else "（Segoe UI Symbol にも字が無い）", mark))
if n_pdf < n_md:
g_bad.append(ch)
if g_bad:
ng.append("字の無い文字が原文のまま出ていない %s" % g_bad)
# ---------------------------------------------------------------- 8.
print("\n== 8. 空白ページ ==")
blank = [i for i, t in enumerate(pages, 1) if len(sq(strip_footer(t, i))) < 20]
print("空白ページ:", blank if blank else "なし")
if blank:
ng.append("空白ページ %s" % blank)
# ---------------------------------------------------------------- 結果
print("\n== 結果 ==")
print("ページ数: %d / サイズ: %.1f KB" % (len(reader.pages), len(raw) / 1024))
print("期待値（原稿から数えた）: 見出し %d / コードブロック %d（Mermaid %d）/ "
"しおり %d / 章内リンク %d" % (len(headings), len(codes), len(mermaids),
len(exp_bm), len(md_links)))
if ng:
print("★NG★")
for x in ng:
print(" -", x)
else:
print("OK（全項目）")
sys.exit(0 if not ng else 1)
