diff --git a/src/auto/configure b/src/auto/configure
index 8ecff53..6673de8 100755
--- a/src/auto/configure
+++ b/src/auto/configure
@@ -4179,6 +4179,40 @@
 fi
 
 
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the compiler can handle Vim code" >&5
+$as_echo_n "checking if the compiler can handle Vim code... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+
+  struct with_flexible_member {
+    int count;  // comment
+    char text[]; // another comment
+  };
+  enum {
+    one,
+    two,
+    three,
+  };
+  long long int a = 1;
+  long long unsigned b = 2;
+  printf("a %lld and a %llu", a, b);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  as_fn_error $? "compiler does not work properly - see auto/config.log" "$LINENO" 5
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --enable-fail-if-missing argument" >&5
 $as_echo_n "checking --enable-fail-if-missing argument... " >&6; }
diff --git a/src/configure.ac b/src/configure.ac
index e37a267..4ae21a1 100644
--- a/src/configure.ac
+++ b/src/configure.ac
@@ -29,6 +29,29 @@
 AC_HEADER_STDC
 AC_HEADER_SYS_WAIT
 
+dnl Check that the C99 features that Vim uses are supported:
+dnl - // commands
+dnl - comma after last enum item
+dnl - "long long int" and "long long unsigned"
+dnl - flexible array member
+AC_MSG_CHECKING(if the compiler can handle Vim code)
+AC_TRY_COMPILE([#include <stdio.h>], [
+  struct with_flexible_member {
+    int count;  // comment
+    char text[]; // another comment
+  };
+  enum {
+    one,
+    two,
+    three,
+  };
+  long long int a = 1;
+  long long unsigned b = 2;
+  printf("a %lld and a %llu", a, b);
+  ],
+AC_MSG_RESULT(yes),
+AC_MSG_ERROR([compiler does not work properly - see auto/config.log]))
+
 dnl Check for the flag that fails if stuff are missing.
 
 AC_MSG_CHECKING(--enable-fail-if-missing argument)
diff --git a/src/version.c b/src/version.c
index aa1e93f..8d5c73a 100644
--- a/src/version.c
+++ b/src/version.c
@@ -763,6 +763,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1730,
+/**/
     1729,
 /**/
     1728,
