@dforge-core/dforge-mcp 0.2.44 → 0.2.46-next

package/skills/dforge-1c-import/scripts/lib/external.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Pull the external reports and processings an infobase keeps in a catalog out to files.
+
+УТП-based configurations store a user's `.erf` / `.epf` in `Справочник.ВнешниеОбработки`,
+attribute `ХранилищеВнешнейОбработки` - a ValueStorage. The value is not compressed:
+
+    01 01 | u32 header length | u32 0 | the header, UTF-8: {"#",<ДвоичныеДанные guid>,{1,{0}}}
+    u32 0 | u32 data length | u32 0 | the file itself
+
+and the file is the same paged container `unpack.py` reads for the configuration, its
+entries nested a level deeper:
+
+    root                  {2,<object guid>,}
+    <object guid>         the object's metadata - its name, forms, templates
+    <guid>.0              a container: `info` + `text` is the object module,
+                          `form` + `module` a form
+    <form or template>    metadata naming it; a template's body is its `.0`, not a container
+    <guid>.1              help, base64 HTML - skipped
+
+    python tools/1c.py external                      # every row, to out/external/<code>/
+    python tools/1c.py external --kind Отчет         # one kind of processing only
+    python tools/1c.py external --catalog <Name>     # another catalog of the same shape
+
+Each row gets `info.json` (code, name, kind, the object's name, its forms and templates)
+and the texts: `ObjectModule.bsl`, `Form.<name>.bsl`, `Form.<name>.form`, `Template.<name>.*`.
+"""
+from __future__ import print_function
+
+import codecs
+import json
+import os
+import re
+import shutil
+import struct
+import sys
+
+import attrs
+import meta
+import migrate
+import paths
+import unpack
+
+CONTAINER = b"\xff\xff\xff\x7f"
+
+
+def stored_file(blob):
+	"""The file a ValueStorage holding ДвоичныеДанные carries, or None."""
+	blob = bytes(blob or b"")
+	if len(blob) < 10 or blob[:2] != b"\x01\x01":
+		return None
+	(head,) = struct.unpack_from("<I", blob, 2)
+	at = 10 + head
+	if len(blob) < at + 12:
+		return None
+	(size,) = struct.unpack_from("<I", blob, at + 4)
+	return blob[at + 12:at + 12 + size]
+
+
+IDENTITY = re.compile(r'\{\d+,\s*\d+,\s*[0-9a-f-]{36}\},\s*"((?:[^"]|"")*)",\s*'
+                      r'(?:\{\d+,\s*"[a-z]{2}",\s*"((?:[^"]|"")*)")?')
+
+
+def name_of(text):
+	"""(name, synonym) off the first identity block - `{1,0,<guid>},"Name",{1,"ru","..."}`.
+	Its guid is the object's own, not the one `root` names."""
+	m = IDENTITY.search(text or "")
+	if not m:
+		return None, None
+	return m.group(1).replace('""', '"'), (m.group(2) or "").replace('""', '"') or None
+
+
+def read(file_bytes):
+	"""{'object': name, 'synonym', 'module': text, 'forms': {name: (form, module)},
+	'templates': {name: bytes}} for one external report or processing."""
+	top = dict(unpack.entries(file_bytes))
+	texts = dict((k, unpack.as_text(v)) for k, v in top.items() if v[:4] != CONTAINER)
+	root = re.search(r"\{2,\s*([0-9a-f-]{36})", texts.get("root") or "")
+	object_guid = root.group(1) if root else None
+	name, synonym = name_of(texts.get(object_guid))
+	out = {"object": name, "synonym": synonym,
+	       "module": None, "forms": {}, "templates": {}}
+	for key, body in sorted(top.items()):
+		if not key.endswith(".0"):
+			continue
+		guid = key[:-2]
+		if body[:4] == CONTAINER:
+			inner = dict(unpack.entries(body))
+			if "form" in inner:
+				form = name_of(texts.get(guid))[0] or guid
+				out["forms"][form] = (unpack.as_text(inner["form"]), unpack.as_text(inner.get("module") or b""))
+			elif "text" in inner:
+				out["module"] = unpack.as_text(inner["text"])
+		elif guid in texts:
+			out["templates"][name_of(texts[guid])[0] or guid] = body
+	return out
+
+
+def template_files(name, body):
+	"""[(file name, bytes)]. A composition schema is a short binary header and then several XML
+	documents back to back - the schema, its settings, ... - each its own file."""
+	starts = [m.start() for m in re.finditer(b"(?:\\xef\\xbb\\xbf)?<\\?xml", body)]
+	if starts:
+		parts = [body[a:b] for a, b in zip(starts, starts[1:] + [len(body)])]
+		return [("Template.%s%s.xml" % (name, "" if i == 0 else ".%d" % i), part)
+		        for i, part in enumerate(parts)]
+	text = unpack.as_text(body)
+	if text:
+		return [("Template.%s.txt" % name, text.encode("utf-8"))]
+	return [("Template.%s.bin" % name, body)]
+
+
+def safe(name):
+	return re.sub(r'[\\/:*?"<>|]', "_", name or "")
+
+
+def write(folder, row, parsed):
+	if os.path.isdir(folder):
+		shutil.rmtree(folder)
+	os.makedirs(folder)
+	files = []
+
+	def put(file_name, data):
+		with open(os.path.join(folder, file_name), "wb") as f:
+			f.write(data if isinstance(data, bytes) else data.encode("utf-8"))
+		files.append(file_name)
+
+	if parsed["module"]:
+		put("ObjectModule.bsl", parsed["module"])
+	for form, (layout, module) in sorted(parsed["forms"].items()):
+		if layout:
+			put("Form.%s.form" % safe(form), layout)
+		if module:
+			put("Form.%s.bsl" % safe(form), module)
+	for template, body in sorted(parsed["templates"].items()):
+		for file_name, data in template_files(safe(template), body):
+			put(file_name, data)
+	info = dict(row, object=parsed["object"], synonym=parsed["synonym"],
+	            forms=sorted(parsed["forms"]), templates=sorted(parsed["templates"]), files=files)
+	with codecs.open(os.path.join(folder, "info.json"), "w", "utf-8") as f:
+		json.dump(info, f, ensure_ascii=False, indent="\t")
+	return info
+
+
+def physical(objects, index, name):
+	"""(table, {attribute: column}) for a catalog, resolved through DBNames."""
+	guid, fields = attrs.fields_of(name, objects, attrs.load_json("typemap.json"))
+	if not guid or guid not in index:
+		raise SystemExit("no catalog %s in this configuration" % name)
+	columns = {}
+	for field in fields or []:
+		entry = index.get(field.get("guid"))
+		if entry and not field.get("section"):
+			columns[field["name"]] = entry["physical"]
+	return index[guid]["physical"], columns
+
+
+def main():
+	args = sys.argv[1:]
+	catalog = args[args.index("--catalog") + 1] if "--catalog" in args else u"ВнешниеОбработки"
+	only = args[args.index("--kind") + 1] if "--kind" in args else None
+
+	objects = attrs.load_json("objects.json")
+	index = meta.dbnames_index()
+	table, columns = physical(objects, index, catalog)
+	storage, kind = columns[u"ХранилищеВнешнейОбработки"], columns[u"ВидОбработки"]
+
+	enum_guid = next(o["guid"] for o in objects
+	                 if o.get("family") == "Enum" and o.get("name") == u"ВидыДополнительныхВнешнихОбработок")
+	enum_table = index[enum_guid]["physical"]
+	kinds = attrs.enum_values(meta.parse(meta.load(enum_guid)), u"ВидыДополнительныхВнешнихОбработок")
+
+	cur = migrate.mssql_connect().cursor()
+	cur.execute("SELECT t._Code, t._Description, t._Marked, e._EnumOrder, t.%s FROM %s t "
+	            "LEFT JOIN %s e ON e._IDRRef = t.%sRRef WHERE t._Folder = 0x01"
+	            % (storage, table, enum_table, kind))
+	root = os.path.join(paths.OUT, "external")
+	index_rows, skipped = [], []
+	for code, name, marked, order, blob in cur.fetchall():
+		kind_name = kinds[int(order)] if order is not None and int(order) < len(kinds) else None
+		if only and kind_name != only:
+			continue
+		row = {"code": code.strip(), "name": name.strip(), "kind": kind_name, "marked": marked == b"\x01"}
+		data = stored_file(blob)
+		if not data or data[:4] != CONTAINER:
+			skipped.append(row)
+			continue
+		info = write(os.path.join(root, row["code"]), row, read(data))
+		index_rows.append(dict((k, info[k]) for k in ("code", "name", "kind", "marked", "object", "files")))
+
+	index_rows.sort(key=lambda r: r["code"])
+	with codecs.open(os.path.join(root, "index.json"), "w", "utf-8") as f:
+		json.dump(index_rows, f, ensure_ascii=False, indent="\t")
+	print("%d written to %s, %d without a file" % (len(index_rows), root, len(skipped)))
+	for row in skipped:
+		print("   no file: %s %s" % (row["code"], row["name"]))
+
+
+if __name__ == "__main__":
+	main()

package/skills/dforge-1c-import/scripts/lib/extract_code.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Extract every 1C module text in the configuration to files, once.
+
+Unpacking on demand costs a container parse per question; this walks every container in
+out/config and writes the module sources to out/code, so from then on the whole business
+logic of the infobase is greppable with ordinary tools.
+
+It iterates the container FILES rather than the metadata tree on purpose: form modules
+are their own Config entries and are not reachable from the object list, so a tree walk
+would silently miss them.
+
+Layout:
+
+    out/code/<Family>/<ObjectName>/<container>.<entry>.bsl
+    out/code/_unowned/<guid>/...        container whose owner is not a top-level object
+    out/code/index.json                 one record per file, for attribution and sizing
+
+    python tools/extract_code.py           # everything
+    python tools/extract_code.py --stats   # re-print the summary from index.json
+"""
+from __future__ import print_function
+
+import codecs
+import json
+import os
+import re
+import sys
+
+import attrs
+import meta
+import unpack
+
+OUT = meta.OUT
+CONFIG = meta.CONFIG
+CODE = os.path.join(OUT, "code")
+
+GUID_PREFIX = re.compile(r"^([0-9a-fA-F-]{36})")
+# a module, as opposed to a form layout or a picture, reads as 1C source
+CODE_MARKERS = ("Процедура", "Функция", "Перем ", "Procedure", "Function")
+SAFE = re.compile(r"[^0-9A-Za-zА-Яа-яЁёІіЇїЄєҐґ._-]")
+
+
+def safe(name):
+	return SAFE.sub("_", name)[:80] or "unnamed"
+
+
+# DBNames names only the classes that own a table. Two more are named here because the
+# evidence is conclusive: 631b75a0's members are ABCАнализПокупателей /
+# АнализДвиженияДенежныхСредств, and 07ee8426's containers hold `form` + `module` rather
+# than the `info` + `text` every module-bearing object has.
+#
+# The rest keep their class GUID as a directory name on purpose. Two of them carry a lot
+# of code - bf845118 (187 members) and 0fe48980 (128) - and both look like common modules
+# from their container shape, which cannot both be true. Guessing would put wrong labels
+# on 500k lines, so out/code/classes.md records the evidence instead and anyone who knows
+# 1C can name them in a minute. Attribution to the owning OBJECT is exact either way.
+CLASS_LABELS = {
+	"631b75a0-29e2-11d6-a3c7-0050bae0a776": "Report",
+	"07ee8426-87f1-11d5-b99c-0050bae0a95d": "Form",
+}
+
+
+def owner_index():
+	"""guid -> (label, object name) for every metadata object in the root.
+
+	objects_all.json is used rather than objects.json: the latter only covers classes
+	that own a physical table, which leaves out common modules, reports and event
+	subscriptions - most of the configuration's code.
+	"""
+	index = {}
+	for obj in attrs.load_json("objects_all.json"):
+		if not obj.get("name"):
+			continue
+		label = (obj.get("family")
+		         or CLASS_LABELS.get(obj["classGuid"])
+		         or "class_" + obj["classGuid"][:8])
+		index[obj["guid"]] = (label, obj["name"])
+	return index
+
+
+def is_code(text):
+	return text is not None and any(marker in text for marker in CODE_MARKERS)
+
+
+def nested_owner_index(unknown, owners):
+	"""Attribute nested containers - form modules, mostly - to the object they belong to.
+
+	A form is its own Config entry with its own GUID and is not in the root object list,
+	but that GUID is written into its owner's definition, so one pass over the root
+	objects' files resolves them.
+	"""
+	unknown = set(unknown)
+	resolved = {}
+	for guid, (label, name) in owners.items():
+		text = meta.load(guid)
+		if text is None:
+			continue
+		for found in set(re.findall(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+		                            r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}", text)):
+			if found in unknown and found not in resolved:
+				resolved[found] = (label, name)
+	return resolved
+
+
+def main():
+	if "--stats" in sys.argv:
+		report(attrs.load_json(os.path.join("code", "index.json")))
+		return
+
+	owners = owner_index()
+	files = sorted(f for f in os.listdir(CONFIG) if f.endswith(".bin"))
+
+	unknown = set()
+	for filename in files:
+		match = GUID_PREFIX.match(filename)
+		if match and match.group(1) not in owners:
+			unknown.add(match.group(1))
+	sys.stderr.write("[i] resolving %d nested containers against %d objects\n"
+	                 % (len(unknown), len(owners)))
+	nested = nested_owner_index(unknown, owners)
+	sys.stderr.write("[i] %d of them attributed\n" % len(nested))
+
+	records = []
+	containers = skipped = 0
+	written = set()
+
+	for i, filename in enumerate(files):
+		path = os.path.join(CONFIG, filename)
+		with open(path, "rb") as f:
+			blob = f.read()
+		if blob[:4] != b"\xff\xff\xff\x7f":
+			skipped += 1
+			continue
+		try:
+			items = unpack.entries(blob)
+		except Exception as exc:                      # a malformed container is data, not a crash
+			records.append({"file": filename, "error": str(exc)[:120]})
+			continue
+		containers += 1
+
+		base = filename[:-len(".bin")]
+		match = GUID_PREFIX.match(base)
+		guid = match.group(1) if match else ""
+		family, name = owners.get(guid) or nested.get(guid) or ("_unowned", guid or base)
+		target = os.path.join(CODE, safe(family), safe(name))
+
+		for entry_name, content in items:
+			text = unpack.as_text(content)
+			if not is_code(text):
+				continue
+			if not os.path.isdir(target):
+				os.makedirs(target)
+			# The container's own identity has to reach the filename. Naming the file
+			# after the suffix alone - the `0` of `<guid>.0` - gave every container of
+			# an object the same name, so an object owning several (a document and its
+			# forms, a report and its variants) kept only whichever was written last.
+			# That silently lost 825,327 lines of 2.36 M, and the index went on
+			# describing files that no longer held what it said.
+			stem = "%s.%s" % (guid[:8] or "x", base.split(".", 1)[-1])
+			out_name = "%s.%s.bsl" % (safe(stem), safe(entry_name))
+			if os.path.join(target, out_name) in written:
+				# Eight hex digits are not a promise. Spend the whole GUID rather
+				# than lose a file to the same bug in a smaller form.
+				out_name = "%s.%s.bsl" % (safe(base), safe(entry_name))
+			written.add(os.path.join(target, out_name))
+			with codecs.open(os.path.join(target, out_name), "w", "utf-8") as f:
+				f.write(text)
+			records.append({
+				"family": family, "object": name, "guid": match.group(1) if match else None,
+				"container": base,
+				"entry": entry_name, "path": os.path.relpath(
+					os.path.join(target, out_name), OUT).replace("\\", "/"),
+				"lines": sum(1 for line in text.splitlines()
+				             if line.strip() and not line.strip().startswith("//")),
+			})
+		if i and i % 500 == 0:
+			sys.stderr.write("[i] %d/%d files, %d modules\n" % (i, len(files), len(records)))
+
+	with codecs.open(os.path.join(CODE, "index.json"), "w", "utf-8") as f:
+		json.dump(records, f, ensure_ascii=False, indent="\t")
+	write_classes(records)
+	print("containers=%d  non-container files skipped=%d" % (containers, skipped))
+	report(records)
+
+
+def write_classes(records):
+	"""What each metadata class turned out to hold, so the unlabelled ones can be named."""
+	import collections
+	objects = attrs.load_json("objects_all.json")
+	by_guid = {o["guid"]: o for o in objects}
+
+	# join on the owner GUID, never on the name: names repeat across classes
+	# (ABCКлассификацияПокупателей is a Document, an InfoRg and a Report)
+	stats = collections.defaultdict(lambda: {"modules": 0, "lines": 0, "objects": set()})
+	for r in records:
+		if "lines" not in r:
+			continue
+		owner = by_guid.get(r.get("guid"))
+		key = owner["classGuid"] if owner else "(not a root object - forms, etc.)"
+		stats[key]["modules"] += 1
+		stats[key]["lines"] += r["lines"]
+		stats[key]["objects"].add(r.get("guid"))
+
+	members = collections.defaultdict(list)
+	for o in objects:
+		if o.get("name"):
+			members[o["classGuid"]].append(o["name"])
+
+	lines = ["# Metadata classes, by what they actually contain", "",
+	         "Generated by `tools/extract_code.py`. Classes without a DBNames family own",
+	         "no table, so they have to be identified from their contents.", "",
+	         "| class GUID | label | members | with code | modules | lines | sample members |",
+	         "|---|---|---:|---:|---:|---:|---|"]
+	for class_guid, names in sorted(members.items(), key=lambda kv: -len(kv[1])):
+		s = stats.get(class_guid, {"modules": 0, "lines": 0, "objects": set()})
+		label = CLASS_LABELS.get(class_guid, "")
+		lines.append("| `%s` | %s | %d | %d | %d | %d | %s |"
+		             % (class_guid, label, len(names), len(s["objects"]),
+		                s["modules"], s["lines"], ", ".join(names[:4])))
+	unowned = stats.get("(not a root object - forms, etc.)")
+	if unowned:
+		lines += ["", "Modules whose container is not a root object (nested forms and the"
+		              " like): %d modules, %d lines."
+		          % (unowned["modules"], unowned["lines"])]
+	with codecs.open(os.path.join(CODE, "classes.md"), "w", "utf-8") as f:
+		f.write("\n".join(lines) + "\n")
+
+
+def report(records):
+	import collections
+	by_family = collections.Counter()
+	lines_by_family = collections.Counter()
+	for r in records:
+		if "lines" not in r:
+			continue
+		by_family[r["family"]] += 1
+		lines_by_family[r["family"]] += r["lines"]
+	print("\n%-16s %8s %10s" % ("family", "modules", "lines"))
+	print("-" * 36)
+	for family, count in by_family.most_common():
+		print("%-16s %8d %10d" % (family, count, lines_by_family[family]))
+	print("-" * 36)
+	print("%-16s %8d %10d" % ("total", sum(by_family.values()),
+	                          sum(lines_by_family.values())))
+	print("\n-> %s" % CODE)
+
+
+if __name__ == "__main__":
+	main()

package/skills/dforge-1c-import/scripts/lib/forms.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Read the 1C forms out of the configuration dump.
+
+The port carries every attribute a catalogue declares, because that is what the metadata
+says - and the metadata says nothing about how they are grouped. `Номенклатура` is a flat
+list of 81 attributes, so the card the port generates is a flat list of 81 fields.
+
+The grouping is in the forms. An ordinary 1C form is not text: it sits in `<guid>.0.bin`
+in 1C's own container format - a 16-byte header, then a chain of blocks whose 31-byte
+ASCII headers give (data size, page size, next page). The first chain is a directory of
+(attributes address, data address) pairs; each attributes block carries an inner file's
+name and each data block its body. A form container holds two of them, `form` and
+`module` - the control tree and the form's code.
+
+Inside `form`, a panel's pages carry their captions:
+
+    {4, {1,1, {"ru","Цены номенклатуры"}}, ..., -1,1,1,"ЦеныНоменклатуры",1, ...
+
+which is where a card's tabs should come from.
+
+    python tools/forms.py                 # coverage, and writes out/formtabs.json
+    python tools/forms.py <1C object>     # that object's forms, and one form's tabs
+
+What is NOT here is which page a given field sits on. A page's controls are not nested
+under it: the page list is one node of the panel and the controls are another, tied by
+an id mapping whose layout is not documented and did not yield to three readings of it.
+The configuration is on ordinary forms throughout - 123 of the 182 ported objects have
+only those, and not one has a managed form with anything in it - so there is no clean
+tree to fall back on. The tabs below are therefore a description of the 1C card, not yet
+a placement for ours.
+"""
+from __future__ import print_function
+
+import codecs
+import collections
+import json
+import os
+import re
+import struct
+import sys
+import zlib
+
+import attrs
+import paths
+import meta
+
+CONFIG = os.path.join(attrs.OUT, "config")
+GUID = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+
+# `{4, {1,1, {"ru","<caption>"}}, ...},-1,1,1,"<name>",1,` - one page of a panel.
+PAGE = re.compile(
+	r'\{1,1,\s*\{"ru","([^"\n]{2,60})"\}[\s\S]{0,400}?,-1,1,1,"([A-Za-zЀ-ӿ_][^"\n]{0,60})",1,',
+	re.S)
+
+
+# --------------------------------------------------------------------------- container
+
+def read_block(buf, at):
+	"""One block chain of a 1C container, concatenated."""
+	header = buf[at:at + 31]
+	if len(header) < 31 or header[:2] != b"\r\n":
+		return None
+	left = int(header[2:10], 16)
+	page, size, following = at, int(header[11:19], 16), int(header[20:28], 16)
+	out = b""
+	while True:
+		chunk = buf[page + 31:page + 31 + size]
+		out += chunk[:left]
+		left -= min(len(chunk), left)
+		if left <= 0 or following == 0x7fffffff:
+			break
+		header = buf[following:following + 31]
+		size, page, following = (int(header[11:19], 16), following,
+		                         int(header[20:28], 16))
+	return out
+
+
+def container_files(path):
+	"""The inner files of a 1C container, by name."""
+	with open(path, "rb") as f:
+		buf = f.read()
+	directory = read_block(buf, 16)
+	if not directory:
+		return {}
+	out = {}
+	for i in range(0, len(directory) - 11, 12):
+		attr_at, data_at, _ = struct.unpack_from("<III", directory, i)
+		header = read_block(buf, attr_at)
+		if not header or len(header) <= 20:
+			continue
+		name = header[20:].decode("utf-16-le", "replace").rstrip(u"\x00")
+		body = read_block(buf, data_at) or b""
+		try:
+			body = zlib.decompressobj(-15).decompress(body)
+		except zlib.error:
+			pass
+		out[name] = body
+	return out
+
+
+def form_body(guid, part="form"):
+	"""A form's control tree as text, whether it was stored packed or plain."""
+	packed = os.path.join(CONFIG, guid + ".0.bin")
+	if os.path.isfile(packed):
+		body = container_files(packed).get(part)
+		return body.decode("utf-8-sig", "replace") if body else None
+	plain = os.path.join(CONFIG, guid + ".0.txt")
+	if part == "form" and os.path.isfile(plain):
+		with codecs.open(plain, "r", "utf-8-sig", "replace") as f:
+			return f.read()
+	return None
+
+
+# --------------------------------------------------------------------------- forms
+
+_ON_DISK = None
+
+
+def on_disk():
+	global _ON_DISK
+	if _ON_DISK is None:
+		_ON_DISK = set(name.split(".")[0] for name in os.listdir(CONFIG))
+	return _ON_DISK
+
+
+def forms_of(object_guid):
+	"""[(1C form name, guid)] for one metadata object, in declaration order."""
+	text = meta.load(object_guid) or ""
+	found = []
+	for guid in dict.fromkeys(re.findall(GUID, text)):
+		if guid == object_guid or guid not in on_disk():
+			continue
+		header = meta.load(guid) or ""
+		name = re.search(u'"(Форма[^"]*)"', header)
+		if name:
+			found.append((name.group(1), guid))
+	return found
+
+
+def tabs(text):
+	"""A panel's pages, in order: [(caption, control name)].
+
+	1C names a page it was never given a caption for `Страница1`, and a form with one
+	such page has no tabs worth porting - that is the whole card.
+	"""
+	found = []
+	for caption, name in PAGE.findall(text or ""):
+		if caption.startswith(u"Страница"):
+			continue
+		found.append((caption, name))
+	return found
+
+
+def element_form(object_guid):
+	"""The form a record opens in, preferring the client's own over the stock one."""
+	found = forms_of(object_guid)
+	for wanted in (u"ФормаЭлементаМСБ",
+	               u"ФормаЭлемента",
+	               u"ФормаДокумента"):
+		for name, guid in found:
+			if name == wanted:
+				return name, guid
+	return (found[0] if found else (None, None))
+
+
+# --------------------------------------------------------------------------- reporting
+
+def model():
+	path = os.path.join(attrs.OUT, "objects_all.json")
+	with codecs.open(path, "r", "utf-8") as f:
+		doc = json.load(f)
+	return doc["objects"] if isinstance(doc, dict) else doc
+
+
+def main():
+	rows = model()
+	if len(sys.argv) > 1:
+		wanted = sys.argv[1].decode("utf-8") if str is bytes else sys.argv[1]
+		row = next((r for r in rows if r.get("name") == wanted), None)
+		if not row:
+			print("no such object: %s" % wanted)
+			return 1
+		for name, guid in forms_of(row["guid"]):
+			text = form_body(guid)
+			found = tabs(text)
+			print("%-28s %8d chars  %d tab(s)"
+			      % (name, len(text or ""), len(found)))
+			for caption, control in found:
+				print("      %-42s %s" % (caption, control))
+		return 0
+
+	# The objects the port actually carries, which is the column map's own list - a
+	# tabular section has no form of its own, so only the owners are asked about.
+	with codecs.open(paths.derived("columnmap.json"), "r", "utf-8") as f:
+		mapping = json.load(f)
+	wanted = set()
+	for entities in mapping.values():
+		for found in entities.values():
+			name = (found.get("object") or "").strip()
+			if name and " / " not in name:
+				wanted.add(name)
+
+	tally = collections.Counter()
+	total_tabs = 0
+	found_tabs = collections.OrderedDict()
+	for row in rows:
+		if row.get("name") not in wanted:
+			continue
+		name, guid = element_form(row["guid"])
+		if not guid:
+			tally["no form"] += 1
+			continue
+		found = tabs(form_body(guid))
+		total_tabs += len(found)
+		tally["tabs" if found else "one page"] += 1
+		if found:
+			found_tabs[row["name"]] = {
+				"form": name,
+				"tabs": [{"caption": caption, "name": control}
+				         for caption, control in found],
+			}
+
+	path = os.path.join(attrs.OUT, "formtabs.json")
+	with codecs.open(path, "w", "utf-8") as f:
+		f.write(json.dumps(found_tabs, ensure_ascii=False, indent="\t"))
+		f.write("\n")
+
+	print("%-12s %s" % ("ported objects", len(wanted)))
+	for key, count in tally.most_common():
+		print("%-12s %d" % (key, count))
+	print("%-12s %d" % ("tabs found", total_tabs))
+	print("\n-> %s" % path)
+	return 0
+
+
+if __name__ == "__main__":
+	sys.exit(main())