Move static userflags into pass_opt_t (#4806)

in order to be able to control it distinctly for each compilation
and not have it affect every compilation because it is static.

This is not strictly necessary for handling user defines in pony-lsp,
but it helps avoid surprises should we get to run multiple compilations on different threads
at one point.

Author: mfelsche

src/libponyc/options/options.c

@@ -249,7 +249,7 @@ static ponyc_opt_process_t special_opt_processing(pass_opt_t *opt)
 #if defined(USE_SCHEDULER_SCALING_PTHREADS)
   // Defined "scheduler_scaling_pthreads" so that SIGUSR2 is made available for
   // use by the signals package when not using signals for scheduler scaling
-  define_build_flag("scheduler_scaling_pthreads");
+  define_userflag(opt->user_flags, "scheduler_scaling_pthreads");
 #endif
 
 #ifndef NDEBUG
@@ -297,7 +297,7 @@ ponyc_opt_process_t ponyc_opt_process(opt_state_t* s, pass_opt_t* opt,
         wants_help = true; break;
       case OPT_DEBUG: opt->release = false; break;
       case OPT_BUILDFLAG:
-        define_build_flag(s->arg_val);
+        define_userflag(opt->user_flags, s->arg_val);
         break;
       case OPT_STRIP: opt->strip_debug = true; break;
       case OPT_PATHS: package_add_paths(s->arg_val, opt); break;

src/libponyc/pass/pass.c

@@ -18,6 +18,7 @@
 #include "../ast/treecheck.h"
 #include "../codegen/codegen.h"
 #include "../pkg/program.h"
+#include "../pkg/buildflagset.h"
 #include "../plugin/plugin.h"
 #include "../../libponyrt/mem/pool.h"
 #include "ponyassert.h"
@@ -104,6 +105,7 @@ void pass_opt_init(pass_opt_t* options)
   options->verbosity = VERBOSITY_INFO;
   options->check.errors = errors_alloc();
   options->ast_print_width = 80;
+  options->user_flags = userflags_create();
   frame_push(&options->check, NULL);
 }
 
@@ -112,6 +114,10 @@ void pass_opt_done(pass_opt_t* options)
 {
   plugin_unload(options);
 
+  // free userflags if any
+  userflags_free(options->user_flags);
+  options->user_flags = NULL;
+
   // Free the error collection.
   errors_free(options->check.errors);
   options->check.errors = NULL;

src/libponyc/pass/pass.h

@@ -5,6 +5,7 @@
 #include "../ast/ast.h"
 #include "../ast/frame.h"
 #include "../ast/source.h"
+#include "../pkg/buildflagset.h"
 
 
 PONY_EXTERN_C_BEGIN
@@ -319,6 +320,9 @@ typedef struct pass_opt_t
 
   plugins_t* plugins;
 
+  // user flags added via command line -D
+  userflags_t* user_flags;
+
   void* data; // User-defined data for unit test callbacks.
 } pass_opt_t;
 

src/libponyc/pkg/buildflagset.c

@@ -574,51 +574,58 @@ const char* buildflagset_print(buildflagset_t* set)
   return set->text_buffer;
 }
 
+// just a thin wrapper around the private flagtab_t
+typedef struct userflags_t {
+  flagtab_t inner;
+} userflags_t;
 
-static flagtab_t* _user_flags = NULL;
-
-bool define_build_flag(const char* name)
+userflags_t* userflags_create()
 {
-  pony_assert(name != NULL);
+  userflags_t* u = POOL_ALLOC(userflags_t);
+  pony_assert(u != NULL);
+  flagtab_init(&(u->inner), 4);
+  return u;
+}
 
-  if(_user_flags == NULL)
+void userflags_free(userflags_t *flags)
+{
+  if(flags != NULL)
   {
-    // Initialise flags table.
-    _user_flags = POOL_ALLOC(flagtab_t);
-    flagtab_init(_user_flags, 8);
+    flagtab_destroy(&flags->inner);
+    POOL_FREE(flagtab_t, flags);
   }
+}
+
+bool define_userflag(userflags_t* flags, const char* name)
+{
+  pony_assert(flags != NULL);
+  pony_assert(name != NULL);
 
   flag_t f1 = {stringtab(name), false};
   size_t index = HASHMAP_UNKNOWN;
-  flag_t* f2 = flagtab_get(_user_flags, &f1, &index);
+  flag_t* f2 = flagtab_get(&(flags->inner), &f1, &index);
 
   if(f2 != NULL)  // Flag already in our table.
     return false;
 
   // Add flag to our table.
   // didn't find it in the map but index is where we can put the
   // new one without another search
-  flagtab_putindex(_user_flags, flag_dup(&f1), index);
+  flagtab_putindex(&(flags->inner), flag_dup(&f1), index);
   return true;
 }
 
 
-bool remove_build_flags(const char* flags[])
+bool remove_userflags(userflags_t* flags, const char* flags_to_remove[])
 {
   pony_assert(flags != NULL);
-
-  if(_user_flags == NULL)
-  {
-    // Initialise flags table.
-    _user_flags = POOL_ALLOC(flagtab_t);
-    flagtab_init(_user_flags, 8);
-  }
+  pony_assert(flags_to_remove != NULL);
 
   size_t removed = 0;
-  for(const char** next = flags; *next != NULL; next += 1)
+  for(const char** next = flags_to_remove; *next != NULL; next += 1)
   {
     flag_t f1 = {stringtab(*next), false};
-    flag_t* found = flagtab_remove(_user_flags, &f1);
+    flag_t* found = flagtab_remove(&(flags->inner), &f1);
     if(found != NULL)
     {
       flag_free(found);
@@ -630,27 +637,20 @@ bool remove_build_flags(const char* flags[])
 }
 
 
-bool is_build_flag_defined(const char* name)
+bool is_userflag_defined(userflags_t* flags, const char* name)
 {
+  pony_assert(flags != NULL);
   pony_assert(name != NULL);
 
-  if(_user_flags == NULL)
-    // Table is not initialised, so no flags are defined.
-    return false;
-
   flag_t f1 = { stringtab(name), false };
   size_t index = HASHMAP_UNKNOWN;
-  flag_t* f2 = flagtab_get(_user_flags, &f1, &index);
+  flag_t* f2 = flagtab_get(&(flags->inner), &f1, &index);
 
   return f2 != NULL;
 }
 
-void clear_build_flags()
+void clear_userflags(userflags_t* flags)
 {
-  if(_user_flags != NULL)
-  {
-    flagtab_destroy(_user_flags);
-    POOL_FREE(flagtab_t, _user_flags);
-    _user_flags = NULL;
-  }
+  pony_assert(flags != NULL);
+  flagtab_destroy(&(flags->inner));
 }

src/libponyc/pkg/buildflagset.h

@@ -78,20 +78,25 @@ const char* buildflagset_print(buildflagset_t* set);
 
 // User build flags are defined on the ponyc command line and used to select
 // code options with ifdef expressions.
+typedef struct userflags_t userflags_t;
+
+userflags_t* userflags_create();
+
+void userflags_free(userflags_t* flags);
 
 // Define the given user build flag.
 // Returns: true on success, false on duplicate flag.
-bool define_build_flag(const char* name);
+bool define_userflag(userflags_t* flags, const char* name);
 
 // Report whether the given user build flag is defined.
-bool is_build_flag_defined(const char* name);
+bool is_userflag_defined(userflags_t* flags, const char* name);
 
 // Remove all flags in the null terminated list
 // Returns: true if one or more of the flags were removed
-bool remove_build_flags(const char* flags[]);
+bool remove_userflags(userflags_t* flags, const char* flags_to_remove[]);
 
 // Remove all flags.
-void clear_build_flags();
+void clear_userflags(userflags_t* flags);
 
 PONY_EXTERN_C_END
 

src/libponyc/pkg/ifdef.c

@@ -155,7 +155,7 @@ static bool cond_eval(ast_t* ast, buildflagset_t* config, bool release,
       }
 
       // Not a platform flag, must be a user flag.
-      return is_build_flag_defined(name);
+      return is_userflag_defined(opt->user_flags, name);
     }
 
     default:

test/libponyc/CMakeLists.txt

@@ -50,6 +50,7 @@ add_executable(libponyc.tests
     type_check_bind.cc
     type_check_subtype.cc
     use.cc
+    userflags.cc
     util.cc
     verify.cc
     with.cc

test/libponyc/buildflagset.cc

@@ -154,53 +154,3 @@ TEST(BuildFlagSetTest, MultipleFlags)
 
   buildflagset_free(set);
 }
-
-
-TEST(BuildFlagSetTest, UserFlagNoneDefined)
-{
-  clear_build_flags();
-  ASSERT_FALSE(is_build_flag_defined("foo"));
-}
-
-
-TEST(BuildFlagSetTest, UserFlagDefined)
-{
-  clear_build_flags();
-  define_build_flag("foo");
-
-  ASSERT_TRUE(is_build_flag_defined("foo"));
-}
-
-
-TEST(BuildFlagSetTest, UserFlagNotDefined)
-{
-  clear_build_flags();
-  define_build_flag("foo");
-
-  ASSERT_TRUE(is_build_flag_defined("foo"));
-  ASSERT_FALSE(is_build_flag_defined("bar"));
-}
-
-
-TEST(BuildFlagSetTest, UserFlagCaseSensitive)
-{
-  clear_build_flags();
-  define_build_flag("foo");
-
-  ASSERT_TRUE(is_build_flag_defined("foo"));
-  ASSERT_FALSE(is_build_flag_defined("FOO"));
-}
-
-
-TEST(BuildFlagSetTest, UserFlagMultiple)
-{
-  clear_build_flags();
-  define_build_flag("foo");
-  define_build_flag("BAR");
-  define_build_flag("Wombat");
-
-  ASSERT_TRUE(is_build_flag_defined("foo"));
-  ASSERT_TRUE(is_build_flag_defined("BAR"));
-  ASSERT_FALSE(is_build_flag_defined("aardvark"));
-  ASSERT_TRUE(is_build_flag_defined("Wombat"));
-}

test/libponyc/userflags.cc

@@ -0,0 +1,64 @@
+#include <gtest/gtest.h>
+#include <platform.h>
+
+#include <pkg/buildflagset.h>
+
+class UserFlagsTest: public testing::Test
+{};
+
+TEST(UserFlagsTest, UserFlagNoneDefined)
+{
+  userflags_t* flags = userflags_create();
+
+  define_userflag(flags, "foo");
+  clear_userflags(flags);
+  ASSERT_FALSE(is_userflag_defined(flags, "foo"));
+  userflags_free(flags);
+}
+
+
+TEST(UserFlagsTest, UserFlagDefined)
+{
+  userflags_t* flags = userflags_create();
+  define_userflag(flags, "foo");
+
+  ASSERT_TRUE(is_userflag_defined(flags, "foo"));
+  userflags_free(flags);
+}
+
+
+TEST(UserFlagsTest, UserFlagNotDefined)
+{
+  userflags_t* flags = userflags_create();
+  define_userflag(flags, "foo");
+
+  ASSERT_TRUE(is_userflag_defined(flags, "foo"));
+  ASSERT_FALSE(is_userflag_defined(flags, "bar"));
+  userflags_free(flags);
+}
+
+
+TEST(UserFlagsTest, UserFlagCaseSensitive)
+{
+  userflags_t* flags = userflags_create();
+  define_userflag(flags, "foo");
+
+  ASSERT_TRUE(is_userflag_defined(flags, "foo"));
+  ASSERT_FALSE(is_userflag_defined(flags, "FOO"));
+  userflags_free(flags);
+}
+
+
+TEST(UserFlagsTest, UserFlagMultiple)
+{
+  userflags_t* flags = userflags_create();
+  define_userflag(flags, "foo");
+  define_userflag(flags, "BAR");
+  define_userflag(flags, "Wombat");
+
+  ASSERT_TRUE(is_userflag_defined(flags, "foo"));
+  ASSERT_TRUE(is_userflag_defined(flags, "BAR"));
+  ASSERT_FALSE(is_userflag_defined(flags, "aardvark"));
+  ASSERT_TRUE(is_userflag_defined(flags, "Wombat"));
+  userflags_free(flags);
+}