Table-driven attribute reading: rebase the reader on generated rows.

Every mechanical attribute read in MJCF now derives from mjcf.schema.
generate_read_table.py emits typed mjXAttr rows (mjcf_read_table.inc,
doc_test-gated) binding each attribute to its spec struct field; field
offsets are offsetof() expressions, so binding mistakes are compile
errors, and the field's C type -- parsed from the headers -- selects the
row kind, so mjtNum-versus-double is decided by the struct, not the
schema. mjXReader::ReadAttrTable is the generic loop; its static core
also serves the section parsers and records XML-authored fields via
mjs_setAuthored for attach conflict resolution. Row kinds cover
strings, string lists, numeric scalars and vectors (exact and ranged),
enums (int- and byte-width), bitwise flag sets, bools, unbounded typed
vectors, fixed char arrays, and identity constants declared by 'set'.
The rows are inline variables, and carry the writing=custom flag,
because the writer will share them.

The keyword maps the rows reference are generated too: the ~48
hand-written mjMap tables become mjcf_map.h, one map and size constant
per enum as C++17 inline variables, retiring the hand-maintained
extern block in xml_base.h. Map names follow the schema enum names
(fluid->fluidshape, TFAuto->FalseTrueAuto, FAuto->FalseAuto,
joint->jointtype, geom->geomtype, jac->jacobian); all maps are
key-order- and value-identical to the hand tables they replace, and
bool_map is hand-emitted (the bool type is built in, not a schema
enum).

The OneX() parsers reduce to genuine irregulars, schema-marked as
reading=custom: orientation alternatives, file attributes (VFS and
asset-dir context), the actuator shorthand remappings and per-type
input maps, springlength's one-value copy, mesh builtin construction,
hfield elevation, texture cube files, flexcomp seeding, the memory
suffix parse, and the flag bit families. All 41 sensors that are pure
identity-plus-references -- including the frame family and insidesite
-- dispatch through a generated tag table; frame-sensor
objtype/reftype vocabulary tightens from the full mju_str2Type
namespace to the documented body/xbody/geom/site/camera subset, so an
invalid keyword now fails at parse time instead of compile time. The
equality family and both tendon types read shared group rows; the
twelve actuator shorthands share the general rows, with per-tag
legality enforced by the schema check. Sections bind non-mjs structs,
the visual sub-sections reaching their anonymous sub-structs through
member paths declared by an element-level field= facet.

Latent irregularities surfaced by the migration and preserved via
schema declarations or remnants: key's name is set even when absent,
eulerseq and gridlayout are fixed char arrays (chars[n], arity in
characters), gridlayout's length-must-match-gridsize stays a
value-conditional remnant, and constructor-style elements (tendon
wraps, asset model, replicate, attach) are annotated as such -- their
attributes are arguments, not field writes.

Two coherence tests guard the schema against the C sources: every
schema enum constant must be a member of the C enum it claims, and
every C member must be a keyword, a count sentinel, or a documented
exemption; and generate_default_table.py emits one row per defaulted
attribute (mjcf_default_table.inc), compared by SchemaDefaultsTest
against a freshly-constructed spec -- the schema cannot disagree with
the C default-constructors without failing the suite.

Verified: doc_test regenerates and diffs every artifact; the full
suite; and an A/B harness compiling the model corpus against the
pre-migration reader -- saved XML and binary models are byte-identical.
PiperOrigin-RevId: 958075724
Change-Id: I9715fe4deeb438eec988fd5084d74ba8b466b10b

test/doc/doc_test.py

@@ -23,8 +23,11 @@ _SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 _REPO_ROOT = os.path.dirname(os.path.dirname(_SCRIPT_DIR))
 sys.path.insert(0, os.path.join(_REPO_ROOT, 'doc', 'generate'))
 import generate_api_header
+import generate_default_table
 import generate_functions
+import generate_mjcf_map
 import generate_mjcf_table
+import generate_read_table
 import generate_schema
 import mjcf_schema
 
@@ -91,6 +94,86 @@ class DocTest(googletest.TestCase):
       if source != file.read():
         self.fail("The file 'mjcf_table.inc' needs to be updated.")
 
+  def test_default_table(self):
+    """Checks that mjcf_default_table.inc matches the schema-generated output."""
+    table_file = os.path.join(_REPO_ROOT, 'src', 'xml',
+                              'mjcf_default_table.inc')
+    source = generate_default_table.generate()
+    with open(table_file, 'r', encoding='utf-8') as file:
+      if source != file.read():
+        self.fail("The file 'mjcf_default_table.inc' needs to be updated.")
+
+  def test_mjcf_map(self):
+    """Checks that mjcf_map.h matches the schema-generated output."""
+    map_file = os.path.join(_REPO_ROOT, 'src', 'xml', 'mjcf_map.h')
+    source = generate_mjcf_map.generate()
+    with open(map_file, 'r', encoding='utf-8') as file:
+      if source != file.read():
+        self.fail("The file 'mjcf_map.h' needs to be updated.")
+
+  def test_read_table(self):
+    """Checks that mjcf_read_table.inc matches the schema-generated output."""
+    table_file = os.path.join(_REPO_ROOT, 'src', 'xml', 'mjcf_read_table.inc')
+    source = generate_read_table.generate()
+    with open(table_file, 'r', encoding='utf-8') as file:
+      if source != file.read():
+        self.fail("The file 'mjcf_read_table.inc' needs to be updated.")
+
+  def test_schema_enum_coverage(self):
+    """Checks schema enums against the C enums they bind.
+
+    Every schema constant must be a member of the bound C enum, and every C
+    member must be a schema keyword, a count sentinel (mjN*), or a documented
+    exemption -- so adding a C enum member without updating the schema fails
+    here.
+    """
+    # C members deliberately not exposed as XML keywords
+    exempt = {
+        'bodysleep': {  # resolved states of 'auto', not settable
+            'mjSLEEP_AUTO_ALLOWED', 'mjSLEEP_AUTO_NEVER'},
+        'geomtype': {   # rendering-only types and the missing-geom sentinel
+            'mjGEOM_ARROW', 'mjGEOM_ARROW1', 'mjGEOM_ARROW2', 'mjGEOM_LINE',
+            'mjGEOM_LINEBOX', 'mjGEOM_FLEX', 'mjGEOM_SKIN', 'mjGEOM_LABEL',
+            'mjGEOM_TRIANGLE', 'mjGEOM_NONE'},
+        'texrole': {    # not settable from XML
+            'mjTEXROLE_USER'},
+    }
+    # deliberately partial: keywords are a documented subset of the C enum
+    partial = {'frameobj'}
+
+    enums_c = {}
+    for name in ('mjtype.h', 'mjspec.h'):
+      path = os.path.join(_REPO_ROOT, 'include', 'mujoco', name)
+      with open(path, 'r', encoding='utf-8') as file:
+        content = file.read()
+      for m in re.finditer(r'typedef enum (mjt\w+)\s*\{(.*?)\}\s*\1;',
+                           content, re.S):
+        enums_c[m.group(1)] = re.findall(r'^\s*(mj[A-Z]\w+)', m.group(2),
+                                         re.M)
+
+    schema_path = os.path.join(_REPO_ROOT, 'src', 'xml', 'mjcf.schema')
+    schema = mjcf_schema.parse_file(schema_path)
+    errors = []
+    for name, enum in schema.enums.items():
+      if not enum.ctype:
+        continue
+      if enum.ctype not in enums_c:
+        errors.append(f'  {name}: C enum {enum.ctype} not found in headers')
+        continue
+      members = set(enums_c[enum.ctype])
+      constants = {value for _, value in enum.items}
+      for bad in sorted(constants - members):
+        errors.append(f'  {name}: {bad} is not a member of {enum.ctype}')
+      if name in partial:
+        continue
+      uncovered = {m for m in members - constants
+                   if not re.match(r'mjN[A-Z]', m)} - exempt.get(name, set())
+      for miss in sorted(uncovered):
+        errors.append(f'  {name}: {enum.ctype} member {miss} has no keyword '
+                      '(add it to the schema or to the exemptions here)')
+    if errors:
+      self.fail('schema enum coverage:\n' + '\n'.join(errors))
+
   def test_schema(self):
     """Checks that XMLschema.rst matches the generated output."""
     schema_file = os.path.join(_REPO_ROOT, 'doc', 'XMLschema.rst')