Descriptor &fromCompDesc{statDesc[1].descriptor()};
for (std::size_t j{0}; j < toElements; ++j,
to.IncrementSubscripts(toAt), from.IncrementSubscripts(fromAt)) {
- comp.CreatePointerDescriptor(toCompDesc, to, toAt, terminator);
+ comp.CreatePointerDescriptor(toCompDesc, to, terminator, toAt);
comp.CreatePointerDescriptor(
- fromCompDesc, from, fromAt, terminator);
+ fromCompDesc, from, terminator, fromAt);
Assign(toCompDesc, fromCompDesc, terminator);
}
} else { // Component has intrinsic type; simply copy raw bytes
type{addendum ? addendum->derivedType() : nullptr}) {
if (const typeInfo::Component *
comp{type->FindDataComponent(compName, std::strlen(compName))}) {
- comp->CreatePointerDescriptor(desc, source, nullptr, handler);
+ comp->CreatePointerDescriptor(desc, source, handler);
return true;
} else {
handler.SignalError(
"a component of its derived type",
compName, name);
}
+ } else if (source.type().IsDerived()) {
+ handler.Crash("Derived type object '%s' in NAMELIST is missing its "
+ "derived type information!",
+ name);
} else {
handler.SignalError("NAMELIST component reference '%%%s' of input group "
"item %s for non-derived type",
Descriptor &mutableDescriptor{staticDesc[whichStaticDesc].descriptor()};
whichStaticDesc ^= 1;
if (*next == '(') {
- HandleSubscripts(io, mutableDescriptor, *useDescriptor, name);
+ if (!(HandleSubscripts(
+ io, mutableDescriptor, *useDescriptor, name))) {
+ return false;
+ }
} else {
- HandleComponent(io, mutableDescriptor, *useDescriptor, name);
+ if (!HandleComponent(io, mutableDescriptor, *useDescriptor, name)) {
+ return false;
+ }
}
useDescriptor = &mutableDescriptor;
next = io.GetCurrentChar();
}
void Component::CreatePointerDescriptor(Descriptor &descriptor,
- const Descriptor &container, const SubscriptValue subscripts[],
- Terminator &terminator) const {
+ const Descriptor &container, Terminator &terminator,
+ const SubscriptValue *subscripts) const {
RUNTIME_CHECK(terminator, genre_ == Genre::Data);
EstablishDescriptor(descriptor, container, terminator);
- descriptor.set_base_addr(container.Element<char>(subscripts) + offset_);
+ if (subscripts) {
+ descriptor.set_base_addr(container.Element<char>(subscripts) + offset_);
+ } else {
+ descriptor.set_base_addr(container.OffsetElement<char>() + offset_);
+ }
descriptor.raw().attribute = CFI_attribute_pointer;
}
}
FILE *DerivedType::Dump(FILE *f) const {
- std::fprintf(
- f, "DerivedType @ 0x%p:\n", reinterpret_cast<const void *>(this));
+ std::fprintf(f, "DerivedType @ %p:\n", reinterpret_cast<const void *>(this));
const std::uint64_t *uints{reinterpret_cast<const std::uint64_t *>(this)};
for (int j{0}; j < 64; ++j) {
int offset{j * static_cast<int>(sizeof *uints)};
- std::fprintf(f, " [+%3d](0x%p) 0x%016jx", offset,
+ std::fprintf(f, " [+%3d](%p) 0x%016jx", offset,
reinterpret_cast<const void *>(&uints[j]),
static_cast<std::uintmax_t>(uints[j]));
if (offset == offsetof(DerivedType, binding_)) {
}
FILE *Component::Dump(FILE *f) const {
- std::fprintf(f, "Component @ 0x%p:\n", reinterpret_cast<const void *>(this));
+ std::fprintf(f, "Component @ %p:\n", reinterpret_cast<const void *>(this));
std::fputs(" name: ", f);
DumpScalarCharacter(f, name(), "Component::name");
if (genre_ == Genre::Data) {
std::fprintf(f, " category %d kind %d rank %d offset 0x%zx\n", category_,
kind_, rank_, static_cast<std::size_t>(offset_));
if (initialization_) {
- std::fprintf(f, " initialization @ 0x%p:\n",
+ std::fprintf(f, " initialization @ %p:\n",
reinterpret_cast<const void *>(initialization_));
for (int j{0}; j < 128; j += sizeof(std::uint64_t)) {
std::fprintf(f, " [%3d] 0x%016jx\n", j,
FILE *SpecialBinding::Dump(FILE *f) const {
std::fprintf(
- f, "SpecialBinding @ 0x%p:\n", reinterpret_cast<const void *>(this));
+ f, "SpecialBinding @ %p:\n", reinterpret_cast<const void *>(this));
switch (which_) {
case Which::ScalarAssignment:
std::fputs(" ScalarAssignment", f);
break;
}
std::fprintf(f, " isArgDescriptorSet: 0x%x\n", isArgDescriptorSet_);
- std::fprintf(f, " proc: 0x%p\n", reinterpret_cast<void *>(proc_));
+ std::fprintf(f, " proc: %p\n", reinterpret_cast<void *>(proc_));
return f;
}