Fix bugzilla 23812 - ImportC: allow adding function attributes to imp…

…orted C functions

This adds a new pragma for ImportC, which allows to set default storage
classes. Only `nothrow`, `@nogc` and `pure` are supported for now.
They can be disabled later using `#pragma attribute(pop)`.

Unknown storage classes are ignored.

changelog/dmd.importc-pragma-stc.dd

@@ -0,0 +1,26 @@
+A pragma for ImportC allows to set `nothrow`, `@nogc` or `pure`
+
+The following new pragma for ImportC allows to set default storage
+classes for function declarations:
+```
+#pragma attribute(push, [storage classes...])
+```
+The storage classes `nothrow`, `nogc` and `pure` are supported.
+Unrecognized attributes are ignored.
+Enabling a default storage class affects all function declarations
+after the pragma until it is disabled with another pragma.
+Declarations in includes are also affected. The following example
+enables `@nogc` and `nothrow` for a library:
+
+```
+#pragma attribute(push, nogc, nothrow)
+#include <somelibrary.h>
+```
+
+The changed storage classes are pushed on a stack. The last change can
+be undone with the following pragma:
+```
+#pragma attribute(pop)
+```
+This can also disable multiple default storage classes at the same time,
+if they were enabled with a single `#pragma attribute(push, ...)` directive.

compiler/src/dmd/cparse.d

@@ -45,6 +45,9 @@ final class CParser(AST) : Parser!AST
  // #pragma pack stack
  Array!Identifier* records; // identifers (or null)
  Array!structalign_t* packs; // parallel alignment values
+
+ STC defaultStorageClasses;
+ Array!STC* defaultStorageClassesStack;
  }
 
  /* C cannot be parsed without determining if an identifier is a type or a variable.
@@ -3019,6 +3022,7 @@ final class CParser(AST) : Parser!AST
  StorageClass stc = specifier._nothrow ? STC.nothrow_ : 0;
  if (specifier._pure)
  stc |= STC.pure_;
+ stc |= defaultStorageClasses;
  AST.Type tf = new AST.TypeFunction(parameterList, t, lkg, stc);
  //tf = tf.addSTC(storageClass); // TODO
  insertTx(ts, tf, t); // ts -> ... -> tf -> t
@@ -5670,6 +5674,8 @@ final class CParser(AST) : Parser!AST
  scan(&n);
  if (n.value == TOK.identifier && n.ident == Id.pack)
  return pragmaPack(loc, true);
+ if (n.value == TOK.identifier && n.ident == Id.attribute)
+ return pragmaAttribute(loc);
  if (n.value != TOK.endOfLine)
  skipToNextLine();
  }
@@ -5877,6 +5883,125 @@ final class CParser(AST) : Parser!AST
  skipToNextLine();
  }
 
+ /*********
+ * # pragma attribute(...)
+ * Sets default storage classes
+ * Params:
+ * startloc = location to use for error messages
+ */
+ private void pragmaAttribute(const ref Loc startloc)
+ {
+ const loc = startloc;
+
+ if (!defaultStorageClassesStack)
+ {
+ defaultStorageClassesStack = new Array!STC;
+ }
+
+ Token n;
+ Lexer.scan(&n);
+ if (n.value != TOK.leftParenthesis)
+ {
+ error(loc, "left parenthesis expected to follow `#pragma attribute`");
+ if (n.value != TOK.endOfLine)
+ skipToNextLine();
+ return;
+ }
+
+ void closingParen()
+ {
+ if (n.value != TOK.rightParenthesis)
+ {
+ error(loc, "right parenthesis expected to close `#pragma attribute(`");
+ }
+ if (n.value != TOK.endOfLine)
+ skipToNextLine();
+ }
+
+ Lexer.scan(&n);
+
+ /* # pragma attribute (push, ...)
+ */
+ if (n.value == TOK.identifier && n.ident == Id.push)
+ {
+ Lexer.scan(&n);
+ if (n.value != TOK.comma)
+ {
+ error(loc, "comma expected to follow `#pragma attribute(push`");
+ if (n.value != TOK.endOfLine)
+ skipToNextLine();
+ return;
+ }
+
+ while (1)
+ {
+ Lexer.scan(&n);
+ if (n.value == TOK.endOfLine)
+ {
+ error(loc, "right parenthesis expected to close `#pragma attribute(push, `");
+ break;
+ }
+
+ if (n.value == TOK.rightParenthesis)
+ break;
+
+ if (n.value == TOK.identifier)
+ {
+ if (n.ident == Id._nothrow)
+ defaultStorageClasses |= STC.nothrow_;
+ else if (n.ident == Id.nogc)
+ defaultStorageClasses |= STC.nogc;
+ else if (n.ident == Id._pure)
+ defaultStorageClasses |= STC.pure_;
+ // Ignore unknown identifiers
+ }
+ else
+ {
+ error(loc, "unrecognized `#pragma attribute(push, %s)`", n.toChars());
+ break;
+ }
+
+ Lexer.scan(&n);
+
+ if (n.value == TOK.rightParenthesis)
+ break;
+
+ if (n.value != TOK.comma)
+ {
+ error(loc, "unrecognized `#pragma attribute(push, %s)`", n.toChars());
+ break;
+ }
+ }
+
+ this.defaultStorageClassesStack.push(defaultStorageClasses);
+
+ return closingParen();
+ }
+
+ /* # pragma attribute(pop)
+ */
+ if (n.value == TOK.identifier && n.ident == Id.pop)
+ {
+ scan(&n);
+ size_t len = this.defaultStorageClassesStack.length;
+
+ if (len)
+ {
+ this.defaultStorageClassesStack.setDim(len - 1);
+ if (len == 1) // stack is now empty
+ defaultStorageClasses = STC.init;
+ else
+ defaultStorageClasses = (*this.defaultStorageClassesStack)[len - 2];
+ }
+
+ return closingParen();
+ }
+
+ error(loc, "unrecognized `#pragma attribute(%s)`", n.toChars());
+ if (n.value != TOK.endOfLine)
+ skipToNextLine();
+ }
+
  //}
 
  /******************************************************************************/

compiler/test/compilable/imports/imp23812.c

@@ -0,0 +1,35 @@
+
+void funcDefault(void);
+
+#pragma attribute(push, nothrow)
+void funcNothrow(void);
+#pragma attribute(pop)
+
+#pragma attribute(push, nogc)
+void funcNogc(void);
+#pragma attribute(pop)
+
+#pragma attribute(push, pure)
+void funcPure(void);
+#pragma attribute(pop)
+
+#pragma attribute(push, nothrow, nogc)
+void funcNothrowNogc(void);
+#pragma attribute(pop)
+
+void funcDefault2(void);
+
+#pragma attribute(push, nothrow)
+#pragma attribute(push, nogc)
+void funcNothrowNogc2(void);
+#pragma attribute(pop)
+void funcNothrow2(void);
+#pragma attribute(pop)
+
+#pragma attribute(push, nothrow)
+void funcWithCallback(void (*f)(void));
+struct Callbacks
+{
+ void (*f)(void);
+};
+#pragma attribute(pop)

compiler/test/compilable/test23812.d

@@ -0,0 +1,75 @@
+// EXTRA_FILES: imports/imp23812.c
+
+import imports.imp23812;
+
+void callDefault()
+{
+ funcDefault();
+ funcDefault2();
+}
+
+static assert(!__traits(compiles, () nothrow { funcDefault(); } ));
+static assert(!__traits(compiles, () @nogc { funcDefault(); } ));
+static assert(!__traits(compiles, () pure { funcDefault(); } ));
+
+static assert(!__traits(compiles, () nothrow { funcDefault2(); } ));
+static assert(!__traits(compiles, () @nogc { funcDefault2(); } ));
+static assert(!__traits(compiles, () pure { funcDefault2(); } ));
+
+void callNothrow() nothrow
+{
+ funcNothrow();
+ funcNothrow2();
+}
+
+static assert(!__traits(compiles, () @nogc { funcNothrow(); } ));
+static assert(!__traits(compiles, () pure { funcNothrow(); } ));
+
+static assert(!__traits(compiles, () @nogc { funcNothrow2(); } ));
+static assert(!__traits(compiles, () pure { funcNothrow2(); } ));
+
+void callNogc() @nogc
+{
+ funcNogc();
+}
+
+static assert(!__traits(compiles, () nothrow { funcNogc(); } ));
+static assert(!__traits(compiles, () pure { funcNogc(); } ));
+
+void callPure() pure
+{
+ funcPure();
+}
+
+static assert(!__traits(compiles, () nothrow { funcPure(); } ));
+static assert(!__traits(compiles, () @nogc { funcPure(); } ));
+
+void callNothrowNogc() nothrow @nogc
+{
+ funcNothrowNogc();
+ funcNothrowNogc2();
+}
+
+static assert(!__traits(compiles, () pure { funcNothrowNogc(); } ));
+
+static assert(!__traits(compiles, () pure { funcNothrowNogc2(); } ));
+
+extern(C) void callbackDefault()
+{
+}
+
+extern(C) void callbackNothrow() nothrow
+{
+}
+
+void callFuncWithCallback() nothrow
+{
+ funcWithCallback(&callbackNothrow);
+
+ Callbacks callbacks;
+ callbacks.f = &callbackNothrow;
+}
+
+static assert(!__traits(compiles, () { funcWithCallback(&callbackDefault); } ));
+
+static assert(!__traits(compiles, () { Callbacks callbacks; callbacks.f = &callbackDefault; } ));