Function pointer restrictions: refactor pointer-name parsing

No changes in behaviour: this commit just moves the pointer-name parsing
introduced in 771a153 to a function of its own. This is to
prepare for a fix of #6609: the same name parsing also needs to be added
to function-pointer-restriction parsing from JSON files.

To enable this code move, the exception class is moved to the global
scope.

Author: tautschnig

src/goto-programs/restrict_function_pointers.cpp

@@ -84,14 +84,14 @@ static void restrict_function_pointer(
 }
 } // namespace
 
-function_pointer_restrictionst::invalid_restriction_exceptiont::
-  invalid_restriction_exceptiont(std::string reason, std::string correct_format)
+invalid_restriction_exceptiont::invalid_restriction_exceptiont(
+  std::string reason,
+  std::string correct_format)
   : reason(std::move(reason)), correct_format(std::move(correct_format))
 {
 }
 
-std::string
-function_pointer_restrictionst::invalid_restriction_exceptiont::what() const
+std::string invalid_restriction_exceptiont::what() const
 {
   std::string res;
 
@@ -291,6 +291,66 @@ function_pointer_restrictionst::parse_function_pointer_restrictions_from_file(
   return merged_restrictions;
 }
 
+/// Parse \p candidate to distinguish whether it refers to a function pointer
+/// symbol directly (as produced by \ref label_function_pointer_call_sites), or
+/// a source location via its statement label. In the latter case, resolve the
+/// name to the underlying function pointer symbol.
+static std::string resolve_pointer_name(
+  const std::string &candidate,
+  const goto_modelt &goto_model)
+{
+  const auto last_dot = candidate.rfind('.');
+  if(
+    last_dot == std::string::npos || last_dot + 1 == candidate.size() ||
+    isdigit(candidate[last_dot + 1]))
+  {
+    return candidate;
+  }
+
+  std::string pointer_name = candidate;
+
+  const auto function_id = pointer_name.substr(0, last_dot);
+  const auto label = pointer_name.substr(last_dot + 1);
+
+  bool found = false;
+  const auto it = goto_model.goto_functions.function_map.find(function_id);
+  if(it != goto_model.goto_functions.function_map.end())
+  {
+    optionalt<source_locationt> location;
+    for(const auto &instruction : it->second.body.instructions)
+    {
+      if(
+        std::find(
+          instruction.labels.begin(), instruction.labels.end(), label) !=
+        instruction.labels.end())
+      {
+        location = instruction.source_location();
+      }
+
+      if(
+        instruction.is_function_call() &&
+        instruction.call_function().id() == ID_dereference &&
+        location.has_value() && instruction.source_location() == *location)
+      {
+        auto const &called_function_pointer =
+          to_dereference_expr(instruction.call_function()).pointer();
+        pointer_name =
+          id2string(to_symbol_expr(called_function_pointer).get_identifier());
+        found = true;
+        break;
+      }
+    }
+  }
+  if(!found)
+  {
+    throw invalid_restriction_exceptiont{
+      "non-existent pointer name " + pointer_name,
+      "pointers should be identifiers or <function_name>.<label>"};
+  }
+
+  return pointer_name;
+}
+
 function_pointer_restrictionst::restrictiont
 function_pointer_restrictionst::parse_function_pointer_restriction(
   const std::string &restriction_opt,
@@ -324,51 +384,8 @@ function_pointer_restrictionst::parse_function_pointer_restriction(
       "couldn't find target name before '/' in `" + restriction_opt + "'"};
   }
 
-  auto pointer_name = restriction_opt.substr(0, pointer_name_end);
-  const auto last_dot = pointer_name.rfind('.');
-  if(
-    last_dot != std::string::npos && last_dot + 1 != pointer_name.size() &&
-    !isdigit(pointer_name[last_dot + 1]))
-  {
-    const auto function_id = pointer_name.substr(0, last_dot);
-    const auto label = pointer_name.substr(last_dot + 1);
-
-    bool found = false;
-    const auto it = goto_model.goto_functions.function_map.find(function_id);
-    if(it != goto_model.goto_functions.function_map.end())
-    {
-      optionalt<source_locationt> location;
-      for(const auto &instruction : it->second.body.instructions)
-      {
-        if(
-          std::find(
-            instruction.labels.begin(), instruction.labels.end(), label) !=
-          instruction.labels.end())
-        {
-          location = instruction.source_location();
-        }
-
-        if(
-          instruction.is_function_call() &&
-          instruction.call_function().id() == ID_dereference &&
-          location.has_value() && instruction.source_location() == *location)
-        {
-          auto const &called_function_pointer =
-            to_dereference_expr(instruction.call_function()).pointer();
-          pointer_name =
-            id2string(to_symbol_expr(called_function_pointer).get_identifier());
-          found = true;
-          break;
-        }
-      }
-    }
-    if(!found)
-    {
-      throw invalid_restriction_exceptiont{"non-existent pointer name " +
-                                             pointer_name,
-                                           restriction_format_message};
-    }
-  }
+  std::string pointer_name = resolve_pointer_name(
+    restriction_opt.substr(0, pointer_name_end), goto_model);
 
   auto const target_names_substring =
     restriction_opt.substr(pointer_name_end + 1);

src/goto-programs/restrict_function_pointers.h

@@ -64,6 +64,19 @@ void parse_function_pointer_restriction_options_from_cmdline(
   const cmdlinet &cmdline,
   optionst &options);
 
+class invalid_restriction_exceptiont : public cprover_exception_baset
+{
+public:
+  explicit invalid_restriction_exceptiont(
+    std::string reason,
+    std::string correct_format = "");
+
+  std::string what() const override;
+
+  std::string reason;
+  std::string correct_format;
+};
+
 class function_pointer_restrictionst
 {
 public:
@@ -89,19 +102,6 @@ class function_pointer_restrictionst
   void write_to_file(const std::string &filename) const;
 
 protected:
-  class invalid_restriction_exceptiont : public cprover_exception_baset
-  {
-  public:
-    explicit invalid_restriction_exceptiont(
-      std::string reason,
-      std::string correct_format = "");
-
-    std::string what() const override;
-
-    std::string reason;
-    std::string correct_format;
-  };
-
   static void typecheck_function_pointer_restrictions(
     const goto_modelt &goto_model,
     const restrictionst &restrictions);

unit/goto-programs/restrict_function_pointers.cpp

@@ -46,32 +46,32 @@ void restriction_parsing_test()
   REQUIRE_THROWS_AS(
     fp_restrictionst::parse_function_pointer_restriction(
       "func", "test", goto_model),
-    fp_restrictionst::invalid_restriction_exceptiont);
+    invalid_restriction_exceptiont);
 
   REQUIRE_THROWS_AS(
     fp_restrictionst::parse_function_pointer_restriction(
       "/func", "test", goto_model),
-    fp_restrictionst::invalid_restriction_exceptiont);
+    invalid_restriction_exceptiont);
 
   REQUIRE_THROWS_AS(
     fp_restrictionst::parse_function_pointer_restriction(
       "func/", "test", goto_model),
-    fp_restrictionst::invalid_restriction_exceptiont);
+    invalid_restriction_exceptiont);
 
   REQUIRE_THROWS_AS(
     fp_restrictionst::parse_function_pointer_restriction(
       "func/,", "test", goto_model),
-    fp_restrictionst::invalid_restriction_exceptiont);
+    invalid_restriction_exceptiont);
 
   REQUIRE_THROWS_AS(
     fp_restrictionst::parse_function_pointer_restriction(
       "func1/func2,", "test", goto_model),
-    fp_restrictionst::invalid_restriction_exceptiont);
+    invalid_restriction_exceptiont);
 
   REQUIRE_THROWS_AS(
     fp_restrictionst::parse_function_pointer_restriction(
       "func1/,func2", "test", goto_model),
-    fp_restrictionst::invalid_restriction_exceptiont);
+    invalid_restriction_exceptiont);
 }
 
 void merge_restrictions_test()