comparison osx/include/kj/async-inl.h @ 62:0994c39f1e94

Cap'n Proto v0.6 + build for OSX

 
   template <typename... ParamTypes>
   friend struct GetFunctorStartAddress;
 
 #if __GNUG__
+
   void* ptr;
   ptrdiff_t adj;
   // Layout of a pointer-to-member-function used by GCC and compatible compilers.
-#else
-#error "TODO(port): PTMF instruction address extraction"
-#endif
-
-#define BODY \
-    PtmfHelper result; \
-    static_assert(sizeof(p) == sizeof(result), "unknown ptmf layout"); \
-    memcpy(&result, &p, sizeof(result)); \
-    return result
-
-  template <typename R, typename C, typename... P, typename F>
-  static PtmfHelper from(F p) { BODY; }
-  // Create a PtmfHelper from some arbitrary pointer-to-member-function which is not
-  // overloaded nor a template. In this case the compiler is able to deduce the full function
-  // signature directly given the name since there is only one function with that name.
-
-  template <typename R, typename C, typename... P>
-  static PtmfHelper from(R (C::*p)(NoInfer<P>...)) { BODY; }
-  template <typename R, typename C, typename... P>
-  static PtmfHelper from(R (C::*p)(NoInfer<P>...) const) { BODY; }
-  // Create a PtmfHelper from some poniter-to-member-function which is a template. In this case
-  // the function must match exactly the containing type C, return type R, and parameter types P...
-  // GetFunctorStartAddress normally specifies exactly the correct C and R, but can only make a
-  // guess at P. Luckily, if the function parameters are template parameters then it's not
-  // necessary to be precise about P.
-#undef BODY
 
   void* apply(void* obj) {
 #if defined(__arm__) || defined(__mips__) || defined(__aarch64__)
     if (adj & 1) {
       ptrdiff_t voff = (ptrdiff_t)ptr;

       return *(void**)(*(char**)obj + voff);
     } else {
       return ptr;
     }
   }
+
+#define BODY \
+    PtmfHelper result; \
+    static_assert(sizeof(p) == sizeof(result), "unknown ptmf layout"); \
+    memcpy(&result, &p, sizeof(result)); \
+    return result
+
+#else  // __GNUG__
+
+  void* apply(void* obj) { return nullptr; }
+  // TODO(port):  PTMF instruction address extraction
+
+#define BODY return PtmfHelper{}
+
+#endif  // __GNUG__, else
+
+  template <typename R, typename C, typename... P, typename F>
+  static PtmfHelper from(F p) { BODY; }
+  // Create a PtmfHelper from some arbitrary pointer-to-member-function which is not
+  // overloaded nor a template. In this case the compiler is able to deduce the full function
+  // signature directly given the name since there is only one function with that name.
+
+  template <typename R, typename C, typename... P>
+  static PtmfHelper from(R (C::*p)(NoInfer<P>...)) { BODY; }
+  template <typename R, typename C, typename... P>
+  static PtmfHelper from(R (C::*p)(NoInfer<P>...) const) { BODY; }
+  // Create a PtmfHelper from some poniter-to-member-function which is a template. In this case
+  // the function must match exactly the containing type C, return type R, and parameter types P...
+  // GetFunctorStartAddress normally specifies exactly the correct C and R, but can only make a
+  // guess at P. Luckily, if the function parameters are template parameters then it's not
+  // necessary to be precise about P.
+#undef BODY
 };
 
 template <typename... ParamTypes>
 struct GetFunctorStartAddress {
   // Given a functor (any object defining operator()), return the start address of the function,

       throwRecoverableException(kj::mv(*exception));
     }
     return _::returnMaybeVoid(kj::mv(*value));
   } else KJ_IF_MAYBE(exception, result.exception) {
     throwFatalException(kj::mv(*exception));
+  } else {
+    // Result contained neither a value nor an exception?
+    KJ_UNREACHABLE;
+  }
+}
+
+template <>
+inline void Promise<void>::wait(WaitScope& waitScope) {
+  // Override <void> case to use throwRecoverableException().
+
+  _::ExceptionOr<_::Void> result;
+
+  waitImpl(kj::mv(node), result, waitScope);
+
+  if (result.value != nullptr) {
+    KJ_IF_MAYBE(exception, result.exception) {
+      throwRecoverableException(kj::mv(*exception));
+    }
+  } else KJ_IF_MAYBE(exception, result.exception) {
+    throwRecoverableException(kj::mv(*exception));
   } else {
     // Result contained neither a value nor an exception?
     KJ_UNREACHABLE;
   }
 }