Use an enum to explicitly state what the execution phase is that the application is currenlty in

resolves #23

Author: Jake Champion

c-dependencies/js-compute-runtime/js-compute-builtins.cpp

@@ -50,6 +50,16 @@ using JS::MutableHandleValue;
 
 using JS::PersistentRooted;
 
+enum class Mode { PreWizening, PostWizening };
+
+Mode execution_mode = Mode::PreWizening;
+
+bool hasWizeningFinished() { return execution_mode == Mode::PostWizening; }
+
+bool isWizening() { return execution_mode == Mode::PreWizening; }
+
+void markWizeningAsFinished() { execution_mode = Mode::PostWizening; }
+
 typedef bool InternalMethod(JSContext *cx, HandleObject receiver, HandleValue extra, CallArgs args);
 template <InternalMethod fun> bool internal_method(JSContext *cx, unsigned argc, Value *vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
@@ -487,7 +497,7 @@ static const uint32_t class_flags = 0;
   }
 
 #define REQUEST_HANDLER_ONLY(name)                                                                 \
-  if (!FetchEvent::instance()) {                                                                   \
+  if (isWizening()) {                                                                              \
     JS_ReportErrorUTF8(cx,                                                                         \
                        "%s can only be used during request handling, "                             \
                        "not during initialization",                                                \
@@ -496,7 +506,7 @@ static const uint32_t class_flags = 0;
   }
 
 #define INIT_ONLY(name)                                                                            \
-  if (FetchEvent::instance()) {                                                                    \
+  if (hasWizeningFinished()) {                                                                     \
     JS_ReportErrorUTF8(cx,                                                                         \
                        "%s can only be used during initialization, "                               \
                        "not during request handling",                                              \

c-dependencies/js-compute-runtime/js-compute-builtins.h

@@ -14,6 +14,10 @@
 
 #pragma clang diagnostic pop
 
+bool hasWizeningFinished();
+bool isWizening();
+void markWizeningAsFinished();
+
 bool define_fastly_sys(JSContext *cx, JS::HandleObject global);
 
 namespace FetchEvent {

c-dependencies/js-compute-runtime/js-compute-runtime.cpp

@@ -68,7 +68,6 @@ static bool dump_mem_stats(JSContext *cx) {
 /* The class of the global object. */
 static JSClass global_class = {"global", JSCLASS_GLOBAL_FLAGS, &JS::DefaultGlobalClassOps};
 
-bool INITIALIZED = false;
 JSContext *CONTEXT = nullptr;
 
 JS::PersistentRootedObject GLOBAL;
@@ -220,7 +219,7 @@ static void abort(JSContext *cx, const char *description) {
 
   // Respond with status `500` if no response was ever sent.
   HandleObject fetch_event = FetchEvent::instance();
-  if (INITIALIZED && !FetchEvent::response_started(fetch_event))
+  if (hasWizeningFinished() && !FetchEvent::response_started(fetch_event))
     FetchEvent::respondWithError(cx, fetch_event);
 
   fflush(stderr);
@@ -352,7 +351,7 @@ static bool addEventListener(JSContext *cx, unsigned argc, Value *vp) {
 }
 
 void init() {
-  assert(!INITIALIZED);
+  assert(isWizening());
 
   if (!init_js())
     exit(1);
@@ -396,7 +395,7 @@ void init() {
   dump_mem_stats(cx);
 #endif
 
-  INITIALIZED = true;
+  markWizeningAsFinished();
 }
 
 WIZER_INIT(init);
@@ -469,9 +468,9 @@ static void wait_for_backends(JSContext *cx, double *total_compute) {
 }
 
 int main(int argc, const char *argv[]) {
-  if (!INITIALIZED) {
+  if (isWizening()) {
     init();
-    assert(INITIALIZED);
+    assert(hasWizeningFinished());
     // fprintf(stderr, "js.wasm must be initialized with a JS source file using
     // Wizer\n"); exit(-1);
   }