diff mbox

c-pragma: adding a data field to pragma_handler

Message ID 4DF23E3F.4010109@pvittet.com
State New
Headers show

Commit Message

Pierre Vittet June 10, 2011, 3:54 p.m. UTC 
I guess this is better now.

Changelog (gcc/c-family):

2011-06-10  Pierre Vittet <piervit@pvittet.com>

     * c-pragma.h (pragma_handler_1arg, pragma_handler_2arg): New handler.
     (gen_pragma_handler): New union.
     (internal_pragma_handler): New type.
     (c_register_pragma_with_data,
     c_register_pragma_with_expansion_and_data): New functions.
     * c-pragma.c (registered_pragmas, c_register_pragma_1,
     c_register_pragma, c_register_pragma_with_expansion,
     c_invoke_pragma_handler): Changed to work with internal_pragma_handler.
     (c_register_pragma_with_data,
     c_register_pragma_with_expansion_and_data): New functions.

Changelog (gcc/testsuite):

2011-06-10  Pierre Vittet <piervit@pvittet.com>

     * g++.dg/plugin/pragma_plugin_with_data.c: New test file.
     * g++.dg/plugin/pragma_plugin_with_data-test-1.C: New test file.
     * g++.dg/plugin/plugin.exp (plugin_test_list): Add the new test

Index: gcc/testsuite/g++.dg/plugin/plugin.exp
===================================================================
--- gcc/testsuite/g++.dg/plugin/plugin.exp	(revision 174521)
+++ gcc/testsuite/g++.dg/plugin/plugin.exp	(working copy)
@@ -49,6 +49,7 @@ load_lib plugin-support.exp
 set plugin_test_list [list \
     { attribute_plugin.c attribute_plugin-test-1.C } \
     { pragma_plugin.c pragma_plugin-test-1.C } \
+    { pragma_plugin_with_data.c pragma_plugin_with_data-test-1.C } \
     { selfassign.c self-assign-test-1.C self-assign-test-2.C self-assign-test-3.C } \
     { dumb_plugin.c dumb-plugin-test-1.C } \
     { header_plugin.c header-plugin-test.C } ]
Index: gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data.c
===================================================================
--- gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data.c	(revision 0)
+++ gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data.c	(revision 0)
@@ -0,0 +1,100 @@
+/* Test pragma adding using an extra data field.  */
+
+#include "gcc-plugin.h"
+#include <stdlib.h>
+#include "function.h"
+#include "c-family/c-pragma.h"
+#include "intl.h"
+
+
+
+int plugin_is_GPL_compatible;
+
+
+
+#define GCC_PRAGMA_BAD (gmsgid) \
+  do { warning (OPT_Wpragmas, gmsgid); goto end; } while (0)
+
+/* handler of #pragma SPACE NAME command (arg1, arg2, ...) or of type
+   #pragma SPACE NAME command.  */
+static void
+handle_pragma_gen (cpp_reader *ARG_UNUSED (dummy), void *data)
+{
+  char *plugin_name = (char *) data;
+
+  warning (0, G_("The name of the pass: %s"),
+           plugin_name);
+
+  enum cpp_ttype token;
+  tree x;
+  const char *command;
+
+  token = pragma_lex (&x);
+  if (token != CPP_NAME)
+    GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+
+  command = IDENTIFIER_POINTER (x);
+
+  /* If the pragma has the form #pragma SPACE NAME cmd (...) then command
+     contains "cmd".  Next element should be a parenthese opening or an end of
+     line.  */
+  token = pragma_lex (&x);
+  if (token != CPP_OPEN_PAREN)
+    {
+      if (token != CPP_EOF)
+      	GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+
+      else /* we have a pragma of the type '#pragma SPACE NAME command'.  */
+	{
+	  /* We have recovered our pragma.  */
+          warning (OPT_Wpragmas, "%<#pragma GCCPLUGIN newPragma%> a simple \
+instruction: %s", command);
+	  return;
+  	}
+    }
+  else
+    { /* opening parenthesis.  */
+      do
+        {
+      	  token = pragma_lex (&x);
+      	  if (token != CPP_NAME && token != CPP_STRING && token != CPP_NUMBER)
+            GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+      	  token = pragma_lex (&x);
+        } while (token == CPP_COMMA);
+
+    if (token == CPP_CLOSE_PAREN && pragma_lex (&x) == CPP_EOF)
+      {
+        /* We have recovered our pragma.  */
+        warning (OPT_Wpragmas, "%<#pragma GCCPLUGIN newPragma%> a more complex \
+instruction: %s", command);
+        return;
+      }
+    else
+      GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+    }
+end: return;
+}
+
+/* Plugin callback called during pragma registration.  */
+
+static void
+register_my_pragma (void *event_data, void *data)
+{
+  warning (0, G_("Callback to register pragmas"));
+  c_register_pragma_with_data ("GCCPLUGIN", "newPragma",
+			       handle_pragma_gen, data);
+}
+
+/* Init the plugin.  */
+int
+plugin_init (struct plugin_name_args *plugin_info,
+             struct plugin_gcc_version *version)
+{
+  const char *plugin_name = plugin_info->base_name;
+
+  register_callback (plugin_name, PLUGIN_PRAGMAS, register_my_pragma,
+	  	     (void *) plugin_name);
+  return 0;
+}
+
+#undef GCC_PRAGMA_BAD
Index: gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data-test-1.C
===================================================================
--- gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data-test-1.C	(revision 0)
+++ gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data-test-1.C	(revision 0)
@@ -0,0 +1,8 @@
+// { dg-warning "Callback to register pragmas" "" { target *-*-* } 0 }
+// { dg-warning "The name of the pass: pragma_plugin_with_data" "" {target *-*-* } 5 }
+// { dg-warning "The name of the pass: pragma_plugin_with_data" "" {target *-*-* } 7 }
+
+#pragma GCCPLUGIN newPragma do_smt // { dg-warning "'#pragma GCCPLUGIN newPragma' a simple instruction: do_smt" }
+
+#pragma GCCPLUGIN newPragma do_smt_else (test ,"test", 2) // { dg-warning "'#pragma GCCPLUGIN newPragma' a more complex instruction: do_smt_else" }
+

Comments

Joseph Myers June 15, 2011, 2:15 p.m. UTC | #1 
On Fri, 10 Jun 2011, Pierre Vittet wrote:

> I guess this is better now.
> 
> Changelog (gcc/c-family):
> 
> 2011-06-10  Pierre Vittet <piervit@pvittet.com>
> 
>     * c-pragma.h (pragma_handler_1arg, pragma_handler_2arg): New handler.
>     (gen_pragma_handler): New union.
>     (internal_pragma_handler): New type.
>     (c_register_pragma_with_data,
>     c_register_pragma_with_expansion_and_data): New functions.
>     * c-pragma.c (registered_pragmas, c_register_pragma_1,
>     c_register_pragma, c_register_pragma_with_expansion,
>     c_invoke_pragma_handler): Changed to work with internal_pragma_handler.
>     (c_register_pragma_with_data,
>     c_register_pragma_with_expansion_and_data): New functions.

Thanks.  The c-family changes are OK if you remove the last patch hunk in 
c-pragma.c (which just reformats existing code); that hunk is OK as a 
separate commit with its own ChangeLog entry, since lines shouldn't be 
wider than 80 columns.  The testsuite changes will need to be approved by 
a plugin maintainer (or a global reviewer) if they haven't already been so 
approved.
diff mbox

Patch

Index: gcc/c-family/c-pragma.c
===================================================================
--- gcc/c-family/c-pragma.c	(revision 174521)
+++ gcc/c-family/c-pragma.c	(working copy)
@@ -1147,13 +1147,12 @@  handle_pragma_float_const_decimal64 (cpp_reader *A
     }
 }
 
-/* A vector of registered pragma callbacks.  */
+/* A vector of registered pragma callbacks, which is never freed.   */
+DEF_VEC_O (internal_pragma_handler);
+DEF_VEC_ALLOC_O (internal_pragma_handler, heap);
 
-DEF_VEC_O (pragma_handler);
-DEF_VEC_ALLOC_O (pragma_handler, heap);
+static VEC(internal_pragma_handler, heap) *registered_pragmas;
 
-static VEC(pragma_handler, heap) *registered_pragmas;
-
 typedef struct
 {
   const char *space;
@@ -1216,7 +1215,7 @@  c_pp_lookup_pragma (unsigned int id, const char **
 
 static void
 c_register_pragma_1 (const char *space, const char *name,
-		     pragma_handler handler, bool allow_expansion)
+                     internal_pragma_handler ihandler, bool allow_expansion)
 {
   unsigned id;
 
@@ -1235,8 +1234,9 @@  c_register_pragma_1 (const char *space, const char
     }
   else
     {
-      VEC_safe_push (pragma_handler, heap, registered_pragmas, &handler);
-      id = VEC_length (pragma_handler, registered_pragmas);
+      VEC_safe_push (internal_pragma_handler, heap, registered_pragmas,
+                     &ihandler);
+      id = VEC_length (internal_pragma_handler, registered_pragmas);
       id += PRAGMA_FIRST_EXTERNAL - 1;
 
       /* The C++ front end allocates 6 bits in cp_token; the C front end
@@ -1248,28 +1248,95 @@  c_register_pragma_1 (const char *space, const char
 				allow_expansion, false);
 }
 
+/* Register a C pragma handler, using a space and a name.  It disallows pragma
+   expansion (if you want it, use c_register_pragma_with_expansion instead).  */
 void
-c_register_pragma (const char *space, const char *name, pragma_handler handler)
+c_register_pragma (const char *space, const char *name,
+                   pragma_handler_1arg handler)
 {
-  c_register_pragma_1 (space, name, handler, false);
+  internal_pragma_handler ihandler;
+
+  ihandler.handler.handler_1arg = handler;
+  ihandler.extra_data = false;
+  ihandler.data = NULL;
+  c_register_pragma_1 (space, name, ihandler, false);
 }
 
+/* Register a C pragma handler, using a space and a name, it also carries an
+   extra data field which can be used by the handler.  It disallows pragma
+   expansion (if you want it, use c_register_pragma_with_expansion_and_data
+   instead).  */
 void
+c_register_pragma_with_data (const char *space, const char *name,
+                             pragma_handler_2arg handler, void * data)
+{
+  internal_pragma_handler ihandler;
+
+  ihandler.handler.handler_2arg = handler;
+  ihandler.extra_data = true;
+  ihandler.data = data;
+  c_register_pragma_1 (space, name, ihandler, false);
+}
+
+/* Register a C pragma handler, using a space and a name.  It allows pragma
+   expansion as in the following example:
+
+   #define NUMBER 10
+   #pragma count (NUMBER)
+
+   Name expansion is still disallowed.  */
+void
 c_register_pragma_with_expansion (const char *space, const char *name,
-				  pragma_handler handler)
+				  pragma_handler_1arg handler)
 {
-  c_register_pragma_1 (space, name, handler, true);
+  internal_pragma_handler ihandler;
+
+  ihandler.handler.handler_1arg = handler;
+  ihandler.extra_data = false;
+  ihandler.data = NULL;
+  c_register_pragma_1 (space, name, ihandler, true);
 }
 
+/* Register a C pragma handler, using a space and a name, it also carries an
+   extra data field which can be used by the handler.  It allows pragma
+   expansion as in the following example:
+
+   #define NUMBER 10
+   #pragma count (NUMBER)
+
+   Name expansion is still disallowed.  */
 void
+c_register_pragma_with_expansion_and_data (const char *space, const char *name,
+                                           pragma_handler_2arg handler,
+                                           void *data)
+{
+  internal_pragma_handler ihandler;
+
+  ihandler.handler.handler_2arg = handler;
+  ihandler.extra_data = true;
+  ihandler.data = data;
+  c_register_pragma_1 (space, name, ihandler, true);
+}
+
+void
 c_invoke_pragma_handler (unsigned int id)
 {
-  pragma_handler handler;
+  internal_pragma_handler *ihandler;
+  pragma_handler_1arg handler_1arg;
+  pragma_handler_2arg handler_2arg;
 
   id -= PRAGMA_FIRST_EXTERNAL;
-  handler = *VEC_index (pragma_handler, registered_pragmas, id);
-
-  handler (parse_in);
+  ihandler = VEC_index (internal_pragma_handler, registered_pragmas, id);
+  if (ihandler->extra_data)
+    {
+      handler_2arg = ihandler->handler.handler_2arg;
+      handler_2arg (parse_in, ihandler->data);
+    }
+  else
+    {
+      handler_1arg = ihandler->handler.handler_1arg;
+      handler_1arg (parse_in);
+    }
 }
 
 /* Set up front-end pragmas.  */
@@ -1308,7 +1375,8 @@  init_pragma (void)
   c_register_pragma ("STDC", "FLOAT_CONST_DECIMAL64",
 		     handle_pragma_float_const_decimal64);
 
-  c_register_pragma_with_expansion (0, "redefine_extname", handle_pragma_redefine_extname);
+  c_register_pragma_with_expansion (0, "redefine_extname",
+                                    handle_pragma_redefine_extname);
   c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix);
 
   c_register_pragma_with_expansion (0, "message", handle_pragma_message);
Index: gcc/c-family/c-pragma.h
===================================================================
--- gcc/c-family/c-pragma.h	(revision 174521)
+++ gcc/c-family/c-pragma.h	(working copy)
@@ -84,10 +84,40 @@  extern bool pop_visibility (int);
 extern void init_pragma (void);
 
 /* Front-end wrappers for pragma registration.  */
-typedef void (*pragma_handler)(struct cpp_reader *);
-extern void c_register_pragma (const char *, const char *, pragma_handler);
-extern void c_register_pragma_with_expansion (const char *, const char *,
-					      pragma_handler);
+typedef void (*pragma_handler_1arg)(struct cpp_reader *);
+/* A second pragma handler, which adds a void * argument allowing to pass extra
+   data to the handler.  */
+typedef void (*pragma_handler_2arg)(struct cpp_reader *, void *);
+
+/* This union allows to abstract the different handlers.  */
+union gen_pragma_handler {
+  pragma_handler_1arg handler_1arg;
+  pragma_handler_2arg handler_2arg;
+};
+/* Internally used to keep the data of the handler.  */
+struct internal_pragma_handler_d {
+  union gen_pragma_handler handler;
+  /* Permits to know if handler is a pragma_handler_1arg (extra_data is false)
+     or a pragma_handler_2arg (extra_data is true).  */
+  bool extra_data;
+  /* A data field which can be used when extra_data is true.  */
+  void * data;
+};
+typedef struct internal_pragma_handler_d internal_pragma_handler;
+
+extern void c_register_pragma (const char *space, const char *name,
+                               pragma_handler_1arg handler);
+extern void c_register_pragma_with_data (const char *space, const char *name,
+                                         pragma_handler_2arg handler,
+                                         void *data);
+
+extern void c_register_pragma_with_expansion (const char *space,
+                                              const char *name,
+                                              pragma_handler_1arg handler);
+extern void c_register_pragma_with_expansion_and_data (const char *space,
+                                                       const char *name,
+                                                   pragma_handler_2arg handler,
+                                                       void *data);
 extern void c_invoke_pragma_handler (unsigned int);
 
 extern void maybe_apply_pragma_weak (tree);