Method loadInstance

lib/loader/ast/component/component_instance.cpp:72–129

}

Expect<void> Loader::loadInstance(AST::Component::Instance &Instance) {
  auto ReportError = [this](auto E) {
    return logLoadError(E, FMgr.getLastOffset(), ASTNodeAttr::Comp_Instance);
  };
  // instance     ::= ie:<instanceexpr>
  //                => (instance ie)
  // instanceexpr ::= 0x00 c:<componentidx> arg*:vec(<instantiatearg>)
  //                => (instantiate c arg*)
  //                | 0x01 e*:vec(<inlineexport>)
  //                => e*

  auto LoadInstArg =
      [this](AST::Component::InstantiateArg<AST::Component::SortIndex> &Arg)
      -> Expect<void> {
    // instantiatearg ::= n:<string> si:<sortidx> => (with n si)
    EXPECTED_TRY(Arg.getName(), FMgr.readName().map_error([this](auto E) {
      return logLoadError(E, FMgr.getLastOffset(),
                          ASTNodeAttr::Comp_InstanceArg);
    }));
    return loadSortIndex(Arg.getIndex()).map_error([](auto E) {
      spdlog::error(ErrInfo::InfoAST(ASTNodeAttr::Comp_InstanceArg));
      return E;
    });
  };

  auto LoadInlineExp =
      [this](AST::Component::InlineExport &Exp) -> Expect<void> {
    // inlineexport ::= n:<exportname> si:<sortidx> => (export n si)
    EXPECTED_TRY(loadExternName(Exp.getName()).map_error([this](auto E) {
      return logLoadError(E, FMgr.getLastOffset(),
                          ASTNodeAttr::Comp_InlineExport);
    }));
    return loadSortIndex(Exp.getSortIdx()).map_error([](auto E) {
      spdlog::error(ErrInfo::InfoAST(ASTNodeAttr::Comp_InlineExport));
      return E;
    });
  };

  EXPECTED_TRY(uint8_t Flag, FMgr.readByte().map_error(ReportError));
  switch (Flag) {
  case 0x00: {
    EXPECTED_TRY(uint32_t Idx, FMgr.readU32().map_error(ReportError));
    std::vector<AST::Component::InstantiateArg<AST::Component::SortIndex>> Args;
    EXPECTED_TRY(loadVec<AST::Component::Instance>(Args, LoadInstArg));
    Instance.setInstantiateArgs(Idx, std::move(Args));
    return {};
  }
  case 0x01: {
    std::vector<AST::Component::InlineExport> Exports;
    EXPECTED_TRY(loadVec<AST::Component::Instance>(Exports, LoadInlineExp));
    Instance.setInlineExports(std::move(Exports));
    return {};
  }
  default:
    return logLoadError(ErrCode::Value::MalformedInstance, FMgr.getLastOffset(),
                        ASTNodeAttr::Comp_Instance);
  }
}