C++ front-end: various fixes and DEBUG

Author: tautschnig

src/ansi-c/scanner.l

@@ -1436,7 +1436,7 @@ __decltype          { if(PARSER.cpp98 &&
 
   /* This is a C11 keyword */
 
-"_Alignof"      { if(!PARSER.cpp98 &&
+"_Alignof"      { if((!PARSER.cpp98 || PARSER.cpp11) &&
                      (PARSER.mode==configt::ansi_ct::flavourt::GCC ||
                       PARSER.mode==configt::ansi_ct::flavourt::CLANG ||
                       PARSER.mode==configt::ansi_ct::flavourt::ARM ||
@@ -1458,7 +1458,7 @@ __decltype          { if(PARSER.cpp98 &&
 "_Atomic"{ws}"(" { // put back all but _Atomic
                    yyless(7);
 
-                   if(!PARSER.cpp98 &&
+                   if((!PARSER.cpp98 || PARSER.cpp11) &&
                       (PARSER.mode==configt::ansi_ct::flavourt::GCC ||
                        PARSER.mode==configt::ansi_ct::flavourt::CLANG ||
                        PARSER.mode==configt::ansi_ct::flavourt::ARM))

src/cbmc/cbmc_parse_options.cpp

@@ -542,11 +542,14 @@ int cbmc_parse_optionst::doit()
   register_languages();
 
   // configure gcc, if required
-  if(config.ansi_c.preprocessor == configt::ansi_ct::preprocessort::GCC)
+  if(config.ansi_c.preprocessor == configt::ansi_ct::preprocessort::GCC ||
+    config.ansi_c.preprocessor == configt::ansi_ct::preprocessort::CLANG)
   {
     gcc_versiont gcc_version;
     gcc_version.get("gcc");
     configure_gcc(gcc_version);
+    config.ansi_c.c_standard = gcc_version.default_c_standard;
+    config.cpp.cpp_standard = gcc_version.default_cxx_standard;
   }
 
   if(cmdline.isset("test-preprocessor"))

src/cpp/cpp_declaration.h

@@ -54,8 +54,11 @@ class cpp_declarationt:public exprt
 
   bool is_class_template() const
   {
+    const typet * t = &type();
+    while(t->id() == ID_merged_type)
+      t = &to_type_with_subtypes(*t).subtypes().back();
     return is_template() &&
-           type().id()==ID_struct &&
+           t->id()==ID_struct &&
            declarators().empty();
   }
 

src/cpp/cpp_typecheck_template.cpp

@@ -987,23 +987,6 @@ void cpp_typecheckt::convert_template_declaration(
 
   if(declaration.is_class_template())
   {
-    // there should not be declarators
-    if(!declaration.declarators().empty())
-    {
-      error().source_location=declaration.source_location();
-      error() << "class template not expected to have declarators"
-              << eom;
-      throw 0;
-    }
-
-    // it needs to be a class template
-    if(type.id()!=ID_struct)
-    {
-      error().source_location=declaration.source_location();
-      error() << "expected class template" << eom;
-      throw 0;
-    }
-
     // Is it class template specialization?
     // We can tell if there are template arguments in the class name,
     // like template<...> class tag<stuff> ...

src/cpp/parse.cpp

@@ -778,7 +778,7 @@ bool Parser::isTypeSpecifier()
          t == TOK_CPROVER_BOOL || t == TOK_CLASS || t == TOK_STRUCT ||
          t == TOK_UNION || t == TOK_ENUM || t == TOK_INTERFACE ||
          t == TOK_TYPENAME || t == TOK_TYPEOF || t == TOK_DECLTYPE ||
-         t == TOK_UNDERLYING_TYPE;
+         t == TOK_UNDERLYING_TYPE || t == TOK_ATOMIC_TYPE_SPECIFIER;
 }
 
 /*
@@ -1336,31 +1336,61 @@ bool Parser::rTempArgDeclaration(cpp_declarationt &declaration)
     if(!rTemplateDecl2(template_type, kind))
       return false;
 
-    // TODO
-
-    cpp_tokent tk1, tk2;
+    cpp_tokent tk1;
 
     if(lex.get_token(tk1) != TOK_CLASS)
       return false;
 
-    if(lex.LookAhead(0) == ',')
+    declaration=cpp_declarationt();
+    set_location(declaration, tk1);
+
+    declaration.set(ID_is_type, true);
+    declaration.type()=template_type;
+
+    declaration.declarators().resize(1);
+    cpp_declaratort &declarator=declaration.declarators().front();
+
+    declarator=cpp_declaratort();
+    declarator.name().make_nil();
+    declarator.type().make_nil();
+    set_location(declarator, tk1);
+
+    if(lex.LookAhead(0) == ',' || lex.LookAhead(0) == '>')
       return true;
 
-    if(!is_identifier(lex.get_token(tk2)))
+    if(lex.LookAhead(0)==TOK_ELLIPSIS)
+    {
+      cpp_tokent tk2;
+      lex.get_token(tk2);
+      declarator.set_has_ellipsis();
+    }
+
+    if(is_identifier(lex.LookAhead(0)))
+    {
+      cpp_tokent tk2;
+      lex.get_token(tk2);
+
+      declarator.name() = cpp_namet(tk2.data.get(ID_C_base_name));
+      set_location(declarator.name(), tk2);
+
+      add_id(declarator.name(), new_scopet::kindt::TYPE_TEMPLATE_PARAMETER);
+    }
+    else
       return false;
-    // Ptree cspec=new PtreeClassSpec(new LeafReserved(tk1),
-    //                                  Ptree::Cons(new Leaf(tk2),nil),
-    //                                  nil);
-    // decl=Ptree::Snoc(decl, cspec);
+
     if(lex.LookAhead(0)=='=')
     {
+      if(declarator.get_has_ellipsis())
+        return false;
+
       typet default_type;
+
       lex.get_token(tk1);
       if(!rTypeName(default_type))
-          return false;
+        return false;
 
-      // decl=Ptree::Nconc(decl, Ptree::List(new Leaf(tk1),
-      //                                      default_type));
+      declarator.value()=exprt(ID_type);
+      declarator.value().type().swap(default_type);
     }
   }
   else
@@ -2502,6 +2532,17 @@ bool Parser::optAttribute(typet &t)
         break;
       }
 
+      case TOK_GCC_IDENTIFIER:
+        if(tk.text == "clang" && lex.LookAhead(0) == TOK_SCOPE)
+        {
+          exprt discarded;
+          if(!rExpression(discarded, false))
+            return false;
+        }
+        else
+          return false;
+        break;
+
     default:
       // TODO: way may wish to change this: GCC, Clang, Visual Studio merely
       // warn when they see an attribute that they don't recognize
@@ -2737,8 +2778,34 @@ bool Parser::optIntegralTypeOrClassSpec(typet &p)
 
     return true;
   }
+  else if(t == TOK_ATOMIC_TYPE_SPECIFIER)
+  {
+#ifdef DEBUG
+    std::cout << std::string(__indent, ' ')
+              << "Parser::optIntegralTypeOrClassSpec 9\n";
+#endif // DEBUG
+    cpp_tokent atomic_tk;
+    lex.get_token(atomic_tk);
+
+    cpp_tokent tk;
+    if(lex.get_token(tk)!='(')
+      return false;
+
+    // the argument is always a type
+    if(!rTypeSpecifier(p, false))
+      return false;
+
+    if(lex.get_token(tk)!=')')
+      return false;
+
+    return true;
+  }
   else
   {
+#ifdef DEBUG
+    std::cout << std::string(__indent, ' ')
+              << "Parser::optIntegralTypeOrClassSpec 10\n";
+#endif // DEBUG
     p.make_nil();
     return true;
   }
@@ -3774,7 +3841,7 @@ bool Parser::rName(irept &name)
         components.back().add(ID_expr_arg).swap(expr);
 
         if(lex.LookAhead(0) != TOK_SCOPE)
-          return false;
+          return true;
       }
       break;
 
@@ -4549,6 +4616,9 @@ bool Parser::rEnumSpec(typet &spec)
     spec.set(ID_C_class, true);
   }
 
+  if(!optAttribute(spec))
+    return false;
+
   if(lex.LookAhead(0)!='{' &&
      lex.LookAhead(0)!=':')
   {
@@ -6721,7 +6791,10 @@ bool Parser::rPostfixExpr(exprt &exp)
   }
 
 #ifdef DEBUG
-  std::cout << std::string(__indent, ' ') << "Parser::rPostfixExpr 1\n";
+  std::cout << std::string(__indent, ' ') << "Parser::rPostfixExpr 1 "
+              << lex.LookAhead(0)
+              << ' ' << lex.peek().text
+              << '\n';
 #endif
 
   exprt e;
@@ -7903,7 +7976,9 @@ std::optional<codet> Parser::rStatement()
       if(!rUsing(cpp_using))
         return {};
 
-      UNIMPLEMENTED;
+      codet statement(ID_cpp_using);
+      // UNIMPLEMENTED;
+      return std::move(statement);
     }
 
   case TOK_STATIC_ASSERT:
@@ -7920,6 +7995,14 @@ std::optional<codet> Parser::rStatement()
       return std::move(statement);
     }
 
+  case '[':
+    {
+      typet discard;
+      if(!optAttribute(discard))
+        return {};
+      return code_blockt{};
+    }
+
   default:
     return rExprStatement();
   }