// // recordwrite.cc // // Implements the callRecordWriteMethod helper for writing struct values // via their write(file, suffix) method in the heterogeneous write() runtime // (write_var in arrayop.h). // #include "stack.h" #include "types.h" #include "record.h" #include "entry.h" #include "access.h" #include "callable.h" #include "fileio.h" #include "util.h" namespace run { // A no-op suffix: pops the file argument and does nothing. static void noSuffixBltin(vm::stack *s) { (void)vm::pop(s); } bool isWriteSuffixType(types::ty *t) { static types::function *suffixType = new types::function( types::primVoid(), types::formal(types::primFile())); return t->kind == types::ty_function && types::equivalent(t, suffixType); } void callRecordWriteMethod(vm::stack *s, vm::vmFrame *frame, types::ty *t, camp::file *f) { // Note: this function does not perform a permission check on the write // method. Access control is enforced at compile time by // isWriteableData (builtin_handlers.cc), which is the sole code path // that constructs the tagged_var array passed to write_var. // Cast to record type (safe because kind is ty_record). types::record *recType = dynamic_cast(t); if (!recType) return; // Construct the expected type of the write method: void (file, void (file)) types::function *suffixType = new types::function( types::primVoid(), types::formal(types::primFile())); types::function *writeType = new types::function( types::primVoid(), types::formal(types::primFile()), types::formal(suffixType)); // Look up the "write" method in the record's protoenv. varEntry *ve = recType->e.lookupVarByType(symbol::trans("write"), writeType); if (!ve) return; // Get the access for the method. trans::access *loc = ve->getLocation(); trans::localAccess *la = dynamic_cast(loc); if (!la) return; // Navigate the frame chain from the record's level to the method's level. // The frame chain is linked via the parentIndex of each frame level. trans::frame *target = la->getLevel(); trans::frame *current = recType->getLevel(); vm::vmFrame *targetFrame = frame; if (target != current) { // Walk up the frame chain. trans::frame *level = current; while (level && level != target) { targetFrame = vm::get((*targetFrame)[level->parentIndex()]); level = level->getParent(); } if (!targetFrame) return; } // Read the callable from the frame at the method's offset. vm::item &methodItem = (*targetFrame)[la->getOffset()]; vm::callable *method = vm::get(methodItem); if (!method) return; // Call the method: push args (file, no-op suffix), then call. static vm::bfunc noSuffix(noSuffixBltin); s->push((vm::item)f); s->push((vm::item)(vm::callable *)&noSuffix); method->call(s); } } // namespace run