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')

test/user/user_objects_test.cc

@@ -554,7 +554,7 @@ TEST_F(RelativeFrameSensorParsingTest, BadRefType) {
   )";
   std::array<char, 1024> error;
   LoadModelFromString(xml, error.data(), error.size());
-  EXPECT_THAT(error.data(), HasSubstr("reference frame object must be"));
+  EXPECT_THAT(error.data(), HasSubstr("invalid keyword: 'light'"));
   EXPECT_THAT(error.data(), HasSubstr("line 8"));
 }
 

test/xml/CMakeLists.txt

@@ -19,6 +19,8 @@ mujoco_test(
   ADDITIONAL_LINK_LIBRARIES compare_model
 )
 
+mujoco_test(schema_defaults_test)
+
 mujoco_test(xml_utils_test)
 
 mujoco_test(

test/xml/schema_defaults_test.cc

@@ -0,0 +1,100 @@
+// Copyright 2026 DeepMind Technologies Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Checks that the attribute defaults declared in mjcf.schema agree with the
+// C default-constructors: every generated row is compared against a
+// freshly-constructed spec element.
+
+#include <map>
+#include <string>
+
+#include <gtest/gtest.h>
+#include <mujoco/mujoco.h>
+#include <mujoco/mjspec.h>
+#include "test/fixture.h"
+
+#include "src/xml/mjcf_default_table.inc"
+
+namespace mujoco {
+namespace {
+
+using SchemaDefaultsTest = MujocoTest;
+
+TEST_F(SchemaDefaultsTest, DeclaredDefaultsMatchConstructors) {
+  mjSpec* spec = mj_makeSpec();
+  mjsBody* world = mjs_findBody(spec, "world");
+  ASSERT_NE(world, nullptr);
+  mjsBody* body = mjs_addBody(world, nullptr);
+
+  std::map<std::string, const void*> objects = {
+      {"mjOption", &spec->option},
+      {"mjVisual", &spec->visual},
+      {"mjsBody", body},
+      {"mjsFrame", mjs_addFrame(body, nullptr)},
+      {"mjsJoint", mjs_addJoint(body, nullptr)},
+      {"mjsGeom", mjs_addGeom(body, nullptr)},
+      {"mjsSite", mjs_addSite(body, nullptr)},
+      {"mjsCamera", mjs_addCamera(body, nullptr)},
+      {"mjsLight", mjs_addLight(body, nullptr)},
+      {"mjsPair", mjs_addPair(spec, nullptr)},
+      {"mjsEquality", mjs_addEquality(spec, nullptr)},
+      {"mjsTendon", mjs_addTendon(spec, nullptr)},
+      {"mjsActuator", mjs_addActuator(spec, nullptr)},
+      {"mjsSensor", mjs_addSensor(spec)},
+      {"mjsMesh", mjs_addMesh(spec, nullptr)},
+      {"mjsSkin", mjs_addSkin(spec)},
+      {"mjsMaterial", mjs_addMaterial(spec, nullptr)},
+      {"mjsTexture", mjs_addTexture(spec)},
+  };
+
+  for (int t = 0; t < kDefaultTablesN; t++) {
+    const mjXDefaultTable& table = kDefaultTables[t];
+    auto it = objects.find(table.structname);
+    ASSERT_NE(it, objects.end()) << "no factory for " << table.structname;
+    const char* base = static_cast<const char*>(it->second);
+    for (int i = 0; i < table.n; i++) {
+      const mjXDefaultEntry& entry = table.entries[i];
+      const char* field = base + entry.offset;
+      for (int j = 0; j < entry.len; j++) {
+        double expected = j < entry.ndecl ? entry.value[j] : 0;
+        double actual = 0;
+        switch (entry.kind) {
+          case 0:  // double
+            actual = reinterpret_cast<const double*>(field)[j];
+            break;
+          case 1:  // float: compare at float precision
+            actual = reinterpret_cast<const float*>(field)[j];
+            expected = static_cast<float>(expected);
+            break;
+          case 2:  // int-sized, including enums
+            actual = reinterpret_cast<const int*>(field)[j];
+            break;
+          case 3:  // byte
+            actual = reinterpret_cast<const unsigned char*>(field)[j];
+            break;
+          case 4:  // mjtNum: compare at mjtNum precision
+            actual = reinterpret_cast<const mjtNum*>(field)[j];
+            expected = static_cast<mjtNum>(expected);
+            break;
+        }
+        EXPECT_EQ(actual, expected)
+            << table.structname << "." << entry.attr << "[" << j << "]";
+      }
+    }
+  }
+  mj_deleteSpec(spec);
+}
+
+}  // namespace
+}  // namespace mujoco